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
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
47 #define NONAMELESSUNION
48 #define NONAMELESSSTRUCT
55 #define USE_COM_CONTEXT_DEF
62 #include "compobj_private.h"
64 #include "wine/unicode.h"
65 #include "wine/debug.h"
67 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
69 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
71 /****************************************************************************
72 * This section defines variables internal to the COM module.
75 static APARTMENT
*MTA
; /* protected by csApartment */
76 static APARTMENT
*MainApartment
; /* the first STA apartment */
77 static struct list apts
= LIST_INIT( apts
); /* protected by csApartment */
79 static CRITICAL_SECTION csApartment
;
80 static CRITICAL_SECTION_DEBUG critsect_debug
=
83 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
84 0, 0, { (DWORD_PTR
)(__FILE__
": csApartment") }
86 static CRITICAL_SECTION csApartment
= { &critsect_debug
, -1, 0, 0, 0, 0 };
88 struct registered_psclsid
96 * This lock count counts the number of times CoInitialize is called. It is
97 * decreased every time CoUninitialize is called. When it hits 0, the COM
100 static LONG s_COMLockCount
= 0;
101 /* Reference count used by CoAddRefServerProcess/CoReleaseServerProcess */
102 static LONG s_COMServerProcessReferences
= 0;
105 * This linked list contains the list of registered class objects. These
106 * are mostly used to register the factories for out-of-proc servers of OLE
109 * TODO: Make this data structure aware of inter-process communication. This
110 * means that parts of this will be exported to rpcss.
112 typedef struct tagRegisteredClass
115 CLSID classIdentifier
;
117 LPUNKNOWN classObject
;
121 LPSTREAM pMarshaledData
; /* FIXME: only really need to store OXID and IPID */
122 void *RpcRegistration
;
125 static struct list RegisteredClassList
= LIST_INIT(RegisteredClassList
);
127 static CRITICAL_SECTION csRegisteredClassList
;
128 static CRITICAL_SECTION_DEBUG class_cs_debug
=
130 0, 0, &csRegisteredClassList
,
131 { &class_cs_debug
.ProcessLocksList
, &class_cs_debug
.ProcessLocksList
},
132 0, 0, { (DWORD_PTR
)(__FILE__
": csRegisteredClassList") }
134 static CRITICAL_SECTION csRegisteredClassList
= { &class_cs_debug
, -1, 0, 0, 0, 0 };
136 /*****************************************************************************
137 * This section contains OpenDllList definitions
139 * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
140 * other functions that do LoadLibrary _without_ giving back a HMODULE.
141 * Without this list these handles would never be freed.
143 * FIXME: a DLL that says OK when asked for unloading is unloaded in the
144 * next unload-call but not before 600 sec.
147 typedef HRESULT (CALLBACK
*DllGetClassObjectFunc
)(REFCLSID clsid
, REFIID iid
, LPVOID
*ppv
);
148 typedef HRESULT (WINAPI
*DllCanUnloadNowFunc
)(void);
150 typedef struct tagOpenDll
155 DllGetClassObjectFunc DllGetClassObject
;
156 DllCanUnloadNowFunc DllCanUnloadNow
;
160 static struct list openDllList
= LIST_INIT(openDllList
);
162 static CRITICAL_SECTION csOpenDllList
;
163 static CRITICAL_SECTION_DEBUG dll_cs_debug
=
165 0, 0, &csOpenDllList
,
166 { &dll_cs_debug
.ProcessLocksList
, &dll_cs_debug
.ProcessLocksList
},
167 0, 0, { (DWORD_PTR
)(__FILE__
": csOpenDllList") }
169 static CRITICAL_SECTION csOpenDllList
= { &dll_cs_debug
, -1, 0, 0, 0, 0 };
171 struct apartment_loaded_dll
179 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',' ',
180 '0','x','#','#','#','#','#','#','#','#',' ',0};
182 /*****************************************************************************
183 * This section contains OpenDllList implementation
186 static OpenDll
*COMPOBJ_DllList_Get(LPCWSTR library_name
)
190 EnterCriticalSection(&csOpenDllList
);
191 LIST_FOR_EACH_ENTRY(ptr
, &openDllList
, OpenDll
, entry
)
193 if (!strcmpiW(library_name
, ptr
->library_name
) &&
194 (InterlockedIncrement(&ptr
->refs
) != 1) /* entry is being destroy if == 1 */)
200 LeaveCriticalSection(&csOpenDllList
);
204 /* caller must ensure that library_name is not already in the open dll list */
205 static HRESULT
COMPOBJ_DllList_Add(LPCWSTR library_name
, OpenDll
**ret
)
211 DllCanUnloadNowFunc DllCanUnloadNow
;
212 DllGetClassObjectFunc DllGetClassObject
;
216 *ret
= COMPOBJ_DllList_Get(library_name
);
217 if (*ret
) return S_OK
;
219 /* do this outside the csOpenDllList to avoid creating a lock dependency on
221 hLibrary
= LoadLibraryExW(library_name
, 0, LOAD_WITH_ALTERED_SEARCH_PATH
);
224 ERR("couldn't load in-process dll %s\n", debugstr_w(library_name
));
225 /* failure: DLL could not be loaded */
226 return E_ACCESSDENIED
; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
229 DllCanUnloadNow
= (void *)GetProcAddress(hLibrary
, "DllCanUnloadNow");
230 /* Note: failing to find DllCanUnloadNow is not a failure */
231 DllGetClassObject
= (void *)GetProcAddress(hLibrary
, "DllGetClassObject");
232 if (!DllGetClassObject
)
234 /* failure: the dll did not export DllGetClassObject */
235 ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name
));
236 FreeLibrary(hLibrary
);
237 return CO_E_DLLNOTFOUND
;
240 EnterCriticalSection( &csOpenDllList
);
242 *ret
= COMPOBJ_DllList_Get(library_name
);
245 /* another caller to this function already added the dll while we
246 * weren't in the critical section */
247 FreeLibrary(hLibrary
);
251 len
= strlenW(library_name
);
252 entry
= HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll
));
254 entry
->library_name
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1)*sizeof(WCHAR
));
255 if (entry
&& entry
->library_name
)
257 memcpy(entry
->library_name
, library_name
, (len
+ 1)*sizeof(WCHAR
));
258 entry
->library
= hLibrary
;
260 entry
->DllCanUnloadNow
= DllCanUnloadNow
;
261 entry
->DllGetClassObject
= DllGetClassObject
;
262 list_add_tail(&openDllList
, &entry
->entry
);
266 HeapFree(GetProcessHeap(), 0, entry
);
268 FreeLibrary(hLibrary
);
273 LeaveCriticalSection( &csOpenDllList
);
278 /* pass FALSE for free_entry to release a reference without destroying the
279 * entry if it reaches zero or TRUE otherwise */
280 static void COMPOBJ_DllList_ReleaseRef(OpenDll
*entry
, BOOL free_entry
)
282 if (!InterlockedDecrement(&entry
->refs
) && free_entry
)
284 EnterCriticalSection(&csOpenDllList
);
285 list_remove(&entry
->entry
);
286 LeaveCriticalSection(&csOpenDllList
);
288 TRACE("freeing %p\n", entry
->library
);
289 FreeLibrary(entry
->library
);
291 HeapFree(GetProcessHeap(), 0, entry
->library_name
);
292 HeapFree(GetProcessHeap(), 0, entry
);
296 /* frees memory associated with active dll list */
297 static void COMPOBJ_DllList_Free(void)
299 OpenDll
*entry
, *cursor2
;
300 EnterCriticalSection(&csOpenDllList
);
301 LIST_FOR_EACH_ENTRY_SAFE(entry
, cursor2
, &openDllList
, OpenDll
, entry
)
303 list_remove(&entry
->entry
);
305 HeapFree(GetProcessHeap(), 0, entry
->library_name
);
306 HeapFree(GetProcessHeap(), 0, entry
);
308 LeaveCriticalSection(&csOpenDllList
);
311 /******************************************************************************
315 static DWORD
apartment_addref(struct apartment
*apt
)
317 DWORD refs
= InterlockedIncrement(&apt
->refs
);
318 TRACE("%s: before = %d\n", wine_dbgstr_longlong(apt
->oxid
), refs
- 1);
322 /* allocates memory and fills in the necessary fields for a new apartment
323 * object. must be called inside apartment cs */
324 static APARTMENT
*apartment_construct(DWORD model
)
328 TRACE("creating new apartment, model=%d\n", model
);
330 apt
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*apt
));
331 apt
->tid
= GetCurrentThreadId();
333 list_init(&apt
->proxies
);
334 list_init(&apt
->stubmgrs
);
335 list_init(&apt
->psclsids
);
336 list_init(&apt
->loaded_dlls
);
339 apt
->remunk_exported
= FALSE
;
341 InitializeCriticalSection(&apt
->cs
);
342 DEBUG_SET_CRITSEC_NAME(&apt
->cs
, "apartment");
344 apt
->multi_threaded
= !(model
& COINIT_APARTMENTTHREADED
);
346 if (apt
->multi_threaded
)
348 /* FIXME: should be randomly generated by in an RPC call to rpcss */
349 apt
->oxid
= ((OXID
)GetCurrentProcessId() << 32) | 0xcafe;
353 /* FIXME: should be randomly generated by in an RPC call to rpcss */
354 apt
->oxid
= ((OXID
)GetCurrentProcessId() << 32) | GetCurrentThreadId();
357 TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt
->oxid
));
359 list_add_head(&apts
, &apt
->entry
);
364 /* gets and existing apartment if one exists or otherwise creates an apartment
365 * structure which stores OLE apartment-local information and stores a pointer
366 * to it in the thread-local storage */
367 static APARTMENT
*apartment_get_or_create(DWORD model
)
369 APARTMENT
*apt
= COM_CurrentApt();
373 if (model
& COINIT_APARTMENTTHREADED
)
375 EnterCriticalSection(&csApartment
);
377 apt
= apartment_construct(model
);
382 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt
->oxid
));
385 LeaveCriticalSection(&csApartment
);
388 apartment_createwindowifneeded(apt
);
392 EnterCriticalSection(&csApartment
);
394 /* The multi-threaded apartment (MTA) contains zero or more threads interacting
395 * with free threaded (ie thread safe) COM objects. There is only ever one MTA
399 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA
->oxid
));
400 apartment_addref(MTA
);
403 MTA
= apartment_construct(model
);
407 LeaveCriticalSection(&csApartment
);
409 COM_CurrentInfo()->apt
= apt
;
415 static inline BOOL
apartment_is_model(const APARTMENT
*apt
, DWORD model
)
417 return (apt
->multi_threaded
== !(model
& COINIT_APARTMENTTHREADED
));
420 static void COM_RevokeRegisteredClassObject(RegisteredClass
*curClass
)
422 list_remove(&curClass
->entry
);
424 if (curClass
->runContext
& CLSCTX_LOCAL_SERVER
)
425 RPC_StopLocalServer(curClass
->RpcRegistration
);
428 * Release the reference to the class object.
430 IUnknown_Release(curClass
->classObject
);
432 if (curClass
->pMarshaledData
)
435 memset(&zero
, 0, sizeof(zero
));
436 IStream_Seek(curClass
->pMarshaledData
, zero
, STREAM_SEEK_SET
, NULL
);
437 CoReleaseMarshalData(curClass
->pMarshaledData
);
438 IStream_Release(curClass
->pMarshaledData
);
441 HeapFree(GetProcessHeap(), 0, curClass
);
444 static void COM_RevokeAllClasses(const struct apartment
*apt
)
446 RegisteredClass
*curClass
, *cursor
;
448 EnterCriticalSection( &csRegisteredClassList
);
450 LIST_FOR_EACH_ENTRY_SAFE(curClass
, cursor
, &RegisteredClassList
, RegisteredClass
, entry
)
452 if (curClass
->apartment_id
== apt
->oxid
)
453 COM_RevokeRegisteredClassObject(curClass
);
456 LeaveCriticalSection( &csRegisteredClassList
);
459 /***********************************************************************
460 * CoRevokeClassObject [OLE32.@]
462 * Removes a class object from the class registry.
465 * dwRegister [I] Cookie returned from CoRegisterClassObject().
469 * Failure: HRESULT code.
472 * Must be called from the same apartment that called CoRegisterClassObject(),
473 * otherwise it will fail with RPC_E_WRONG_THREAD.
476 * CoRegisterClassObject
478 HRESULT WINAPI
CoRevokeClassObject(
481 HRESULT hr
= E_INVALIDARG
;
482 RegisteredClass
*curClass
;
485 TRACE("(%08x)\n",dwRegister
);
487 apt
= COM_CurrentApt();
490 ERR("COM was not initialized\n");
491 return CO_E_NOTINITIALIZED
;
494 EnterCriticalSection( &csRegisteredClassList
);
496 LIST_FOR_EACH_ENTRY(curClass
, &RegisteredClassList
, RegisteredClass
, entry
)
499 * Check if we have a match on the cookie.
501 if (curClass
->dwCookie
== dwRegister
)
503 if (curClass
->apartment_id
== apt
->oxid
)
505 COM_RevokeRegisteredClassObject(curClass
);
510 ERR("called from wrong apartment, should be called from %s\n",
511 wine_dbgstr_longlong(curClass
->apartment_id
));
512 hr
= RPC_E_WRONG_THREAD
;
518 LeaveCriticalSection( &csRegisteredClassList
);
523 /* frees unused libraries loaded by apartment_getclassobject by calling the
524 * DLL's DllCanUnloadNow entry point */
525 static void apartment_freeunusedlibraries(struct apartment
*apt
, DWORD delay
)
527 struct apartment_loaded_dll
*entry
, *next
;
528 EnterCriticalSection(&apt
->cs
);
529 LIST_FOR_EACH_ENTRY_SAFE(entry
, next
, &apt
->loaded_dlls
, struct apartment_loaded_dll
, entry
)
531 if (entry
->dll
->DllCanUnloadNow
&& (entry
->dll
->DllCanUnloadNow() == S_OK
))
533 DWORD real_delay
= delay
;
535 if (real_delay
== INFINITE
)
537 /* DLLs that return multi-threaded objects aren't unloaded
538 * straight away to cope for programs that have races between
539 * last object destruction and threads in the DLLs that haven't
540 * finished, despite DllCanUnloadNow returning S_OK */
541 if (entry
->multi_threaded
)
542 real_delay
= 10 * 60 * 1000; /* 10 minutes */
547 if (!real_delay
|| (entry
->unload_time
&& (entry
->unload_time
< GetTickCount())))
549 list_remove(&entry
->entry
);
550 COMPOBJ_DllList_ReleaseRef(entry
->dll
, TRUE
);
551 HeapFree(GetProcessHeap(), 0, entry
);
554 entry
->unload_time
= GetTickCount() + real_delay
;
556 else if (entry
->unload_time
)
557 entry
->unload_time
= 0;
559 LeaveCriticalSection(&apt
->cs
);
562 DWORD
apartment_release(struct apartment
*apt
)
566 EnterCriticalSection(&csApartment
);
568 ret
= InterlockedDecrement(&apt
->refs
);
569 TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt
->oxid
), ret
);
570 /* destruction stuff that needs to happen under csApartment CS */
573 if (apt
== MTA
) MTA
= NULL
;
574 else if (apt
== MainApartment
) MainApartment
= NULL
;
575 list_remove(&apt
->entry
);
578 LeaveCriticalSection(&csApartment
);
582 struct list
*cursor
, *cursor2
;
584 TRACE("destroying apartment %p, oxid %s\n", apt
, wine_dbgstr_longlong(apt
->oxid
));
586 /* Release the references to the registered class objects */
587 COM_RevokeAllClasses(apt
);
589 /* no locking is needed for this apartment, because no other thread
590 * can access it at this point */
592 apartment_disconnectproxies(apt
);
594 if (apt
->win
) DestroyWindow(apt
->win
);
595 if (apt
->host_apt_tid
) PostThreadMessageW(apt
->host_apt_tid
, WM_QUIT
, 0, 0);
597 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &apt
->stubmgrs
)
599 struct stub_manager
*stubmgr
= LIST_ENTRY(cursor
, struct stub_manager
, entry
);
600 /* release the implicit reference given by the fact that the
601 * stub has external references (it must do since it is in the
602 * stub manager list in the apartment and all non-apartment users
603 * must have a ref on the apartment and so it cannot be destroyed).
605 stub_manager_int_release(stubmgr
);
608 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &apt
->psclsids
)
610 struct registered_psclsid
*registered_psclsid
=
611 LIST_ENTRY(cursor
, struct registered_psclsid
, entry
);
613 list_remove(®istered_psclsid
->entry
);
614 HeapFree(GetProcessHeap(), 0, registered_psclsid
);
617 /* if this assert fires, then another thread took a reference to a
618 * stub manager without taking a reference to the containing
619 * apartment, which it must do. */
620 assert(list_empty(&apt
->stubmgrs
));
622 if (apt
->filter
) IUnknown_Release(apt
->filter
);
624 /* free as many unused libraries as possible... */
625 apartment_freeunusedlibraries(apt
, 0);
627 /* ... and free the memory for the apartment loaded dll entry and
628 * release the dll list reference without freeing the library for the
630 while ((cursor
= list_head(&apt
->loaded_dlls
)))
632 struct apartment_loaded_dll
*apartment_loaded_dll
= LIST_ENTRY(cursor
, struct apartment_loaded_dll
, entry
);
633 COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll
->dll
, FALSE
);
635 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll
);
638 DEBUG_CLEAR_CRITSEC_NAME(&apt
->cs
);
639 DeleteCriticalSection(&apt
->cs
);
641 HeapFree(GetProcessHeap(), 0, apt
);
647 /* The given OXID must be local to this process:
649 * The ref parameter is here mostly to ensure people remember that
650 * they get one, you should normally take a ref for thread safety.
652 APARTMENT
*apartment_findfromoxid(OXID oxid
, BOOL ref
)
654 APARTMENT
*result
= NULL
;
657 EnterCriticalSection(&csApartment
);
658 LIST_FOR_EACH( cursor
, &apts
)
660 struct apartment
*apt
= LIST_ENTRY( cursor
, struct apartment
, entry
);
661 if (apt
->oxid
== oxid
)
664 if (ref
) apartment_addref(result
);
668 LeaveCriticalSection(&csApartment
);
673 /* gets the apartment which has a given creator thread ID. The caller must
674 * release the reference from the apartment as soon as the apartment pointer
675 * is no longer required. */
676 APARTMENT
*apartment_findfromtid(DWORD tid
)
678 APARTMENT
*result
= NULL
;
681 EnterCriticalSection(&csApartment
);
682 LIST_FOR_EACH( cursor
, &apts
)
684 struct apartment
*apt
= LIST_ENTRY( cursor
, struct apartment
, entry
);
688 apartment_addref(result
);
692 LeaveCriticalSection(&csApartment
);
697 /* gets the main apartment if it exists. The caller must
698 * release the reference from the apartment as soon as the apartment pointer
699 * is no longer required. */
700 static APARTMENT
*apartment_findmain(void)
704 EnterCriticalSection(&csApartment
);
706 result
= MainApartment
;
707 if (result
) apartment_addref(result
);
709 LeaveCriticalSection(&csApartment
);
714 /* gets the multi-threaded apartment if it exists. The caller must
715 * release the reference from the apartment as soon as the apartment pointer
716 * is no longer required. */
717 static APARTMENT
*apartment_find_multi_threaded(void)
719 APARTMENT
*result
= NULL
;
722 EnterCriticalSection(&csApartment
);
724 LIST_FOR_EACH( cursor
, &apts
)
726 struct apartment
*apt
= LIST_ENTRY( cursor
, struct apartment
, entry
);
727 if (apt
->multi_threaded
)
730 apartment_addref(result
);
735 LeaveCriticalSection(&csApartment
);
739 /* gets the specified class object by loading the appropriate DLL, if
740 * necessary and calls the DllGetClassObject function for the DLL */
741 static HRESULT
apartment_getclassobject(struct apartment
*apt
, LPCWSTR dllpath
,
742 BOOL apartment_threaded
,
743 REFCLSID rclsid
, REFIID riid
, void **ppv
)
745 static const WCHAR wszOle32
[] = {'o','l','e','3','2','.','d','l','l',0};
748 struct apartment_loaded_dll
*apartment_loaded_dll
;
750 if (!strcmpiW(dllpath
, wszOle32
))
752 /* we don't need to control the lifetime of this dll, so use the local
753 * implementation of DllGetClassObject directly */
754 TRACE("calling ole32!DllGetClassObject\n");
755 hr
= DllGetClassObject(rclsid
, riid
, ppv
);
758 ERR("DllGetClassObject returned error 0x%08x\n", hr
);
763 EnterCriticalSection(&apt
->cs
);
765 LIST_FOR_EACH_ENTRY(apartment_loaded_dll
, &apt
->loaded_dlls
, struct apartment_loaded_dll
, entry
)
766 if (!strcmpiW(dllpath
, apartment_loaded_dll
->dll
->library_name
))
768 TRACE("found %s already loaded\n", debugstr_w(dllpath
));
775 apartment_loaded_dll
= HeapAlloc(GetProcessHeap(), 0, sizeof(*apartment_loaded_dll
));
776 if (!apartment_loaded_dll
)
780 apartment_loaded_dll
->unload_time
= 0;
781 apartment_loaded_dll
->multi_threaded
= FALSE
;
782 hr
= COMPOBJ_DllList_Add( dllpath
, &apartment_loaded_dll
->dll
);
784 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll
);
788 TRACE("added new loaded dll %s\n", debugstr_w(dllpath
));
789 list_add_tail(&apt
->loaded_dlls
, &apartment_loaded_dll
->entry
);
793 LeaveCriticalSection(&apt
->cs
);
797 /* one component being multi-threaded overrides any number of
798 * apartment-threaded components */
799 if (!apartment_threaded
)
800 apartment_loaded_dll
->multi_threaded
= TRUE
;
802 TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll
->dll
->DllGetClassObject
);
803 /* OK: get the ClassObject */
804 hr
= apartment_loaded_dll
->dll
->DllGetClassObject(rclsid
, riid
, ppv
);
807 ERR("DllGetClassObject returned error 0x%08x\n", hr
);
813 /***********************************************************************
814 * COM_RegReadPath [internal]
816 * Reads a registry value and expands it when necessary
818 static DWORD
COM_RegReadPath(HKEY hkeyroot
, const WCHAR
*keyname
, const WCHAR
*valuename
, WCHAR
* dst
, DWORD dstlen
)
824 DWORD dwLength
= dstlen
* sizeof(WCHAR
);
826 if((ret
= RegOpenKeyExW(hkeyroot
, keyname
, 0, KEY_READ
, &key
)) == ERROR_SUCCESS
) {
827 if( (ret
= RegQueryValueExW(key
, NULL
, NULL
, &keytype
, (LPBYTE
)src
, &dwLength
)) == ERROR_SUCCESS
) {
828 if (keytype
== REG_EXPAND_SZ
) {
829 if (dstlen
<= ExpandEnvironmentStringsW(src
, dst
, dstlen
)) ret
= ERROR_MORE_DATA
;
831 const WCHAR
*quote_start
;
832 quote_start
= strchrW(src
, '\"');
834 const WCHAR
*quote_end
= strchrW(quote_start
+ 1, '\"');
836 memmove(src
, quote_start
+ 1,
837 (quote_end
- quote_start
- 1) * sizeof(WCHAR
));
838 src
[quote_end
- quote_start
- 1] = '\0';
841 lstrcpynW(dst
, src
, dstlen
);
849 struct host_object_params
852 CLSID clsid
; /* clsid of object to marshal */
853 IID iid
; /* interface to marshal */
854 HANDLE event
; /* event signalling when ready for multi-threaded case */
855 HRESULT hr
; /* result for multi-threaded case */
856 IStream
*stream
; /* stream that the object will be marshaled into */
857 BOOL apartment_threaded
; /* is the component purely apartment-threaded? */
860 static HRESULT
apartment_hostobject(struct apartment
*apt
,
861 const struct host_object_params
*params
)
865 static const LARGE_INTEGER llZero
;
866 WCHAR dllpath
[MAX_PATH
+1];
868 TRACE("clsid %s, iid %s\n", debugstr_guid(¶ms
->clsid
), debugstr_guid(¶ms
->iid
));
870 if (COM_RegReadPath(params
->hkeydll
, NULL
, NULL
, dllpath
, ARRAYSIZE(dllpath
)) != ERROR_SUCCESS
)
872 /* failure: CLSID is not found in registry */
873 WARN("class %s not registered inproc\n", debugstr_guid(¶ms
->clsid
));
874 return REGDB_E_CLASSNOTREG
;
877 hr
= apartment_getclassobject(apt
, dllpath
, params
->apartment_threaded
,
878 ¶ms
->clsid
, ¶ms
->iid
, (void **)&object
);
882 hr
= CoMarshalInterface(params
->stream
, ¶ms
->iid
, object
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
884 IUnknown_Release(object
);
885 IStream_Seek(params
->stream
, llZero
, STREAM_SEEK_SET
, NULL
);
890 static LRESULT CALLBACK
apartment_wndproc(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
895 RPC_ExecuteCall((struct dispatch_params
*)lParam
);
898 return apartment_hostobject(COM_CurrentApt(), (const struct host_object_params
*)lParam
);
900 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
904 struct host_thread_params
906 COINIT threading_model
;
911 /* thread for hosting an object to allow an object to appear to be created in
912 * an apartment with an incompatible threading model */
913 static DWORD CALLBACK
apartment_hostobject_thread(LPVOID p
)
915 struct host_thread_params
*params
= p
;
918 struct apartment
*apt
;
922 hr
= CoInitializeEx(NULL
, params
->threading_model
);
923 if (FAILED(hr
)) return hr
;
925 apt
= COM_CurrentApt();
926 if (params
->threading_model
== COINIT_APARTMENTTHREADED
)
928 apartment_createwindowifneeded(apt
);
929 params
->apartment_hwnd
= apartment_getwindow(apt
);
932 params
->apartment_hwnd
= NULL
;
934 /* force the message queue to be created before signaling parent thread */
935 PeekMessageW(&msg
, NULL
, WM_USER
, WM_USER
, PM_NOREMOVE
);
937 SetEvent(params
->ready_event
);
938 params
= NULL
; /* can't touch params after here as it may be invalid */
940 while (GetMessageW(&msg
, NULL
, 0, 0))
942 if (!msg
.hwnd
&& (msg
.message
== DM_HOSTOBJECT
))
944 struct host_object_params
*obj_params
= (struct host_object_params
*)msg
.lParam
;
945 obj_params
->hr
= apartment_hostobject(apt
, obj_params
);
946 SetEvent(obj_params
->event
);
950 TranslateMessage(&msg
);
951 DispatchMessageW(&msg
);
962 /* finds or creates a host apartment, creates the object inside it and returns
963 * a proxy to it so that the object can be used in the apartment of the
964 * caller of this function */
965 static HRESULT
apartment_hostobject_in_hostapt(
966 struct apartment
*apt
, BOOL multi_threaded
, BOOL main_apartment
,
967 HKEY hkeydll
, REFCLSID rclsid
, REFIID riid
, void **ppv
)
969 struct host_object_params params
;
970 HWND apartment_hwnd
= NULL
;
971 DWORD apartment_tid
= 0;
974 if (!multi_threaded
&& main_apartment
)
976 APARTMENT
*host_apt
= apartment_findmain();
979 apartment_hwnd
= apartment_getwindow(host_apt
);
980 apartment_release(host_apt
);
986 EnterCriticalSection(&apt
->cs
);
988 if (!apt
->host_apt_tid
)
990 struct host_thread_params thread_params
;
994 thread_params
.threading_model
= multi_threaded
? COINIT_MULTITHREADED
: COINIT_APARTMENTTHREADED
;
995 handles
[0] = thread_params
.ready_event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
996 thread_params
.apartment_hwnd
= NULL
;
997 handles
[1] = CreateThread(NULL
, 0, apartment_hostobject_thread
, &thread_params
, 0, &apt
->host_apt_tid
);
1000 CloseHandle(handles
[0]);
1001 LeaveCriticalSection(&apt
->cs
);
1002 return E_OUTOFMEMORY
;
1004 wait_value
= WaitForMultipleObjects(2, handles
, FALSE
, INFINITE
);
1005 CloseHandle(handles
[0]);
1006 CloseHandle(handles
[1]);
1007 if (wait_value
== WAIT_OBJECT_0
)
1008 apt
->host_apt_hwnd
= thread_params
.apartment_hwnd
;
1011 LeaveCriticalSection(&apt
->cs
);
1012 return E_OUTOFMEMORY
;
1016 if (multi_threaded
|| !main_apartment
)
1018 apartment_hwnd
= apt
->host_apt_hwnd
;
1019 apartment_tid
= apt
->host_apt_tid
;
1022 LeaveCriticalSection(&apt
->cs
);
1025 /* another thread may have become the main apartment in the time it took
1026 * us to create the thread for the host apartment */
1027 if (!apartment_hwnd
&& !multi_threaded
&& main_apartment
)
1029 APARTMENT
*host_apt
= apartment_findmain();
1032 apartment_hwnd
= apartment_getwindow(host_apt
);
1033 apartment_release(host_apt
);
1037 params
.hkeydll
= hkeydll
;
1038 params
.clsid
= *rclsid
;
1040 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, ¶ms
.stream
);
1043 params
.apartment_threaded
= !multi_threaded
;
1047 params
.event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1048 if (!PostThreadMessageW(apartment_tid
, DM_HOSTOBJECT
, 0, (LPARAM
)¶ms
))
1052 WaitForSingleObject(params
.event
, INFINITE
);
1055 CloseHandle(params
.event
);
1059 if (!apartment_hwnd
)
1061 ERR("host apartment didn't create window\n");
1065 hr
= SendMessageW(apartment_hwnd
, DM_HOSTOBJECT
, 0, (LPARAM
)¶ms
);
1068 hr
= CoUnmarshalInterface(params
.stream
, riid
, ppv
);
1069 IStream_Release(params
.stream
);
1073 /* create a window for the apartment or return the current one if one has
1074 * already been created */
1075 HRESULT
apartment_createwindowifneeded(struct apartment
*apt
)
1077 if (apt
->multi_threaded
)
1082 HWND hwnd
= CreateWindowW(wszAptWinClass
, NULL
, 0,
1084 HWND_MESSAGE
, 0, hProxyDll
, NULL
);
1087 ERR("CreateWindow failed with error %d\n", GetLastError());
1088 return HRESULT_FROM_WIN32(GetLastError());
1090 if (InterlockedCompareExchangePointer((PVOID
*)&apt
->win
, hwnd
, NULL
))
1091 /* someone beat us to it */
1092 DestroyWindow(hwnd
);
1098 /* retrieves the window for the main- or apartment-threaded apartment */
1099 HWND
apartment_getwindow(const struct apartment
*apt
)
1101 assert(!apt
->multi_threaded
);
1105 void apartment_joinmta(void)
1107 apartment_addref(MTA
);
1108 COM_CurrentInfo()->apt
= MTA
;
1111 static void COMPOBJ_InitProcess( void )
1115 /* Dispatching to the correct thread in an apartment is done through
1116 * window messages rather than RPC transports. When an interface is
1117 * marshalled into another apartment in the same process, a window of the
1118 * following class is created. The *caller* of CoMarshalInterface (i.e., the
1119 * application) is responsible for pumping the message loop in that thread.
1120 * The WM_USER messages which point to the RPCs are then dispatched to
1121 * apartment_wndproc by the user's code from the apartment in which the
1122 * interface was unmarshalled.
1124 memset(&wclass
, 0, sizeof(wclass
));
1125 wclass
.lpfnWndProc
= apartment_wndproc
;
1126 wclass
.hInstance
= hProxyDll
;
1127 wclass
.lpszClassName
= wszAptWinClass
;
1128 RegisterClassW(&wclass
);
1131 static void COMPOBJ_UninitProcess( void )
1133 UnregisterClassW(wszAptWinClass
, hProxyDll
);
1136 static void COM_TlsDestroy(void)
1138 struct oletls
*info
= NtCurrentTeb()->ReservedForOle
;
1141 if (info
->apt
) apartment_release(info
->apt
);
1142 if (info
->errorinfo
) IErrorInfo_Release(info
->errorinfo
);
1143 if (info
->state
) IUnknown_Release(info
->state
);
1144 if (info
->spy
) IUnknown_Release(info
->spy
);
1145 if (info
->context_token
) IObjContext_Release(info
->context_token
);
1146 HeapFree(GetProcessHeap(), 0, info
);
1147 NtCurrentTeb()->ReservedForOle
= NULL
;
1151 /******************************************************************************
1152 * CoBuildVersion [OLE32.@]
1154 * Gets the build version of the DLL.
1159 * Current build version, hiword is majornumber, loword is minornumber
1161 DWORD WINAPI
CoBuildVersion(void)
1163 TRACE("Returning version %d, build %d.\n", rmm
, rup
);
1164 return (rmm
<<16)+rup
;
1167 /******************************************************************************
1168 * CoRegisterInitializeSpy [OLE32.@]
1170 * Add a Spy that watches CoInitializeEx calls
1173 * spy [I] Pointer to IUnknown interface that will be QueryInterface'd.
1174 * cookie [II] cookie receiver
1177 * Success: S_OK if not already initialized, S_FALSE otherwise.
1178 * Failure: HRESULT code.
1183 HRESULT WINAPI
CoRegisterInitializeSpy(IInitializeSpy
*spy
, ULARGE_INTEGER
*cookie
)
1185 struct oletls
*info
= COM_CurrentInfo();
1188 TRACE("(%p, %p)\n", spy
, cookie
);
1190 if (!spy
|| !cookie
|| !info
)
1193 WARN("Could not allocate tls\n");
1194 return E_INVALIDARG
;
1199 FIXME("Already registered?\n");
1200 return E_UNEXPECTED
;
1203 hr
= IUnknown_QueryInterface(spy
, &IID_IInitializeSpy
, (void **) &info
->spy
);
1206 cookie
->QuadPart
= (DWORD_PTR
)spy
;
1212 /******************************************************************************
1213 * CoRevokeInitializeSpy [OLE32.@]
1215 * Remove a spy that previously watched CoInitializeEx calls
1218 * cookie [I] The cookie obtained from a previous CoRegisterInitializeSpy call
1221 * Success: S_OK if a spy is removed
1222 * Failure: E_INVALIDARG
1227 HRESULT WINAPI
CoRevokeInitializeSpy(ULARGE_INTEGER cookie
)
1229 struct oletls
*info
= COM_CurrentInfo();
1230 TRACE("(%s)\n", wine_dbgstr_longlong(cookie
.QuadPart
));
1232 if (!info
|| !info
->spy
|| cookie
.QuadPart
!= (DWORD_PTR
)info
->spy
)
1233 return E_INVALIDARG
;
1235 IUnknown_Release(info
->spy
);
1241 /******************************************************************************
1242 * CoInitialize [OLE32.@]
1244 * Initializes the COM libraries by calling CoInitializeEx with
1245 * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
1248 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1251 * Success: S_OK if not already initialized, S_FALSE otherwise.
1252 * Failure: HRESULT code.
1257 HRESULT WINAPI
CoInitialize(LPVOID lpReserved
)
1260 * Just delegate to the newer method.
1262 return CoInitializeEx(lpReserved
, COINIT_APARTMENTTHREADED
);
1265 /******************************************************************************
1266 * CoInitializeEx [OLE32.@]
1268 * Initializes the COM libraries.
1271 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1272 * dwCoInit [I] One or more flags from the COINIT enumeration. See notes.
1275 * S_OK if successful,
1276 * S_FALSE if this function was called already.
1277 * RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
1282 * The behavior used to set the IMalloc used for memory management is
1284 * The dwCoInit parameter must specify one of the following apartment
1286 *| COINIT_APARTMENTTHREADED - A single-threaded apartment (STA).
1287 *| COINIT_MULTITHREADED - A multi-threaded apartment (MTA).
1288 * The parameter may also specify zero or more of the following flags:
1289 *| COINIT_DISABLE_OLE1DDE - Don't use DDE for OLE1 support.
1290 *| COINIT_SPEED_OVER_MEMORY - Trade memory for speed.
1295 HRESULT WINAPI
CoInitializeEx(LPVOID lpReserved
, DWORD dwCoInit
)
1297 struct oletls
*info
= COM_CurrentInfo();
1301 TRACE("(%p, %x)\n", lpReserved
, (int)dwCoInit
);
1303 if (lpReserved
!=NULL
)
1305 ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved
, (int)dwCoInit
, lpReserved
);
1309 * Check the lock count. If this is the first time going through the initialize
1310 * process, we have to initialize the libraries.
1312 * And crank-up that lock count.
1314 if (InterlockedExchangeAdd(&s_COMLockCount
,1)==0)
1317 * Initialize the various COM libraries and data structures.
1319 TRACE("() - Initializing the COM libraries\n");
1321 /* we may need to defer this until after apartment initialisation */
1322 RunningObjectTableImpl_Initialize();
1326 IInitializeSpy_PreInitialize(info
->spy
, dwCoInit
, info
->inits
);
1328 if (!(apt
= info
->apt
))
1330 apt
= apartment_get_or_create(dwCoInit
);
1331 if (!apt
) return E_OUTOFMEMORY
;
1333 else if (!apartment_is_model(apt
, dwCoInit
))
1335 /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
1336 code then we are probably using the wrong threading model to implement that API. */
1337 ERR("Attempt to change threading model of this apartment from %s to %s\n",
1338 apt
->multi_threaded
? "multi-threaded" : "apartment threaded",
1339 dwCoInit
& COINIT_APARTMENTTHREADED
? "apartment threaded" : "multi-threaded");
1340 return RPC_E_CHANGED_MODE
;
1348 IInitializeSpy_PostInitialize(info
->spy
, hr
, dwCoInit
, info
->inits
);
1353 /***********************************************************************
1354 * CoUninitialize [OLE32.@]
1356 * This method will decrement the refcount on the current apartment, freeing
1357 * the resources associated with it if it is the last thread in the apartment.
1358 * If the last apartment is freed, the function will additionally release
1359 * any COM resources associated with the process.
1369 void WINAPI
CoUninitialize(void)
1371 struct oletls
* info
= COM_CurrentInfo();
1376 /* will only happen on OOM */
1380 IInitializeSpy_PreUninitialize(info
->spy
, info
->inits
);
1385 ERR("Mismatched CoUninitialize\n");
1388 IInitializeSpy_PostUninitialize(info
->spy
, info
->inits
);
1394 apartment_release(info
->apt
);
1399 * Decrease the reference count.
1400 * If we are back to 0 locks on the COM library, make sure we free
1401 * all the associated data structures.
1403 lCOMRefCnt
= InterlockedExchangeAdd(&s_COMLockCount
,-1);
1406 TRACE("() - Releasing the COM libraries\n");
1408 RunningObjectTableImpl_UnInitialize();
1410 else if (lCOMRefCnt
<1) {
1411 ERR( "CoUninitialize() - not CoInitialized.\n" );
1412 InterlockedExchangeAdd(&s_COMLockCount
,1); /* restore the lock count. */
1415 IInitializeSpy_PostUninitialize(info
->spy
, info
->inits
);
1418 /******************************************************************************
1419 * CoDisconnectObject [OLE32.@]
1421 * Disconnects all connections to this object from remote processes. Dispatches
1422 * pending RPCs while blocking new RPCs from occurring, and then calls
1423 * IMarshal::DisconnectObject on the given object.
1425 * Typically called when the object server is forced to shut down, for instance by
1429 * lpUnk [I] The object whose stub should be disconnected.
1430 * reserved [I] Reserved. Should be set to 0.
1434 * Failure: HRESULT code.
1437 * CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
1439 HRESULT WINAPI
CoDisconnectObject( LPUNKNOWN lpUnk
, DWORD reserved
)
1445 TRACE("(%p, 0x%08x)\n", lpUnk
, reserved
);
1447 hr
= IUnknown_QueryInterface(lpUnk
, &IID_IMarshal
, (void **)&marshal
);
1450 hr
= IMarshal_DisconnectObject(marshal
, reserved
);
1451 IMarshal_Release(marshal
);
1455 apt
= COM_CurrentApt();
1457 return CO_E_NOTINITIALIZED
;
1459 apartment_disconnectobject(apt
, lpUnk
);
1461 /* Note: native is pretty broken here because it just silently
1462 * fails, without returning an appropriate error code if the object was
1463 * not found, making apps think that the object was disconnected, when
1464 * it actually wasn't */
1469 /******************************************************************************
1470 * CoCreateGuid [OLE32.@]
1472 * Simply forwards to UuidCreate in RPCRT4.
1475 * pguid [O] Points to the GUID to initialize.
1479 * Failure: HRESULT code.
1484 HRESULT WINAPI
CoCreateGuid(GUID
*pguid
)
1486 DWORD status
= UuidCreate(pguid
);
1487 if (status
== RPC_S_OK
|| status
== RPC_S_UUID_LOCAL_ONLY
) return S_OK
;
1488 return HRESULT_FROM_WIN32( status
);
1491 /******************************************************************************
1492 * CLSIDFromString [OLE32.@]
1493 * IIDFromString [OLE32.@]
1495 * Converts a unique identifier from its string representation into
1499 * idstr [I] The string representation of the GUID.
1500 * id [O] GUID converted from the string.
1504 * CO_E_CLASSSTRING if idstr is not a valid CLSID
1509 static HRESULT
__CLSIDFromString(LPCWSTR s
, CLSID
*id
)
1515 memset( id
, 0, sizeof (CLSID
) );
1519 /* validate the CLSID string */
1520 if (strlenW(s
) != 38)
1521 return CO_E_CLASSSTRING
;
1523 if ((s
[0]!='{') || (s
[9]!='-') || (s
[14]!='-') || (s
[19]!='-') || (s
[24]!='-') || (s
[37]!='}'))
1524 return CO_E_CLASSSTRING
;
1526 for (i
=1; i
<37; i
++) {
1527 if ((i
== 9)||(i
== 14)||(i
== 19)||(i
== 24)) continue;
1528 if (!(((s
[i
] >= '0') && (s
[i
] <= '9')) ||
1529 ((s
[i
] >= 'a') && (s
[i
] <= 'f')) ||
1530 ((s
[i
] >= 'A') && (s
[i
] <= 'F'))))
1531 return CO_E_CLASSSTRING
;
1534 TRACE("%s -> %p\n", debugstr_w(s
), id
);
1536 /* quick lookup table */
1537 memset(table
, 0, 256);
1539 for (i
= 0; i
< 10; i
++) {
1542 for (i
= 0; i
< 6; i
++) {
1543 table
['A' + i
] = i
+10;
1544 table
['a' + i
] = i
+10;
1547 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
1549 id
->Data1
= (table
[s
[1]] << 28 | table
[s
[2]] << 24 | table
[s
[3]] << 20 | table
[s
[4]] << 16 |
1550 table
[s
[5]] << 12 | table
[s
[6]] << 8 | table
[s
[7]] << 4 | table
[s
[8]]);
1551 id
->Data2
= table
[s
[10]] << 12 | table
[s
[11]] << 8 | table
[s
[12]] << 4 | table
[s
[13]];
1552 id
->Data3
= table
[s
[15]] << 12 | table
[s
[16]] << 8 | table
[s
[17]] << 4 | table
[s
[18]];
1554 /* these are just sequential bytes */
1555 id
->Data4
[0] = table
[s
[20]] << 4 | table
[s
[21]];
1556 id
->Data4
[1] = table
[s
[22]] << 4 | table
[s
[23]];
1557 id
->Data4
[2] = table
[s
[25]] << 4 | table
[s
[26]];
1558 id
->Data4
[3] = table
[s
[27]] << 4 | table
[s
[28]];
1559 id
->Data4
[4] = table
[s
[29]] << 4 | table
[s
[30]];
1560 id
->Data4
[5] = table
[s
[31]] << 4 | table
[s
[32]];
1561 id
->Data4
[6] = table
[s
[33]] << 4 | table
[s
[34]];
1562 id
->Data4
[7] = table
[s
[35]] << 4 | table
[s
[36]];
1567 /*****************************************************************************/
1569 HRESULT WINAPI
CLSIDFromString(LPOLESTR idstr
, CLSID
*id
)
1574 return E_INVALIDARG
;
1576 ret
= __CLSIDFromString(idstr
, id
);
1577 if(ret
!= S_OK
) { /* It appears a ProgID is also valid */
1578 ret
= CLSIDFromProgID(idstr
, id
);
1584 /******************************************************************************
1585 * StringFromCLSID [OLE32.@]
1586 * StringFromIID [OLE32.@]
1588 * Converts a GUID into the respective string representation.
1589 * The target string is allocated using the OLE IMalloc.
1592 * id [I] the GUID to be converted.
1593 * idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
1600 * StringFromGUID2, CLSIDFromString
1602 HRESULT WINAPI
StringFromCLSID(REFCLSID id
, LPOLESTR
*idstr
)
1607 if ((ret
= CoGetMalloc(0,&mllc
))) return ret
;
1608 if (!(*idstr
= IMalloc_Alloc( mllc
, CHARS_IN_GUID
* sizeof(WCHAR
) ))) return E_OUTOFMEMORY
;
1609 StringFromGUID2( id
, *idstr
, CHARS_IN_GUID
);
1613 /******************************************************************************
1614 * StringFromGUID2 [OLE32.@]
1616 * Modified version of StringFromCLSID that allows you to specify max
1620 * id [I] GUID to convert to string.
1621 * str [O] Buffer where the result will be stored.
1622 * cmax [I] Size of the buffer in characters.
1625 * Success: The length of the resulting string in characters.
1628 INT WINAPI
StringFromGUID2(REFGUID id
, LPOLESTR str
, INT cmax
)
1630 static const WCHAR formatW
[] = { '{','%','0','8','X','-','%','0','4','X','-',
1631 '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
1632 '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
1633 '%','0','2','X','%','0','2','X','}',0 };
1634 if (!id
|| cmax
< CHARS_IN_GUID
) return 0;
1635 sprintfW( str
, formatW
, id
->Data1
, id
->Data2
, id
->Data3
,
1636 id
->Data4
[0], id
->Data4
[1], id
->Data4
[2], id
->Data4
[3],
1637 id
->Data4
[4], id
->Data4
[5], id
->Data4
[6], id
->Data4
[7] );
1638 return CHARS_IN_GUID
;
1641 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
1642 HRESULT
COM_OpenKeyForCLSID(REFCLSID clsid
, LPCWSTR keyname
, REGSAM access
, HKEY
*subkey
)
1644 static const WCHAR wszCLSIDSlash
[] = {'C','L','S','I','D','\\',0};
1645 WCHAR path
[CHARS_IN_GUID
+ ARRAYSIZE(wszCLSIDSlash
) - 1];
1649 strcpyW(path
, wszCLSIDSlash
);
1650 StringFromGUID2(clsid
, path
+ strlenW(wszCLSIDSlash
), CHARS_IN_GUID
);
1651 res
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, path
, 0, keyname
? KEY_READ
: access
, &key
);
1652 if (res
== ERROR_FILE_NOT_FOUND
)
1653 return REGDB_E_CLASSNOTREG
;
1654 else if (res
!= ERROR_SUCCESS
)
1655 return REGDB_E_READREGDB
;
1663 res
= RegOpenKeyExW(key
, keyname
, 0, access
, subkey
);
1665 if (res
== ERROR_FILE_NOT_FOUND
)
1666 return REGDB_E_KEYMISSING
;
1667 else if (res
!= ERROR_SUCCESS
)
1668 return REGDB_E_READREGDB
;
1673 /* open HKCR\\AppId\\{string form of appid clsid} key */
1674 HRESULT
COM_OpenKeyForAppIdFromCLSID(REFCLSID clsid
, REGSAM access
, HKEY
*subkey
)
1676 static const WCHAR szAppId
[] = { 'A','p','p','I','d',0 };
1677 static const WCHAR szAppIdKey
[] = { 'A','p','p','I','d','\\',0 };
1679 WCHAR buf
[CHARS_IN_GUID
];
1680 WCHAR keyname
[ARRAYSIZE(szAppIdKey
) + CHARS_IN_GUID
];
1686 /* read the AppID value under the class's key */
1687 hr
= COM_OpenKeyForCLSID(clsid
, NULL
, KEY_READ
, &hkey
);
1692 res
= RegQueryValueExW(hkey
, szAppId
, NULL
, &type
, (LPBYTE
)buf
, &size
);
1694 if (res
== ERROR_FILE_NOT_FOUND
)
1695 return REGDB_E_KEYMISSING
;
1696 else if (res
!= ERROR_SUCCESS
|| type
!=REG_SZ
)
1697 return REGDB_E_READREGDB
;
1699 strcpyW(keyname
, szAppIdKey
);
1700 strcatW(keyname
, buf
);
1701 res
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, keyname
, 0, access
, subkey
);
1702 if (res
== ERROR_FILE_NOT_FOUND
)
1703 return REGDB_E_KEYMISSING
;
1704 else if (res
!= ERROR_SUCCESS
)
1705 return REGDB_E_READREGDB
;
1710 /******************************************************************************
1711 * ProgIDFromCLSID [OLE32.@]
1713 * Converts a class id into the respective program ID.
1716 * clsid [I] Class ID, as found in registry.
1717 * ppszProgID [O] Associated ProgID.
1722 * REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
1724 HRESULT WINAPI
ProgIDFromCLSID(REFCLSID clsid
, LPOLESTR
*ppszProgID
)
1726 static const WCHAR wszProgID
[] = {'P','r','o','g','I','D',0};
1733 ERR("ppszProgId isn't optional\n");
1734 return E_INVALIDARG
;
1738 ret
= COM_OpenKeyForCLSID(clsid
, wszProgID
, KEY_READ
, &hkey
);
1742 if (RegQueryValueW(hkey
, NULL
, NULL
, &progidlen
))
1743 ret
= REGDB_E_CLASSNOTREG
;
1747 *ppszProgID
= CoTaskMemAlloc(progidlen
* sizeof(WCHAR
));
1750 if (RegQueryValueW(hkey
, NULL
, *ppszProgID
, &progidlen
))
1751 ret
= REGDB_E_CLASSNOTREG
;
1754 ret
= E_OUTOFMEMORY
;
1761 /******************************************************************************
1762 * CLSIDFromProgID [OLE32.@]
1764 * Converts a program id into the respective GUID.
1767 * progid [I] Unicode program ID, as found in registry.
1768 * clsid [O] Associated CLSID.
1772 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
1774 HRESULT WINAPI
CLSIDFromProgID(LPCOLESTR progid
, LPCLSID clsid
)
1776 static const WCHAR clsidW
[] = { '\\','C','L','S','I','D',0 };
1777 WCHAR buf2
[CHARS_IN_GUID
];
1778 LONG buf2len
= sizeof(buf2
);
1782 if (!progid
|| !clsid
)
1784 ERR("neither progid (%p) nor clsid (%p) are optional\n", progid
, clsid
);
1785 return E_INVALIDARG
;
1788 /* initialise clsid in case of failure */
1789 memset(clsid
, 0, sizeof(*clsid
));
1791 buf
= HeapAlloc( GetProcessHeap(),0,(strlenW(progid
)+8) * sizeof(WCHAR
) );
1792 strcpyW( buf
, progid
);
1793 strcatW( buf
, clsidW
);
1794 if (RegOpenKeyW(HKEY_CLASSES_ROOT
,buf
,&xhkey
))
1796 HeapFree(GetProcessHeap(),0,buf
);
1797 WARN("couldn't open key for ProgID %s\n", debugstr_w(progid
));
1798 return CO_E_CLASSSTRING
;
1800 HeapFree(GetProcessHeap(),0,buf
);
1802 if (RegQueryValueW(xhkey
,NULL
,buf2
,&buf2len
))
1805 WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid
));
1806 return CO_E_CLASSSTRING
;
1809 return __CLSIDFromString(buf2
,clsid
);
1813 /*****************************************************************************
1814 * CoGetPSClsid [OLE32.@]
1816 * Retrieves the CLSID of the proxy/stub factory that implements
1817 * IPSFactoryBuffer for the specified interface.
1820 * riid [I] Interface whose proxy/stub CLSID is to be returned.
1821 * pclsid [O] Where to store returned proxy/stub CLSID.
1826 * REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
1830 * The standard marshaller activates the object with the CLSID
1831 * returned and uses the CreateProxy and CreateStub methods on its
1832 * IPSFactoryBuffer interface to construct the proxies and stubs for a
1835 * CoGetPSClsid determines this CLSID by searching the
1836 * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
1837 * in the registry and any interface id registered by
1838 * CoRegisterPSClsid within the current process.
1842 * Native returns S_OK for interfaces with a key in HKCR\Interface, but
1843 * without a ProxyStubClsid32 key and leaves garbage in pclsid. This should be
1844 * considered a bug in native unless an application depends on this (unlikely).
1847 * CoRegisterPSClsid.
1849 HRESULT WINAPI
CoGetPSClsid(REFIID riid
, CLSID
*pclsid
)
1851 static const WCHAR wszInterface
[] = {'I','n','t','e','r','f','a','c','e','\\',0};
1852 static const WCHAR wszPSC
[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
1853 WCHAR path
[ARRAYSIZE(wszInterface
) - 1 + CHARS_IN_GUID
- 1 + ARRAYSIZE(wszPSC
)];
1854 WCHAR value
[CHARS_IN_GUID
];
1857 APARTMENT
*apt
= COM_CurrentApt();
1858 struct registered_psclsid
*registered_psclsid
;
1860 TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid
), pclsid
);
1864 ERR("apartment not initialised\n");
1865 return CO_E_NOTINITIALIZED
;
1870 ERR("pclsid isn't optional\n");
1871 return E_INVALIDARG
;
1874 EnterCriticalSection(&apt
->cs
);
1876 LIST_FOR_EACH_ENTRY(registered_psclsid
, &apt
->psclsids
, struct registered_psclsid
, entry
)
1877 if (IsEqualIID(®istered_psclsid
->iid
, riid
))
1879 *pclsid
= registered_psclsid
->clsid
;
1880 LeaveCriticalSection(&apt
->cs
);
1884 LeaveCriticalSection(&apt
->cs
);
1886 /* Interface\\{string form of riid}\\ProxyStubClsid32 */
1887 strcpyW(path
, wszInterface
);
1888 StringFromGUID2(riid
, path
+ ARRAYSIZE(wszInterface
) - 1, CHARS_IN_GUID
);
1889 strcpyW(path
+ ARRAYSIZE(wszInterface
) - 1 + CHARS_IN_GUID
- 1, wszPSC
);
1891 /* Open the key.. */
1892 if (RegOpenKeyExW(HKEY_CLASSES_ROOT
, path
, 0, KEY_READ
, &hkey
))
1894 WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid
));
1895 return REGDB_E_IIDNOTREG
;
1898 /* ... Once we have the key, query the registry to get the
1899 value of CLSID as a string, and convert it into a
1900 proper CLSID structure to be passed back to the app */
1901 len
= sizeof(value
);
1902 if (ERROR_SUCCESS
!= RegQueryValueW(hkey
, NULL
, value
, &len
))
1905 return REGDB_E_IIDNOTREG
;
1909 /* We have the CLSID we want back from the registry as a string, so
1910 let's convert it into a CLSID structure */
1911 if (CLSIDFromString(value
, pclsid
) != NOERROR
)
1912 return REGDB_E_IIDNOTREG
;
1914 TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid
));
1918 /*****************************************************************************
1919 * CoRegisterPSClsid [OLE32.@]
1921 * Register a proxy/stub CLSID for the given interface in the current process
1925 * riid [I] Interface whose proxy/stub CLSID is to be registered.
1926 * rclsid [I] CLSID of the proxy/stub.
1930 * Failure: E_OUTOFMEMORY
1934 * This function does not add anything to the registry and the effects are
1935 * limited to the lifetime of the current process.
1940 HRESULT WINAPI
CoRegisterPSClsid(REFIID riid
, REFCLSID rclsid
)
1942 APARTMENT
*apt
= COM_CurrentApt();
1943 struct registered_psclsid
*registered_psclsid
;
1945 TRACE("(%s, %s)\n", debugstr_guid(riid
), debugstr_guid(rclsid
));
1949 ERR("apartment not initialised\n");
1950 return CO_E_NOTINITIALIZED
;
1953 EnterCriticalSection(&apt
->cs
);
1955 LIST_FOR_EACH_ENTRY(registered_psclsid
, &apt
->psclsids
, struct registered_psclsid
, entry
)
1956 if (IsEqualIID(®istered_psclsid
->iid
, riid
))
1958 registered_psclsid
->clsid
= *rclsid
;
1959 LeaveCriticalSection(&apt
->cs
);
1963 registered_psclsid
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid
));
1964 if (!registered_psclsid
)
1966 LeaveCriticalSection(&apt
->cs
);
1967 return E_OUTOFMEMORY
;
1970 registered_psclsid
->iid
= *riid
;
1971 registered_psclsid
->clsid
= *rclsid
;
1972 list_add_head(&apt
->psclsids
, ®istered_psclsid
->entry
);
1974 LeaveCriticalSection(&apt
->cs
);
1981 * COM_GetRegisteredClassObject
1983 * This internal method is used to scan the registered class list to
1984 * find a class object.
1987 * rclsid Class ID of the class to find.
1988 * dwClsContext Class context to match.
1989 * ppv [out] returns a pointer to the class object. Complying
1990 * to normal COM usage, this method will increase the
1991 * reference count on this object.
1993 static HRESULT
COM_GetRegisteredClassObject(const struct apartment
*apt
, REFCLSID rclsid
,
1994 DWORD dwClsContext
, LPUNKNOWN
* ppUnk
)
1996 HRESULT hr
= S_FALSE
;
1997 RegisteredClass
*curClass
;
1999 EnterCriticalSection( &csRegisteredClassList
);
2001 LIST_FOR_EACH_ENTRY(curClass
, &RegisteredClassList
, RegisteredClass
, entry
)
2004 * Check if we have a match on the class ID and context.
2006 if ((apt
->oxid
== curClass
->apartment_id
) &&
2007 (dwClsContext
& curClass
->runContext
) &&
2008 IsEqualGUID(&(curClass
->classIdentifier
), rclsid
))
2011 * We have a match, return the pointer to the class object.
2013 *ppUnk
= curClass
->classObject
;
2015 IUnknown_AddRef(curClass
->classObject
);
2022 LeaveCriticalSection( &csRegisteredClassList
);
2027 /******************************************************************************
2028 * CoRegisterClassObject [OLE32.@]
2030 * Registers the class object for a given class ID. Servers housed in EXE
2031 * files use this method instead of exporting DllGetClassObject to allow
2032 * other code to connect to their objects.
2035 * rclsid [I] CLSID of the object to register.
2036 * pUnk [I] IUnknown of the object.
2037 * dwClsContext [I] CLSCTX flags indicating the context in which to run the executable.
2038 * flags [I] REGCLS flags indicating how connections are made.
2039 * lpdwRegister [I] A unique cookie that can be passed to CoRevokeClassObject.
2043 * E_INVALIDARG if lpdwRegister or pUnk are NULL,
2044 * CO_E_OBJISREG if the object is already registered. We should not return this.
2047 * CoRevokeClassObject, CoGetClassObject
2050 * In-process objects are only registered for the current apartment.
2051 * CoGetClassObject() and CoCreateInstance() will not return objects registered
2052 * in other apartments.
2055 * MSDN claims that multiple interface registrations are legal, but we
2056 * can't do that with our current implementation.
2058 HRESULT WINAPI
CoRegisterClassObject(
2063 LPDWORD lpdwRegister
)
2065 RegisteredClass
* newClass
;
2066 LPUNKNOWN foundObject
;
2070 TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
2071 debugstr_guid(rclsid
),pUnk
,dwClsContext
,flags
,lpdwRegister
);
2073 if ( (lpdwRegister
==0) || (pUnk
==0) )
2074 return E_INVALIDARG
;
2076 apt
= COM_CurrentApt();
2079 ERR("COM was not initialized\n");
2080 return CO_E_NOTINITIALIZED
;
2085 /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
2086 * differentiates the flag from REGCLS_MULTI_SEPARATE. */
2087 if (flags
& REGCLS_MULTIPLEUSE
)
2088 dwClsContext
|= CLSCTX_INPROC_SERVER
;
2091 * First, check if the class is already registered.
2092 * If it is, this should cause an error.
2094 hr
= COM_GetRegisteredClassObject(apt
, rclsid
, dwClsContext
, &foundObject
);
2096 if (flags
& REGCLS_MULTIPLEUSE
) {
2097 if (dwClsContext
& CLSCTX_LOCAL_SERVER
)
2098 hr
= CoLockObjectExternal(foundObject
, TRUE
, FALSE
);
2099 IUnknown_Release(foundObject
);
2102 IUnknown_Release(foundObject
);
2103 ERR("object already registered for class %s\n", debugstr_guid(rclsid
));
2104 return CO_E_OBJISREG
;
2107 newClass
= HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass
));
2108 if ( newClass
== NULL
)
2109 return E_OUTOFMEMORY
;
2111 newClass
->classIdentifier
= *rclsid
;
2112 newClass
->apartment_id
= apt
->oxid
;
2113 newClass
->runContext
= dwClsContext
;
2114 newClass
->connectFlags
= flags
;
2115 newClass
->pMarshaledData
= NULL
;
2116 newClass
->RpcRegistration
= NULL
;
2119 * Use the address of the chain node as the cookie since we are sure it's
2120 * unique. FIXME: not on 64-bit platforms.
2122 newClass
->dwCookie
= (DWORD
)newClass
;
2125 * Since we're making a copy of the object pointer, we have to increase its
2128 newClass
->classObject
= pUnk
;
2129 IUnknown_AddRef(newClass
->classObject
);
2131 EnterCriticalSection( &csRegisteredClassList
);
2132 list_add_tail(&RegisteredClassList
, &newClass
->entry
);
2133 LeaveCriticalSection( &csRegisteredClassList
);
2135 *lpdwRegister
= newClass
->dwCookie
;
2137 if (dwClsContext
& CLSCTX_LOCAL_SERVER
) {
2138 hr
= CreateStreamOnHGlobal(0, TRUE
, &newClass
->pMarshaledData
);
2140 FIXME("Failed to create stream on hglobal, %x\n", hr
);
2143 hr
= CoMarshalInterface(newClass
->pMarshaledData
, &IID_IUnknown
,
2144 newClass
->classObject
, MSHCTX_LOCAL
, NULL
,
2145 MSHLFLAGS_TABLESTRONG
);
2147 FIXME("CoMarshalInterface failed, %x!\n",hr
);
2151 hr
= RPC_StartLocalServer(&newClass
->classIdentifier
,
2152 newClass
->pMarshaledData
,
2153 flags
& (REGCLS_MULTIPLEUSE
|REGCLS_MULTI_SEPARATE
),
2154 &newClass
->RpcRegistration
);
2159 static void get_threading_model(HKEY key
, LPWSTR value
, DWORD len
)
2161 static const WCHAR wszThreadingModel
[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
2164 DWORD dwLength
= len
* sizeof(WCHAR
);
2166 ret
= RegQueryValueExW(key
, wszThreadingModel
, NULL
, &keytype
, (LPBYTE
)value
, &dwLength
);
2167 if ((ret
!= ERROR_SUCCESS
) || (keytype
!= REG_SZ
))
2171 static HRESULT
get_inproc_class_object(APARTMENT
*apt
, HKEY hkeydll
,
2172 REFCLSID rclsid
, REFIID riid
,
2173 BOOL hostifnecessary
, void **ppv
)
2175 WCHAR dllpath
[MAX_PATH
+1];
2176 BOOL apartment_threaded
;
2178 if (hostifnecessary
)
2180 static const WCHAR wszApartment
[] = {'A','p','a','r','t','m','e','n','t',0};
2181 static const WCHAR wszFree
[] = {'F','r','e','e',0};
2182 static const WCHAR wszBoth
[] = {'B','o','t','h',0};
2183 WCHAR threading_model
[10 /* strlenW(L"apartment")+1 */];
2185 get_threading_model(hkeydll
, threading_model
, ARRAYSIZE(threading_model
));
2187 if (!strcmpiW(threading_model
, wszApartment
))
2189 apartment_threaded
= TRUE
;
2190 if (apt
->multi_threaded
)
2191 return apartment_hostobject_in_hostapt(apt
, FALSE
, FALSE
, hkeydll
, rclsid
, riid
, ppv
);
2194 else if (!strcmpiW(threading_model
, wszFree
))
2196 apartment_threaded
= FALSE
;
2197 if (!apt
->multi_threaded
)
2198 return apartment_hostobject_in_hostapt(apt
, TRUE
, FALSE
, hkeydll
, rclsid
, riid
, ppv
);
2200 /* everything except "Apartment", "Free" and "Both" */
2201 else if (strcmpiW(threading_model
, wszBoth
))
2203 apartment_threaded
= TRUE
;
2204 /* everything else is main-threaded */
2205 if (threading_model
[0])
2206 FIXME("unrecognised threading model %s for object %s, should be main-threaded?\n",
2207 debugstr_w(threading_model
), debugstr_guid(rclsid
));
2209 if (apt
->multi_threaded
|| !apt
->main
)
2210 return apartment_hostobject_in_hostapt(apt
, FALSE
, TRUE
, hkeydll
, rclsid
, riid
, ppv
);
2213 apartment_threaded
= FALSE
;
2216 apartment_threaded
= !apt
->multi_threaded
;
2218 if (COM_RegReadPath(hkeydll
, NULL
, NULL
, dllpath
, ARRAYSIZE(dllpath
)) != ERROR_SUCCESS
)
2220 /* failure: CLSID is not found in registry */
2221 WARN("class %s not registered inproc\n", debugstr_guid(rclsid
));
2222 return REGDB_E_CLASSNOTREG
;
2225 return apartment_getclassobject(apt
, dllpath
, apartment_threaded
,
2229 /***********************************************************************
2230 * CoGetClassObject [OLE32.@]
2232 * Creates an object of the specified class.
2235 * rclsid [I] Class ID to create an instance of.
2236 * dwClsContext [I] Flags to restrict the location of the created instance.
2237 * pServerInfo [I] Optional. Details for connecting to a remote server.
2238 * iid [I] The ID of the interface of the instance to return.
2239 * ppv [O] On returns, contains a pointer to the specified interface of the object.
2243 * Failure: HRESULT code.
2246 * The dwClsContext parameter can be one or more of the following:
2247 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2248 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2249 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2250 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2253 * CoCreateInstance()
2255 HRESULT WINAPI
CoGetClassObject(
2256 REFCLSID rclsid
, DWORD dwClsContext
, COSERVERINFO
*pServerInfo
,
2257 REFIID iid
, LPVOID
*ppv
)
2259 LPUNKNOWN regClassObject
;
2260 HRESULT hres
= E_UNEXPECTED
;
2262 BOOL release_apt
= FALSE
;
2264 TRACE("CLSID: %s,IID: %s\n", debugstr_guid(rclsid
), debugstr_guid(iid
));
2267 return E_INVALIDARG
;
2271 if (!(apt
= COM_CurrentApt()))
2273 if (!(apt
= apartment_find_multi_threaded()))
2275 ERR("apartment not initialised\n");
2276 return CO_E_NOTINITIALIZED
;
2282 FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
2283 debugstr_w(pServerInfo
->pwszName
), pServerInfo
->pAuthInfo
);
2287 * First, try and see if we can't match the class ID with one of the
2288 * registered classes.
2290 if (S_OK
== COM_GetRegisteredClassObject(apt
, rclsid
, dwClsContext
,
2293 /* Get the required interface from the retrieved pointer. */
2294 hres
= IUnknown_QueryInterface(regClassObject
, iid
, ppv
);
2297 * Since QI got another reference on the pointer, we want to release the
2298 * one we already have. If QI was unsuccessful, this will release the object. This
2299 * is good since we are not returning it in the "out" parameter.
2301 IUnknown_Release(regClassObject
);
2302 if (release_apt
) apartment_release(apt
);
2306 /* First try in-process server */
2307 if (CLSCTX_INPROC_SERVER
& dwClsContext
)
2309 static const WCHAR wszInprocServer32
[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
2312 if (IsEqualCLSID(rclsid
, &CLSID_InProcFreeMarshaler
))
2314 if (release_apt
) apartment_release(apt
);
2315 return FTMarshalCF_Create(iid
, ppv
);
2318 hres
= COM_OpenKeyForCLSID(rclsid
, wszInprocServer32
, KEY_READ
, &hkey
);
2321 if (hres
== REGDB_E_CLASSNOTREG
)
2322 ERR("class %s not registered\n", debugstr_guid(rclsid
));
2323 else if (hres
== REGDB_E_KEYMISSING
)
2325 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid
));
2326 hres
= REGDB_E_CLASSNOTREG
;
2330 if (SUCCEEDED(hres
))
2332 hres
= get_inproc_class_object(apt
, hkey
, rclsid
, iid
,
2333 !(dwClsContext
& WINE_CLSCTX_DONT_HOST
), ppv
);
2337 /* return if we got a class, otherwise fall through to one of the
2339 if (SUCCEEDED(hres
))
2341 if (release_apt
) apartment_release(apt
);
2346 /* Next try in-process handler */
2347 if (CLSCTX_INPROC_HANDLER
& dwClsContext
)
2349 static const WCHAR wszInprocHandler32
[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
2352 hres
= COM_OpenKeyForCLSID(rclsid
, wszInprocHandler32
, KEY_READ
, &hkey
);
2355 if (hres
== REGDB_E_CLASSNOTREG
)
2356 ERR("class %s not registered\n", debugstr_guid(rclsid
));
2357 else if (hres
== REGDB_E_KEYMISSING
)
2359 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid
));
2360 hres
= REGDB_E_CLASSNOTREG
;
2364 if (SUCCEEDED(hres
))
2366 hres
= get_inproc_class_object(apt
, hkey
, rclsid
, iid
,
2367 !(dwClsContext
& WINE_CLSCTX_DONT_HOST
), ppv
);
2371 /* return if we got a class, otherwise fall through to one of the
2373 if (SUCCEEDED(hres
))
2375 if (release_apt
) apartment_release(apt
);
2379 if (release_apt
) apartment_release(apt
);
2381 /* Next try out of process */
2382 if (CLSCTX_LOCAL_SERVER
& dwClsContext
)
2384 hres
= RPC_GetLocalClassObject(rclsid
,iid
,ppv
);
2385 if (SUCCEEDED(hres
))
2389 /* Finally try remote: this requires networked DCOM (a lot of work) */
2390 if (CLSCTX_REMOTE_SERVER
& dwClsContext
)
2392 FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
2393 hres
= REGDB_E_CLASSNOTREG
;
2397 ERR("no class object %s could be created for context 0x%x\n",
2398 debugstr_guid(rclsid
), dwClsContext
);
2402 /***********************************************************************
2403 * CoResumeClassObjects (OLE32.@)
2405 * Resumes all class objects registered with REGCLS_SUSPENDED.
2409 * Failure: HRESULT code.
2411 HRESULT WINAPI
CoResumeClassObjects(void)
2417 /***********************************************************************
2418 * CoCreateInstance [OLE32.@]
2420 * Creates an instance of the specified class.
2423 * rclsid [I] Class ID to create an instance of.
2424 * pUnkOuter [I] Optional outer unknown to allow aggregation with another object.
2425 * dwClsContext [I] Flags to restrict the location of the created instance.
2426 * iid [I] The ID of the interface of the instance to return.
2427 * ppv [O] On returns, contains a pointer to the specified interface of the instance.
2431 * Failure: HRESULT code.
2434 * The dwClsContext parameter can be one or more of the following:
2435 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2436 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2437 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2438 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2440 * Aggregation is the concept of deferring the IUnknown of an object to another
2441 * object. This allows a separate object to behave as though it was part of
2442 * the object and to allow this the pUnkOuter parameter can be set. Note that
2443 * not all objects support having an outer of unknown.
2446 * CoGetClassObject()
2448 HRESULT WINAPI
CoCreateInstance(
2450 LPUNKNOWN pUnkOuter
,
2456 LPCLASSFACTORY lpclf
= 0;
2459 TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid
),
2460 pUnkOuter
, dwClsContext
, debugstr_guid(iid
), ppv
);
2469 * Initialize the "out" parameter
2473 if (!(apt
= COM_CurrentApt()))
2475 if (!(apt
= apartment_find_multi_threaded()))
2477 ERR("apartment not initialised\n");
2478 return CO_E_NOTINITIALIZED
;
2480 apartment_release(apt
);
2484 * The Standard Global Interface Table (GIT) object is a process-wide singleton.
2485 * Rather than create a class factory, we can just check for it here
2487 if (IsEqualIID(rclsid
, &CLSID_StdGlobalInterfaceTable
)) {
2488 if (StdGlobalInterfaceTableInstance
== NULL
)
2489 StdGlobalInterfaceTableInstance
= StdGlobalInterfaceTable_Construct();
2490 hres
= IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable
*) StdGlobalInterfaceTableInstance
, iid
, ppv
);
2491 if (hres
) return hres
;
2493 TRACE("Retrieved GIT (%p)\n", *ppv
);
2498 * Get a class factory to construct the object we want.
2500 hres
= CoGetClassObject(rclsid
,
2510 * Create the object and don't forget to release the factory
2512 hres
= IClassFactory_CreateInstance(lpclf
, pUnkOuter
, iid
, ppv
);
2513 IClassFactory_Release(lpclf
);
2516 if (hres
== CLASS_E_NOAGGREGATION
&& pUnkOuter
)
2517 FIXME("Class %s does not support aggregation\n", debugstr_guid(rclsid
));
2519 FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n", debugstr_guid(iid
), debugstr_guid(rclsid
),hres
);
2525 /***********************************************************************
2526 * CoCreateInstanceEx [OLE32.@]
2528 HRESULT WINAPI
CoCreateInstanceEx(
2530 LPUNKNOWN pUnkOuter
,
2532 COSERVERINFO
* pServerInfo
,
2536 IUnknown
* pUnk
= NULL
;
2539 ULONG successCount
= 0;
2544 if ( (cmq
==0) || (pResults
==NULL
))
2545 return E_INVALIDARG
;
2547 if (pServerInfo
!=NULL
)
2548 FIXME("() non-NULL pServerInfo not supported!\n");
2551 * Initialize all the "out" parameters.
2553 for (index
= 0; index
< cmq
; index
++)
2555 pResults
[index
].pItf
= NULL
;
2556 pResults
[index
].hr
= E_NOINTERFACE
;
2560 * Get the object and get its IUnknown pointer.
2562 hr
= CoCreateInstance(rclsid
,
2572 * Then, query for all the interfaces requested.
2574 for (index
= 0; index
< cmq
; index
++)
2576 pResults
[index
].hr
= IUnknown_QueryInterface(pUnk
,
2577 pResults
[index
].pIID
,
2578 (VOID
**)&(pResults
[index
].pItf
));
2580 if (pResults
[index
].hr
== S_OK
)
2585 * Release our temporary unknown pointer.
2587 IUnknown_Release(pUnk
);
2589 if (successCount
== 0)
2590 return E_NOINTERFACE
;
2592 if (successCount
!=cmq
)
2593 return CO_S_NOTALLINTERFACES
;
2598 /***********************************************************************
2599 * CoLoadLibrary (OLE32.@)
2604 * lpszLibName [I] Path to library.
2605 * bAutoFree [I] Whether the library should automatically be freed.
2608 * Success: Handle to loaded library.
2612 * CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2614 HINSTANCE WINAPI
CoLoadLibrary(LPOLESTR lpszLibName
, BOOL bAutoFree
)
2616 TRACE("(%s, %d)\n", debugstr_w(lpszLibName
), bAutoFree
);
2618 return LoadLibraryExW(lpszLibName
, 0, LOAD_WITH_ALTERED_SEARCH_PATH
);
2621 /***********************************************************************
2622 * CoFreeLibrary [OLE32.@]
2624 * Unloads a library from memory.
2627 * hLibrary [I] Handle to library to unload.
2633 * CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2635 void WINAPI
CoFreeLibrary(HINSTANCE hLibrary
)
2637 FreeLibrary(hLibrary
);
2641 /***********************************************************************
2642 * CoFreeAllLibraries [OLE32.@]
2644 * Function for backwards compatibility only. Does nothing.
2650 * CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
2652 void WINAPI
CoFreeAllLibraries(void)
2657 /***********************************************************************
2658 * CoFreeUnusedLibrariesEx [OLE32.@]
2660 * Frees any previously unused libraries whose delay has expired and marks
2661 * currently unused libraries for unloading. Unused are identified as those that
2662 * return S_OK from their DllCanUnloadNow function.
2665 * dwUnloadDelay [I] Unload delay in milliseconds.
2666 * dwReserved [I] Reserved. Set to 0.
2672 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2674 void WINAPI
CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay
, DWORD dwReserved
)
2676 struct apartment
*apt
= COM_CurrentApt();
2679 ERR("apartment not initialised\n");
2683 apartment_freeunusedlibraries(apt
, dwUnloadDelay
);
2686 /***********************************************************************
2687 * CoFreeUnusedLibraries [OLE32.@]
2689 * Frees any unused libraries. Unused are identified as those that return
2690 * S_OK from their DllCanUnloadNow function.
2696 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2698 void WINAPI
CoFreeUnusedLibraries(void)
2700 CoFreeUnusedLibrariesEx(INFINITE
, 0);
2703 /***********************************************************************
2704 * CoFileTimeNow [OLE32.@]
2706 * Retrieves the current time in FILETIME format.
2709 * lpFileTime [O] The current time.
2714 HRESULT WINAPI
CoFileTimeNow( FILETIME
*lpFileTime
)
2716 GetSystemTimeAsFileTime( lpFileTime
);
2720 /******************************************************************************
2721 * CoLockObjectExternal [OLE32.@]
2723 * Increments or decrements the external reference count of a stub object.
2726 * pUnk [I] Stub object.
2727 * fLock [I] If TRUE then increments the external ref-count,
2728 * otherwise decrements.
2729 * fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2730 * calling CoDisconnectObject.
2734 * Failure: HRESULT code.
2737 * If fLock is TRUE and an object is passed in that doesn't have a stub
2738 * manager then a new stub manager is created for the object.
2740 HRESULT WINAPI
CoLockObjectExternal(
2743 BOOL fLastUnlockReleases
)
2745 struct stub_manager
*stubmgr
;
2746 struct apartment
*apt
;
2748 TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2749 pUnk
, fLock
? "TRUE" : "FALSE", fLastUnlockReleases
? "TRUE" : "FALSE");
2751 apt
= COM_CurrentApt();
2752 if (!apt
) return CO_E_NOTINITIALIZED
;
2754 stubmgr
= get_stub_manager_from_object(apt
, pUnk
);
2759 stub_manager_ext_addref(stubmgr
, 1, FALSE
);
2761 stub_manager_ext_release(stubmgr
, 1, FALSE
, fLastUnlockReleases
);
2763 stub_manager_int_release(stubmgr
);
2769 stubmgr
= new_stub_manager(apt
, pUnk
);
2773 stub_manager_ext_addref(stubmgr
, 1, FALSE
);
2774 stub_manager_int_release(stubmgr
);
2781 WARN("stub object not found %p\n", pUnk
);
2782 /* Note: native is pretty broken here because it just silently
2783 * fails, without returning an appropriate error code, making apps
2784 * think that the object was disconnected, when it actually wasn't */
2789 /***********************************************************************
2790 * CoInitializeWOW (OLE32.@)
2792 * WOW equivalent of CoInitialize?
2801 HRESULT WINAPI
CoInitializeWOW(DWORD x
,DWORD y
)
2803 FIXME("(0x%08x,0x%08x),stub!\n",x
,y
);
2807 /***********************************************************************
2808 * CoGetState [OLE32.@]
2810 * Retrieves the thread state object previously stored by CoSetState().
2813 * ppv [I] Address where pointer to object will be stored.
2817 * Failure: E_OUTOFMEMORY.
2820 * Crashes on all invalid ppv addresses, including NULL.
2821 * If the function returns a non-NULL object then the caller must release its
2822 * reference on the object when the object is no longer required.
2827 HRESULT WINAPI
CoGetState(IUnknown
** ppv
)
2829 struct oletls
*info
= COM_CurrentInfo();
2830 if (!info
) return E_OUTOFMEMORY
;
2836 IUnknown_AddRef(info
->state
);
2838 TRACE("apt->state=%p\n", info
->state
);
2844 /***********************************************************************
2845 * CoSetState [OLE32.@]
2847 * Sets the thread state object.
2850 * pv [I] Pointer to state object to be stored.
2853 * The system keeps a reference on the object while the object stored.
2857 * Failure: E_OUTOFMEMORY.
2859 HRESULT WINAPI
CoSetState(IUnknown
* pv
)
2861 struct oletls
*info
= COM_CurrentInfo();
2862 if (!info
) return E_OUTOFMEMORY
;
2864 if (pv
) IUnknown_AddRef(pv
);
2868 TRACE("-- release %p now\n", info
->state
);
2869 IUnknown_Release(info
->state
);
2878 /******************************************************************************
2879 * CoTreatAsClass [OLE32.@]
2881 * Sets the TreatAs value of a class.
2884 * clsidOld [I] Class to set TreatAs value on.
2885 * clsidNew [I] The class the clsidOld should be treated as.
2889 * Failure: HRESULT code.
2894 HRESULT WINAPI
CoTreatAsClass(REFCLSID clsidOld
, REFCLSID clsidNew
)
2896 static const WCHAR wszAutoTreatAs
[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
2897 static const WCHAR wszTreatAs
[] = {'T','r','e','a','t','A','s',0};
2899 WCHAR szClsidNew
[CHARS_IN_GUID
];
2901 WCHAR auto_treat_as
[CHARS_IN_GUID
];
2902 LONG auto_treat_as_size
= sizeof(auto_treat_as
);
2905 res
= COM_OpenKeyForCLSID(clsidOld
, NULL
, KEY_READ
| KEY_WRITE
, &hkey
);
2908 if (!memcmp( clsidOld
, clsidNew
, sizeof(*clsidOld
) ))
2910 if (!RegQueryValueW(hkey
, wszAutoTreatAs
, auto_treat_as
, &auto_treat_as_size
) &&
2911 CLSIDFromString(auto_treat_as
, &id
) == S_OK
)
2913 if (RegSetValueW(hkey
, wszTreatAs
, REG_SZ
, auto_treat_as
, sizeof(auto_treat_as
)))
2915 res
= REGDB_E_WRITEREGDB
;
2921 RegDeleteKeyW(hkey
, wszTreatAs
);
2925 else if (!StringFromGUID2(clsidNew
, szClsidNew
, ARRAYSIZE(szClsidNew
)) &&
2926 !RegSetValueW(hkey
, wszTreatAs
, REG_SZ
, szClsidNew
, sizeof(szClsidNew
)))
2928 res
= REGDB_E_WRITEREGDB
;
2933 if (hkey
) RegCloseKey(hkey
);
2937 /******************************************************************************
2938 * CoGetTreatAsClass [OLE32.@]
2940 * Gets the TreatAs value of a class.
2943 * clsidOld [I] Class to get the TreatAs value of.
2944 * clsidNew [I] The class the clsidOld should be treated as.
2948 * Failure: HRESULT code.
2953 HRESULT WINAPI
CoGetTreatAsClass(REFCLSID clsidOld
, LPCLSID clsidNew
)
2955 static const WCHAR wszTreatAs
[] = {'T','r','e','a','t','A','s',0};
2957 WCHAR szClsidNew
[CHARS_IN_GUID
];
2959 LONG len
= sizeof(szClsidNew
);
2961 FIXME("(%s,%p)\n", debugstr_guid(clsidOld
), clsidNew
);
2962 *clsidNew
= *clsidOld
; /* copy over old value */
2964 res
= COM_OpenKeyForCLSID(clsidOld
, wszTreatAs
, KEY_READ
, &hkey
);
2970 if (RegQueryValueW(hkey
, NULL
, szClsidNew
, &len
))
2975 res
= CLSIDFromString(szClsidNew
,clsidNew
);
2977 ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew
), res
);
2979 if (hkey
) RegCloseKey(hkey
);
2983 /******************************************************************************
2984 * CoGetCurrentProcess [OLE32.@]
2986 * Gets the current process ID.
2989 * The current process ID.
2992 * Is DWORD really the correct return type for this function?
2994 DWORD WINAPI
CoGetCurrentProcess(void)
2996 return GetCurrentProcessId();
2999 /******************************************************************************
3000 * CoRegisterMessageFilter [OLE32.@]
3002 * Registers a message filter.
3005 * lpMessageFilter [I] Pointer to interface.
3006 * lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
3010 * Failure: HRESULT code.
3013 * Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
3014 * lpMessageFilter removes the message filter.
3016 * If lplpMessageFilter is not NULL the previous message filter will be
3017 * returned in the memory pointer to this parameter and the caller is
3018 * responsible for releasing the object.
3020 * The current thread be in an apartment otherwise the function will crash.
3022 HRESULT WINAPI
CoRegisterMessageFilter(
3023 LPMESSAGEFILTER lpMessageFilter
,
3024 LPMESSAGEFILTER
*lplpMessageFilter
)
3026 struct apartment
*apt
;
3027 IMessageFilter
*lpOldMessageFilter
;
3029 TRACE("(%p, %p)\n", lpMessageFilter
, lplpMessageFilter
);
3031 apt
= COM_CurrentApt();
3033 /* can't set a message filter in a multi-threaded apartment */
3034 if (!apt
|| apt
->multi_threaded
)
3036 WARN("can't set message filter in MTA or uninitialized apt\n");
3037 return CO_E_NOT_SUPPORTED
;
3040 if (lpMessageFilter
)
3041 IMessageFilter_AddRef(lpMessageFilter
);
3043 EnterCriticalSection(&apt
->cs
);
3045 lpOldMessageFilter
= apt
->filter
;
3046 apt
->filter
= lpMessageFilter
;
3048 LeaveCriticalSection(&apt
->cs
);
3050 if (lplpMessageFilter
)
3051 *lplpMessageFilter
= lpOldMessageFilter
;
3052 else if (lpOldMessageFilter
)
3053 IMessageFilter_Release(lpOldMessageFilter
);
3058 /***********************************************************************
3059 * CoIsOle1Class [OLE32.@]
3061 * Determines whether the specified class an OLE v1 class.
3064 * clsid [I] Class to test.
3067 * TRUE if the class is an OLE v1 class, or FALSE otherwise.
3069 BOOL WINAPI
CoIsOle1Class(REFCLSID clsid
)
3071 FIXME("%s\n", debugstr_guid(clsid
));
3075 /***********************************************************************
3076 * IsEqualGUID [OLE32.@]
3078 * Compares two Unique Identifiers.
3081 * rguid1 [I] The first GUID to compare.
3082 * rguid2 [I] The other GUID to compare.
3088 BOOL WINAPI
IsEqualGUID(
3092 return !memcmp(rguid1
,rguid2
,sizeof(GUID
));
3095 /***********************************************************************
3096 * CoInitializeSecurity [OLE32.@]
3098 HRESULT WINAPI
CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc
, LONG cAuthSvc
,
3099 SOLE_AUTHENTICATION_SERVICE
* asAuthSvc
,
3100 void* pReserved1
, DWORD dwAuthnLevel
,
3101 DWORD dwImpLevel
, void* pReserved2
,
3102 DWORD dwCapabilities
, void* pReserved3
)
3104 FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc
, cAuthSvc
,
3105 asAuthSvc
, pReserved1
, dwAuthnLevel
, dwImpLevel
, pReserved2
,
3106 dwCapabilities
, pReserved3
);
3110 /***********************************************************************
3111 * CoSuspendClassObjects [OLE32.@]
3113 * Suspends all registered class objects to prevent further requests coming in
3114 * for those objects.
3118 * Failure: HRESULT code.
3120 HRESULT WINAPI
CoSuspendClassObjects(void)
3126 /***********************************************************************
3127 * CoAddRefServerProcess [OLE32.@]
3129 * Helper function for incrementing the reference count of a local-server
3133 * New reference count.
3136 * CoReleaseServerProcess().
3138 ULONG WINAPI
CoAddRefServerProcess(void)
3144 EnterCriticalSection(&csRegisteredClassList
);
3145 refs
= ++s_COMServerProcessReferences
;
3146 LeaveCriticalSection(&csRegisteredClassList
);
3148 TRACE("refs before: %d\n", refs
- 1);
3153 /***********************************************************************
3154 * CoReleaseServerProcess [OLE32.@]
3156 * Helper function for decrementing the reference count of a local-server
3160 * New reference count.
3163 * When reference count reaches 0, this function suspends all registered
3164 * classes so no new connections are accepted.
3167 * CoAddRefServerProcess(), CoSuspendClassObjects().
3169 ULONG WINAPI
CoReleaseServerProcess(void)
3175 EnterCriticalSection(&csRegisteredClassList
);
3177 refs
= --s_COMServerProcessReferences
;
3178 /* FIXME: if (!refs) COM_SuspendClassObjects(); */
3180 LeaveCriticalSection(&csRegisteredClassList
);
3182 TRACE("refs after: %d\n", refs
);
3187 /***********************************************************************
3188 * CoIsHandlerConnected [OLE32.@]
3190 * Determines whether a proxy is connected to a remote stub.
3193 * pUnk [I] Pointer to object that may or may not be connected.
3196 * TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
3199 BOOL WINAPI
CoIsHandlerConnected(IUnknown
*pUnk
)
3201 FIXME("%p\n", pUnk
);
3206 /***********************************************************************
3207 * CoAllowSetForegroundWindow [OLE32.@]
3210 HRESULT WINAPI
CoAllowSetForegroundWindow(IUnknown
*pUnk
, void *pvReserved
)
3212 FIXME("(%p, %p): stub\n", pUnk
, pvReserved
);
3216 /***********************************************************************
3217 * CoQueryProxyBlanket [OLE32.@]
3219 * Retrieves the security settings being used by a proxy.
3222 * pProxy [I] Pointer to the proxy object.
3223 * pAuthnSvc [O] The type of authentication service.
3224 * pAuthzSvc [O] The type of authorization service.
3225 * ppServerPrincName [O] Optional. The server prinicple name.
3226 * pAuthnLevel [O] The authentication level.
3227 * pImpLevel [O] The impersonation level.
3228 * ppAuthInfo [O] Information specific to the authorization/authentication service.
3229 * pCapabilities [O] Flags affecting the security behaviour.
3233 * Failure: HRESULT code.
3236 * CoCopyProxy, CoSetProxyBlanket.
3238 HRESULT WINAPI
CoQueryProxyBlanket(IUnknown
*pProxy
, DWORD
*pAuthnSvc
,
3239 DWORD
*pAuthzSvc
, OLECHAR
**ppServerPrincName
, DWORD
*pAuthnLevel
,
3240 DWORD
*pImpLevel
, void **ppAuthInfo
, DWORD
*pCapabilities
)
3242 IClientSecurity
*pCliSec
;
3245 TRACE("%p\n", pProxy
);
3247 hr
= IUnknown_QueryInterface(pProxy
, &IID_IClientSecurity
, (void **)&pCliSec
);
3250 hr
= IClientSecurity_QueryBlanket(pCliSec
, pProxy
, pAuthnSvc
,
3251 pAuthzSvc
, ppServerPrincName
,
3252 pAuthnLevel
, pImpLevel
, ppAuthInfo
,
3254 IClientSecurity_Release(pCliSec
);
3257 if (FAILED(hr
)) ERR("-- failed with 0x%08x\n", hr
);
3261 /***********************************************************************
3262 * CoSetProxyBlanket [OLE32.@]
3264 * Sets the security settings for a proxy.
3267 * pProxy [I] Pointer to the proxy object.
3268 * AuthnSvc [I] The type of authentication service.
3269 * AuthzSvc [I] The type of authorization service.
3270 * pServerPrincName [I] The server prinicple name.
3271 * AuthnLevel [I] The authentication level.
3272 * ImpLevel [I] The impersonation level.
3273 * pAuthInfo [I] Information specific to the authorization/authentication service.
3274 * Capabilities [I] Flags affecting the security behaviour.
3278 * Failure: HRESULT code.
3281 * CoQueryProxyBlanket, CoCopyProxy.
3283 HRESULT WINAPI
CoSetProxyBlanket(IUnknown
*pProxy
, DWORD AuthnSvc
,
3284 DWORD AuthzSvc
, OLECHAR
*pServerPrincName
, DWORD AuthnLevel
,
3285 DWORD ImpLevel
, void *pAuthInfo
, DWORD Capabilities
)
3287 IClientSecurity
*pCliSec
;
3290 TRACE("%p\n", pProxy
);
3292 hr
= IUnknown_QueryInterface(pProxy
, &IID_IClientSecurity
, (void **)&pCliSec
);
3295 hr
= IClientSecurity_SetBlanket(pCliSec
, pProxy
, AuthnSvc
,
3296 AuthzSvc
, pServerPrincName
,
3297 AuthnLevel
, ImpLevel
, pAuthInfo
,
3299 IClientSecurity_Release(pCliSec
);
3302 if (FAILED(hr
)) ERR("-- failed with 0x%08x\n", hr
);
3306 /***********************************************************************
3307 * CoCopyProxy [OLE32.@]
3312 * pProxy [I] Pointer to the proxy object.
3313 * ppCopy [O] Copy of the proxy.
3317 * Failure: HRESULT code.
3320 * CoQueryProxyBlanket, CoSetProxyBlanket.
3322 HRESULT WINAPI
CoCopyProxy(IUnknown
*pProxy
, IUnknown
**ppCopy
)
3324 IClientSecurity
*pCliSec
;
3327 TRACE("%p\n", pProxy
);
3329 hr
= IUnknown_QueryInterface(pProxy
, &IID_IClientSecurity
, (void **)&pCliSec
);
3332 hr
= IClientSecurity_CopyProxy(pCliSec
, pProxy
, ppCopy
);
3333 IClientSecurity_Release(pCliSec
);
3336 if (FAILED(hr
)) ERR("-- failed with 0x%08x\n", hr
);
3341 /***********************************************************************
3342 * CoGetCallContext [OLE32.@]
3344 * Gets the context of the currently executing server call in the current
3348 * riid [I] Context interface to return.
3349 * ppv [O] Pointer to memory that will receive the context on return.
3353 * Failure: HRESULT code.
3355 HRESULT WINAPI
CoGetCallContext(REFIID riid
, void **ppv
)
3357 struct oletls
*info
= COM_CurrentInfo();
3359 TRACE("(%s, %p)\n", debugstr_guid(riid
), ppv
);
3362 return E_OUTOFMEMORY
;
3364 if (!info
->call_state
)
3365 return RPC_E_CALL_COMPLETE
;
3367 return IUnknown_QueryInterface(info
->call_state
, riid
, ppv
);
3370 /***********************************************************************
3371 * CoSwitchCallContext [OLE32.@]
3373 * Switches the context of the currently executing server call in the current
3377 * pObject [I] Pointer to new context object
3378 * ppOldObject [O] Pointer to memory that will receive old context object pointer
3382 * Failure: HRESULT code.
3384 HRESULT WINAPI
CoSwitchCallContext(IUnknown
*pObject
, IUnknown
**ppOldObject
)
3386 struct oletls
*info
= COM_CurrentInfo();
3388 TRACE("(%p, %p)\n", pObject
, ppOldObject
);
3391 return E_OUTOFMEMORY
;
3393 *ppOldObject
= info
->call_state
;
3394 info
->call_state
= pObject
; /* CoSwitchCallContext does not addref nor release objects */
3399 /***********************************************************************
3400 * CoQueryClientBlanket [OLE32.@]
3402 * Retrieves the authentication information about the client of the currently
3403 * executing server call in the current thread.
3406 * pAuthnSvc [O] Optional. The type of authentication service.
3407 * pAuthzSvc [O] Optional. The type of authorization service.
3408 * pServerPrincName [O] Optional. The server prinicple name.
3409 * pAuthnLevel [O] Optional. The authentication level.
3410 * pImpLevel [O] Optional. The impersonation level.
3411 * pPrivs [O] Optional. Information about the privileges of the client.
3412 * pCapabilities [IO] Optional. Flags affecting the security behaviour.
3416 * Failure: HRESULT code.
3419 * CoImpersonateClient, CoRevertToSelf, CoGetCallContext.
3421 HRESULT WINAPI
CoQueryClientBlanket(
3424 OLECHAR
**pServerPrincName
,
3427 RPC_AUTHZ_HANDLE
*pPrivs
,
3428 DWORD
*pCapabilities
)
3430 IServerSecurity
*pSrvSec
;
3433 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
3434 pAuthnSvc
, pAuthzSvc
, pServerPrincName
, pAuthnLevel
, pImpLevel
,
3435 pPrivs
, pCapabilities
);
3437 hr
= CoGetCallContext(&IID_IServerSecurity
, (void **)&pSrvSec
);
3440 hr
= IServerSecurity_QueryBlanket(
3441 pSrvSec
, pAuthnSvc
, pAuthzSvc
, pServerPrincName
, pAuthnLevel
,
3442 pImpLevel
, pPrivs
, pCapabilities
);
3443 IServerSecurity_Release(pSrvSec
);
3449 /***********************************************************************
3450 * CoImpersonateClient [OLE32.@]
3452 * Impersonates the client of the currently executing server call in the
3460 * Failure: HRESULT code.
3463 * If this function fails then the current thread will not be impersonating
3464 * the client and all actions will take place on behalf of the server.
3465 * Therefore, it is important to check the return value from this function.
3468 * CoRevertToSelf, CoQueryClientBlanket, CoGetCallContext.
3470 HRESULT WINAPI
CoImpersonateClient(void)
3472 IServerSecurity
*pSrvSec
;
3477 hr
= CoGetCallContext(&IID_IServerSecurity
, (void **)&pSrvSec
);
3480 hr
= IServerSecurity_ImpersonateClient(pSrvSec
);
3481 IServerSecurity_Release(pSrvSec
);
3487 /***********************************************************************
3488 * CoRevertToSelf [OLE32.@]
3490 * Ends the impersonation of the client of the currently executing server
3491 * call in the current thread.
3498 * Failure: HRESULT code.
3501 * CoImpersonateClient, CoQueryClientBlanket, CoGetCallContext.
3503 HRESULT WINAPI
CoRevertToSelf(void)
3505 IServerSecurity
*pSrvSec
;
3510 hr
= CoGetCallContext(&IID_IServerSecurity
, (void **)&pSrvSec
);
3513 hr
= IServerSecurity_RevertToSelf(pSrvSec
);
3514 IServerSecurity_Release(pSrvSec
);
3520 static BOOL
COM_PeekMessage(struct apartment
*apt
, MSG
*msg
)
3522 /* first try to retrieve messages for incoming COM calls to the apartment window */
3523 return PeekMessageW(msg
, apt
->win
, WM_USER
, WM_APP
- 1, PM_REMOVE
|PM_NOYIELD
) ||
3524 /* next retrieve other messages necessary for the app to remain responsive */
3525 PeekMessageW(msg
, NULL
, WM_DDE_FIRST
, WM_DDE_LAST
, PM_REMOVE
|PM_NOYIELD
) ||
3526 PeekMessageW(msg
, NULL
, 0, 0, PM_QS_PAINT
|PM_QS_SENDMESSAGE
|PM_REMOVE
|PM_NOYIELD
);
3529 /***********************************************************************
3530 * CoWaitForMultipleHandles [OLE32.@]
3532 * Waits for one or more handles to become signaled.
3535 * dwFlags [I] Flags. See notes.
3536 * dwTimeout [I] Timeout in milliseconds.
3537 * cHandles [I] Number of handles pointed to by pHandles.
3538 * pHandles [I] Handles to wait for.
3539 * lpdwindex [O] Index of handle that was signaled.
3543 * Failure: RPC_S_CALLPENDING on timeout.
3547 * The dwFlags parameter can be zero or more of the following:
3548 *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
3549 *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
3552 * MsgWaitForMultipleObjects, WaitForMultipleObjects.
3554 HRESULT WINAPI
CoWaitForMultipleHandles(DWORD dwFlags
, DWORD dwTimeout
,
3555 ULONG cHandles
, LPHANDLE pHandles
, LPDWORD lpdwindex
)
3558 DWORD start_time
= GetTickCount();
3559 APARTMENT
*apt
= COM_CurrentApt();
3560 BOOL message_loop
= apt
&& !apt
->multi_threaded
;
3562 TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags
, dwTimeout
, cHandles
,
3563 pHandles
, lpdwindex
);
3567 DWORD now
= GetTickCount();
3570 if (now
- start_time
> dwTimeout
)
3572 hr
= RPC_S_CALLPENDING
;
3578 DWORD wait_flags
= ((dwFlags
& COWAIT_WAITALL
) ? MWMO_WAITALL
: 0) |
3579 ((dwFlags
& COWAIT_ALERTABLE
) ? MWMO_ALERTABLE
: 0);
3581 TRACE("waiting for rpc completion or window message\n");
3583 res
= MsgWaitForMultipleObjectsEx(cHandles
, pHandles
,
3584 (dwTimeout
== INFINITE
) ? INFINITE
: start_time
+ dwTimeout
- now
,
3585 QS_ALLINPUT
, wait_flags
);
3587 if (res
== WAIT_OBJECT_0
+ cHandles
) /* messages available */
3591 /* call message filter */
3593 if (COM_CurrentApt()->filter
)
3595 PENDINGTYPE pendingtype
=
3596 COM_CurrentInfo()->pending_call_count_server
?
3597 PENDINGTYPE_NESTED
: PENDINGTYPE_TOPLEVEL
;
3598 DWORD be_handled
= IMessageFilter_MessagePending(
3599 COM_CurrentApt()->filter
, 0 /* FIXME */,
3600 now
- start_time
, pendingtype
);
3601 TRACE("IMessageFilter_MessagePending returned %d\n", be_handled
);
3604 case PENDINGMSG_CANCELCALL
:
3605 WARN("call canceled\n");
3606 hr
= RPC_E_CALL_CANCELED
;
3608 case PENDINGMSG_WAITNOPROCESS
:
3609 case PENDINGMSG_WAITDEFPROCESS
:
3611 /* FIXME: MSDN is very vague about the difference
3612 * between WAITNOPROCESS and WAITDEFPROCESS - there
3613 * appears to be none, so it is possibly a left-over
3614 * from the 16-bit world. */
3619 /* note: using "if" here instead of "while" might seem less
3620 * efficient, but only if we are optimising for quick delivery
3621 * of pending messages, rather than quick completion of the
3623 if (COM_PeekMessage(apt
, &msg
))
3625 TRACE("received message whilst waiting for RPC: 0x%04x\n", msg
.message
);
3626 TranslateMessage(&msg
);
3627 DispatchMessageW(&msg
);
3628 if (msg
.message
== WM_QUIT
)
3630 TRACE("resending WM_QUIT to outer message loop\n");
3631 PostQuitMessage(msg
.wParam
);
3632 /* no longer need to process messages */
3633 message_loop
= FALSE
;
3641 TRACE("waiting for rpc completion\n");
3643 res
= WaitForMultipleObjectsEx(cHandles
, pHandles
,
3644 (dwFlags
& COWAIT_WAITALL
) ? TRUE
: FALSE
,
3645 (dwTimeout
== INFINITE
) ? INFINITE
: start_time
+ dwTimeout
- now
,
3646 (dwFlags
& COWAIT_ALERTABLE
) ? TRUE
: FALSE
);
3649 if (res
< WAIT_OBJECT_0
+ cHandles
)
3651 /* handle signaled, store index */
3652 *lpdwindex
= (res
- WAIT_OBJECT_0
);
3655 else if (res
== WAIT_TIMEOUT
)
3657 hr
= RPC_S_CALLPENDING
;
3662 ERR("Unexpected wait termination: %d, %d\n", res
, GetLastError());
3667 TRACE("-- 0x%08x\n", hr
);
3672 /***********************************************************************
3673 * CoGetObject [OLE32.@]
3675 * Gets the object named by converting the name to a moniker and binding to it.
3678 * pszName [I] String representing the object.
3679 * pBindOptions [I] Parameters affecting the binding to the named object.
3680 * riid [I] Interface to bind to on the objecct.
3681 * ppv [O] On output, the interface riid of the object represented
3686 * Failure: HRESULT code.
3689 * MkParseDisplayName.
3691 HRESULT WINAPI
CoGetObject(LPCWSTR pszName
, BIND_OPTS
*pBindOptions
,
3692 REFIID riid
, void **ppv
)
3699 hr
= CreateBindCtx(0, &pbc
);
3703 hr
= IBindCtx_SetBindOptions(pbc
, pBindOptions
);
3710 hr
= MkParseDisplayName(pbc
, pszName
, &chEaten
, &pmk
);
3713 hr
= IMoniker_BindToObject(pmk
, pbc
, NULL
, riid
, ppv
);
3714 IMoniker_Release(pmk
);
3718 IBindCtx_Release(pbc
);
3723 /***********************************************************************
3724 * CoRegisterChannelHook [OLE32.@]
3726 * Registers a process-wide hook that is called during ORPC calls.
3729 * guidExtension [I] GUID of the channel hook to register.
3730 * pChannelHook [I] Channel hook object to register.
3734 * Failure: HRESULT code.
3736 HRESULT WINAPI
CoRegisterChannelHook(REFGUID guidExtension
, IChannelHook
*pChannelHook
)
3738 TRACE("(%s, %p)\n", debugstr_guid(guidExtension
), pChannelHook
);
3740 return RPC_RegisterChannelHook(guidExtension
, pChannelHook
);
3743 typedef struct Context
3745 const IComThreadingInfoVtbl
*lpVtbl
;
3746 const IContextCallbackVtbl
*lpCallbackVtbl
;
3747 const IObjContextVtbl
*lpContextVtbl
;
3752 static inline Context
*impl_from_IComThreadingInfo( IComThreadingInfo
*iface
)
3754 return (Context
*)((char*)iface
- FIELD_OFFSET(Context
, lpVtbl
));
3757 static inline Context
*impl_from_IContextCallback( IContextCallback
*iface
)
3759 return (Context
*)((char*)iface
- FIELD_OFFSET(Context
, lpCallbackVtbl
));
3762 static inline Context
*impl_from_IObjContext( IObjContext
*iface
)
3764 return (Context
*)((char*)iface
- FIELD_OFFSET(Context
, lpContextVtbl
));
3767 static HRESULT
Context_QueryInterface(Context
*iface
, REFIID riid
, LPVOID
*ppv
)
3771 if (IsEqualIID(riid
, &IID_IComThreadingInfo
) ||
3772 IsEqualIID(riid
, &IID_IUnknown
))
3774 *ppv
= &iface
->lpVtbl
;
3776 else if (IsEqualIID(riid
, &IID_IContextCallback
))
3778 *ppv
= &iface
->lpCallbackVtbl
;
3780 else if (IsEqualIID(riid
, &IID_IObjContext
))
3782 *ppv
= &iface
->lpContextVtbl
;
3787 IUnknown_AddRef((IUnknown
*)*ppv
);
3791 FIXME("interface not implemented %s\n", debugstr_guid(riid
));
3792 return E_NOINTERFACE
;
3795 static ULONG
Context_AddRef(Context
*This
)
3797 return InterlockedIncrement(&This
->refs
);
3800 static ULONG
Context_Release(Context
*This
)
3802 ULONG refs
= InterlockedDecrement(&This
->refs
);
3804 HeapFree(GetProcessHeap(), 0, This
);
3808 static HRESULT WINAPI
Context_CTI_QueryInterface(IComThreadingInfo
*iface
, REFIID riid
, LPVOID
*ppv
)
3810 Context
*This
= impl_from_IComThreadingInfo(iface
);
3811 return Context_QueryInterface(This
, riid
, ppv
);
3814 static ULONG WINAPI
Context_CTI_AddRef(IComThreadingInfo
*iface
)
3816 Context
*This
= impl_from_IComThreadingInfo(iface
);
3817 return Context_AddRef(This
);
3820 static ULONG WINAPI
Context_CTI_Release(IComThreadingInfo
*iface
)
3822 Context
*This
= impl_from_IComThreadingInfo(iface
);
3823 return Context_Release(This
);
3826 static HRESULT WINAPI
Context_CTI_GetCurrentApartmentType(IComThreadingInfo
*iface
, APTTYPE
*apttype
)
3828 Context
*This
= impl_from_IComThreadingInfo(iface
);
3830 TRACE("(%p)\n", apttype
);
3832 *apttype
= This
->apttype
;
3836 static HRESULT WINAPI
Context_CTI_GetCurrentThreadType(IComThreadingInfo
*iface
, THDTYPE
*thdtype
)
3838 Context
*This
= impl_from_IComThreadingInfo(iface
);
3840 TRACE("(%p)\n", thdtype
);
3842 switch (This
->apttype
)
3845 case APTTYPE_MAINSTA
:
3846 *thdtype
= THDTYPE_PROCESSMESSAGES
;
3849 *thdtype
= THDTYPE_BLOCKMESSAGES
;
3855 static HRESULT WINAPI
Context_CTI_GetCurrentLogicalThreadId(IComThreadingInfo
*iface
, GUID
*logical_thread_id
)
3857 FIXME("(%p): stub\n", logical_thread_id
);
3861 static HRESULT WINAPI
Context_CTI_SetCurrentLogicalThreadId(IComThreadingInfo
*iface
, REFGUID logical_thread_id
)
3863 FIXME("(%s): stub\n", debugstr_guid(logical_thread_id
));
3867 static const IComThreadingInfoVtbl Context_Threading_Vtbl
=
3869 Context_CTI_QueryInterface
,
3871 Context_CTI_Release
,
3872 Context_CTI_GetCurrentApartmentType
,
3873 Context_CTI_GetCurrentThreadType
,
3874 Context_CTI_GetCurrentLogicalThreadId
,
3875 Context_CTI_SetCurrentLogicalThreadId
3878 static HRESULT WINAPI
Context_CC_QueryInterface(IContextCallback
*iface
, REFIID riid
, LPVOID
*ppv
)
3880 Context
*This
= impl_from_IContextCallback(iface
);
3881 return Context_QueryInterface(This
, riid
, ppv
);
3884 static ULONG WINAPI
Context_CC_AddRef(IContextCallback
*iface
)
3886 Context
*This
= impl_from_IContextCallback(iface
);
3887 return Context_AddRef(This
);
3890 static ULONG WINAPI
Context_CC_Release(IContextCallback
*iface
)
3892 Context
*This
= impl_from_IContextCallback(iface
);
3893 return Context_Release(This
);
3896 static HRESULT WINAPI
Context_CC_ContextCallback(IContextCallback
*iface
, PFNCONTEXTCALL pCallback
,
3897 ComCallData
*param
, REFIID riid
, int method
, IUnknown
*punk
)
3899 Context
*This
= impl_from_IContextCallback(iface
);
3901 FIXME("(%p/%p)->(%p, %p, %s, %d, %p)\n", This
, iface
, pCallback
, param
, debugstr_guid(riid
), method
, punk
);
3905 static const IContextCallbackVtbl Context_Callback_Vtbl
=
3907 Context_CC_QueryInterface
,
3910 Context_CC_ContextCallback
3913 static HRESULT WINAPI
Context_OC_QueryInterface(IObjContext
*iface
, REFIID riid
, LPVOID
*ppv
)
3915 Context
*This
= impl_from_IObjContext(iface
);
3916 return Context_QueryInterface(This
, riid
, ppv
);
3919 static ULONG WINAPI
Context_OC_AddRef(IObjContext
*iface
)
3921 Context
*This
= impl_from_IObjContext(iface
);
3922 return Context_AddRef(This
);
3925 static ULONG WINAPI
Context_OC_Release(IObjContext
*iface
)
3927 Context
*This
= impl_from_IObjContext(iface
);
3928 return Context_Release(This
);
3931 static HRESULT WINAPI
Context_OC_SetProperty(IObjContext
*iface
, REFGUID propid
, CPFLAGS flags
, IUnknown
*punk
)
3933 Context
*This
= impl_from_IObjContext(iface
);
3935 FIXME("(%p/%p)->(%s, %x, %p)\n", This
, iface
, debugstr_guid(propid
), flags
, punk
);
3939 static HRESULT WINAPI
Context_OC_RemoveProperty(IObjContext
*iface
, REFGUID propid
)
3941 Context
*This
= impl_from_IObjContext(iface
);
3943 FIXME("(%p/%p)->(%s)\n", This
, iface
, debugstr_guid(propid
));
3947 static HRESULT WINAPI
Context_OC_GetProperty(IObjContext
*iface
, REFGUID propid
, CPFLAGS
*flags
, IUnknown
**punk
)
3949 Context
*This
= impl_from_IObjContext(iface
);
3951 FIXME("(%p/%p)->(%s, %p, %p)\n", This
, iface
, debugstr_guid(propid
), flags
, punk
);
3955 static HRESULT WINAPI
Context_OC_EnumContextProps(IObjContext
*iface
, IEnumContextProps
**props
)
3957 Context
*This
= impl_from_IObjContext(iface
);
3959 FIXME("(%p/%p)->(%p)\n", This
, iface
, props
);
3963 static void WINAPI
Context_OC_Reserved1(IObjContext
*iface
)
3965 Context
*This
= impl_from_IObjContext(iface
);
3966 FIXME("(%p/%p)\n", This
, iface
);
3969 static void WINAPI
Context_OC_Reserved2(IObjContext
*iface
)
3971 Context
*This
= impl_from_IObjContext(iface
);
3972 FIXME("(%p/%p)\n", This
, iface
);
3975 static void WINAPI
Context_OC_Reserved3(IObjContext
*iface
)
3977 Context
*This
= impl_from_IObjContext(iface
);
3978 FIXME("(%p/%p)\n", This
, iface
);
3981 static void WINAPI
Context_OC_Reserved4(IObjContext
*iface
)
3983 Context
*This
= impl_from_IObjContext(iface
);
3984 FIXME("(%p/%p)\n", This
, iface
);
3987 static void WINAPI
Context_OC_Reserved5(IObjContext
*iface
)
3989 Context
*This
= impl_from_IObjContext(iface
);
3990 FIXME("(%p/%p)\n", This
, iface
);
3993 static void WINAPI
Context_OC_Reserved6(IObjContext
*iface
)
3995 Context
*This
= impl_from_IObjContext(iface
);
3996 FIXME("(%p/%p)\n", This
, iface
);
3999 static void WINAPI
Context_OC_Reserved7(IObjContext
*iface
)
4001 Context
*This
= impl_from_IObjContext(iface
);
4002 FIXME("(%p/%p)\n", This
, iface
);
4005 static const IObjContextVtbl Context_Object_Vtbl
=
4007 Context_OC_QueryInterface
,
4010 Context_OC_SetProperty
,
4011 Context_OC_RemoveProperty
,
4012 Context_OC_GetProperty
,
4013 Context_OC_EnumContextProps
,
4014 Context_OC_Reserved1
,
4015 Context_OC_Reserved2
,
4016 Context_OC_Reserved3
,
4017 Context_OC_Reserved4
,
4018 Context_OC_Reserved5
,
4019 Context_OC_Reserved6
,
4020 Context_OC_Reserved7
4023 /***********************************************************************
4024 * CoGetObjectContext [OLE32.@]
4026 * Retrieves an object associated with the current context (i.e. apartment).
4029 * riid [I] ID of the interface of the object to retrieve.
4030 * ppv [O] Address where object will be stored on return.
4034 * Failure: HRESULT code.
4036 HRESULT WINAPI
CoGetObjectContext(REFIID riid
, void **ppv
)
4038 APARTMENT
*apt
= COM_CurrentApt();
4042 TRACE("(%s, %p)\n", debugstr_guid(riid
), ppv
);
4047 if (!(apt
= apartment_find_multi_threaded()))
4049 ERR("apartment not initialised\n");
4050 return CO_E_NOTINITIALIZED
;
4052 apartment_release(apt
);
4055 context
= HeapAlloc(GetProcessHeap(), 0, sizeof(*context
));
4057 return E_OUTOFMEMORY
;
4059 context
->lpVtbl
= &Context_Threading_Vtbl
;
4060 context
->lpCallbackVtbl
= &Context_Callback_Vtbl
;
4061 context
->lpContextVtbl
= &Context_Object_Vtbl
;
4063 if (apt
->multi_threaded
)
4064 context
->apttype
= APTTYPE_MTA
;
4066 context
->apttype
= APTTYPE_MAINSTA
;
4068 context
->apttype
= APTTYPE_STA
;
4070 hr
= IUnknown_QueryInterface((IUnknown
*)&context
->lpVtbl
, riid
, ppv
);
4071 IUnknown_Release((IUnknown
*)&context
->lpVtbl
);
4077 /***********************************************************************
4078 * CoGetContextToken [OLE32.@]
4080 HRESULT WINAPI
CoGetContextToken( ULONG_PTR
*token
)
4082 struct oletls
*info
= COM_CurrentInfo();
4084 TRACE("(%p)\n", token
);
4087 return E_OUTOFMEMORY
;
4092 if (!(apt
= apartment_find_multi_threaded()))
4094 ERR("apartment not initialised\n");
4095 return CO_E_NOTINITIALIZED
;
4097 apartment_release(apt
);
4103 if (!info
->context_token
)
4108 hr
= CoGetObjectContext(&IID_IObjContext
, (void **)&ctx
);
4109 if (FAILED(hr
)) return hr
;
4110 info
->context_token
= ctx
;
4113 *token
= (ULONG_PTR
)info
->context_token
;
4114 TRACE("apt->context_token=%p\n", info
->context_token
);
4119 HRESULT
Handler_DllGetClassObject(REFCLSID rclsid
, REFIID riid
, LPVOID
*ppv
)
4121 static const WCHAR wszInprocHandler32
[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
4125 hres
= COM_OpenKeyForCLSID(rclsid
, wszInprocHandler32
, KEY_READ
, &hkey
);
4126 if (SUCCEEDED(hres
))
4128 WCHAR dllpath
[MAX_PATH
+1];
4130 if (COM_RegReadPath(hkey
, NULL
, NULL
, dllpath
, ARRAYSIZE(dllpath
)) == ERROR_SUCCESS
)
4132 static const WCHAR wszOle32
[] = {'o','l','e','3','2','.','d','l','l',0};
4133 if (!strcmpiW(dllpath
, wszOle32
))
4136 return HandlerCF_Create(rclsid
, riid
, ppv
);
4140 WARN("not creating object for inproc handler path %s\n", debugstr_w(dllpath
));
4144 return CLASS_E_CLASSNOTAVAILABLE
;
4147 /***********************************************************************
4150 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID fImpLoad
)
4152 TRACE("%p 0x%x %p\n", hinstDLL
, fdwReason
, fImpLoad
);
4155 case DLL_PROCESS_ATTACH
:
4156 hProxyDll
= hinstDLL
;
4157 COMPOBJ_InitProcess();
4158 if (TRACE_ON(ole
)) CoRegisterMallocSpy((LPVOID
)-1);
4161 case DLL_PROCESS_DETACH
:
4162 if (TRACE_ON(ole
)) CoRevokeMallocSpy();
4163 OLEDD_UnInitialize();
4164 COMPOBJ_UninitProcess();
4165 RPC_UnregisterAllChannelHooks();
4166 COMPOBJ_DllList_Free();
4169 case DLL_THREAD_DETACH
:
4176 /* NOTE: DllRegisterServer and DllUnregisterServer are in regsvr.c */