sync with trunk r46493
[reactos.git] / dll / win32 / ole32 / compobj.c
1 /*
2 * COMPOBJ library
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1998 Justin Bradford
6 * Copyright 1999 Francis Beaudet
7 * Copyright 1999 Sylvain St-Germain
8 * Copyright 2002 Marcus Meissner
9 * Copyright 2004 Mike Hearn
10 * Copyright 2005-2006 Robert Shearman (for CodeWeavers)
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 *
26 * Note
27 * 1. COINIT_MULTITHREADED is 0; it is the lack of COINIT_APARTMENTTHREADED
28 * Therefore do not test against COINIT_MULTITHREADED
29 *
30 * TODO list: (items bunched together depend on each other)
31 *
32 * - Implement the service control manager (in rpcss) to keep track
33 * of registered class objects: ISCM::ServerRegisterClsid et al
34 * - Implement the OXID resolver so we don't need magic endpoint names for
35 * clients and servers to meet up
36 *
37 */
38
39 #include "config.h"
40
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <assert.h>
45
46 #define COBJMACROS
47 #define NONAMELESSUNION
48 #define NONAMELESSSTRUCT
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "winerror.h"
53 #include "winreg.h"
54 #include "winuser.h"
55 #define USE_COM_CONTEXT_DEF
56 #include "objbase.h"
57 #include "ole2.h"
58 #include "ole2ver.h"
59 #include "ctxtcall.h"
60 #include "dde.h"
61
62 #include "compobj_private.h"
63
64 #include "wine/unicode.h"
65 #include "wine/debug.h"
66
67 WINE_DEFAULT_DEBUG_CHANNEL(ole);
68
69 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
70
71 /****************************************************************************
72 * This section defines variables internal to the COM module.
73 */
74
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 */
78
79 static CRITICAL_SECTION csApartment;
80 static CRITICAL_SECTION_DEBUG critsect_debug =
81 {
82 0, 0, &csApartment,
83 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
84 0, 0, { (DWORD_PTR)(__FILE__ ": csApartment") }
85 };
86 static CRITICAL_SECTION csApartment = { &critsect_debug, -1, 0, 0, 0, 0 };
87
88 struct registered_psclsid
89 {
90 struct list entry;
91 IID iid;
92 CLSID clsid;
93 };
94
95 /*
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
98 * libraries are freed
99 */
100 static LONG s_COMLockCount = 0;
101 /* Reference count used by CoAddRefServerProcess/CoReleaseServerProcess */
102 static LONG s_COMServerProcessReferences = 0;
103
104 /*
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
107 * objects.
108 *
109 * TODO: Make this data structure aware of inter-process communication. This
110 * means that parts of this will be exported to rpcss.
111 */
112 typedef struct tagRegisteredClass
113 {
114 struct list entry;
115 CLSID classIdentifier;
116 OXID apartment_id;
117 LPUNKNOWN classObject;
118 DWORD runContext;
119 DWORD connectFlags;
120 DWORD dwCookie;
121 LPSTREAM pMarshaledData; /* FIXME: only really need to store OXID and IPID */
122 void *RpcRegistration;
123 } RegisteredClass;
124
125 static struct list RegisteredClassList = LIST_INIT(RegisteredClassList);
126
127 static CRITICAL_SECTION csRegisteredClassList;
128 static CRITICAL_SECTION_DEBUG class_cs_debug =
129 {
130 0, 0, &csRegisteredClassList,
131 { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
132 0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
133 };
134 static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 };
135
136 /*****************************************************************************
137 * This section contains OpenDllList definitions
138 *
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.
142 *
143 * FIXME: a DLL that says OK when asked for unloading is unloaded in the
144 * next unload-call but not before 600 sec.
145 */
146
147 typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
148 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
149
150 typedef struct tagOpenDll
151 {
152 LONG refs;
153 LPWSTR library_name;
154 HANDLE library;
155 DllGetClassObjectFunc DllGetClassObject;
156 DllCanUnloadNowFunc DllCanUnloadNow;
157 struct list entry;
158 } OpenDll;
159
160 static struct list openDllList = LIST_INIT(openDllList);
161
162 static CRITICAL_SECTION csOpenDllList;
163 static CRITICAL_SECTION_DEBUG dll_cs_debug =
164 {
165 0, 0, &csOpenDllList,
166 { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
167 0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
168 };
169 static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 };
170
171 struct apartment_loaded_dll
172 {
173 struct list entry;
174 OpenDll *dll;
175 DWORD unload_time;
176 BOOL multi_threaded;
177 };
178
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};
181
182 /*****************************************************************************
183 * This section contains OpenDllList implementation
184 */
185
186 static OpenDll *COMPOBJ_DllList_Get(LPCWSTR library_name)
187 {
188 OpenDll *ptr;
189 OpenDll *ret = NULL;
190 EnterCriticalSection(&csOpenDllList);
191 LIST_FOR_EACH_ENTRY(ptr, &openDllList, OpenDll, entry)
192 {
193 if (!strcmpiW(library_name, ptr->library_name) &&
194 (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroy if == 1 */)
195 {
196 ret = ptr;
197 break;
198 }
199 }
200 LeaveCriticalSection(&csOpenDllList);
201 return ret;
202 }
203
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)
206 {
207 OpenDll *entry;
208 int len;
209 HRESULT hr = S_OK;
210 HANDLE hLibrary;
211 DllCanUnloadNowFunc DllCanUnloadNow;
212 DllGetClassObjectFunc DllGetClassObject;
213
214 TRACE("\n");
215
216 *ret = COMPOBJ_DllList_Get(library_name);
217 if (*ret) return S_OK;
218
219 /* do this outside the csOpenDllList to avoid creating a lock dependency on
220 * the loader lock */
221 hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
222 if (!hLibrary)
223 {
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? */
227 }
228
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)
233 {
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;
238 }
239
240 EnterCriticalSection( &csOpenDllList );
241
242 *ret = COMPOBJ_DllList_Get(library_name);
243 if (*ret)
244 {
245 /* another caller to this function already added the dll while we
246 * weren't in the critical section */
247 FreeLibrary(hLibrary);
248 }
249 else
250 {
251 len = strlenW(library_name);
252 entry = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
253 if (entry)
254 entry->library_name = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
255 if (entry && entry->library_name)
256 {
257 memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
258 entry->library = hLibrary;
259 entry->refs = 1;
260 entry->DllCanUnloadNow = DllCanUnloadNow;
261 entry->DllGetClassObject = DllGetClassObject;
262 list_add_tail(&openDllList, &entry->entry);
263 }
264 else
265 {
266 HeapFree(GetProcessHeap(), 0, entry);
267 hr = E_OUTOFMEMORY;
268 FreeLibrary(hLibrary);
269 }
270 *ret = entry;
271 }
272
273 LeaveCriticalSection( &csOpenDllList );
274
275 return hr;
276 }
277
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)
281 {
282 if (!InterlockedDecrement(&entry->refs) && free_entry)
283 {
284 EnterCriticalSection(&csOpenDllList);
285 list_remove(&entry->entry);
286 LeaveCriticalSection(&csOpenDllList);
287
288 TRACE("freeing %p\n", entry->library);
289 FreeLibrary(entry->library);
290
291 HeapFree(GetProcessHeap(), 0, entry->library_name);
292 HeapFree(GetProcessHeap(), 0, entry);
293 }
294 }
295
296 /* frees memory associated with active dll list */
297 static void COMPOBJ_DllList_Free(void)
298 {
299 OpenDll *entry, *cursor2;
300 EnterCriticalSection(&csOpenDllList);
301 LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &openDllList, OpenDll, entry)
302 {
303 list_remove(&entry->entry);
304
305 HeapFree(GetProcessHeap(), 0, entry->library_name);
306 HeapFree(GetProcessHeap(), 0, entry);
307 }
308 LeaveCriticalSection(&csOpenDllList);
309 }
310
311 /******************************************************************************
312 * Manage apartments.
313 */
314
315 static DWORD apartment_addref(struct apartment *apt)
316 {
317 DWORD refs = InterlockedIncrement(&apt->refs);
318 TRACE("%s: before = %d\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
319 return refs;
320 }
321
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)
325 {
326 APARTMENT *apt;
327
328 TRACE("creating new apartment, model=%d\n", model);
329
330 apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
331 apt->tid = GetCurrentThreadId();
332
333 list_init(&apt->proxies);
334 list_init(&apt->stubmgrs);
335 list_init(&apt->psclsids);
336 list_init(&apt->loaded_dlls);
337 apt->ipidc = 0;
338 apt->refs = 1;
339 apt->remunk_exported = FALSE;
340 apt->oidc = 1;
341 InitializeCriticalSection(&apt->cs);
342 DEBUG_SET_CRITSEC_NAME(&apt->cs, "apartment");
343
344 apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
345
346 if (apt->multi_threaded)
347 {
348 /* FIXME: should be randomly generated by in an RPC call to rpcss */
349 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
350 }
351 else
352 {
353 /* FIXME: should be randomly generated by in an RPC call to rpcss */
354 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
355 }
356
357 TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
358
359 list_add_head(&apts, &apt->entry);
360
361 return apt;
362 }
363
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)
368 {
369 APARTMENT *apt = COM_CurrentApt();
370
371 if (!apt)
372 {
373 if (model & COINIT_APARTMENTTHREADED)
374 {
375 EnterCriticalSection(&csApartment);
376
377 apt = apartment_construct(model);
378 if (!MainApartment)
379 {
380 MainApartment = apt;
381 apt->main = TRUE;
382 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
383 }
384
385 LeaveCriticalSection(&csApartment);
386
387 if (apt->main)
388 apartment_createwindowifneeded(apt);
389 }
390 else
391 {
392 EnterCriticalSection(&csApartment);
393
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
396 * in a process */
397 if (MTA)
398 {
399 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA->oxid));
400 apartment_addref(MTA);
401 }
402 else
403 MTA = apartment_construct(model);
404
405 apt = MTA;
406
407 LeaveCriticalSection(&csApartment);
408 }
409 COM_CurrentInfo()->apt = apt;
410 }
411
412 return apt;
413 }
414
415 static inline BOOL apartment_is_model(const APARTMENT *apt, DWORD model)
416 {
417 return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
418 }
419
420 static void COM_RevokeRegisteredClassObject(RegisteredClass *curClass)
421 {
422 list_remove(&curClass->entry);
423
424 if (curClass->runContext & CLSCTX_LOCAL_SERVER)
425 RPC_StopLocalServer(curClass->RpcRegistration);
426
427 /*
428 * Release the reference to the class object.
429 */
430 IUnknown_Release(curClass->classObject);
431
432 if (curClass->pMarshaledData)
433 {
434 LARGE_INTEGER zero;
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);
439 }
440
441 HeapFree(GetProcessHeap(), 0, curClass);
442 }
443
444 static void COM_RevokeAllClasses(const struct apartment *apt)
445 {
446 RegisteredClass *curClass, *cursor;
447
448 EnterCriticalSection( &csRegisteredClassList );
449
450 LIST_FOR_EACH_ENTRY_SAFE(curClass, cursor, &RegisteredClassList, RegisteredClass, entry)
451 {
452 if (curClass->apartment_id == apt->oxid)
453 COM_RevokeRegisteredClassObject(curClass);
454 }
455
456 LeaveCriticalSection( &csRegisteredClassList );
457 }
458
459 /***********************************************************************
460 * CoRevokeClassObject [OLE32.@]
461 *
462 * Removes a class object from the class registry.
463 *
464 * PARAMS
465 * dwRegister [I] Cookie returned from CoRegisterClassObject().
466 *
467 * RETURNS
468 * Success: S_OK.
469 * Failure: HRESULT code.
470 *
471 * NOTES
472 * Must be called from the same apartment that called CoRegisterClassObject(),
473 * otherwise it will fail with RPC_E_WRONG_THREAD.
474 *
475 * SEE ALSO
476 * CoRegisterClassObject
477 */
478 HRESULT WINAPI CoRevokeClassObject(
479 DWORD dwRegister)
480 {
481 HRESULT hr = E_INVALIDARG;
482 RegisteredClass *curClass;
483 APARTMENT *apt;
484
485 TRACE("(%08x)\n",dwRegister);
486
487 apt = COM_CurrentApt();
488 if (!apt)
489 {
490 ERR("COM was not initialized\n");
491 return CO_E_NOTINITIALIZED;
492 }
493
494 EnterCriticalSection( &csRegisteredClassList );
495
496 LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
497 {
498 /*
499 * Check if we have a match on the cookie.
500 */
501 if (curClass->dwCookie == dwRegister)
502 {
503 if (curClass->apartment_id == apt->oxid)
504 {
505 COM_RevokeRegisteredClassObject(curClass);
506 hr = S_OK;
507 }
508 else
509 {
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;
513 }
514 break;
515 }
516 }
517
518 LeaveCriticalSection( &csRegisteredClassList );
519
520 return hr;
521 }
522
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)
526 {
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)
530 {
531 if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
532 {
533 DWORD real_delay = delay;
534
535 if (real_delay == INFINITE)
536 {
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 */
543 else
544 real_delay = 0;
545 }
546
547 if (!real_delay || (entry->unload_time && (entry->unload_time < GetTickCount())))
548 {
549 list_remove(&entry->entry);
550 COMPOBJ_DllList_ReleaseRef(entry->dll, TRUE);
551 HeapFree(GetProcessHeap(), 0, entry);
552 }
553 else
554 entry->unload_time = GetTickCount() + real_delay;
555 }
556 else if (entry->unload_time)
557 entry->unload_time = 0;
558 }
559 LeaveCriticalSection(&apt->cs);
560 }
561
562 DWORD apartment_release(struct apartment *apt)
563 {
564 DWORD ret;
565
566 EnterCriticalSection(&csApartment);
567
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 */
571 if (ret == 0)
572 {
573 if (apt == MTA) MTA = NULL;
574 else if (apt == MainApartment) MainApartment = NULL;
575 list_remove(&apt->entry);
576 }
577
578 LeaveCriticalSection(&csApartment);
579
580 if (ret == 0)
581 {
582 struct list *cursor, *cursor2;
583
584 TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
585
586 /* Release the references to the registered class objects */
587 COM_RevokeAllClasses(apt);
588
589 /* no locking is needed for this apartment, because no other thread
590 * can access it at this point */
591
592 apartment_disconnectproxies(apt);
593
594 if (apt->win) DestroyWindow(apt->win);
595 if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
596
597 LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
598 {
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).
604 */
605 stub_manager_int_release(stubmgr);
606 }
607
608 LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->psclsids)
609 {
610 struct registered_psclsid *registered_psclsid =
611 LIST_ENTRY(cursor, struct registered_psclsid, entry);
612
613 list_remove(&registered_psclsid->entry);
614 HeapFree(GetProcessHeap(), 0, registered_psclsid);
615 }
616
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));
621
622 if (apt->filter) IUnknown_Release(apt->filter);
623
624 /* free as many unused libraries as possible... */
625 apartment_freeunusedlibraries(apt, 0);
626
627 /* ... and free the memory for the apartment loaded dll entry and
628 * release the dll list reference without freeing the library for the
629 * rest */
630 while ((cursor = list_head(&apt->loaded_dlls)))
631 {
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);
634 list_remove(cursor);
635 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
636 }
637
638 DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
639 DeleteCriticalSection(&apt->cs);
640
641 HeapFree(GetProcessHeap(), 0, apt);
642 }
643
644 return ret;
645 }
646
647 /* The given OXID must be local to this process:
648 *
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.
651 */
652 APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
653 {
654 APARTMENT *result = NULL;
655 struct list *cursor;
656
657 EnterCriticalSection(&csApartment);
658 LIST_FOR_EACH( cursor, &apts )
659 {
660 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
661 if (apt->oxid == oxid)
662 {
663 result = apt;
664 if (ref) apartment_addref(result);
665 break;
666 }
667 }
668 LeaveCriticalSection(&csApartment);
669
670 return result;
671 }
672
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)
677 {
678 APARTMENT *result = NULL;
679 struct list *cursor;
680
681 EnterCriticalSection(&csApartment);
682 LIST_FOR_EACH( cursor, &apts )
683 {
684 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
685 if (apt->tid == tid)
686 {
687 result = apt;
688 apartment_addref(result);
689 break;
690 }
691 }
692 LeaveCriticalSection(&csApartment);
693
694 return result;
695 }
696
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)
701 {
702 APARTMENT *result;
703
704 EnterCriticalSection(&csApartment);
705
706 result = MainApartment;
707 if (result) apartment_addref(result);
708
709 LeaveCriticalSection(&csApartment);
710
711 return result;
712 }
713
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)
718 {
719 APARTMENT *result = NULL;
720 struct list *cursor;
721
722 EnterCriticalSection(&csApartment);
723
724 LIST_FOR_EACH( cursor, &apts )
725 {
726 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
727 if (apt->multi_threaded)
728 {
729 result = apt;
730 apartment_addref(result);
731 break;
732 }
733 }
734
735 LeaveCriticalSection(&csApartment);
736 return result;
737 }
738
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)
744 {
745 static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
746 HRESULT hr = S_OK;
747 BOOL found = FALSE;
748 struct apartment_loaded_dll *apartment_loaded_dll;
749
750 if (!strcmpiW(dllpath, wszOle32))
751 {
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);
756
757 if (hr != S_OK)
758 ERR("DllGetClassObject returned error 0x%08x\n", hr);
759
760 return hr;
761 }
762
763 EnterCriticalSection(&apt->cs);
764
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))
767 {
768 TRACE("found %s already loaded\n", debugstr_w(dllpath));
769 found = TRUE;
770 break;
771 }
772
773 if (!found)
774 {
775 apartment_loaded_dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*apartment_loaded_dll));
776 if (!apartment_loaded_dll)
777 hr = E_OUTOFMEMORY;
778 if (SUCCEEDED(hr))
779 {
780 apartment_loaded_dll->unload_time = 0;
781 apartment_loaded_dll->multi_threaded = FALSE;
782 hr = COMPOBJ_DllList_Add( dllpath, &apartment_loaded_dll->dll );
783 if (FAILED(hr))
784 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
785 }
786 if (SUCCEEDED(hr))
787 {
788 TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
789 list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
790 }
791 }
792
793 LeaveCriticalSection(&apt->cs);
794
795 if (SUCCEEDED(hr))
796 {
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;
801
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);
805
806 if (hr != S_OK)
807 ERR("DllGetClassObject returned error 0x%08x\n", hr);
808 }
809
810 return hr;
811 }
812
813 /***********************************************************************
814 * COM_RegReadPath [internal]
815 *
816 * Reads a registry value and expands it when necessary
817 */
818 static DWORD COM_RegReadPath(HKEY hkeyroot, const WCHAR *keyname, const WCHAR *valuename, WCHAR * dst, DWORD dstlen)
819 {
820 DWORD ret;
821 HKEY key;
822 DWORD keytype;
823 WCHAR src[MAX_PATH];
824 DWORD dwLength = dstlen * sizeof(WCHAR);
825
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;
830 } else {
831 const WCHAR *quote_start;
832 quote_start = strchrW(src, '\"');
833 if (quote_start) {
834 const WCHAR *quote_end = strchrW(quote_start + 1, '\"');
835 if (quote_end) {
836 memmove(src, quote_start + 1,
837 (quote_end - quote_start - 1) * sizeof(WCHAR));
838 src[quote_end - quote_start - 1] = '\0';
839 }
840 }
841 lstrcpynW(dst, src, dstlen);
842 }
843 }
844 RegCloseKey (key);
845 }
846 return ret;
847 }
848
849 struct host_object_params
850 {
851 HKEY hkeydll;
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? */
858 };
859
860 static HRESULT apartment_hostobject(struct apartment *apt,
861 const struct host_object_params *params)
862 {
863 IUnknown *object;
864 HRESULT hr;
865 static const LARGE_INTEGER llZero;
866 WCHAR dllpath[MAX_PATH+1];
867
868 TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
869
870 if (COM_RegReadPath(params->hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
871 {
872 /* failure: CLSID is not found in registry */
873 WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
874 return REGDB_E_CLASSNOTREG;
875 }
876
877 hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded,
878 &params->clsid, &params->iid, (void **)&object);
879 if (FAILED(hr))
880 return hr;
881
882 hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
883 if (FAILED(hr))
884 IUnknown_Release(object);
885 IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
886
887 return hr;
888 }
889
890 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
891 {
892 switch (msg)
893 {
894 case DM_EXECUTERPC:
895 RPC_ExecuteCall((struct dispatch_params *)lParam);
896 return 0;
897 case DM_HOSTOBJECT:
898 return apartment_hostobject(COM_CurrentApt(), (const struct host_object_params *)lParam);
899 default:
900 return DefWindowProcW(hWnd, msg, wParam, lParam);
901 }
902 }
903
904 struct host_thread_params
905 {
906 COINIT threading_model;
907 HANDLE ready_event;
908 HWND apartment_hwnd;
909 };
910
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)
914 {
915 struct host_thread_params *params = p;
916 MSG msg;
917 HRESULT hr;
918 struct apartment *apt;
919
920 TRACE("\n");
921
922 hr = CoInitializeEx(NULL, params->threading_model);
923 if (FAILED(hr)) return hr;
924
925 apt = COM_CurrentApt();
926 if (params->threading_model == COINIT_APARTMENTTHREADED)
927 {
928 apartment_createwindowifneeded(apt);
929 params->apartment_hwnd = apartment_getwindow(apt);
930 }
931 else
932 params->apartment_hwnd = NULL;
933
934 /* force the message queue to be created before signaling parent thread */
935 PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
936
937 SetEvent(params->ready_event);
938 params = NULL; /* can't touch params after here as it may be invalid */
939
940 while (GetMessageW(&msg, NULL, 0, 0))
941 {
942 if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
943 {
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);
947 }
948 else
949 {
950 TranslateMessage(&msg);
951 DispatchMessageW(&msg);
952 }
953 }
954
955 TRACE("exiting\n");
956
957 CoUninitialize();
958
959 return S_OK;
960 }
961
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)
968 {
969 struct host_object_params params;
970 HWND apartment_hwnd = NULL;
971 DWORD apartment_tid = 0;
972 HRESULT hr;
973
974 if (!multi_threaded && main_apartment)
975 {
976 APARTMENT *host_apt = apartment_findmain();
977 if (host_apt)
978 {
979 apartment_hwnd = apartment_getwindow(host_apt);
980 apartment_release(host_apt);
981 }
982 }
983
984 if (!apartment_hwnd)
985 {
986 EnterCriticalSection(&apt->cs);
987
988 if (!apt->host_apt_tid)
989 {
990 struct host_thread_params thread_params;
991 HANDLE handles[2];
992 DWORD wait_value;
993
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);
998 if (!handles[1])
999 {
1000 CloseHandle(handles[0]);
1001 LeaveCriticalSection(&apt->cs);
1002 return E_OUTOFMEMORY;
1003 }
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;
1009 else
1010 {
1011 LeaveCriticalSection(&apt->cs);
1012 return E_OUTOFMEMORY;
1013 }
1014 }
1015
1016 if (multi_threaded || !main_apartment)
1017 {
1018 apartment_hwnd = apt->host_apt_hwnd;
1019 apartment_tid = apt->host_apt_tid;
1020 }
1021
1022 LeaveCriticalSection(&apt->cs);
1023 }
1024
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)
1028 {
1029 APARTMENT *host_apt = apartment_findmain();
1030 if (host_apt)
1031 {
1032 apartment_hwnd = apartment_getwindow(host_apt);
1033 apartment_release(host_apt);
1034 }
1035 }
1036
1037 params.hkeydll = hkeydll;
1038 params.clsid = *rclsid;
1039 params.iid = *riid;
1040 hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
1041 if (FAILED(hr))
1042 return hr;
1043 params.apartment_threaded = !multi_threaded;
1044 if (multi_threaded)
1045 {
1046 params.hr = S_OK;
1047 params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
1048 if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
1049 hr = E_OUTOFMEMORY;
1050 else
1051 {
1052 WaitForSingleObject(params.event, INFINITE);
1053 hr = params.hr;
1054 }
1055 CloseHandle(params.event);
1056 }
1057 else
1058 {
1059 if (!apartment_hwnd)
1060 {
1061 ERR("host apartment didn't create window\n");
1062 hr = E_OUTOFMEMORY;
1063 }
1064 else
1065 hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
1066 }
1067 if (SUCCEEDED(hr))
1068 hr = CoUnmarshalInterface(params.stream, riid, ppv);
1069 IStream_Release(params.stream);
1070 return hr;
1071 }
1072
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)
1076 {
1077 if (apt->multi_threaded)
1078 return S_OK;
1079
1080 if (!apt->win)
1081 {
1082 HWND hwnd = CreateWindowW(wszAptWinClass, NULL, 0,
1083 0, 0, 0, 0,
1084 HWND_MESSAGE, 0, hProxyDll, NULL);
1085 if (!hwnd)
1086 {
1087 ERR("CreateWindow failed with error %d\n", GetLastError());
1088 return HRESULT_FROM_WIN32(GetLastError());
1089 }
1090 if (InterlockedCompareExchangePointer((PVOID *)&apt->win, hwnd, NULL))
1091 /* someone beat us to it */
1092 DestroyWindow(hwnd);
1093 }
1094
1095 return S_OK;
1096 }
1097
1098 /* retrieves the window for the main- or apartment-threaded apartment */
1099 HWND apartment_getwindow(const struct apartment *apt)
1100 {
1101 assert(!apt->multi_threaded);
1102 return apt->win;
1103 }
1104
1105 void apartment_joinmta(void)
1106 {
1107 apartment_addref(MTA);
1108 COM_CurrentInfo()->apt = MTA;
1109 }
1110
1111 static void COMPOBJ_InitProcess( void )
1112 {
1113 WNDCLASSW wclass;
1114
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.
1123 */
1124 memset(&wclass, 0, sizeof(wclass));
1125 wclass.lpfnWndProc = apartment_wndproc;
1126 wclass.hInstance = hProxyDll;
1127 wclass.lpszClassName = wszAptWinClass;
1128 RegisterClassW(&wclass);
1129 }
1130
1131 static void COMPOBJ_UninitProcess( void )
1132 {
1133 UnregisterClassW(wszAptWinClass, hProxyDll);
1134 }
1135
1136 static void COM_TlsDestroy(void)
1137 {
1138 struct oletls *info = NtCurrentTeb()->ReservedForOle;
1139 if (info)
1140 {
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;
1148 }
1149 }
1150
1151 /******************************************************************************
1152 * CoBuildVersion [OLE32.@]
1153 *
1154 * Gets the build version of the DLL.
1155 *
1156 * PARAMS
1157 *
1158 * RETURNS
1159 * Current build version, hiword is majornumber, loword is minornumber
1160 */
1161 DWORD WINAPI CoBuildVersion(void)
1162 {
1163 TRACE("Returning version %d, build %d.\n", rmm, rup);
1164 return (rmm<<16)+rup;
1165 }
1166
1167 /******************************************************************************
1168 * CoRegisterInitializeSpy [OLE32.@]
1169 *
1170 * Add a Spy that watches CoInitializeEx calls
1171 *
1172 * PARAMS
1173 * spy [I] Pointer to IUnknown interface that will be QueryInterface'd.
1174 * cookie [II] cookie receiver
1175 *
1176 * RETURNS
1177 * Success: S_OK if not already initialized, S_FALSE otherwise.
1178 * Failure: HRESULT code.
1179 *
1180 * SEE ALSO
1181 * CoInitializeEx
1182 */
1183 HRESULT WINAPI CoRegisterInitializeSpy(IInitializeSpy *spy, ULARGE_INTEGER *cookie)
1184 {
1185 struct oletls *info = COM_CurrentInfo();
1186 HRESULT hr;
1187
1188 TRACE("(%p, %p)\n", spy, cookie);
1189
1190 if (!spy || !cookie || !info)
1191 {
1192 if (!info)
1193 WARN("Could not allocate tls\n");
1194 return E_INVALIDARG;
1195 }
1196
1197 if (info->spy)
1198 {
1199 FIXME("Already registered?\n");
1200 return E_UNEXPECTED;
1201 }
1202
1203 hr = IUnknown_QueryInterface(spy, &IID_IInitializeSpy, (void **) &info->spy);
1204 if (SUCCEEDED(hr))
1205 {
1206 cookie->QuadPart = (DWORD_PTR)spy;
1207 return S_OK;
1208 }
1209 return hr;
1210 }
1211
1212 /******************************************************************************
1213 * CoRevokeInitializeSpy [OLE32.@]
1214 *
1215 * Remove a spy that previously watched CoInitializeEx calls
1216 *
1217 * PARAMS
1218 * cookie [I] The cookie obtained from a previous CoRegisterInitializeSpy call
1219 *
1220 * RETURNS
1221 * Success: S_OK if a spy is removed
1222 * Failure: E_INVALIDARG
1223 *
1224 * SEE ALSO
1225 * CoInitializeEx
1226 */
1227 HRESULT WINAPI CoRevokeInitializeSpy(ULARGE_INTEGER cookie)
1228 {
1229 struct oletls *info = COM_CurrentInfo();
1230 TRACE("(%s)\n", wine_dbgstr_longlong(cookie.QuadPart));
1231
1232 if (!info || !info->spy || cookie.QuadPart != (DWORD_PTR)info->spy)
1233 return E_INVALIDARG;
1234
1235 IUnknown_Release(info->spy);
1236 info->spy = NULL;
1237 return S_OK;
1238 }
1239
1240
1241 /******************************************************************************
1242 * CoInitialize [OLE32.@]
1243 *
1244 * Initializes the COM libraries by calling CoInitializeEx with
1245 * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
1246 *
1247 * PARAMS
1248 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1249 *
1250 * RETURNS
1251 * Success: S_OK if not already initialized, S_FALSE otherwise.
1252 * Failure: HRESULT code.
1253 *
1254 * SEE ALSO
1255 * CoInitializeEx
1256 */
1257 HRESULT WINAPI CoInitialize(LPVOID lpReserved)
1258 {
1259 /*
1260 * Just delegate to the newer method.
1261 */
1262 return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
1263 }
1264
1265 /******************************************************************************
1266 * CoInitializeEx [OLE32.@]
1267 *
1268 * Initializes the COM libraries.
1269 *
1270 * PARAMS
1271 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1272 * dwCoInit [I] One or more flags from the COINIT enumeration. See notes.
1273 *
1274 * RETURNS
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
1278 * threading model.
1279 *
1280 * NOTES
1281 *
1282 * The behavior used to set the IMalloc used for memory management is
1283 * obsolete.
1284 * The dwCoInit parameter must specify one of the following apartment
1285 * threading models:
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.
1291 *
1292 * SEE ALSO
1293 * CoUninitialize
1294 */
1295 HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
1296 {
1297 struct oletls *info = COM_CurrentInfo();
1298 HRESULT hr = S_OK;
1299 APARTMENT *apt;
1300
1301 TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
1302
1303 if (lpReserved!=NULL)
1304 {
1305 ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
1306 }
1307
1308 /*
1309 * Check the lock count. If this is the first time going through the initialize
1310 * process, we have to initialize the libraries.
1311 *
1312 * And crank-up that lock count.
1313 */
1314 if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
1315 {
1316 /*
1317 * Initialize the various COM libraries and data structures.
1318 */
1319 TRACE("() - Initializing the COM libraries\n");
1320
1321 /* we may need to defer this until after apartment initialisation */
1322 RunningObjectTableImpl_Initialize();
1323 }
1324
1325 if (info->spy)
1326 IInitializeSpy_PreInitialize(info->spy, dwCoInit, info->inits);
1327
1328 if (!(apt = info->apt))
1329 {
1330 apt = apartment_get_or_create(dwCoInit);
1331 if (!apt) return E_OUTOFMEMORY;
1332 }
1333 else if (!apartment_is_model(apt, dwCoInit))
1334 {
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;
1341 }
1342 else
1343 hr = S_FALSE;
1344
1345 info->inits++;
1346
1347 if (info->spy)
1348 IInitializeSpy_PostInitialize(info->spy, hr, dwCoInit, info->inits);
1349
1350 return hr;
1351 }
1352
1353 /***********************************************************************
1354 * CoUninitialize [OLE32.@]
1355 *
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.
1360 *
1361 * PARAMS
1362 *
1363 * RETURNS
1364 * Nothing.
1365 *
1366 * SEE ALSO
1367 * CoInitializeEx
1368 */
1369 void WINAPI CoUninitialize(void)
1370 {
1371 struct oletls * info = COM_CurrentInfo();
1372 LONG lCOMRefCnt;
1373
1374 TRACE("()\n");
1375
1376 /* will only happen on OOM */
1377 if (!info) return;
1378
1379 if (info->spy)
1380 IInitializeSpy_PreUninitialize(info->spy, info->inits);
1381
1382 /* sanity check */
1383 if (!info->inits)
1384 {
1385 ERR("Mismatched CoUninitialize\n");
1386
1387 if (info->spy)
1388 IInitializeSpy_PostUninitialize(info->spy, info->inits);
1389 return;
1390 }
1391
1392 if (!--info->inits)
1393 {
1394 apartment_release(info->apt);
1395 info->apt = NULL;
1396 }
1397
1398 /*
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.
1402 */
1403 lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
1404 if (lCOMRefCnt==1)
1405 {
1406 TRACE("() - Releasing the COM libraries\n");
1407
1408 RunningObjectTableImpl_UnInitialize();
1409 }
1410 else if (lCOMRefCnt<1) {
1411 ERR( "CoUninitialize() - not CoInitialized.\n" );
1412 InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
1413 }
1414 if (info->spy)
1415 IInitializeSpy_PostUninitialize(info->spy, info->inits);
1416 }
1417
1418 /******************************************************************************
1419 * CoDisconnectObject [OLE32.@]
1420 *
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.
1424 *
1425 * Typically called when the object server is forced to shut down, for instance by
1426 * the user.
1427 *
1428 * PARAMS
1429 * lpUnk [I] The object whose stub should be disconnected.
1430 * reserved [I] Reserved. Should be set to 0.
1431 *
1432 * RETURNS
1433 * Success: S_OK.
1434 * Failure: HRESULT code.
1435 *
1436 * SEE ALSO
1437 * CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
1438 */
1439 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
1440 {
1441 HRESULT hr;
1442 IMarshal *marshal;
1443 APARTMENT *apt;
1444
1445 TRACE("(%p, 0x%08x)\n", lpUnk, reserved);
1446
1447 hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
1448 if (hr == S_OK)
1449 {
1450 hr = IMarshal_DisconnectObject(marshal, reserved);
1451 IMarshal_Release(marshal);
1452 return hr;
1453 }
1454
1455 apt = COM_CurrentApt();
1456 if (!apt)
1457 return CO_E_NOTINITIALIZED;
1458
1459 apartment_disconnectobject(apt, lpUnk);
1460
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 */
1465
1466 return S_OK;
1467 }
1468
1469 /******************************************************************************
1470 * CoCreateGuid [OLE32.@]
1471 *
1472 * Simply forwards to UuidCreate in RPCRT4.
1473 *
1474 * PARAMS
1475 * pguid [O] Points to the GUID to initialize.
1476 *
1477 * RETURNS
1478 * Success: S_OK.
1479 * Failure: HRESULT code.
1480 *
1481 * SEE ALSO
1482 * UuidCreate
1483 */
1484 HRESULT WINAPI CoCreateGuid(GUID *pguid)
1485 {
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 );
1489 }
1490
1491 /******************************************************************************
1492 * CLSIDFromString [OLE32.@]
1493 * IIDFromString [OLE32.@]
1494 *
1495 * Converts a unique identifier from its string representation into
1496 * the GUID struct.
1497 *
1498 * PARAMS
1499 * idstr [I] The string representation of the GUID.
1500 * id [O] GUID converted from the string.
1501 *
1502 * RETURNS
1503 * S_OK on success
1504 * CO_E_CLASSSTRING if idstr is not a valid CLSID
1505 *
1506 * SEE ALSO
1507 * StringFromCLSID
1508 */
1509 static HRESULT __CLSIDFromString(LPCWSTR s, CLSID *id)
1510 {
1511 int i;
1512 BYTE table[256];
1513
1514 if (!s) {
1515 memset( id, 0, sizeof (CLSID) );
1516 return S_OK;
1517 }
1518
1519 /* validate the CLSID string */
1520 if (strlenW(s) != 38)
1521 return CO_E_CLASSSTRING;
1522
1523 if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
1524 return CO_E_CLASSSTRING;
1525
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;
1532 }
1533
1534 TRACE("%s -> %p\n", debugstr_w(s), id);
1535
1536 /* quick lookup table */
1537 memset(table, 0, 256);
1538
1539 for (i = 0; i < 10; i++) {
1540 table['0' + i] = i;
1541 }
1542 for (i = 0; i < 6; i++) {
1543 table['A' + i] = i+10;
1544 table['a' + i] = i+10;
1545 }
1546
1547 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
1548
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]];
1553
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]];
1563
1564 return S_OK;
1565 }
1566
1567 /*****************************************************************************/
1568
1569 HRESULT WINAPI CLSIDFromString(LPOLESTR idstr, CLSID *id )
1570 {
1571 HRESULT ret;
1572
1573 if (!id)
1574 return E_INVALIDARG;
1575
1576 ret = __CLSIDFromString(idstr, id);
1577 if(ret != S_OK) { /* It appears a ProgID is also valid */
1578 ret = CLSIDFromProgID(idstr, id);
1579 }
1580 return ret;
1581 }
1582
1583
1584 /******************************************************************************
1585 * StringFromCLSID [OLE32.@]
1586 * StringFromIID [OLE32.@]
1587 *
1588 * Converts a GUID into the respective string representation.
1589 * The target string is allocated using the OLE IMalloc.
1590 *
1591 * PARAMS
1592 * id [I] the GUID to be converted.
1593 * idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
1594 *
1595 * RETURNS
1596 * S_OK
1597 * E_FAIL
1598 *
1599 * SEE ALSO
1600 * StringFromGUID2, CLSIDFromString
1601 */
1602 HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
1603 {
1604 HRESULT ret;
1605 LPMALLOC mllc;
1606
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 );
1610 return S_OK;
1611 }
1612
1613 /******************************************************************************
1614 * StringFromGUID2 [OLE32.@]
1615 *
1616 * Modified version of StringFromCLSID that allows you to specify max
1617 * buffer size.
1618 *
1619 * PARAMS
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.
1623 *
1624 * RETURNS
1625 * Success: The length of the resulting string in characters.
1626 * Failure: 0.
1627 */
1628 INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
1629 {
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;
1639 }
1640
1641 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
1642 HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
1643 {
1644 static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
1645 WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) - 1];
1646 LONG res;
1647 HKEY key;
1648
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;
1656
1657 if (!keyname)
1658 {
1659 *subkey = key;
1660 return S_OK;
1661 }
1662
1663 res = RegOpenKeyExW(key, keyname, 0, access, subkey);
1664 RegCloseKey(key);
1665 if (res == ERROR_FILE_NOT_FOUND)
1666 return REGDB_E_KEYMISSING;
1667 else if (res != ERROR_SUCCESS)
1668 return REGDB_E_READREGDB;
1669
1670 return S_OK;
1671 }
1672
1673 /* open HKCR\\AppId\\{string form of appid clsid} key */
1674 HRESULT COM_OpenKeyForAppIdFromCLSID(REFCLSID clsid, REGSAM access, HKEY *subkey)
1675 {
1676 static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
1677 static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
1678 DWORD res;
1679 WCHAR buf[CHARS_IN_GUID];
1680 WCHAR keyname[ARRAYSIZE(szAppIdKey) + CHARS_IN_GUID];
1681 DWORD size;
1682 HKEY hkey;
1683 DWORD type;
1684 HRESULT hr;
1685
1686 /* read the AppID value under the class's key */
1687 hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
1688 if (FAILED(hr))
1689 return hr;
1690
1691 size = sizeof(buf);
1692 res = RegQueryValueExW(hkey, szAppId, NULL, &type, (LPBYTE)buf, &size);
1693 RegCloseKey(hkey);
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;
1698
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;
1706
1707 return S_OK;
1708 }
1709
1710 /******************************************************************************
1711 * ProgIDFromCLSID [OLE32.@]
1712 *
1713 * Converts a class id into the respective program ID.
1714 *
1715 * PARAMS
1716 * clsid [I] Class ID, as found in registry.
1717 * ppszProgID [O] Associated ProgID.
1718 *
1719 * RETURNS
1720 * S_OK
1721 * E_OUTOFMEMORY
1722 * REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
1723 */
1724 HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *ppszProgID)
1725 {
1726 static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
1727 HKEY hkey;
1728 HRESULT ret;
1729 LONG progidlen = 0;
1730
1731 if (!ppszProgID)
1732 {
1733 ERR("ppszProgId isn't optional\n");
1734 return E_INVALIDARG;
1735 }
1736
1737 *ppszProgID = NULL;
1738 ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
1739 if (FAILED(ret))
1740 return ret;
1741
1742 if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
1743 ret = REGDB_E_CLASSNOTREG;
1744
1745 if (ret == S_OK)
1746 {
1747 *ppszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
1748 if (*ppszProgID)
1749 {
1750 if (RegQueryValueW(hkey, NULL, *ppszProgID, &progidlen))
1751 ret = REGDB_E_CLASSNOTREG;
1752 }
1753 else
1754 ret = E_OUTOFMEMORY;
1755 }
1756
1757 RegCloseKey(hkey);
1758 return ret;
1759 }
1760
1761 /******************************************************************************
1762 * CLSIDFromProgID [OLE32.@]
1763 *
1764 * Converts a program id into the respective GUID.
1765 *
1766 * PARAMS
1767 * progid [I] Unicode program ID, as found in registry.
1768 * clsid [O] Associated CLSID.
1769 *
1770 * RETURNS
1771 * Success: S_OK
1772 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
1773 */
1774 HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID clsid)
1775 {
1776 static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
1777 WCHAR buf2[CHARS_IN_GUID];
1778 LONG buf2len = sizeof(buf2);
1779 HKEY xhkey;
1780 WCHAR *buf;
1781
1782 if (!progid || !clsid)
1783 {
1784 ERR("neither progid (%p) nor clsid (%p) are optional\n", progid, clsid);
1785 return E_INVALIDARG;
1786 }
1787
1788 /* initialise clsid in case of failure */
1789 memset(clsid, 0, sizeof(*clsid));
1790
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))
1795 {
1796 HeapFree(GetProcessHeap(),0,buf);
1797 WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
1798 return CO_E_CLASSSTRING;
1799 }
1800 HeapFree(GetProcessHeap(),0,buf);
1801
1802 if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
1803 {
1804 RegCloseKey(xhkey);
1805 WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
1806 return CO_E_CLASSSTRING;
1807 }
1808 RegCloseKey(xhkey);
1809 return __CLSIDFromString(buf2,clsid);
1810 }
1811
1812
1813 /*****************************************************************************
1814 * CoGetPSClsid [OLE32.@]
1815 *
1816 * Retrieves the CLSID of the proxy/stub factory that implements
1817 * IPSFactoryBuffer for the specified interface.
1818 *
1819 * PARAMS
1820 * riid [I] Interface whose proxy/stub CLSID is to be returned.
1821 * pclsid [O] Where to store returned proxy/stub CLSID.
1822 *
1823 * RETURNS
1824 * S_OK
1825 * E_OUTOFMEMORY
1826 * REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
1827 *
1828 * NOTES
1829 *
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
1833 * given object.
1834 *
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.
1839 *
1840 * BUGS
1841 *
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).
1845 *
1846 * SEE ALSO
1847 * CoRegisterPSClsid.
1848 */
1849 HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
1850 {
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];
1855 LONG len;
1856 HKEY hkey;
1857 APARTMENT *apt = COM_CurrentApt();
1858 struct registered_psclsid *registered_psclsid;
1859
1860 TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
1861
1862 if (!apt)
1863 {
1864 ERR("apartment not initialised\n");
1865 return CO_E_NOTINITIALIZED;
1866 }
1867
1868 if (!pclsid)
1869 {
1870 ERR("pclsid isn't optional\n");
1871 return E_INVALIDARG;
1872 }
1873
1874 EnterCriticalSection(&apt->cs);
1875
1876 LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
1877 if (IsEqualIID(&registered_psclsid->iid, riid))
1878 {
1879 *pclsid = registered_psclsid->clsid;
1880 LeaveCriticalSection(&apt->cs);
1881 return S_OK;
1882 }
1883
1884 LeaveCriticalSection(&apt->cs);
1885
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);
1890
1891 /* Open the key.. */
1892 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey))
1893 {
1894 WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
1895 return REGDB_E_IIDNOTREG;
1896 }
1897
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))
1903 {
1904 RegCloseKey(hkey);
1905 return REGDB_E_IIDNOTREG;
1906 }
1907 RegCloseKey(hkey);
1908
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;
1913
1914 TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
1915 return S_OK;
1916 }
1917
1918 /*****************************************************************************
1919 * CoRegisterPSClsid [OLE32.@]
1920 *
1921 * Register a proxy/stub CLSID for the given interface in the current process
1922 * only.
1923 *
1924 * PARAMS
1925 * riid [I] Interface whose proxy/stub CLSID is to be registered.
1926 * rclsid [I] CLSID of the proxy/stub.
1927 *
1928 * RETURNS
1929 * Success: S_OK
1930 * Failure: E_OUTOFMEMORY
1931 *
1932 * NOTES
1933 *
1934 * This function does not add anything to the registry and the effects are
1935 * limited to the lifetime of the current process.
1936 *
1937 * SEE ALSO
1938 * CoGetPSClsid.
1939 */
1940 HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid)
1941 {
1942 APARTMENT *apt = COM_CurrentApt();
1943 struct registered_psclsid *registered_psclsid;
1944
1945 TRACE("(%s, %s)\n", debugstr_guid(riid), debugstr_guid(rclsid));
1946
1947 if (!apt)
1948 {
1949 ERR("apartment not initialised\n");
1950 return CO_E_NOTINITIALIZED;
1951 }
1952
1953 EnterCriticalSection(&apt->cs);
1954
1955 LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
1956 if (IsEqualIID(&registered_psclsid->iid, riid))
1957 {
1958 registered_psclsid->clsid = *rclsid;
1959 LeaveCriticalSection(&apt->cs);
1960 return S_OK;
1961 }
1962
1963 registered_psclsid = HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid));
1964 if (!registered_psclsid)
1965 {
1966 LeaveCriticalSection(&apt->cs);
1967 return E_OUTOFMEMORY;
1968 }
1969
1970 registered_psclsid->iid = *riid;
1971 registered_psclsid->clsid = *rclsid;
1972 list_add_head(&apt->psclsids, &registered_psclsid->entry);
1973
1974 LeaveCriticalSection(&apt->cs);
1975
1976 return S_OK;
1977 }
1978
1979
1980 /***
1981 * COM_GetRegisteredClassObject
1982 *
1983 * This internal method is used to scan the registered class list to
1984 * find a class object.
1985 *
1986 * Params:
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.
1992 */
1993 static HRESULT COM_GetRegisteredClassObject(const struct apartment *apt, REFCLSID rclsid,
1994 DWORD dwClsContext, LPUNKNOWN* ppUnk)
1995 {
1996 HRESULT hr = S_FALSE;
1997 RegisteredClass *curClass;
1998
1999 EnterCriticalSection( &csRegisteredClassList );
2000
2001 LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
2002 {
2003 /*
2004 * Check if we have a match on the class ID and context.
2005 */
2006 if ((apt->oxid == curClass->apartment_id) &&
2007 (dwClsContext & curClass->runContext) &&
2008 IsEqualGUID(&(curClass->classIdentifier), rclsid))
2009 {
2010 /*
2011 * We have a match, return the pointer to the class object.
2012 */
2013 *ppUnk = curClass->classObject;
2014
2015 IUnknown_AddRef(curClass->classObject);
2016
2017 hr = S_OK;
2018 break;
2019 }
2020 }
2021
2022 LeaveCriticalSection( &csRegisteredClassList );
2023
2024 return hr;
2025 }
2026
2027 /******************************************************************************
2028 * CoRegisterClassObject [OLE32.@]
2029 *
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.
2033 *
2034 * PARAMS
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.
2040 *
2041 * RETURNS
2042 * S_OK on success,
2043 * E_INVALIDARG if lpdwRegister or pUnk are NULL,
2044 * CO_E_OBJISREG if the object is already registered. We should not return this.
2045 *
2046 * SEE ALSO
2047 * CoRevokeClassObject, CoGetClassObject
2048 *
2049 * NOTES
2050 * In-process objects are only registered for the current apartment.
2051 * CoGetClassObject() and CoCreateInstance() will not return objects registered
2052 * in other apartments.
2053 *
2054 * BUGS
2055 * MSDN claims that multiple interface registrations are legal, but we
2056 * can't do that with our current implementation.
2057 */
2058 HRESULT WINAPI CoRegisterClassObject(
2059 REFCLSID rclsid,
2060 LPUNKNOWN pUnk,
2061 DWORD dwClsContext,
2062 DWORD flags,
2063 LPDWORD lpdwRegister)
2064 {
2065 static LONG next_cookie;
2066 RegisteredClass* newClass;
2067 LPUNKNOWN foundObject;
2068 HRESULT hr;
2069 APARTMENT *apt;
2070
2071 TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
2072 debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
2073
2074 if ( (lpdwRegister==0) || (pUnk==0) )
2075 return E_INVALIDARG;
2076
2077 apt = COM_CurrentApt();
2078 if (!apt)
2079 {
2080 ERR("COM was not initialized\n");
2081 return CO_E_NOTINITIALIZED;
2082 }
2083
2084 *lpdwRegister = 0;
2085
2086 /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
2087 * differentiates the flag from REGCLS_MULTI_SEPARATE. */
2088 if (flags & REGCLS_MULTIPLEUSE)
2089 dwClsContext |= CLSCTX_INPROC_SERVER;
2090
2091 /*
2092 * First, check if the class is already registered.
2093 * If it is, this should cause an error.
2094 */
2095 hr = COM_GetRegisteredClassObject(apt, rclsid, dwClsContext, &foundObject);
2096 if (hr == S_OK) {
2097 if (flags & REGCLS_MULTIPLEUSE) {
2098 if (dwClsContext & CLSCTX_LOCAL_SERVER)
2099 hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
2100 IUnknown_Release(foundObject);
2101 return hr;
2102 }
2103 IUnknown_Release(foundObject);
2104 ERR("object already registered for class %s\n", debugstr_guid(rclsid));
2105 return CO_E_OBJISREG;
2106 }
2107
2108 newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
2109 if ( newClass == NULL )
2110 return E_OUTOFMEMORY;
2111
2112 newClass->classIdentifier = *rclsid;
2113 newClass->apartment_id = apt->oxid;
2114 newClass->runContext = dwClsContext;
2115 newClass->connectFlags = flags;
2116 newClass->pMarshaledData = NULL;
2117 newClass->RpcRegistration = NULL;
2118
2119 if (!(newClass->dwCookie = InterlockedIncrement( &next_cookie )))
2120 newClass->dwCookie = InterlockedIncrement( &next_cookie );
2121
2122 /*
2123 * Since we're making a copy of the object pointer, we have to increase its
2124 * reference count.
2125 */
2126 newClass->classObject = pUnk;
2127 IUnknown_AddRef(newClass->classObject);
2128
2129 EnterCriticalSection( &csRegisteredClassList );
2130 list_add_tail(&RegisteredClassList, &newClass->entry);
2131 LeaveCriticalSection( &csRegisteredClassList );
2132
2133 *lpdwRegister = newClass->dwCookie;
2134
2135 if (dwClsContext & CLSCTX_LOCAL_SERVER) {
2136 hr = CreateStreamOnHGlobal(0, TRUE, &newClass->pMarshaledData);
2137 if (hr) {
2138 FIXME("Failed to create stream on hglobal, %x\n", hr);
2139 return hr;
2140 }
2141 hr = CoMarshalInterface(newClass->pMarshaledData, &IID_IUnknown,
2142 newClass->classObject, MSHCTX_LOCAL, NULL,
2143 MSHLFLAGS_TABLESTRONG);
2144 if (hr) {
2145 FIXME("CoMarshalInterface failed, %x!\n",hr);
2146 return hr;
2147 }
2148
2149 hr = RPC_StartLocalServer(&newClass->classIdentifier,
2150 newClass->pMarshaledData,
2151 flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
2152 &newClass->RpcRegistration);
2153 }
2154 return S_OK;
2155 }
2156
2157 static void get_threading_model(HKEY key, LPWSTR value, DWORD len)
2158 {
2159 static const WCHAR wszThreadingModel[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
2160 DWORD keytype;
2161 DWORD ret;
2162 DWORD dwLength = len * sizeof(WCHAR);
2163
2164 ret = RegQueryValueExW(key, wszThreadingModel, NULL, &keytype, (LPBYTE)value, &dwLength);
2165 if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
2166 value[0] = '\0';
2167 }
2168
2169 static HRESULT get_inproc_class_object(APARTMENT *apt, HKEY hkeydll,
2170 REFCLSID rclsid, REFIID riid,
2171 BOOL hostifnecessary, void **ppv)
2172 {
2173 WCHAR dllpath[MAX_PATH+1];
2174 BOOL apartment_threaded;
2175
2176 if (hostifnecessary)
2177 {
2178 static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
2179 static const WCHAR wszFree[] = {'F','r','e','e',0};
2180 static const WCHAR wszBoth[] = {'B','o','t','h',0};
2181 WCHAR threading_model[10 /* strlenW(L"apartment")+1 */];
2182
2183 get_threading_model(hkeydll, threading_model, ARRAYSIZE(threading_model));
2184 /* "Apartment" */
2185 if (!strcmpiW(threading_model, wszApartment))
2186 {
2187 apartment_threaded = TRUE;
2188 if (apt->multi_threaded)
2189 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, hkeydll, rclsid, riid, ppv);
2190 }
2191 /* "Free" */
2192 else if (!strcmpiW(threading_model, wszFree))
2193 {
2194 apartment_threaded = FALSE;
2195 if (!apt->multi_threaded)
2196 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, hkeydll, rclsid, riid, ppv);
2197 }
2198 /* everything except "Apartment", "Free" and "Both" */
2199 else if (strcmpiW(threading_model, wszBoth))
2200 {
2201 apartment_threaded = TRUE;
2202 /* everything else is main-threaded */
2203 if (threading_model[0])
2204 FIXME("unrecognised threading model %s for object %s, should be main-threaded?\n",
2205 debugstr_w(threading_model), debugstr_guid(rclsid));
2206
2207 if (apt->multi_threaded || !apt->main)
2208 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, hkeydll, rclsid, riid, ppv);
2209 }
2210 else
2211 apartment_threaded = FALSE;
2212 }
2213 else
2214 apartment_threaded = !apt->multi_threaded;
2215
2216 if (COM_RegReadPath(hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
2217 {
2218 /* failure: CLSID is not found in registry */
2219 WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
2220 return REGDB_E_CLASSNOTREG;
2221 }
2222
2223 return apartment_getclassobject(apt, dllpath, apartment_threaded,
2224 rclsid, riid, ppv);
2225 }
2226
2227 /***********************************************************************
2228 * CoGetClassObject [OLE32.@]
2229 *
2230 * Creates an object of the specified class.
2231 *
2232 * PARAMS
2233 * rclsid [I] Class ID to create an instance of.
2234 * dwClsContext [I] Flags to restrict the location of the created instance.
2235 * pServerInfo [I] Optional. Details for connecting to a remote server.
2236 * iid [I] The ID of the interface of the instance to return.
2237 * ppv [O] On returns, contains a pointer to the specified interface of the object.
2238 *
2239 * RETURNS
2240 * Success: S_OK
2241 * Failure: HRESULT code.
2242 *
2243 * NOTES
2244 * The dwClsContext parameter can be one or more of the following:
2245 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2246 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2247 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2248 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2249 *
2250 * SEE ALSO
2251 * CoCreateInstance()
2252 */
2253 HRESULT WINAPI CoGetClassObject(
2254 REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
2255 REFIID iid, LPVOID *ppv)
2256 {
2257 LPUNKNOWN regClassObject;
2258 HRESULT hres = E_UNEXPECTED;
2259 APARTMENT *apt;
2260 BOOL release_apt = FALSE;
2261
2262 TRACE("CLSID: %s,IID: %s\n", debugstr_guid(rclsid), debugstr_guid(iid));
2263
2264 if (!ppv)
2265 return E_INVALIDARG;
2266
2267 *ppv = NULL;
2268
2269 if (!(apt = COM_CurrentApt()))
2270 {
2271 if (!(apt = apartment_find_multi_threaded()))
2272 {
2273 ERR("apartment not initialised\n");
2274 return CO_E_NOTINITIALIZED;
2275 }
2276 release_apt = TRUE;
2277 }
2278
2279 if (pServerInfo) {
2280 FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
2281 debugstr_w(pServerInfo->pwszName), pServerInfo->pAuthInfo);
2282 }
2283
2284 /*
2285 * First, try and see if we can't match the class ID with one of the
2286 * registered classes.
2287 */
2288 if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
2289 &regClassObject))
2290 {
2291 /* Get the required interface from the retrieved pointer. */
2292 hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
2293
2294 /*
2295 * Since QI got another reference on the pointer, we want to release the
2296 * one we already have. If QI was unsuccessful, this will release the object. This
2297 * is good since we are not returning it in the "out" parameter.
2298 */
2299 IUnknown_Release(regClassObject);
2300 if (release_apt) apartment_release(apt);
2301 return hres;
2302 }
2303
2304 /* First try in-process server */
2305 if (CLSCTX_INPROC_SERVER & dwClsContext)
2306 {
2307 static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
2308 HKEY hkey;
2309
2310 if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
2311 {
2312 if (release_apt) apartment_release(apt);
2313 return FTMarshalCF_Create(iid, ppv);
2314 }
2315
2316 hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
2317 if (FAILED(hres))
2318 {
2319 if (hres == REGDB_E_CLASSNOTREG)
2320 ERR("class %s not registered\n", debugstr_guid(rclsid));
2321 else if (hres == REGDB_E_KEYMISSING)
2322 {
2323 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
2324 hres = REGDB_E_CLASSNOTREG;
2325 }
2326 }
2327
2328 if (SUCCEEDED(hres))
2329 {
2330 hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2331 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2332 RegCloseKey(hkey);
2333 }
2334
2335 /* return if we got a class, otherwise fall through to one of the
2336 * other types */
2337 if (SUCCEEDED(hres))
2338 {
2339 if (release_apt) apartment_release(apt);
2340 return hres;
2341 }
2342 }
2343
2344 /* Next try in-process handler */
2345 if (CLSCTX_INPROC_HANDLER & dwClsContext)
2346 {
2347 static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
2348 HKEY hkey;
2349
2350 hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
2351 if (FAILED(hres))
2352 {
2353 if (hres == REGDB_E_CLASSNOTREG)
2354 ERR("class %s not registered\n", debugstr_guid(rclsid));
2355 else if (hres == REGDB_E_KEYMISSING)
2356 {
2357 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
2358 hres = REGDB_E_CLASSNOTREG;
2359 }
2360 }
2361
2362 if (SUCCEEDED(hres))
2363 {
2364 hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2365 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2366 RegCloseKey(hkey);
2367 }
2368
2369 /* return if we got a class, otherwise fall through to one of the
2370 * other types */
2371 if (SUCCEEDED(hres))
2372 {
2373 if (release_apt) apartment_release(apt);
2374 return hres;
2375 }
2376 }
2377 if (release_apt) apartment_release(apt);
2378
2379 /* Next try out of process */
2380 if (CLSCTX_LOCAL_SERVER & dwClsContext)
2381 {
2382 hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
2383 if (SUCCEEDED(hres))
2384 return hres;
2385 }
2386
2387 /* Finally try remote: this requires networked DCOM (a lot of work) */
2388 if (CLSCTX_REMOTE_SERVER & dwClsContext)
2389 {
2390 FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
2391 hres = REGDB_E_CLASSNOTREG;
2392 }
2393
2394 if (FAILED(hres))
2395 ERR("no class object %s could be created for context 0x%x\n",
2396 debugstr_guid(rclsid), dwClsContext);
2397 return hres;
2398 }
2399
2400 /***********************************************************************
2401 * CoResumeClassObjects (OLE32.@)
2402 *
2403 * Resumes all class objects registered with REGCLS_SUSPENDED.
2404 *
2405 * RETURNS
2406 * Success: S_OK.
2407 * Failure: HRESULT code.
2408 */
2409 HRESULT WINAPI CoResumeClassObjects(void)
2410 {
2411 FIXME("stub\n");
2412 return S_OK;
2413 }
2414
2415 /***********************************************************************
2416 * CoCreateInstance [OLE32.@]
2417 *
2418 * Creates an instance of the specified class.
2419 *
2420 * PARAMS
2421 * rclsid [I] Class ID to create an instance of.
2422 * pUnkOuter [I] Optional outer unknown to allow aggregation with another object.
2423 * dwClsContext [I] Flags to restrict the location of the created instance.
2424 * iid [I] The ID of the interface of the instance to return.
2425 * ppv [O] On returns, contains a pointer to the specified interface of the instance.
2426 *
2427 * RETURNS
2428 * Success: S_OK
2429 * Failure: HRESULT code.
2430 *
2431 * NOTES
2432 * The dwClsContext parameter can be one or more of the following:
2433 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2434 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2435 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2436 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2437 *
2438 * Aggregation is the concept of deferring the IUnknown of an object to another
2439 * object. This allows a separate object to behave as though it was part of
2440 * the object and to allow this the pUnkOuter parameter can be set. Note that
2441 * not all objects support having an outer of unknown.
2442 *
2443 * SEE ALSO
2444 * CoGetClassObject()
2445 */
2446 HRESULT WINAPI CoCreateInstance(
2447 REFCLSID rclsid,
2448 LPUNKNOWN pUnkOuter,
2449 DWORD dwClsContext,
2450 REFIID iid,
2451 LPVOID *ppv)
2452 {
2453 HRESULT hres;
2454 LPCLASSFACTORY lpclf = 0;
2455 APARTMENT *apt;
2456
2457 TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
2458 pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
2459
2460 /*
2461 * Sanity check
2462 */
2463 if (ppv==0)
2464 return E_POINTER;
2465
2466 /*
2467 * Initialize the "out" parameter
2468 */
2469 *ppv = 0;
2470
2471 if (!(apt = COM_CurrentApt()))
2472 {
2473 if (!(apt = apartment_find_multi_threaded()))
2474 {
2475 ERR("apartment not initialised\n");
2476 return CO_E_NOTINITIALIZED;
2477 }
2478 apartment_release(apt);
2479 }
2480
2481 /*
2482 * The Standard Global Interface Table (GIT) object is a process-wide singleton.
2483 * Rather than create a class factory, we can just check for it here
2484 */
2485 if (IsEqualIID(rclsid, &CLSID_StdGlobalInterfaceTable)) {
2486 if (StdGlobalInterfaceTableInstance == NULL)
2487 StdGlobalInterfaceTableInstance = StdGlobalInterfaceTable_Construct();
2488 hres = IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable*) StdGlobalInterfaceTableInstance, iid, ppv);
2489 if (hres) return hres;
2490
2491 TRACE("Retrieved GIT (%p)\n", *ppv);
2492 return S_OK;
2493 }
2494
2495 /*
2496 * Get a class factory to construct the object we want.
2497 */
2498 hres = CoGetClassObject(rclsid,
2499 dwClsContext,
2500 NULL,
2501 &IID_IClassFactory,
2502 (LPVOID)&lpclf);
2503
2504 if (FAILED(hres))
2505 return hres;
2506
2507 /*
2508 * Create the object and don't forget to release the factory
2509 */
2510 hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
2511 IClassFactory_Release(lpclf);
2512 if(FAILED(hres))
2513 {
2514 if (hres == CLASS_E_NOAGGREGATION && pUnkOuter)
2515 FIXME("Class %s does not support aggregation\n", debugstr_guid(rclsid));
2516 else
2517 FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n", debugstr_guid(iid), debugstr_guid(rclsid),hres);
2518 }
2519
2520 return hres;
2521 }
2522
2523 /***********************************************************************
2524 * CoCreateInstanceEx [OLE32.@]
2525 */
2526 HRESULT WINAPI CoCreateInstanceEx(
2527 REFCLSID rclsid,
2528 LPUNKNOWN pUnkOuter,
2529 DWORD dwClsContext,
2530 COSERVERINFO* pServerInfo,
2531 ULONG cmq,
2532 MULTI_QI* pResults)
2533 {
2534 IUnknown* pUnk = NULL;
2535 HRESULT hr;
2536 ULONG index;
2537 ULONG successCount = 0;
2538
2539 /*
2540 * Sanity check
2541 */
2542 if ( (cmq==0) || (pResults==NULL))
2543 return E_INVALIDARG;
2544
2545 if (pServerInfo!=NULL)
2546 FIXME("() non-NULL pServerInfo not supported!\n");
2547
2548 /*
2549 * Initialize all the "out" parameters.
2550 */
2551 for (index = 0; index < cmq; index++)
2552 {
2553 pResults[index].pItf = NULL;
2554 pResults[index].hr = E_NOINTERFACE;
2555 }
2556
2557 /*
2558 * Get the object and get its IUnknown pointer.
2559 */
2560 hr = CoCreateInstance(rclsid,
2561 pUnkOuter,
2562 dwClsContext,
2563 &IID_IUnknown,
2564 (VOID**)&pUnk);
2565
2566 if (hr)
2567 return hr;
2568
2569 /*
2570 * Then, query for all the interfaces requested.
2571 */
2572 for (index = 0; index < cmq; index++)
2573 {
2574 pResults[index].hr = IUnknown_QueryInterface(pUnk,
2575 pResults[index].pIID,
2576 (VOID**)&(pResults[index].pItf));
2577
2578 if (pResults[index].hr == S_OK)
2579 successCount++;
2580 }
2581
2582 /*
2583 * Release our temporary unknown pointer.
2584 */
2585 IUnknown_Release(pUnk);
2586
2587 if (successCount == 0)
2588 return E_NOINTERFACE;
2589
2590 if (successCount!=cmq)
2591 return CO_S_NOTALLINTERFACES;
2592
2593 return S_OK;
2594 }
2595
2596 /***********************************************************************
2597 * CoLoadLibrary (OLE32.@)
2598 *
2599 * Loads a library.
2600 *
2601 * PARAMS
2602 * lpszLibName [I] Path to library.
2603 * bAutoFree [I] Whether the library should automatically be freed.
2604 *
2605 * RETURNS
2606 * Success: Handle to loaded library.
2607 * Failure: NULL.
2608 *
2609 * SEE ALSO
2610 * CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2611 */
2612 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
2613 {
2614 TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
2615
2616 return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
2617 }
2618
2619 /***********************************************************************
2620 * CoFreeLibrary [OLE32.@]
2621 *
2622 * Unloads a library from memory.
2623 *
2624 * PARAMS
2625 * hLibrary [I] Handle to library to unload.
2626 *
2627 * RETURNS
2628 * Nothing
2629 *
2630 * SEE ALSO
2631 * CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2632 */
2633 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
2634 {
2635 FreeLibrary(hLibrary);
2636 }
2637
2638
2639 /***********************************************************************
2640 * CoFreeAllLibraries [OLE32.@]
2641 *
2642 * Function for backwards compatibility only. Does nothing.
2643 *
2644 * RETURNS
2645 * Nothing.
2646 *
2647 * SEE ALSO
2648 * CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
2649 */
2650 void WINAPI CoFreeAllLibraries(void)
2651 {
2652 /* NOP */
2653 }
2654
2655 /***********************************************************************
2656 * CoFreeUnusedLibrariesEx [OLE32.@]
2657 *
2658 * Frees any previously unused libraries whose delay has expired and marks
2659 * currently unused libraries for unloading. Unused are identified as those that
2660 * return S_OK from their DllCanUnloadNow function.
2661 *
2662 * PARAMS
2663 * dwUnloadDelay [I] Unload delay in milliseconds.
2664 * dwReserved [I] Reserved. Set to 0.
2665 *
2666 * RETURNS
2667 * Nothing.
2668 *
2669 * SEE ALSO
2670 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2671 */
2672 void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved)
2673 {
2674 struct apartment *apt = COM_CurrentApt();
2675 if (!apt)
2676 {
2677 ERR("apartment not initialised\n");
2678 return;
2679 }
2680
2681 apartment_freeunusedlibraries(apt, dwUnloadDelay);
2682 }
2683
2684 /***********************************************************************
2685 * CoFreeUnusedLibraries [OLE32.@]
2686 *
2687 * Frees any unused libraries. Unused are identified as those that return
2688 * S_OK from their DllCanUnloadNow function.
2689 *
2690 * RETURNS
2691 * Nothing.
2692 *
2693 * SEE ALSO
2694 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2695 */
2696 void WINAPI CoFreeUnusedLibraries(void)
2697 {
2698 CoFreeUnusedLibrariesEx(INFINITE, 0);
2699 }
2700
2701 /***********************************************************************
2702 * CoFileTimeNow [OLE32.@]
2703 *
2704 * Retrieves the current time in FILETIME format.
2705 *
2706 * PARAMS
2707 * lpFileTime [O] The current time.
2708 *
2709 * RETURNS
2710 * S_OK.
2711 */
2712 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
2713 {
2714 GetSystemTimeAsFileTime( lpFileTime );
2715 return S_OK;
2716 }
2717
2718 /******************************************************************************
2719 * CoLockObjectExternal [OLE32.@]
2720 *
2721 * Increments or decrements the external reference count of a stub object.
2722 *
2723 * PARAMS
2724 * pUnk [I] Stub object.
2725 * fLock [I] If TRUE then increments the external ref-count,
2726 * otherwise decrements.
2727 * fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2728 * calling CoDisconnectObject.
2729 *
2730 * RETURNS
2731 * Success: S_OK.
2732 * Failure: HRESULT code.
2733 *
2734 * NOTES
2735 * If fLock is TRUE and an object is passed in that doesn't have a stub
2736 * manager then a new stub manager is created for the object.
2737 */
2738 HRESULT WINAPI CoLockObjectExternal(
2739 LPUNKNOWN pUnk,
2740 BOOL fLock,
2741 BOOL fLastUnlockReleases)
2742 {
2743 struct stub_manager *stubmgr;
2744 struct apartment *apt;
2745
2746 TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2747 pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
2748
2749 apt = COM_CurrentApt();
2750 if (!apt) return CO_E_NOTINITIALIZED;
2751
2752 stubmgr = get_stub_manager_from_object(apt, pUnk);
2753
2754 if (stubmgr)
2755 {
2756 if (fLock)
2757 stub_manager_ext_addref(stubmgr, 1, FALSE);
2758 else
2759 stub_manager_ext_release(stubmgr, 1, FALSE, fLastUnlockReleases);
2760
2761 stub_manager_int_release(stubmgr);
2762
2763 return S_OK;
2764 }
2765 else if (fLock)
2766 {
2767 stubmgr = new_stub_manager(apt, pUnk);
2768
2769 if (stubmgr)
2770 {
2771 stub_manager_ext_addref(stubmgr, 1, FALSE);
2772 stub_manager_int_release(stubmgr);
2773 }
2774
2775 return S_OK;
2776 }
2777 else
2778 {
2779 WARN("stub object not found %p\n", pUnk);
2780 /* Note: native is pretty broken here because it just silently
2781 * fails, without returning an appropriate error code, making apps
2782 * think that the object was disconnected, when it actually wasn't */
2783 return S_OK;
2784 }
2785 }
2786
2787 /***********************************************************************
2788 * CoInitializeWOW (OLE32.@)
2789 *
2790 * WOW equivalent of CoInitialize?
2791 *
2792 * PARAMS
2793 * x [I] Unknown.
2794 * y [I] Unknown.
2795 *
2796 * RETURNS
2797 * Unknown.
2798 */
2799 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
2800 {
2801 FIXME("(0x%08x,0x%08x),stub!\n",x,y);
2802 return 0;
2803 }
2804
2805 /***********************************************************************
2806 * CoGetState [OLE32.@]
2807 *
2808 * Retrieves the thread state object previously stored by CoSetState().
2809 *
2810 * PARAMS
2811 * ppv [I] Address where pointer to object will be stored.
2812 *
2813 * RETURNS
2814 * Success: S_OK.
2815 * Failure: E_OUTOFMEMORY.
2816 *
2817 * NOTES
2818 * Crashes on all invalid ppv addresses, including NULL.
2819 * If the function returns a non-NULL object then the caller must release its
2820 * reference on the object when the object is no longer required.
2821 *
2822 * SEE ALSO
2823 * CoSetState().
2824 */
2825 HRESULT WINAPI CoGetState(IUnknown ** ppv)
2826 {
2827 struct oletls *info = COM_CurrentInfo();
2828 if (!info) return E_OUTOFMEMORY;
2829
2830 *ppv = NULL;
2831
2832 if (info->state)
2833 {
2834 IUnknown_AddRef(info->state);
2835 *ppv = info->state;
2836 TRACE("apt->state=%p\n", info->state);
2837 }
2838
2839 return S_OK;
2840 }
2841
2842 /***********************************************************************
2843 * CoSetState [OLE32.@]
2844 *
2845 * Sets the thread state object.
2846 *
2847 * PARAMS
2848 * pv [I] Pointer to state object to be stored.
2849 *
2850 * NOTES
2851 * The system keeps a reference on the object while the object stored.
2852 *
2853 * RETURNS
2854 * Success: S_OK.
2855 * Failure: E_OUTOFMEMORY.
2856 */
2857 HRESULT WINAPI CoSetState(IUnknown * pv)
2858 {
2859 struct oletls *info = COM_CurrentInfo();
2860 if (!info) return E_OUTOFMEMORY;
2861
2862 if (pv) IUnknown_AddRef(pv);
2863
2864 if (info->state)
2865 {
2866 TRACE("-- release %p now\n", info->state);
2867 IUnknown_Release(info->state);
2868 }
2869
2870 info->state = pv;
2871
2872 return S_OK;
2873 }
2874
2875
2876 /******************************************************************************
2877 * CoTreatAsClass [OLE32.@]
2878 *
2879 * Sets the TreatAs value of a class.
2880 *
2881 * PARAMS
2882 * clsidOld [I] Class to set TreatAs value on.
2883 * clsidNew [I] The class the clsidOld should be treated as.
2884 *
2885 * RETURNS
2886 * Success: S_OK.
2887 * Failure: HRESULT code.
2888 *
2889 * SEE ALSO
2890 * CoGetTreatAsClass
2891 */
2892 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
2893 {
2894 static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
2895 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2896 HKEY hkey = NULL;
2897 WCHAR szClsidNew[CHARS_IN_GUID];
2898 HRESULT res = S_OK;
2899 WCHAR auto_treat_as[CHARS_IN_GUID];
2900 LONG auto_treat_as_size = sizeof(auto_treat_as);
2901 CLSID id;
2902
2903 res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2904 if (FAILED(res))
2905 goto done;
2906 if (!memcmp( clsidOld, clsidNew, sizeof(*clsidOld) ))
2907 {
2908 if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
2909 CLSIDFromString(auto_treat_as, &id) == S_OK)
2910 {
2911 if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
2912 {
2913 res = REGDB_E_WRITEREGDB;
2914 goto done;
2915 }
2916 }
2917 else
2918 {
2919 RegDeleteKeyW(hkey, wszTreatAs);
2920 goto done;
2921 }
2922 }
2923 else if (!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew)) &&
2924 !RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)))
2925 {
2926 res = REGDB_E_WRITEREGDB;
2927 goto done;
2928 }
2929
2930 done:
2931 if (hkey) RegCloseKey(hkey);
2932 return res;
2933 }
2934
2935 /******************************************************************************
2936 * CoGetTreatAsClass [OLE32.@]
2937 *
2938 * Gets the TreatAs value of a class.
2939 *
2940 * PARAMS
2941 * clsidOld [I] Class to get the TreatAs value of.
2942 * clsidNew [I] The class the clsidOld should be treated as.
2943 *
2944 * RETURNS
2945 * Success: S_OK.
2946 * Failure: HRESULT code.
2947 *
2948 * SEE ALSO
2949 * CoSetTreatAsClass
2950 */
2951 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
2952 {
2953 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2954 HKEY hkey = NULL;
2955 WCHAR szClsidNew[CHARS_IN_GUID];
2956 HRESULT res = S_OK;
2957 LONG len = sizeof(szClsidNew);
2958
2959 TRACE("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
2960 *clsidNew = *clsidOld; /* copy over old value */
2961
2962 res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
2963 if (FAILED(res))
2964 {
2965 res = S_FALSE;
2966 goto done;
2967 }
2968 if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
2969 {
2970 res = S_FALSE;
2971 goto done;
2972 }
2973 res = CLSIDFromString(szClsidNew,clsidNew);
2974 if (FAILED(res))
2975 ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
2976 done:
2977 if (hkey) RegCloseKey(hkey);
2978 return res;
2979 }
2980
2981 /******************************************************************************
2982 * CoGetCurrentProcess [OLE32.@]
2983 *
2984 * Gets the current process ID.
2985 *
2986 * RETURNS
2987 * The current process ID.
2988 *
2989 * NOTES
2990 * Is DWORD really the correct return type for this function?
2991 */
2992 DWORD WINAPI CoGetCurrentProcess(void)
2993 {
2994 return GetCurrentProcessId();
2995 }
2996
2997 /******************************************************************************
2998 * CoRegisterMessageFilter [OLE32.@]
2999 *
3000 * Registers a message filter.
3001 *
3002 * PARAMS
3003 * lpMessageFilter [I] Pointer to interface.
3004 * lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
3005 *
3006 * RETURNS
3007 * Success: S_OK.
3008 * Failure: HRESULT code.
3009 *
3010 * NOTES
3011 * Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
3012 * lpMessageFilter removes the message filter.
3013 *
3014 * If lplpMessageFilter is not NULL the previous message filter will be
3015 * returned in the memory pointer to this parameter and the caller is
3016 * responsible for releasing the object.
3017 *
3018 * The current thread be in an apartment otherwise the function will crash.
3019 */
3020 HRESULT WINAPI CoRegisterMessageFilter(
3021 LPMESSAGEFILTER lpMessageFilter,
3022 LPMESSAGEFILTER *lplpMessageFilter)
3023 {
3024 struct apartment *apt;
3025 IMessageFilter *lpOldMessageFilter;
3026
3027 TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
3028
3029 apt = COM_CurrentApt();
3030
3031 /* can't set a message filter in a multi-threaded apartment */
3032 if (!apt || apt->multi_threaded)
3033 {
3034 WARN("can't set message filter in MTA or uninitialized apt\n");
3035 return CO_E_NOT_SUPPORTED;
3036 }
3037
3038 if (lpMessageFilter)
3039 IMessageFilter_AddRef(lpMessageFilter);
3040
3041 EnterCriticalSection(&apt->cs);
3042
3043 lpOldMessageFilter = apt->filter;
3044 apt->filter = lpMessageFilter;
3045
3046 LeaveCriticalSection(&apt->cs);
3047
3048 if (lplpMessageFilter)
3049 *lplpMessageFilter = lpOldMessageFilter;
3050 else if (lpOldMessageFilter)
3051 IMessageFilter_Release(lpOldMessageFilter);
3052
3053 return S_OK;
3054 }
3055
3056 /***********************************************************************
3057 * CoIsOle1Class [OLE32.@]
3058 *
3059 * Determines whether the specified class an OLE v1 class.
3060 *
3061 * PARAMS
3062 * clsid [I] Class to test.
3063 *
3064 * RETURNS
3065 * TRUE if the class is an OLE v1 class, or FALSE otherwise.
3066 */
3067 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
3068 {
3069 FIXME("%s\n", debugstr_guid(clsid));
3070 return FALSE;
3071 }
3072
3073 /***********************************************************************
3074 * IsEqualGUID [OLE32.@]
3075 *
3076 * Compares two Unique Identifiers.
3077 *
3078 * PARAMS
3079 * rguid1 [I] The first GUID to compare.
3080 * rguid2 [I] The other GUID to compare.
3081 *
3082 * RETURNS
3083 * TRUE if equal
3084 */
3085 #undef IsEqualGUID
3086 BOOL WINAPI IsEqualGUID(
3087 REFGUID rguid1,
3088 REFGUID rguid2)
3089 {
3090 return !memcmp(rguid1,rguid2,sizeof(GUID));
3091 }
3092
3093 /***********************************************************************
3094 * CoInitializeSecurity [OLE32.@]
3095 */
3096 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
3097 SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
3098 void* pReserved1, DWORD dwAuthnLevel,
3099 DWORD dwImpLevel, void* pReserved2,
3100 DWORD dwCapabilities, void* pReserved3)
3101 {
3102 FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
3103 asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
3104 dwCapabilities, pReserved3);
3105 return S_OK;
3106 }
3107
3108 /***********************************************************************
3109 * CoSuspendClassObjects [OLE32.@]
3110 *
3111 * Suspends all registered class objects to prevent further requests coming in
3112 * for those objects.
3113 *
3114 * RETURNS
3115 * Success: S_OK.
3116 * Failure: HRESULT code.
3117 */
3118 HRESULT WINAPI CoSuspendClassObjects(void)
3119 {
3120 FIXME("\n");
3121 return S_OK;
3122 }
3123
3124 /***********************************************************************
3125 * CoAddRefServerProcess [OLE32.@]
3126 *
3127 * Helper function for incrementing the reference count of a local-server
3128 * process.
3129 *
3130 * RETURNS
3131 * New reference count.
3132 *
3133 * SEE ALSO
3134 * CoReleaseServerProcess().
3135 */
3136 ULONG WINAPI CoAddRefServerProcess(void)
3137 {
3138 ULONG refs;
3139
3140 TRACE("\n");
3141
3142 EnterCriticalSection(&csRegisteredClassList);
3143 refs = ++s_COMServerProcessReferences;
3144 LeaveCriticalSection(&csRegisteredClassList);
3145
3146 TRACE("refs before: %d\n", refs - 1);
3147
3148 return refs;
3149 }
3150
3151 /***********************************************************************
3152 * CoReleaseServerProcess [OLE32.@]
3153 *
3154 * Helper function for decrementing the reference count of a local-server
3155 * process.
3156 *
3157 * RETURNS
3158 * New reference count.
3159 *
3160 * NOTES
3161 * When reference count reaches 0, this function suspends all registered
3162 * classes so no new connections are accepted.
3163 *
3164 * SEE ALSO
3165 * CoAddRefServerProcess(), CoSuspendClassObjects().
3166 */
3167 ULONG WINAPI CoReleaseServerProcess(void)
3168 {
3169 ULONG refs;
3170
3171 TRACE("\n");
3172
3173 EnterCriticalSection(&csRegisteredClassList);
3174
3175 refs = --s_COMServerProcessReferences;
3176 /* FIXME: if (!refs) COM_SuspendClassObjects(); */
3177
3178 LeaveCriticalSection(&csRegisteredClassList);
3179
3180 TRACE("refs after: %d\n", refs);
3181
3182 return refs;
3183 }
3184
3185 /***********************************************************************
3186 * CoIsHandlerConnected [OLE32.@]
3187 *
3188 * Determines whether a proxy is connected to a remote stub.
3189 *
3190 * PARAMS
3191 * pUnk [I] Pointer to object that may or may not be connected.
3192 *
3193 * RETURNS
3194 * TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
3195 * FALSE otherwise.
3196 */
3197 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
3198 {
3199 FIXME("%p\n", pUnk);
3200
3201 return TRUE;
3202 }
3203
3204 /***********************************************************************
3205 * CoAllowSetForegroundWindow [OLE32.@]
3206 *
3207 */
3208 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
3209 {
3210 FIXME("(%p, %p): stub\n", pUnk, pvReserved);
3211 return S_OK;
3212 }
3213
3214 /***********************************************************************
3215 * CoQueryProxyBlanket [OLE32.@]
3216 *
3217 * Retrieves the security settings being used by a proxy.
3218 *
3219 * PARAMS
3220 * pProxy [I] Pointer to the proxy object.
3221 * pAuthnSvc [O] The type of authentication service.
3222 * pAuthzSvc [O] The type of authorization service.
3223 * ppServerPrincName [O] Optional. The server prinicple name.
3224 * pAuthnLevel [O] The authentication level.
3225 * pImpLevel [O] The impersonation level.
3226 * ppAuthInfo [O] Information specific to the authorization/authentication service.
3227 * pCapabilities [O] Flags affecting the security behaviour.
3228 *
3229 * RETURNS
3230 * Success: S_OK.
3231 * Failure: HRESULT code.
3232 *
3233 * SEE ALSO
3234 * CoCopyProxy, CoSetProxyBlanket.
3235 */
3236 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
3237 DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
3238 DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
3239 {
3240 IClientSecurity *pCliSec;
3241 HRESULT hr;
3242
3243 TRACE("%p\n", pProxy);
3244
3245 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3246 if (SUCCEEDED(hr))
3247 {
3248 hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
3249 pAuthzSvc, ppServerPrincName,
3250 pAuthnLevel, pImpLevel, ppAuthInfo,
3251 pCapabilities);
3252 IClientSecurity_Release(pCliSec);
3253 }
3254
3255 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3256 return hr;
3257 }
3258
3259 /***********************************************************************
3260 * CoSetProxyBlanket [OLE32.@]
3261 *
3262 * Sets the security settings for a proxy.
3263 *
3264 * PARAMS
3265 * pProxy [I] Pointer to the proxy object.
3266 * AuthnSvc [I] The type of authentication service.
3267 * AuthzSvc [I] The type of authorization service.
3268 * pServerPrincName [I] The server prinicple name.
3269 * AuthnLevel [I] The authentication level.
3270 * ImpLevel [I] The impersonation level.
3271 * pAuthInfo [I] Information specific to the authorization/authentication service.
3272 * Capabilities [I] Flags affecting the security behaviour.
3273 *
3274 * RETURNS
3275 * Success: S_OK.
3276 * Failure: HRESULT code.
3277 *
3278 * SEE ALSO
3279 * CoQueryProxyBlanket, CoCopyProxy.
3280 */
3281 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
3282 DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
3283 DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
3284 {
3285 IClientSecurity *pCliSec;
3286 HRESULT hr;
3287
3288 TRACE("%p\n", pProxy);
3289
3290 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3291 if (SUCCEEDED(hr))
3292 {
3293 hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
3294 AuthzSvc, pServerPrincName,
3295 AuthnLevel, ImpLevel, pAuthInfo,
3296 Capabilities);
3297 IClientSecurity_Release(pCliSec);
3298 }
3299
3300 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3301 return hr;
3302 }
3303
3304 /***********************************************************************
3305 * CoCopyProxy [OLE32.@]
3306 *
3307 * Copies a proxy.
3308 *
3309 * PARAMS
3310 * pProxy [I] Pointer to the proxy object.
3311 * ppCopy [O] Copy of the proxy.
3312 *
3313 * RETURNS
3314 * Success: S_OK.
3315 * Failure: HRESULT code.
3316 *
3317 * SEE ALSO
3318 * CoQueryProxyBlanket, CoSetProxyBlanket.
3319 */
3320 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
3321 {
3322 IClientSecurity *pCliSec;
3323 HRESULT hr;
3324
3325 TRACE("%p\n", pProxy);
3326
3327 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3328 if (SUCCEEDED(hr))
3329 {
3330 hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
3331 IClientSecurity_Release(pCliSec);
3332 }
3333
3334 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3335 return hr;
3336 }
3337
3338
3339 /***********************************************************************
3340 * CoGetCallContext [OLE32.@]
3341 *
3342 * Gets the context of the currently executing server call in the current
3343 * thread.
3344 *
3345 * PARAMS
3346 * riid [I] Context interface to return.
3347 * ppv [O] Pointer to memory that will receive the context on return.
3348 *
3349 * RETURNS
3350 * Success: S_OK.
3351 * Failure: HRESULT code.
3352 */
3353 HRESULT WINAPI CoGetCallContext(REFIID riid, void **ppv)
3354 {
3355 struct oletls *info = COM_CurrentInfo