projects / reactos.git / blob
? search:


b2cf72b07cb1766f486aa286589e5b2628dc8c27
[reactos.git] / reactos / lib / 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 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 * Note
26 * 1. COINIT_MULTITHREADED is 0; it is the lack of COINIT_APARTMENTTHREADED
27 * Therefore do not test against COINIT_MULTITHREADED
28 *
29 * TODO list: (items bunched together depend on each other)
30 *
31 * - Implement the service control manager (in rpcss) to keep track
32 * of registered class objects: ISCM::ServerRegisterClsid et al
33 * - Implement the OXID resolver so we don't need magic endpoint names for
34 * clients and servers to meet up
35 *
36 * - Pump the message loop during RPC calls.
37 * - Call IMessageFilter functions.
38 *
39 * - Make all ole interface marshaling use NDR to be wire compatible with
40 * native DCOM
41 * - Use & interpret ORPCTHIS & ORPCTHAT.
42 *
43 */
44
45 #include "config.h"
46
47 #include <stdlib.h>
48 #include <stdarg.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <assert.h>
52
53 #define COBJMACROS
54 #define NONAMELESSUNION
55 #define NONAMELESSSTRUCT
56
57 #include "windef.h"
58 #include "winbase.h"
59 #include "winerror.h"
60 #include "winreg.h"
61 #include "winuser.h"
62 #include "objbase.h"
63 #include "ole2.h"
64 #include "ole2ver.h"
65
66 #include "compobj_private.h"
67
68 #include "wine/unicode.h"
69 #include "wine/debug.h"
70
71 WINE_DEFAULT_DEBUG_CHANNEL(ole);
72
73 HINSTANCE OLE32_hInstance = 0; /* FIXME: make static ... */
74
75 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
76
77 /****************************************************************************
78 * This section defines variables internal to the COM module.
79 *
80 * TODO: Most of these things will have to be made thread-safe.
81 */
82
83 static HRESULT COM_GetRegisteredClassObject(REFCLSID rclsid, DWORD dwClsContext, LPUNKNOWN* ppUnk);
84 static void COM_RevokeAllClasses(void);
85
86 const CLSID CLSID_StdGlobalInterfaceTable = { 0x00000323, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
87
88 APARTMENT *MTA; /* protected by csApartment */
89 static struct list apts = LIST_INIT( apts ); /* protected by csApartment */
90
91 static CRITICAL_SECTION csApartment;
92 static CRITICAL_SECTION_DEBUG critsect_debug =
93 {
94 0, 0, &csApartment,
95 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
96 0, 0, { (DWORD_PTR)(__FILE__ ": csApartment") }
97 };
98 static CRITICAL_SECTION csApartment = { &critsect_debug, -1, 0, 0, 0, 0 };
99
100 /*
101 * This lock count counts the number of times CoInitialize is called. It is
102 * decreased every time CoUninitialize is called. When it hits 0, the COM
103 * libraries are freed
104 */
105 static LONG s_COMLockCount = 0;
106
107 /*
108 * This linked list contains the list of registered class objects. These
109 * are mostly used to register the factories for out-of-proc servers of OLE
110 * objects.
111 *
112 * TODO: Make this data structure aware of inter-process communication. This
113 * means that parts of this will be exported to the Wine Server.
114 */
115 typedef struct tagRegisteredClass
116 {
117 CLSID classIdentifier;
118 LPUNKNOWN classObject;
119 DWORD runContext;
120 DWORD connectFlags;
121 DWORD dwCookie;
122 LPSTREAM pMarshaledData; /* FIXME: only really need to store OXID and IPID */
123 struct tagRegisteredClass* nextClass;
124 } RegisteredClass;
125
126 static RegisteredClass* firstRegisteredClass = NULL;
127
128 static CRITICAL_SECTION csRegisteredClassList;
129 static CRITICAL_SECTION_DEBUG class_cs_debug =
130 {
131 0, 0, &csRegisteredClassList,
132 { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
133 0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
134 };
135 static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 };
136
137 /*****************************************************************************
138 * This section contains OpenDllList definitions
139 *
140 * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
141 * other functions that do LoadLibrary _without_ giving back a HMODULE.
142 * Without this list these handles would never be freed.
143 *
144 * FIXME: a DLL that says OK when asked for unloading is unloaded in the
145 * next unload-call but not before 600 sec.
146 */
147
148 typedef struct tagOpenDll {
149 HINSTANCE hLibrary;
150 struct tagOpenDll *next;
151 } OpenDll;
152
153 static OpenDll *openDllList = NULL; /* linked list of open dlls */
154
155 static CRITICAL_SECTION csOpenDllList;
156 static CRITICAL_SECTION_DEBUG dll_cs_debug =
157 {
158 0, 0, &csOpenDllList,
159 { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
160 0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
161 };
162 static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 };
163
164 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',' ',
165 '0','x','#','#','#','#','#','#','#','#',' ',0};
166 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
167
168 static void COMPOBJ_DLLList_Add(HANDLE hLibrary);
169 static void COMPOBJ_DllList_FreeUnused(int Timeout);
170
171 static void COMPOBJ_InitProcess( void )
172 {
173 WNDCLASSW wclass;
174
175 /* Dispatching to the correct thread in an apartment is done through
176 * window messages rather than RPC transports. When an interface is
177 * marshalled into another apartment in the same process, a window of the
178 * following class is created. The *caller* of CoMarshalInterface (ie the
179 * application) is responsible for pumping the message loop in that thread.
180 * The WM_USER messages which point to the RPCs are then dispatched to
181 * COM_AptWndProc by the user's code from the apartment in which the interface
182 * was unmarshalled.
183 */
184 memset(&wclass, 0, sizeof(wclass));
185 wclass.lpfnWndProc = apartment_wndproc;
186 wclass.hInstance = OLE32_hInstance;
187 wclass.lpszClassName = wszAptWinClass;
188 RegisterClassW(&wclass);
189 }
190
191 static void COMPOBJ_UninitProcess( void )
192 {
193 UnregisterClassW(wszAptWinClass, OLE32_hInstance);
194 }
195
196 static void COM_TlsDestroy(void)
197 {
198 struct oletls *info = NtCurrentTeb()->ReservedForOle;
199 if (info)
200 {
201 if (info->apt) apartment_release(info->apt);
202 if (info->errorinfo) IErrorInfo_Release(info->errorinfo);
203 if (info->state) IUnknown_Release(info->state);
204 HeapFree(GetProcessHeap(), 0, info);
205 NtCurrentTeb()->ReservedForOle = NULL;
206 }
207 }
208
209 /******************************************************************************
210 * Manage apartments.
211 */
212
213 /* allocates memory and fills in the necessary fields for a new apartment
214 * object */
215 static APARTMENT *apartment_construct(DWORD model)
216 {
217 APARTMENT *apt;
218
219 TRACE("creating new apartment, model=%ld\n", model);
220
221 apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
222 apt->tid = GetCurrentThreadId();
223
224 list_init(&apt->proxies);
225 list_init(&apt->stubmgrs);
226 apt->ipidc = 0;
227 apt->refs = 1;
228 apt->remunk_exported = FALSE;
229 apt->oidc = 1;
230 InitializeCriticalSection(&apt->cs);
231 DEBUG_SET_CRITSEC_NAME(&apt->cs, "apartment");
232
233 apt->model = model;
234
235 if (model & COINIT_APARTMENTTHREADED)
236 {
237 /* FIXME: should be randomly generated by in an RPC call to rpcss */
238 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
239 apt->win = CreateWindowW(wszAptWinClass, NULL, 0,
240 0, 0, 0, 0,
241 0, 0, OLE32_hInstance, NULL);
242 }
243 else
244 {
245 /* FIXME: should be randomly generated by in an RPC call to rpcss */
246 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
247 }
248
249 TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
250
251 /* the locking here is not currently needed for the MTA case, but it
252 * doesn't hurt and makes the code simpler */
253 EnterCriticalSection(&csApartment);
254 list_add_head(&apts, &apt->entry);
255 LeaveCriticalSection(&csApartment);
256
257 return apt;
258 }
259
260 /* gets and existing apartment if one exists or otherwise creates an apartment
261 * structure which stores OLE apartment-local information and stores a pointer
262 * to it in the thread-local storage */
263 static APARTMENT *apartment_get_or_create(DWORD model)
264 {
265 APARTMENT *apt = COM_CurrentApt();
266
267 if (!apt)
268 {
269 if (model & COINIT_APARTMENTTHREADED)
270 {
271 apt = apartment_construct(model);
272 COM_CurrentInfo()->apt = apt;
273 }
274 else
275 {
276 EnterCriticalSection(&csApartment);
277
278 /* The multi-threaded apartment (MTA) contains zero or more threads interacting
279 * with free threaded (ie thread safe) COM objects. There is only ever one MTA
280 * in a process */
281 if (MTA)
282 {
283 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA->oxid));
284 apartment_addref(MTA);
285 }
286 else
287 MTA = apartment_construct(model);
288
289 apt = MTA;
290 COM_CurrentInfo()->apt = apt;
291
292 LeaveCriticalSection(&csApartment);
293 }
294 }
295
296 return apt;
297 }
298
299 DWORD apartment_addref(struct apartment *apt)
300 {
301 DWORD refs = InterlockedIncrement(&apt->refs);
302 TRACE("%s: before = %ld\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
303 return refs;
304 }
305
306 DWORD apartment_release(struct apartment *apt)
307 {
308 DWORD ret;
309
310 EnterCriticalSection(&csApartment);
311
312 ret = InterlockedDecrement(&apt->refs);
313 TRACE("%s: after = %ld\n", wine_dbgstr_longlong(apt->oxid), ret);
314 /* destruction stuff that needs to happen under csApartment CS */
315 if (ret == 0)
316 {
317 if (apt == MTA) MTA = NULL;
318 list_remove(&apt->entry);
319 }
320
321 LeaveCriticalSection(&csApartment);
322
323 if (ret == 0)
324 {
325 struct list *cursor, *cursor2;
326
327 TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
328
329 /* no locking is needed for this apartment, because no other thread
330 * can access it at this point */
331
332 apartment_disconnectproxies(apt);
333
334 if (apt->win) DestroyWindow(apt->win);
335
336 LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
337 {
338 struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
339 /* release the implicit reference given by the fact that the
340 * stub has external references (it must do since it is in the
341 * stub manager list in the apartment and all non-apartment users
342 * must have a ref on the apartment and so it cannot be destroyed).
343 */
344 stub_manager_int_release(stubmgr);
345 }
346
347 /* if this assert fires, then another thread took a reference to a
348 * stub manager without taking a reference to the containing
349 * apartment, which it must do. */
350 assert(list_empty(&apt->stubmgrs));
351
352 if (apt->filter) IUnknown_Release(apt->filter);
353
354 DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
355 DeleteCriticalSection(&apt->cs);
356
357 HeapFree(GetProcessHeap(), 0, apt);
358 }
359
360 return ret;
361 }
362
363 /* The given OXID must be local to this process:
364 *
365 * The ref parameter is here mostly to ensure people remember that
366 * they get one, you should normally take a ref for thread safety.
367 */
368 APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
369 {
370 APARTMENT *result = NULL;
371 struct list *cursor;
372
373 EnterCriticalSection(&csApartment);
374 LIST_FOR_EACH( cursor, &apts )
375 {
376 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
377 if (apt->oxid == oxid)
378 {
379 result = apt;
380 if (ref) apartment_addref(result);
381 break;
382 }
383 }
384 LeaveCriticalSection(&csApartment);
385
386 return result;
387 }
388
389 /* gets the apartment which has a given creator thread ID. The caller must
390 * release the reference from the apartment as soon as the apartment pointer
391 * is no longer required. */
392 APARTMENT *apartment_findfromtid(DWORD tid)
393 {
394 APARTMENT *result = NULL;
395 struct list *cursor;
396
397 EnterCriticalSection(&csApartment);
398 LIST_FOR_EACH( cursor, &apts )
399 {
400 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
401 if (apt->tid == tid)
402 {
403 result = apt;
404 apartment_addref(result);
405 break;
406 }
407 }
408 LeaveCriticalSection(&csApartment);
409
410 return result;
411 }
412
413 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
414 {
415 switch (msg)
416 {
417 case DM_EXECUTERPC:
418 RPC_ExecuteCall((struct dispatch_params *)lParam);
419 return 0;
420 default:
421 return DefWindowProcW(hWnd, msg, wParam, lParam);
422 }
423 }
424
425 /*****************************************************************************
426 * This section contains OpenDllList implemantation
427 */
428
429 static void COMPOBJ_DLLList_Add(HANDLE hLibrary)
430 {
431 OpenDll *ptr;
432 OpenDll *tmp;
433
434 TRACE("\n");
435
436 EnterCriticalSection( &csOpenDllList );
437
438 if (openDllList == NULL) {
439 /* empty list -- add first node */
440 openDllList = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
441 openDllList->hLibrary=hLibrary;
442 openDllList->next = NULL;
443 } else {
444 /* search for this dll */
445 int found = FALSE;
446 for (ptr = openDllList; ptr->next != NULL; ptr=ptr->next) {
447 if (ptr->hLibrary == hLibrary) {
448 found = TRUE;
449 break;
450 }
451 }
452 if (!found) {
453 /* dll not found, add it */
454 tmp = openDllList;
455 openDllList = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
456 openDllList->hLibrary = hLibrary;
457 openDllList->next = tmp;
458 }
459 }
460
461 LeaveCriticalSection( &csOpenDllList );
462 }
463
464 static void COMPOBJ_DllList_FreeUnused(int Timeout)
465 {
466 OpenDll *curr, *next, *prev = NULL;
467 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
468 DllCanUnloadNowFunc DllCanUnloadNow;
469
470 TRACE("\n");
471
472 EnterCriticalSection( &csOpenDllList );
473
474 for (curr = openDllList; curr != NULL; ) {
475 DllCanUnloadNow = (DllCanUnloadNowFunc) GetProcAddress(curr->hLibrary, "DllCanUnloadNow");
476
477 if ( (DllCanUnloadNow != NULL) && (DllCanUnloadNow() == S_OK) ) {
478 next = curr->next;
479
480 TRACE("freeing %p\n", curr->hLibrary);
481 FreeLibrary(curr->hLibrary);
482
483 HeapFree(GetProcessHeap(), 0, curr);
484 if (curr == openDllList) {
485 openDllList = next;
486 } else {
487 prev->next = next;
488 }
489
490 curr = next;
491 } else {
492 prev = curr;
493 curr = curr->next;
494 }
495 }
496
497 LeaveCriticalSection( &csOpenDllList );
498 }
499
500 /******************************************************************************
501 * CoBuildVersion [OLE32.@]
502 * CoBuildVersion [COMPOBJ.1]
503 *
504 * Gets the build version of the DLL.
505 *
506 * PARAMS
507 *
508 * RETURNS
509 * Current build version, hiword is majornumber, loword is minornumber
510 */
511 DWORD WINAPI CoBuildVersion(void)
512 {
513 TRACE("Returning version %d, build %d.\n", rmm, rup);
514 return (rmm<<16)+rup;
515 }
516
517 /******************************************************************************
518 * CoInitialize [OLE32.@]
519 *
520 * Initializes the COM libraries by calling CoInitializeEx with
521 * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
522 *
523 * PARAMS
524 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
525 *
526 * RETURNS
527 * Success: S_OK if not already initialized, S_FALSE otherwise.
528 * Failure: HRESULT code.
529 *
530 * SEE ALSO
531 * CoInitializeEx
532 */
533 HRESULT WINAPI CoInitialize(LPVOID lpReserved)
534 {
535 /*
536 * Just delegate to the newer method.
537 */
538 return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
539 }
540
541 /******************************************************************************
542 * CoInitializeEx [OLE32.@]
543 *
544 * Initializes the COM libraries.
545 *
546 * PARAMS
547 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
548 * dwCoInit [I] One or more flags from the COINIT enumeration. See notes.
549 *
550 * RETURNS
551 * S_OK if successful,
552 * S_FALSE if this function was called already.
553 * RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
554 * threading model.
555 *
556 * NOTES
557 *
558 * The behavior used to set the IMalloc used for memory management is
559 * obsolete.
560 * The dwCoInit parameter must specify of of the following apartment
561 * threading models:
562 *| COINIT_APARTMENTTHREADED - A single-threaded apartment (STA).
563 *| COINIT_MULTITHREADED - A multi-threaded apartment (MTA).
564 * The parameter may also specify zero or more of the following flags:
565 *| COINIT_DISABLE_OLE1DDE - Don't use DDE for OLE1 support.
566 *| COINIT_SPEED_OVER_MEMORY - Trade memory for speed.
567 *
568 * SEE ALSO
569 * CoUninitialize
570 */
571 HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
572 {
573 HRESULT hr = S_OK;
574 APARTMENT *apt;
575
576 TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
577
578 if (lpReserved!=NULL)
579 {
580 ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
581 }
582
583 /*
584 * Check the lock count. If this is the first time going through the initialize
585 * process, we have to initialize the libraries.
586 *
587 * And crank-up that lock count.
588 */
589 if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
590 {
591 /*
592 * Initialize the various COM libraries and data structures.
593 */
594 TRACE("() - Initializing the COM libraries\n");
595
596 /* we may need to defer this until after apartment initialisation */
597 RunningObjectTableImpl_Initialize();
598 }
599
600 if (!(apt = COM_CurrentInfo()->apt))
601 {
602 apt = apartment_get_or_create(dwCoInit);
603 if (!apt) return E_OUTOFMEMORY;
604 }
605 else if (dwCoInit != apt->model)
606 {
607 /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
608 code then we are probably using the wrong threading model to implement that API. */
609 ERR("Attempt to change threading model of this apartment from 0x%lx to 0x%lx\n", apt->model, dwCoInit);
610 return RPC_E_CHANGED_MODE;
611 }
612 else
613 hr = S_FALSE;
614
615 COM_CurrentInfo()->inits++;
616
617 return hr;
618 }
619
620 /* On COM finalization for a STA thread, the message queue is flushed to ensure no
621 pending RPCs are ignored. Non-COM messages are discarded at this point.
622 */
623 static void COM_FlushMessageQueue(void)
624 {
625 MSG message;
626 APARTMENT *apt = COM_CurrentApt();
627
628 if (!apt || !apt->win) return;
629
630 TRACE("Flushing STA message queue\n");
631
632 while (PeekMessageA(&message, NULL, 0, 0, PM_REMOVE))
633 {
634 if (message.hwnd != apt->win)
635 {
636 WARN("discarding message 0x%x for window %p\n", message.message, message.hwnd);
637 continue;
638 }
639
640 TranslateMessage(&message);
641 DispatchMessageA(&message);
642 }
643 }
644
645 /***********************************************************************
646 * CoUninitialize [OLE32.@]
647 *
648 * This method will decrement the refcount on the current apartment, freeing
649 * the resources associated with it if it is the last thread in the apartment.
650 * If the last apartment is freed, the function will additionally release
651 * any COM resources associated with the process.
652 *
653 * PARAMS
654 *
655 * RETURNS
656 * Nothing.
657 *
658 * SEE ALSO
659 * CoInitializeEx
660 */
661 void WINAPI CoUninitialize(void)
662 {
663 struct oletls * info = COM_CurrentInfo();
664 LONG lCOMRefCnt;
665
666 TRACE("()\n");
667
668 /* will only happen on OOM */
669 if (!info) return;
670
671 /* sanity check */
672 if (!info->inits)
673 {
674 ERR("Mismatched CoUninitialize\n");
675 return;
676 }
677
678 if (!--info->inits)
679 {
680 apartment_release(info->apt);
681 info->apt = NULL;
682 }
683
684 /*
685 * Decrease the reference count.
686 * If we are back to 0 locks on the COM library, make sure we free
687 * all the associated data structures.
688 */
689 lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
690 if (lCOMRefCnt==1)
691 {
692 TRACE("() - Releasing the COM libraries\n");
693
694 RunningObjectTableImpl_UnInitialize();
695
696 /* Release the references to the registered class objects */
697 COM_RevokeAllClasses();
698
699 /* This will free the loaded COM Dlls */
700 CoFreeAllLibraries();
701
702 /* This ensures we deal with any pending RPCs */
703 COM_FlushMessageQueue();
704 }
705 else if (lCOMRefCnt<1) {
706 ERR( "CoUninitialize() - not CoInitialized.\n" );
707 InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
708 }
709 }
710
711 /******************************************************************************
712 * CoDisconnectObject [OLE32.@]
713 * CoDisconnectObject [COMPOBJ.15]
714 *
715 * Disconnects all connections to this object from remote processes. Dispatches
716 * pending RPCs while blocking new RPCs from occurring, and then calls
717 * IMarshal::DisconnectObject on the given object.
718 *
719 * Typically called when the object server is forced to shut down, for instance by
720 * the user.
721 *
722 * PARAMS
723 * lpUnk [I] The object whose stub should be disconnected.
724 * reserved [I] Reserved. Should be set to 0.
725 *
726 * RETURNS
727 * Success: S_OK.
728 * Failure: HRESULT code.
729 *
730 * SEE ALSO
731 * CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
732 */
733 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
734 {
735 HRESULT hr;
736 IMarshal *marshal;
737 APARTMENT *apt;
738
739 TRACE("(%p, 0x%08lx)\n", lpUnk, reserved);
740
741 hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
742 if (hr == S_OK)
743 {
744 hr = IMarshal_DisconnectObject(marshal, reserved);
745 IMarshal_Release(marshal);
746 return hr;
747 }
748
749 apt = COM_CurrentApt();
750 if (!apt)
751 return CO_E_NOTINITIALIZED;
752
753 apartment_disconnectobject(apt, lpUnk);
754
755 /* Note: native is pretty broken here because it just silently
756 * fails, without returning an appropriate error code if the object was
757 * not found, making apps think that the object was disconnected, when
758 * it actually wasn't */
759
760 return S_OK;
761 }
762
763 /******************************************************************************
764 * CoCreateGuid [OLE32.@]
765 *
766 * Simply forwards to UuidCreate in RPCRT4.
767 *
768 * PARAMS
769 * pguid [O] Points to the GUID to initialize.
770 *
771 * RETURNS
772 * Success: S_OK.
773 * Failure: HRESULT code.
774 *
775 * SEE ALSO
776 * UuidCreate
777 */
778 HRESULT WINAPI CoCreateGuid(GUID *pguid)
779 {
780 return UuidCreate(pguid);
781 }
782
783 /******************************************************************************
784 * CLSIDFromString [OLE32.@]
785 * IIDFromString [OLE32.@]
786 *
787 * Converts a unique identifier from its string representation into
788 * the GUID struct.
789 *
790 * PARAMS
791 * idstr [I] The string representation of the GUID.
792 * id [O] GUID converted from the string.
793 *
794 * RETURNS
795 * S_OK on success
796 * CO_E_CLASSSTRING if idstr is not a valid CLSID
797 *
798 * BUGS
799 *
800 * In Windows, if idstr is not a valid CLSID string then it gets
801 * treated as a ProgID. Wine currently doesn't do this. If idstr is
802 * NULL it's treated as an all-zero GUID.
803 *
804 * SEE ALSO
805 * StringFromCLSID
806 */
807 HRESULT WINAPI __CLSIDFromStringA(LPCSTR idstr, CLSID *id)
808 {
809 const BYTE *s;
810 int i;
811 BYTE table[256];
812
813 if (!idstr) {
814 memset( id, 0, sizeof (CLSID) );
815 return S_OK;
816 }
817
818 /* validate the CLSID string */
819 if (strlen(idstr) != 38)
820 return CO_E_CLASSSTRING;
821
822 s = (const BYTE *) idstr;
823 if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
824 return CO_E_CLASSSTRING;
825
826 for (i=1; i<37; i++) {
827 if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
828 if (!(((s[i] >= '0') && (s[i] <= '9')) ||
829 ((s[i] >= 'a') && (s[i] <= 'f')) ||
830 ((s[i] >= 'A') && (s[i] <= 'F'))))
831 return CO_E_CLASSSTRING;
832 }
833
834 TRACE("%s -> %p\n", s, id);
835
836 /* quick lookup table */
837 memset(table, 0, 256);
838
839 for (i = 0; i < 10; i++) {
840 table['0' + i] = i;
841 }
842 for (i = 0; i < 6; i++) {
843 table['A' + i] = i+10;
844 table['a' + i] = i+10;
845 }
846
847 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
848
849 id->Data1 = (table[s[1]] << 28 | table[s[2]] << 24 | table[s[3]] << 20 | table[s[4]] << 16 |
850 table[s[5]] << 12 | table[s[6]] << 8 | table[s[7]] << 4 | table[s[8]]);
851 id->Data2 = table[s[10]] << 12 | table[s[11]] << 8 | table[s[12]] << 4 | table[s[13]];
852 id->Data3 = table[s[15]] << 12 | table[s[16]] << 8 | table[s[17]] << 4 | table[s[18]];
853
854 /* these are just sequential bytes */
855 id->Data4[0] = table[s[20]] << 4 | table[s[21]];
856 id->Data4[1] = table[s[22]] << 4 | table[s[23]];
857 id->Data4[2] = table[s[25]] << 4 | table[s[26]];
858 id->Data4[3] = table[s[27]] << 4 | table[s[28]];
859 id->Data4[4] = table[s[29]] << 4 | table[s[30]];
860 id->Data4[5] = table[s[31]] << 4 | table[s[32]];
861 id->Data4[6] = table[s[33]] << 4 | table[s[34]];
862 id->Data4[7] = table[s[35]] << 4 | table[s[36]];
863
864 return S_OK;
865 }
866
867 /*****************************************************************************/
868
869 HRESULT WINAPI CLSIDFromString(LPOLESTR idstr, CLSID *id )
870 {
871 char xid[40];
872 HRESULT ret;
873
874 if (!WideCharToMultiByte( CP_ACP, 0, idstr, -1, xid, sizeof(xid), NULL, NULL ))
875 return CO_E_CLASSSTRING;
876
877
878 ret = __CLSIDFromStringA(xid,id);
879 if(ret != S_OK) { /* It appears a ProgID is also valid */
880 ret = CLSIDFromProgID(idstr, id);
881 }
882 return ret;
883 }
884
885 /* Converts a GUID into the respective string representation. */
886 HRESULT WINE_StringFromCLSID(
887 const CLSID *id, /* [in] GUID to be converted */
888 LPSTR idstr /* [out] pointer to buffer to contain converted guid */
889 ) {
890 static const char *hex = "0123456789ABCDEF";
891 char *s;
892 int i;
893
894 if (!id)
895 { ERR("called with id=Null\n");
896 *idstr = 0x00;
897 return E_FAIL;
898 }
899
900 sprintf(idstr, "{%08lX-%04X-%04X-%02X%02X-",
901 id->Data1, id->Data2, id->Data3,
902 id->Data4[0], id->Data4[1]);
903 s = &idstr[25];
904
905 /* 6 hex bytes */
906 for (i = 2; i < 8; i++) {
907 *s++ = hex[id->Data4[i]>>4];
908 *s++ = hex[id->Data4[i] & 0xf];
909 }
910
911 *s++ = '}';
912 *s++ = '\0';
913
914 TRACE("%p->%s\n", id, idstr);
915
916 return S_OK;
917 }
918
919
920 /******************************************************************************
921 * StringFromCLSID [OLE32.@]
922 * StringFromIID [OLE32.@]
923 *
924 * Converts a GUID into the respective string representation.
925 * The target string is allocated using the OLE IMalloc.
926 *
927 * PARAMS
928 * id [I] the GUID to be converted.
929 * idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
930 *
931 * RETURNS
932 * S_OK
933 * E_FAIL
934 *
935 * SEE ALSO
936 * StringFromGUID2, CLSIDFromString
937 */
938 HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
939 {
940 char buf[80];
941 HRESULT ret;
942 LPMALLOC mllc;
943
944 if ((ret = CoGetMalloc(0,&mllc)))
945 return ret;
946
947 ret=WINE_StringFromCLSID(id,buf);
948 if (!ret) {
949 DWORD len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
950 *idstr = IMalloc_Alloc( mllc, len * sizeof(WCHAR) );
951 MultiByteToWideChar( CP_ACP, 0, buf, -1, *idstr, len );
952 }
953 return ret;
954 }
955
956 /******************************************************************************
957 * StringFromGUID2 [OLE32.@]
958 * StringFromGUID2 [COMPOBJ.76]
959 *
960 * Modified version of StringFromCLSID that allows you to specify max
961 * buffer size.
962 *
963 * PARAMS
964 * id [I] GUID to convert to string.
965 * str [O] Buffer where the result will be stored.
966 * cmax [I] Size of the buffer in characters.
967 *
968 * RETURNS
969 * Success: The length of the resulting string in characters.
970 * Failure: 0.
971 */
972 INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
973 {
974 char xguid[80];
975
976 if (WINE_StringFromCLSID(id,xguid))
977 return 0;
978 return MultiByteToWideChar( CP_ACP, 0, xguid, -1, str, cmax );
979 }
980
981 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
982 HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
983 {
984 static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
985 WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) - 1];
986 LONG res;
987 HKEY key;
988
989 strcpyW(path, wszCLSIDSlash);
990 StringFromGUID2(clsid, path + strlenW(wszCLSIDSlash), CHARS_IN_GUID);
991 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, keyname ? KEY_READ : access, &key);
992 if (res == ERROR_FILE_NOT_FOUND)
993 return REGDB_E_CLASSNOTREG;
994 else if (res != ERROR_SUCCESS)
995 return REGDB_E_READREGDB;
996
997 if (!keyname)
998 {
999 *subkey = key;
1000 return S_OK;
1001 }
1002
1003 res = RegOpenKeyExW(key, keyname, 0, access, subkey);
1004 RegCloseKey(key);
1005 if (res == ERROR_FILE_NOT_FOUND)
1006 return REGDB_E_KEYMISSING;
1007 else if (res != ERROR_SUCCESS)
1008 return REGDB_E_READREGDB;
1009
1010 return S_OK;
1011 }
1012
1013 /******************************************************************************
1014 * ProgIDFromCLSID [OLE32.@]
1015 *
1016 * Converts a class id into the respective program ID.
1017 *
1018 * PARAMS
1019 * clsid [I] Class ID, as found in registry.
1020 * lplpszProgID [O] Associated ProgID.
1021 *
1022 * RETURNS
1023 * S_OK
1024 * E_OUTOFMEMORY
1025 * REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
1026 */
1027 HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *lplpszProgID)
1028 {
1029 static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
1030 HKEY hkey;
1031 HRESULT ret;
1032 LONG progidlen = 0;
1033
1034 ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
1035 if (FAILED(ret))
1036 return ret;
1037
1038 if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
1039 ret = REGDB_E_CLASSNOTREG;
1040
1041 if (ret == S_OK)
1042 {
1043 *lplpszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
1044 if (*lplpszProgID)
1045 {
1046 if (RegQueryValueW(hkey, NULL, *lplpszProgID, &progidlen))
1047 ret = REGDB_E_CLASSNOTREG;
1048 }
1049 else
1050 ret = E_OUTOFMEMORY;
1051 }
1052
1053 RegCloseKey(hkey);
1054 return ret;
1055 }
1056
1057 /******************************************************************************
1058 * CLSIDFromProgID [OLE32.@]
1059 *
1060 * Converts a program id into the respective GUID.
1061 *
1062 * PARAMS
1063 * progid [I] Unicode program ID, as found in registry.
1064 * riid [O] Associated CLSID.
1065 *
1066 * RETURNS
1067 * Success: S_OK
1068 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
1069 */
1070 HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID riid)
1071 {
1072 static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
1073 WCHAR buf2[CHARS_IN_GUID];
1074 LONG buf2len = sizeof(buf2);
1075 HKEY xhkey;
1076
1077 WCHAR *buf = HeapAlloc( GetProcessHeap(),0,(strlenW(progid)+8) * sizeof(WCHAR) );
1078 strcpyW( buf, progid );
1079 strcatW( buf, clsidW );
1080 if (RegOpenKeyW(HKEY_CLASSES_ROOT,buf,&xhkey))
1081 {
1082 HeapFree(GetProcessHeap(),0,buf);
1083 return CO_E_CLASSSTRING;
1084 }
1085 HeapFree(GetProcessHeap(),0,buf);
1086
1087 if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
1088 {
1089 RegCloseKey(xhkey);
1090 return CO_E_CLASSSTRING;
1091 }
1092 RegCloseKey(xhkey);
1093 return CLSIDFromString(buf2,riid);
1094 }
1095
1096
1097 /*****************************************************************************
1098 * CoGetPSClsid [OLE32.@]
1099 *
1100 * Retrieves the CLSID of the proxy/stub factory that implements
1101 * IPSFactoryBuffer for the specified interface.
1102 *
1103 * PARAMS
1104 * riid [I] Interface whose proxy/stub CLSID is to be returned.
1105 * pclsid [O] Where to store returned proxy/stub CLSID.
1106 *
1107 * RETURNS
1108 * S_OK
1109 * E_OUTOFMEMORY
1110 * REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
1111 *
1112 * NOTES
1113 *
1114 * The standard marshaller activates the object with the CLSID
1115 * returned and uses the CreateProxy and CreateStub methods on its
1116 * IPSFactoryBuffer interface to construct the proxies and stubs for a
1117 * given object.
1118 *
1119 * CoGetPSClsid determines this CLSID by searching the
1120 * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
1121 * in the registry and any interface id registered by
1122 * CoRegisterPSClsid within the current process.
1123 *
1124 * BUGS
1125 *
1126 * We only search the registry, not ids registered with
1127 * CoRegisterPSClsid.
1128 * Also, native returns S_OK for interfaces with a key in HKCR\Interface, but
1129 * without a ProxyStubClsid32 key and leaves garbage in pclsid. This should be
1130 * considered a bug in native unless an application depends on this (unlikely).
1131 */
1132 HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
1133 {
1134 static const WCHAR wszInterface[] = {'I','n','t','e','r','f','a','c','e','\\',0};
1135 static const WCHAR wszPSC[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
1136 WCHAR path[ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1 + ARRAYSIZE(wszPSC)];
1137 WCHAR value[CHARS_IN_GUID];
1138 LONG len;
1139 HKEY hkey;
1140
1141 TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
1142
1143 /* Interface\\{string form of riid}\\ProxyStubClsid32 */
1144 strcpyW(path, wszInterface);
1145 StringFromGUID2(riid, path + ARRAYSIZE(wszInterface) - 1, CHARS_IN_GUID);
1146 strcpyW(path + ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1, wszPSC);
1147
1148 /* Open the key.. */
1149 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey))
1150 {
1151 WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
1152 return REGDB_E_IIDNOTREG;
1153 }
1154
1155 /* ... Once we have the key, query the registry to get the
1156 value of CLSID as a string, and convert it into a
1157 proper CLSID structure to be passed back to the app */
1158 len = sizeof(value);
1159 if (ERROR_SUCCESS != RegQueryValueW(hkey, NULL, value, &len))
1160 {
1161 RegCloseKey(hkey);
1162 return REGDB_E_IIDNOTREG;
1163 }
1164 RegCloseKey(hkey);
1165
1166 /* We have the CLSid we want back from the registry as a string, so
1167 lets convert it into a CLSID structure */
1168 if (CLSIDFromString(value, pclsid) != NOERROR)
1169 return REGDB_E_IIDNOTREG;
1170
1171 TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
1172 return S_OK;
1173 }
1174
1175
1176
1177 /***********************************************************************
1178 * WriteClassStm (OLE32.@)
1179 *
1180 * Writes a CLSID to a stream.
1181 *
1182 * PARAMS
1183 * pStm [I] Stream to write to.
1184 * rclsid [I] CLSID to write.
1185 *
1186 * RETURNS
1187 * Success: S_OK.
1188 * Failure: HRESULT code.
1189 */
1190 HRESULT WINAPI WriteClassStm(IStream *pStm,REFCLSID rclsid)
1191 {
1192 TRACE("(%p,%p)\n",pStm,rclsid);
1193
1194 if (rclsid==NULL)
1195 return E_INVALIDARG;
1196
1197 return IStream_Write(pStm,rclsid,sizeof(CLSID),NULL);
1198 }
1199
1200 /***********************************************************************
1201 * ReadClassStm (OLE32.@)
1202 *
1203 * Reads a CLSID from a stream.
1204 *
1205 * PARAMS
1206 * pStm [I] Stream to read from.
1207 * rclsid [O] CLSID to read.
1208 *
1209 * RETURNS
1210 * Success: S_OK.
1211 * Failure: HRESULT code.
1212 */
1213 HRESULT WINAPI ReadClassStm(IStream *pStm,CLSID *pclsid)
1214 {
1215 ULONG nbByte;
1216 HRESULT res;
1217
1218 TRACE("(%p,%p)\n",pStm,pclsid);
1219
1220 if (pclsid==NULL)
1221 return E_INVALIDARG;
1222
1223 res = IStream_Read(pStm,(void*)pclsid,sizeof(CLSID),&nbByte);
1224
1225 if (FAILED(res))
1226 return res;
1227
1228 if (nbByte != sizeof(CLSID))
1229 return S_FALSE;
1230 else
1231 return S_OK;
1232 }
1233
1234
1235 /***
1236 * COM_GetRegisteredClassObject
1237 *
1238 * This internal method is used to scan the registered class list to
1239 * find a class object.
1240 *
1241 * Params:
1242 * rclsid Class ID of the class to find.
1243 * dwClsContext Class context to match.
1244 * ppv [out] returns a pointer to the class object. Complying
1245 * to normal COM usage, this method will increase the
1246 * reference count on this object.
1247 */
1248 static HRESULT COM_GetRegisteredClassObject(
1249 REFCLSID rclsid,
1250 DWORD dwClsContext,
1251 LPUNKNOWN* ppUnk)
1252 {
1253 HRESULT hr = S_FALSE;
1254 RegisteredClass* curClass;
1255
1256 EnterCriticalSection( &csRegisteredClassList );
1257
1258 /*
1259 * Sanity check
1260 */
1261 assert(ppUnk!=0);
1262
1263 /*
1264 * Iterate through the whole list and try to match the class ID.
1265 */
1266 curClass = firstRegisteredClass;
1267
1268 while (curClass != 0)
1269 {
1270 /*
1271 * Check if we have a match on the class ID.
1272 */
1273 if (IsEqualGUID(&(curClass->classIdentifier), rclsid))
1274 {
1275 /*
1276 * Since we don't do out-of process or DCOM just right away, let's ignore the
1277 * class context.
1278 */
1279
1280 /*
1281 * We have a match, return the pointer to the class object.
1282 */
1283 *ppUnk = curClass->classObject;
1284
1285 IUnknown_AddRef(curClass->classObject);
1286
1287 hr = S_OK;
1288 goto end;
1289 }
1290
1291 /*
1292 * Step to the next class in the list.
1293 */
1294 curClass = curClass->nextClass;
1295 }
1296
1297 end:
1298 LeaveCriticalSection( &csRegisteredClassList );
1299 /*
1300 * If we get to here, we haven't found our class.
1301 */
1302 return hr;
1303 }
1304
1305 /******************************************************************************
1306 * CoRegisterClassObject [OLE32.@]
1307 *
1308 * Registers the class object for a given class ID. Servers housed in EXE
1309 * files use this method instead of exporting DllGetClassObject to allow
1310 * other code to connect to their objects.
1311 *
1312 * PARAMS
1313 * rclsid [I] CLSID of the object to register.
1314 * pUnk [I] IUnknown of the object.
1315 * dwClsContext [I] CLSCTX flags indicating the context in which to run the executable.
1316 * flags [I] REGCLS flags indicating how connections are made.
1317 * lpdwRegister [I] A unique cookie that can be passed to CoRevokeClassObject.
1318 *
1319 * RETURNS
1320 * S_OK on success,
1321 * E_INVALIDARG if lpdwRegister or pUnk are NULL,
1322 * CO_E_OBJISREG if the object is already registered. We should not return this.
1323 *
1324 * SEE ALSO
1325 * CoRevokeClassObject, CoGetClassObject
1326 *
1327 * BUGS
1328 * MSDN claims that multiple interface registrations are legal, but we
1329 * can't do that with our current implementation.
1330 */
1331 HRESULT WINAPI CoRegisterClassObject(
1332 REFCLSID rclsid,
1333 LPUNKNOWN pUnk,
1334 DWORD dwClsContext,
1335 DWORD flags,
1336 LPDWORD lpdwRegister)
1337 {
1338 RegisteredClass* newClass;
1339 LPUNKNOWN foundObject;
1340 HRESULT hr;
1341
1342 TRACE("(%s,%p,0x%08lx,0x%08lx,%p)\n",
1343 debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
1344
1345 if ( (lpdwRegister==0) || (pUnk==0) )
1346 return E_INVALIDARG;
1347
1348 if (!COM_CurrentApt())
1349 {
1350 ERR("COM was not initialized\n");
1351 return CO_E_NOTINITIALIZED;
1352 }
1353
1354 *lpdwRegister = 0;
1355
1356 /*
1357 * First, check if the class is already registered.
1358 * If it is, this should cause an error.
1359 */
1360 hr = COM_GetRegisteredClassObject(rclsid, dwClsContext, &foundObject);
1361 if (hr == S_OK) {
1362 if (flags & REGCLS_MULTIPLEUSE) {
1363 if (dwClsContext & CLSCTX_LOCAL_SERVER)
1364 hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
1365 IUnknown_Release(foundObject);
1366 return hr;
1367 }
1368 IUnknown_Release(foundObject);
1369 ERR("object already registered for class %s\n", debugstr_guid(rclsid));
1370 return CO_E_OBJISREG;
1371 }
1372
1373 newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
1374 if ( newClass == NULL )
1375 return E_OUTOFMEMORY;
1376
1377 EnterCriticalSection( &csRegisteredClassList );
1378
1379 newClass->classIdentifier = *rclsid;
1380 newClass->runContext = dwClsContext;
1381 newClass->connectFlags = flags;
1382 newClass->pMarshaledData = NULL;
1383
1384 /*
1385 * Use the address of the chain node as the cookie since we are sure it's
1386 * unique. FIXME: not on 64-bit platforms.
1387 */
1388 newClass->dwCookie = (DWORD)newClass;
1389 newClass->nextClass = firstRegisteredClass;
1390
1391 /*
1392 * Since we're making a copy of the object pointer, we have to increase its
1393 * reference count.
1394 */
1395 newClass->classObject = pUnk;
1396 IUnknown_AddRef(newClass->classObject);
1397
1398 firstRegisteredClass = newClass;
1399 LeaveCriticalSection( &csRegisteredClassList );
1400
1401 *lpdwRegister = newClass->dwCookie;
1402
1403 if (dwClsContext & CLSCTX_LOCAL_SERVER) {
1404 IClassFactory *classfac;
1405
1406 hr = IUnknown_QueryInterface(newClass->classObject, &IID_IClassFactory,
1407 (LPVOID*)&classfac);
1408 if (hr) return hr;
1409
1410 hr = CreateStreamOnHGlobal(0, TRUE, &newClass->pMarshaledData);
1411 if (hr) {
1412 FIXME("Failed to create stream on hglobal, %lx\n", hr);
1413 IUnknown_Release(classfac);
1414 return hr;
1415 }
1416 hr = CoMarshalInterface(newClass->pMarshaledData, &IID_IClassFactory,
1417 (LPVOID)classfac, MSHCTX_LOCAL, NULL,
1418 MSHLFLAGS_TABLESTRONG);
1419 if (hr) {
1420 FIXME("CoMarshalInterface failed, %lx!\n",hr);
1421 IUnknown_Release(classfac);
1422 return hr;
1423 }
1424
1425 IUnknown_Release(classfac);
1426
1427 RPC_StartLocalServer(&newClass->classIdentifier, newClass->pMarshaledData);
1428 }
1429 return S_OK;
1430 }
1431
1432 /***********************************************************************
1433 * CoRevokeClassObject [OLE32.@]
1434 *
1435 * Removes a class object from the class registry.
1436 *
1437 * PARAMS
1438 * dwRegister [I] Cookie returned from CoRegisterClassObject().
1439 *
1440 * RETURNS
1441 * Success: S_OK.
1442 * Failure: HRESULT code.
1443 *
1444 * SEE ALSO
1445 * CoRegisterClassObject
1446 */
1447 HRESULT WINAPI CoRevokeClassObject(
1448 DWORD dwRegister)
1449 {
1450 HRESULT hr = E_INVALIDARG;
1451 RegisteredClass** prevClassLink;
1452 RegisteredClass* curClass;
1453
1454 TRACE("(%08lx)\n",dwRegister);
1455
1456 EnterCriticalSection( &csRegisteredClassList );
1457
1458 /*
1459 * Iterate through the whole list and try to match the cookie.
1460 */
1461 curClass = firstRegisteredClass;
1462 prevClassLink = &firstRegisteredClass;
1463
1464 while (curClass != 0)
1465 {
1466 /*
1467 * Check if we have a match on the cookie.
1468 */
1469 if (curClass->dwCookie == dwRegister)
1470 {
1471 /*
1472 * Remove the class from the chain.
1473 */
1474 *prevClassLink = curClass->nextClass;
1475
1476 /*
1477 * Release the reference to the class object.
1478 */
1479 IUnknown_Release(curClass->classObject);
1480
1481 if (curClass->pMarshaledData)
1482 {
1483 LARGE_INTEGER zero;
1484 memset(&zero, 0, sizeof(zero));
1485 /* FIXME: stop local server thread */
1486 IStream_Seek(curClass->pMarshaledData, zero, SEEK_SET, NULL);
1487 CoReleaseMarshalData(curClass->pMarshaledData);
1488 }
1489
1490 /*
1491 * Free the memory used by the chain node.
1492 */
1493 HeapFree(GetProcessHeap(), 0, curClass);
1494
1495 hr = S_OK;
1496 goto end;
1497 }
1498
1499 /*
1500 * Step to the next class in the list.
1501 */
1502 prevClassLink = &(curClass->nextClass);
1503 curClass = curClass->nextClass;
1504 }
1505
1506 end:
1507 LeaveCriticalSection( &csRegisteredClassList );
1508 /*
1509 * If we get to here, we haven't found our class.
1510 */
1511 return hr;
1512 }
1513
1514 /***********************************************************************
1515 * COM_RegReadPath [internal]
1516 *
1517 * Reads a registry value and expands it when necessary
1518 */
1519 HRESULT COM_RegReadPath(HKEY hkeyroot, const WCHAR *keyname, const WCHAR *valuename, WCHAR * dst, DWORD dstlen)
1520 {
1521 HRESULT hres;
1522 HKEY key;
1523 DWORD keytype;
1524 WCHAR src[MAX_PATH];
1525 DWORD dwLength = dstlen * sizeof(WCHAR);
1526
1527 if((hres = RegOpenKeyExW(hkeyroot, keyname, 0, KEY_READ, &key)) == ERROR_SUCCESS) {
1528 if( (hres = RegQueryValueExW(key, NULL, NULL, &keytype, (LPBYTE)src, &dwLength)) == ERROR_SUCCESS ) {
1529 if (keytype == REG_EXPAND_SZ) {
1530 if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) hres = ERROR_MORE_DATA;
1531 } else {
1532 lstrcpynW(dst, src, dstlen);
1533 }
1534 }
1535 RegCloseKey (key);
1536 }
1537 return hres;
1538 }
1539
1540 static HRESULT get_inproc_class_object(HKEY hkeydll, REFCLSID rclsid, REFIID riid, void **ppv)
1541 {
1542 HINSTANCE hLibrary;
1543 typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
1544 DllGetClassObjectFunc DllGetClassObject;
1545 WCHAR dllpath[MAX_PATH+1];
1546
1547 if (COM_RegReadPath(hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
1548 {
1549 /* failure: CLSID is not found in registry */
1550 WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
1551 return REGDB_E_CLASSNOTREG;
1552 }
1553
1554 if ((hLibrary = LoadLibraryExW(dllpath, 0, LOAD_WITH_ALTERED_SEARCH_PATH)) == 0)
1555 {
1556 /* failure: DLL could not be loaded */
1557 ERR("couldn't load in-process dll %s\n", debugstr_w(dllpath));
1558 return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
1559 }
1560
1561 if (!(DllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(hLibrary, "DllGetClassObject")))
1562 {
1563 /* failure: the dll did not export DllGetClassObject */
1564 ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(dllpath));
1565 FreeLibrary( hLibrary );
1566 return CO_E_DLLNOTFOUND;
1567 }
1568
1569 /* OK: get the ClassObject */
1570 COMPOBJ_DLLList_Add( hLibrary );
1571 return DllGetClassObject(rclsid, riid, ppv);
1572 }
1573
1574 /***********************************************************************
1575 * CoGetClassObject [OLE32.@]
1576 *
1577 * FIXME. If request allows of several options and there is a failure
1578 * with one (other than not being registered) do we try the
1579 * others or return failure? (E.g. inprocess is registered but
1580 * the DLL is not found but the server version works)
1581 */
1582 HRESULT WINAPI CoGetClassObject(
1583 REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
1584 REFIID iid, LPVOID *ppv)
1585 {
1586 LPUNKNOWN regClassObject;
1587 HRESULT hres = E_UNEXPECTED;
1588
1589 TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
1590
1591 if (pServerInfo) {
1592 FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo->pwszName));
1593 FIXME("\t\tpAuthInfo=%p\n",pServerInfo->pAuthInfo);
1594 }
1595
1596 /*
1597 * First, try and see if we can't match the class ID with one of the
1598 * registered classes.
1599 */
1600 if (S_OK == COM_GetRegisteredClassObject(rclsid, dwClsContext, &regClassObject))
1601 {
1602 /* Get the required interface from the retrieved pointer. */
1603 hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
1604
1605 /*
1606 * Since QI got another reference on the pointer, we want to release the
1607 * one we already have. If QI was unsuccessful, this will release the object. This
1608 * is good since we are not returning it in the "out" parameter.
1609 */
1610 IUnknown_Release(regClassObject);
1611
1612 return hres;
1613 }
1614
1615 /* First try in-process server */
1616 if (CLSCTX_INPROC_SERVER & dwClsContext)
1617 {
1618 static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
1619 HKEY hkey;
1620
1621 hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
1622 if (FAILED(hres))
1623 {
1624 if (hres == REGDB_E_CLASSNOTREG)
1625 ERR("class %s not registered\n", debugstr_guid(rclsid));
1626 else
1627 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
1628 }
1629
1630 if (SUCCEEDED(hres))
1631 {
1632 hres = get_inproc_class_object(hkey, rclsid, iid, ppv);
1633 RegCloseKey(hkey);
1634 }
1635
1636 /* return if we got a class, otherwise fall through to one of the
1637 * other types */
1638 if (SUCCEEDED(hres))
1639 return hres;
1640 }
1641
1642 /* Next try in-process handler */
1643 if (CLSCTX_INPROC_HANDLER & dwClsContext)
1644 {
1645 static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
1646 HKEY hkey;
1647
1648 hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
1649 if (FAILED(hres))
1650 {
1651 if (hres == REGDB_E_CLASSNOTREG)
1652 ERR("class %s not registered\n", debugstr_guid(rclsid));
1653 else
1654 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
1655 }
1656
1657 if (SUCCEEDED(hres))
1658 {
1659 hres = get_inproc_class_object(hkey, rclsid, iid, ppv);
1660 RegCloseKey(hkey);
1661 }
1662
1663 /* return if we got a class, otherwise fall through to one of the
1664 * other types */
1665 if (SUCCEEDED(hres))
1666 return hres;
1667 }
1668
1669 /* Next try out of process */
1670 if (CLSCTX_LOCAL_SERVER & dwClsContext)
1671 {
1672 return RPC_GetLocalClassObject(rclsid,iid,ppv);
1673 }
1674
1675 /* Finally try remote: this requires networked DCOM (a lot of work) */
1676 if (CLSCTX_REMOTE_SERVER & dwClsContext)
1677 {
1678 FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
1679 hres = E_NOINTERFACE;
1680 }
1681
1682 if (FAILED(hres))
1683 ERR("no class object %s could be created for for context 0x%lx\n",
1684 debugstr_guid(rclsid), dwClsContext);
1685 return hres;
1686 }
1687
1688 /***********************************************************************
1689 * CoResumeClassObjects (OLE32.@)
1690 *
1691 * Resumes all class objects registered with REGCLS_SUSPENDED.
1692 *
1693 * RETURNS
1694 * Success: S_OK.
1695 * Failure: HRESULT code.
1696 */
1697 HRESULT WINAPI CoResumeClassObjects(void)
1698 {
1699 FIXME("stub\n");
1700 return S_OK;
1701 }
1702
1703 /***********************************************************************
1704 * GetClassFile (OLE32.@)
1705 *
1706 * This function supplies the CLSID associated with the given filename.
1707 */
1708 HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid)
1709 {
1710 IStorage *pstg=0;
1711 HRESULT res;
1712 int nbElm, length, i;
1713 LONG sizeProgId;
1714 LPOLESTR *pathDec=0,absFile=0,progId=0;
1715 LPWSTR extension;
1716 static const WCHAR bkslashW[] = {'\\',0};
1717 static const WCHAR dotW[] = {'.',0};
1718
1719 TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
1720
1721 /* if the file contain a storage object the return the CLSID written by IStorage_SetClass method*/
1722 if((StgIsStorageFile(filePathName))==S_OK){
1723
1724 res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
1725
1726 if (SUCCEEDED(res))
1727 res=ReadClassStg(pstg,pclsid);
1728
1729 IStorage_Release(pstg);
1730
1731 return res;
1732 }
1733 /* if the file is not a storage object then attemps to match various bits in the file against a
1734 pattern in the registry. this case is not frequently used ! so I present only the psodocode for
1735 this case
1736
1737 for(i=0;i<nFileTypes;i++)
1738
1739 for(i=0;j<nPatternsForType;j++){
1740
1741 PATTERN pat;
1742 HANDLE hFile;
1743
1744 pat=ReadPatternFromRegistry(i,j);
1745 hFile=CreateFileW(filePathName,,,,,,hFile);
1746 SetFilePosition(hFile,pat.offset);
1747 ReadFile(hFile,buf,pat.size,&r,NULL);
1748 if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
1749
1750 *pclsid=ReadCLSIDFromRegistry(i);
1751 return S_OK;
1752 }
1753 }
1754 */
1755
1756 /* if the above strategies fail then search for the extension key in the registry */
1757
1758 /* get the last element (absolute file) in the path name */
1759 nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
1760 absFile=pathDec[nbElm-1];
1761
1762 /* failed if the path represente a directory and not an absolute file name*/
1763 if (!lstrcmpW(absFile, bkslashW))
1764 return MK_E_INVALIDEXTENSION;
1765
1766 /* get the extension of the file */
1767 extension = NULL;
1768 length=lstrlenW(absFile);
1769 for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
1770 /* nothing */;
1771
1772 if (!extension || !lstrcmpW(extension, dotW))
1773 return MK_E_INVALIDEXTENSION;
1774
1775 res=RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
1776
1777 /* get the progId associated to the extension */
1778 progId = CoTaskMemAlloc(sizeProgId);
1779 res = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
1780
1781 if (res==ERROR_SUCCESS)
1782 /* return the clsid associated to the progId */
1783 res= CLSIDFromProgID(progId,pclsid);
1784
1785 for(i=0; pathDec[i]!=NULL;i++)
1786 CoTaskMemFree(pathDec[i]);
1787 CoTaskMemFree(pathDec);
1788
1789 CoTaskMemFree(progId);
1790
1791 if (res==ERROR_SUCCESS)
1792 return res;
1793
1794 return MK_E_INVALIDEXTENSION;
1795 }
1796
1797 /***********************************************************************
1798 * CoCreateInstance [OLE32.@]
1799 */
1800 HRESULT WINAPI CoCreateInstance(
1801 REFCLSID rclsid,
1802 LPUNKNOWN pUnkOuter,
1803 DWORD dwClsContext,
1804 REFIID iid,
1805 LPVOID *ppv)
1806 {
1807 HRESULT hres;
1808 LPCLASSFACTORY lpclf = 0;
1809
1810 TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08lx, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
1811 pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
1812
1813 if (!COM_CurrentApt()) return CO_E_NOTINITIALIZED;
1814
1815 /*
1816 * Sanity check
1817 */
1818 if (ppv==0)
1819 return E_POINTER;
1820
1821 /*
1822 * Initialize the "out" parameter
1823 */
1824 *ppv = 0;
1825
1826 /*
1827 * The Standard Global Interface Table (GIT) object is a process-wide singleton.
1828 * Rather than create a class factory, we can just check for it here
1829 */
1830 if (IsEqualIID(rclsid, &CLSID_StdGlobalInterfaceTable)) {
1831 if (StdGlobalInterfaceTableInstance == NULL)
1832 StdGlobalInterfaceTableInstance = StdGlobalInterfaceTable_Construct();
1833 hres = IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable*) StdGlobalInterfaceTableInstance, iid, ppv);
1834 if (hres) return hres;
1835
1836 TRACE("Retrieved GIT (%p)\n", *ppv);
1837 return S_OK;
1838 }
1839
1840 /*
1841 * Get a class factory to construct the object we want.
1842 */
1843 hres = CoGetClassObject(rclsid,
1844 dwClsContext,
1845 NULL,
1846 &IID_IClassFactory,
1847 (LPVOID)&lpclf);
1848
1849 if (FAILED(hres)) {
1850 FIXME("no classfactory created for CLSID %s, hres is 0x%08lx\n",
1851 debugstr_guid(rclsid),hres);
1852 return hres;
1853 }
1854
1855 /*
1856 * Create the object and don't forget to release the factory
1857 */
1858 hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
1859 IClassFactory_Release(lpclf);
1860 if(FAILED(hres))
1861 FIXME("no instance created for interface %s of class %s, hres is 0x%08lx\n",
1862 debugstr_guid(iid), debugstr_guid(rclsid),hres);
1863
1864 return hres;
1865 }
1866
1867 /***********************************************************************
1868 * CoCreateInstanceEx [OLE32.@]
1869 */
1870 HRESULT WINAPI CoCreateInstanceEx(
1871 REFCLSID rclsid,
1872 LPUNKNOWN pUnkOuter,
1873 DWORD dwClsContext,
1874 COSERVERINFO* pServerInfo,
1875 ULONG cmq,
1876 MULTI_QI* pResults)
1877 {
1878 IUnknown* pUnk = NULL;
1879 HRESULT hr;
1880 ULONG index;
1881 ULONG successCount = 0;
1882
1883 /*
1884 * Sanity check
1885 */
1886 if ( (cmq==0) || (pResults==NULL))
1887 return E_INVALIDARG;
1888
1889 if (pServerInfo!=NULL)
1890 FIXME("() non-NULL pServerInfo not supported!\n");
1891
1892 /*
1893 * Initialize all the "out" parameters.
1894 */
1895 for (index = 0; index < cmq; index++)
1896 {
1897 pResults[index].pItf = NULL;
1898 pResults[index].hr = E_NOINTERFACE;
1899 }
1900
1901 /*
1902 * Get the object and get its IUnknown pointer.
1903 */
1904 hr = CoCreateInstance(rclsid,
1905 pUnkOuter,
1906 dwClsContext,
1907 &IID_IUnknown,
1908 (VOID**)&pUnk);
1909
1910 if (hr)
1911 return hr;
1912
1913 /*
1914 * Then, query for all the interfaces requested.
1915 */
1916 for (index = 0; index < cmq; index++)
1917 {
1918 pResults[index].hr = IUnknown_QueryInterface(pUnk,
1919 pResults[index].pIID,
1920 (VOID**)&(pResults[index].pItf));
1921
1922 if (pResults[index].hr == S_OK)
1923 successCount++;
1924 }
1925
1926 /*
1927 * Release our temporary unknown pointer.
1928 */
1929 IUnknown_Release(pUnk);
1930
1931 if (successCount == 0)
1932 return E_NOINTERFACE;
1933
1934 if (successCount!=cmq)
1935 return CO_S_NOTALLINTERFACES;
1936
1937 return S_OK;
1938 }
1939
1940 /***********************************************************************
1941 * CoLoadLibrary (OLE32.@)
1942 *
1943 * Loads a library.
1944 *
1945 * PARAMS
1946 * lpszLibName [I] Path to library.
1947 * bAutoFree [I] Whether the library should automatically be freed.
1948 *
1949 * RETURNS
1950 * Success: Handle to loaded library.
1951 * Failure: NULL.
1952 *
1953 * SEE ALSO
1954 * CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
1955 */
1956 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
1957 {
1958 TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
1959
1960 return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
1961 }
1962
1963 /***********************************************************************
1964 * CoFreeLibrary [OLE32.@]
1965 *
1966 * Unloads a library from memory.
1967 *
1968 * PARAMS
1969 * hLibrary [I] Handle to library to unload.
1970 *
1971 * RETURNS
1972 * Nothing
1973 *
1974 * SEE ALSO
1975 * CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
1976 */
1977 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
1978 {
1979 FreeLibrary(hLibrary);
1980 }
1981
1982
1983 /***********************************************************************
1984 * CoFreeAllLibraries [OLE32.@]
1985 *
1986 * Function for backwards compatibility only. Does nothing.
1987 *
1988 * RETURNS
1989 * Nothing.
1990 *
1991 * SEE ALSO
1992 * CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
1993 */
1994 void WINAPI CoFreeAllLibraries(void)
1995 {
1996 /* NOP */
1997 }
1998
1999
2000 /***********************************************************************
2001 * CoFreeUnusedLibraries [OLE32.@]
2002 * CoFreeUnusedLibraries [COMPOBJ.17]
2003 *
2004 * Frees any unused libraries. Unused are identified as those that return
2005 * S_OK from their DllCanUnloadNow function.
2006 *
2007 * RETURNS
2008 * Nothing.
2009 *
2010 * SEE ALSO
2011 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2012 */
2013 void WINAPI CoFreeUnusedLibraries(void)
2014 {
2015 /* FIXME: Calls to CoFreeUnusedLibraries from any thread always route
2016 * through the main apartment's thread to call DllCanUnloadNow */
2017 COMPOBJ_DllList_FreeUnused(0);
2018 }
2019
2020 /***********************************************************************
2021 * CoFileTimeNow [OLE32.@]
2022 * CoFileTimeNow [COMPOBJ.82]
2023 *
2024 * Retrieves the current time in FILETIME format.
2025 *
2026 * PARAMS
2027 * lpFileTime [O] The current time.
2028 *
2029 * RETURNS
2030 * S_OK.
2031 */
2032 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
2033 {
2034 GetSystemTimeAsFileTime( lpFileTime );
2035 return S_OK;
2036 }
2037
2038 static void COM_RevokeAllClasses()
2039 {
2040 EnterCriticalSection( &csRegisteredClassList );
2041
2042 while (firstRegisteredClass!=0)
2043 {
2044 CoRevokeClassObject(firstRegisteredClass->dwCookie);
2045 }
2046
2047 LeaveCriticalSection( &csRegisteredClassList );
2048 }
2049
2050 /******************************************************************************
2051 * CoLockObjectExternal [OLE32.@]
2052 *
2053 * Increments or decrements the external reference count of a stub object.
2054 *
2055 * PARAMS
2056 * pUnk [I] Stub object.
2057 * fLock [I] If TRUE then increments the external ref-count,
2058 * otherwise decrements.
2059 * fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2060 * calling CoDisconnectObject.
2061 *
2062 * RETURNS
2063 * Success: S_OK.
2064 * Failure: HRESULT code.
2065 */
2066 HRESULT WINAPI CoLockObjectExternal(
2067 LPUNKNOWN pUnk,
2068 BOOL fLock,
2069 BOOL fLastUnlockReleases)
2070 {
2071 struct stub_manager *stubmgr;
2072 struct apartment *apt;
2073
2074 TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2075 pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
2076
2077 apt = COM_CurrentApt();
2078 if (!apt) return CO_E_NOTINITIALIZED;
2079
2080 stubmgr = get_stub_manager_from_object(apt, pUnk);
2081
2082 if (stubmgr)
2083 {
2084 if (fLock)
2085 stub_manager_ext_addref(stubmgr, 1);
2086 else
2087 stub_manager_ext_release(stubmgr, 1);
2088
2089 stub_manager_int_release(stubmgr);
2090
2091 return S_OK;
2092 }
2093 else
2094 {
2095 WARN("stub object not found %p\n", pUnk);
2096 /* Note: native is pretty broken here because it just silently
2097 * fails, without returning an appropriate error code, making apps
2098 * think that the object was disconnected, when it actually wasn't */
2099 return S_OK;
2100 }
2101 }
2102
2103 /***********************************************************************
2104 * CoInitializeWOW (OLE32.@)
2105 *
2106 * WOW equivalent of CoInitialize?
2107 *
2108 * PARAMS
2109 * x [I] Unknown.
2110 * y [I] Unknown.
2111 *
2112 * RETURNS
2113 * Unknown.
2114 */
2115 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
2116 {
2117 FIXME("(0x%08lx,0x%08lx),stub!\n",x,y);
2118 return 0;
2119 }
2120
2121 /***********************************************************************
2122 * CoGetState [OLE32.@]
2123 *
2124 * Retrieves the thread state object previously stored by CoSetState().
2125 *
2126 * PARAMS
2127 * ppv [I] Address where pointer to object will be stored.
2128 *
2129 * RETURNS
2130 * Success: S_OK.
2131 * Failure: E_OUTOFMEMORY.
2132 *
2133 * NOTES
2134 * Crashes on all invalid ppv addresses, including NULL.
2135 * If the function returns a non-NULL object then the caller must release its
2136 * reference on the object when the object is no longer required.
2137 *
2138 * SEE ALSO
2139 * CoSetState().
2140 */
2141 HRESULT WINAPI CoGetState(IUnknown ** ppv)
2142 {
2143 struct oletls *info = COM_CurrentInfo();
2144 if (!info) return E_OUTOFMEMORY;
2145
2146 *ppv = NULL;
2147
2148 if (info->state)
2149 {
2150 IUnknown_AddRef(info->state);
2151 *ppv = info->state;
2152 TRACE("apt->state=%p\n", info->state);
2153 }
2154
2155 return S_OK;
2156 }
2157
2158 /***********************************************************************
2159 * CoSetState [OLE32.@]
2160 *
2161 * Sets the thread state object.
2162 *
2163 * PARAMS
2164 * pv [I] Pointer to state object to be stored.
2165 *
2166 * NOTES
2167 * The system keeps a reference on the object while the object stored.
2168 *
2169 * RETURNS
2170 * Success: S_OK.
2171 * Failure: E_OUTOFMEMORY.
2172 */
2173 HRESULT WINAPI CoSetState(IUnknown * pv)
2174 {
2175 struct oletls *info = COM_CurrentInfo();
2176 if (!info) return E_OUTOFMEMORY;
2177
2178 if (pv) IUnknown_AddRef(pv);
2179
2180 if (info->state)
2181 {
2182 TRACE("-- release %p now\n", info->state);
2183 IUnknown_Release(info->state);
2184 }
2185
2186 info->state = pv;
2187
2188 return S_OK;
2189 }
2190
2191
2192 /******************************************************************************
2193 * OleGetAutoConvert [OLE32.@]
2194 */
2195 HRESULT WINAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
2196 {
2197 static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2198 HKEY hkey = NULL;
2199 WCHAR buf[CHARS_IN_GUID];
2200 LONG len;
2201 HRESULT res = S_OK;
2202
2203 res = COM_OpenKeyForCLSID(clsidOld, wszAutoConvertTo, KEY_READ, &hkey);
2204 if (FAILED(res))
2205 goto done;
2206
2207 len = sizeof(buf);
2208 if (RegQueryValueW(hkey, NULL, buf, &len))
2209 {
2210 res = REGDB_E_KEYMISSING;
2211 goto done;
2212 }
2213 res = CLSIDFromString(buf, pClsidNew);
2214 done:
2215 if (hkey) RegCloseKey(hkey);
2216 return res;
2217 }
2218
2219 /******************************************************************************
2220 * CoTreatAsClass [OLE32.@]
2221 *
2222 * Sets the TreatAs value of a class.
2223 *
2224 * PARAMS
2225 * clsidOld [I] Class to set TreatAs value on.
2226 * clsidNew [I] The class the clsidOld should be treated as.
2227 *
2228 * RETURNS
2229 * Success: S_OK.
2230 * Failure: HRESULT code.
2231 *
2232 * SEE ALSO
2233 * CoGetTreatAsClass
2234 */
2235 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
2236 {
2237 static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
2238 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2239 HKEY hkey = NULL;
2240 WCHAR szClsidNew[CHARS_IN_GUID];
2241 HRESULT res = S_OK;
2242 WCHAR auto_treat_as[CHARS_IN_GUID];
2243 LONG auto_treat_as_size = sizeof(auto_treat_as);
2244 CLSID id;
2245
2246 res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2247 if (FAILED(res))
2248 goto done;
2249 if (!memcmp( clsidOld, clsidNew, sizeof(*clsidOld) ))
2250 {
2251 if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
2252 !CLSIDFromString(auto_treat_as, &id))
2253 {
2254 if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
2255 {
2256 res = REGDB_E_WRITEREGDB;
2257 goto done;
2258 }
2259 }
2260 else
2261 {
2262 RegDeleteKeyW(hkey, wszTreatAs);
2263 goto done;
2264 }
2265 }
2266 else if (!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew)) &&
2267 !RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)))
2268 {
2269 res = REGDB_E_WRITEREGDB;
2270 goto done;
2271 }
2272
2273 done:
2274 if (hkey) RegCloseKey(hkey);
2275 return res;
2276 }
2277
2278 /******************************************************************************
2279 * CoGetTreatAsClass [OLE32.@]
2280 *
2281 * Gets the TreatAs value of a class.
2282 *
2283 * PARAMS
2284 * clsidOld [I] Class to get the TreatAs value of.
2285 * clsidNew [I] The class the clsidOld should be treated as.
2286 *
2287 * RETURNS
2288 * Success: S_OK.
2289 * Failure: HRESULT code.
2290 *
2291 * SEE ALSO
2292 * CoSetTreatAsClass
2293 */
2294 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
2295 {
2296 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2297 HKEY hkey = NULL;
2298 WCHAR szClsidNew[CHARS_IN_GUID];
2299 HRESULT res = S_OK;
2300 LONG len = sizeof(szClsidNew);
2301
2302 FIXME("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
2303 memcpy(clsidNew,clsidOld,sizeof(CLSID)); /* copy over old value */
2304
2305 res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
2306 if (FAILED(res))
2307 goto done;
2308 if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
2309 {
2310 res = S_FALSE;
2311 goto done;
2312 }
2313 res = CLSIDFromString(szClsidNew,clsidNew);
2314 if (FAILED(res))
2315 ERR("Failed CLSIDFromStringA(%s), hres 0x%08lx\n", debugstr_w(szClsidNew), res);
2316 done:
2317 if (hkey) RegCloseKey(hkey);
2318 return res;
2319 }
2320
2321 /******************************************************************************
2322 * CoGetCurrentProcess [OLE32.@]
2323 * CoGetCurrentProcess [COMPOBJ.34]
2324 *
2325 * Gets the current process ID.
2326 *
2327 * RETURNS
2328 * The current process ID.
2329 *
2330 * NOTES
2331 * Is DWORD really the correct return type for this function?
2332 */
2333 DWORD WINAPI CoGetCurrentProcess(void)
2334 {
2335 return GetCurrentProcessId();
2336 }
2337
2338 /******************************************************************************
2339 * CoRegisterMessageFilter [OLE32.@]
2340 *
2341 * Registers a message filter.
2342 *
2343 * PARAMS
2344 * lpMessageFilter [I] Pointer to interface.
2345 * lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
2346 *
2347 * RETURNS
2348 * Success: S_OK.
2349 * Failure: HRESULT code.
2350 */
2351 HRESULT WINAPI CoRegisterMessageFilter(
2352 LPMESSAGEFILTER lpMessageFilter,
2353 LPMESSAGEFILTER *lplpMessageFilter)
2354 {
2355 FIXME("stub\n");
2356 if (lplpMessageFilter) {
2357 *lplpMessageFilter = NULL;
2358 }
2359 return S_OK;
2360 }
2361
2362 /***********************************************************************
2363 * CoIsOle1Class [OLE32.@]
2364 *
2365 * Determines whether the specified class an OLE v1 class.
2366 *
2367 * PARAMS
2368 * clsid [I] Class to test.
2369 *
2370 * RETURNS
2371 * TRUE if the class is an OLE v1 class, or FALSE otherwise.
2372 */
2373 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
2374 {
2375 FIXME("%s\n", debugstr_guid(clsid));
2376 return FALSE;
2377 }
2378
2379 /***********************************************************************
2380 * IsEqualGUID [OLE32.@]
2381 *
2382 * Compares two Unique Identifiers.
2383 *
2384 * PARAMS
2385 * rguid1 [I] The first GUID to compare.
2386 * rguid2 [I] The other GUID to compare.
2387 *
2388 * RETURNS
2389 * TRUE if equal
2390 */
2391 #undef IsEqualGUID
2392 BOOL WINAPI IsEqualGUID(
2393 REFGUID rguid1,
2394 REFGUID rguid2)
2395 {
2396 return !memcmp(rguid1,rguid2,sizeof(GUID));
2397 }
2398
2399 /***********************************************************************
2400 * CoInitializeSecurity [OLE32.@]
2401 */
2402 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
2403 SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
2404 void* pReserved1, DWORD dwAuthnLevel,
2405 DWORD dwImpLevel, void* pReserved2,
2406 DWORD dwCapabilities, void* pReserved3)
2407 {
2408 FIXME("(%p,%ld,%p,%p,%ld,%ld,%p,%ld,%p) - stub!\n", pSecDesc, cAuthSvc,
2409 asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
2410 dwCapabilities, pReserved3);
2411 return S_OK;
2412 }
2413
2414 /***********************************************************************
2415 * CoSuspendClassObjects [OLE32.@]
2416 *
2417 * Suspends all registered class objects to prevent further requests coming in
2418 * for those objects.
2419 *
2420 * RETURNS
2421 * Success: S_OK.
2422 * Failure: HRESULT code.
2423 */
2424 HRESULT WINAPI CoSuspendClassObjects(void)
2425 {
2426 FIXME("\n");
2427 return S_OK;
2428 }
2429
2430 /***********************************************************************
2431 * CoAddRefServerProcess [OLE32.@]
2432 *
2433 * Helper function for incrementing the reference count of a local-server
2434 * process.
2435 *
2436 * RETURNS
2437 * New reference count.
2438 */
2439 ULONG WINAPI CoAddRefServerProcess(void)
2440 {
2441 FIXME("\n");
2442 return 2;
2443 }
2444
2445 /***********************************************************************
2446 * CoReleaseServerProcess [OLE32.@]
2447 *
2448 * Helper function for decrementing the reference count of a local-server
2449 * process.
2450 *
2451 * RETURNS
2452 * New reference count.
2453 */
2454 ULONG WINAPI CoReleaseServerProcess(void)
2455 {
2456 FIXME("\n");
2457 return 1;
2458 }
2459
2460 /***********************************************************************
2461 * CoIsHandlerConnected [OLE32.@]
2462 *
2463 * Determines whether a proxy is connected to a remote stub.
2464 *
2465 * PARAMS
2466 * pUnk [I] Pointer to object that may or may not be connected.
2467 *
2468 * RETURNS
2469 * TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
2470 * FALSE otherwise.
2471 */
2472 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
2473 {
2474 FIXME("%p\n", pUnk);
2475
2476 return TRUE;
2477 }
2478
2479 /***********************************************************************
2480 * CoAllowSetForegroundWindow [OLE32.@]
2481 *
2482 */
2483 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
2484 {
2485 FIXME("(%p, %p): stub\n", pUnk, pvReserved);
2486 return S_OK;
2487 }
2488
2489 /***********************************************************************
2490 * CoQueryProxyBlanket [OLE32.@]
2491 *
2492 * Retrieves the security settings being used by a proxy.
2493 *
2494 * PARAMS
2495 * pProxy [I] Pointer to the proxy object.
2496 * pAuthnSvc [O] The type of authentication service.
2497 * pAuthzSvc [O] The type of authorization service.
2498 * ppServerPrincName [O] Optional. The server prinicple name.
2499 * pAuthnLevel [O] The authentication level.
2500 * pImpLevel [O] The impersonation level.
2501 * ppAuthInfo [O] Information specific to the authorization/authentication service.
2502 * pCapabilities [O] Flags affecting the security behaviour.
2503 *
2504 * RETURNS
2505 * Success: S_OK.
2506 * Failure: HRESULT code.
2507 *
2508 * SEE ALSO
2509 * CoCopyProxy, CoSetProxyBlanket.
2510 */
2511 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
2512 DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
2513 DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
2514 {
2515 IClientSecurity *pCliSec;
2516 HRESULT hr;
2517
2518 TRACE("%p\n", pProxy);
2519
2520 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
2521 if (SUCCEEDED(hr))
2522 {
2523 hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
2524 pAuthzSvc, ppServerPrincName,
2525 pAuthnLevel, pImpLevel, ppAuthInfo,
2526 pCapabilities);
2527 IClientSecurity_Release(pCliSec);
2528 }
2529
2530 if (FAILED(hr)) ERR("-- failed with 0x%08lx\n", hr);
2531 return hr;
2532 }
2533
2534 /***********************************************************************
2535 * CoSetProxyBlanket [OLE32.@]
2536 *
2537 * Sets the security settings for a proxy.
2538 *
2539 * PARAMS
2540 * pProxy [I] Pointer to the proxy object.
2541 * AuthnSvc [I] The type of authentication service.
2542 * AuthzSvc [I] The type of authorization service.
2543 * pServerPrincName [I] The server prinicple name.
2544 * AuthnLevel [I] The authentication level.
2545 * ImpLevel [I] The impersonation level.
2546 * pAuthInfo [I] Information specific to the authorization/authentication service.
2547 * Capabilities [I] Flags affecting the security behaviour.
2548 *
2549 * RETURNS
2550 * Success: S_OK.
2551 * Failure: HRESULT code.
2552 *
2553 * SEE ALSO
2554 * CoQueryProxyBlanket, CoCopyProxy.
2555 */
2556 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
2557 DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
2558 DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
2559 {
2560 IClientSecurity *pCliSec;
2561 HRESULT hr;
2562
2563 TRACE("%p\n", pProxy);
2564
2565 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
2566 if (SUCCEEDED(hr))
2567 {
2568 hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
2569 AuthzSvc, pServerPrincName,
2570 AuthnLevel, ImpLevel, pAuthInfo,
2571 Capabilities);
2572 IClientSecurity_Release(pCliSec);
2573 }
2574
2575 if (FAILED(hr)) ERR("-- failed with 0x%08lx\n", hr);
2576 return hr;
2577 }
2578
2579 /***********************************************************************
2580 * CoCopyProxy [OLE32.@]
2581 *
2582 * Copies a proxy.
2583 *
2584 * PARAMS
2585 * pProxy [I] Pointer to the proxy object.
2586 * ppCopy [O] Copy of the proxy.
2587 *
2588 * RETURNS
2589 * Success: S_OK.
2590 * Failure: HRESULT code.
2591 *
2592 * SEE ALSO
2593 * CoQueryProxyBlanket, CoSetProxyBlanket.
2594 */
2595 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
2596 {
2597 IClientSecurity *pCliSec;
2598 HRESULT hr;
2599
2600 TRACE("%p\n", pProxy);
2601
2602 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
2603 if (SUCCEEDED(hr))
2604 {
2605 hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
2606 IClientSecurity_Release(pCliSec);
2607 }
2608
2609 if (FAILED(hr)) ERR("-- failed with 0x%08lx\n", hr);
2610 return hr;
2611 }
2612
2613
2614 /***********************************************************************
2615 * CoWaitForMultipleHandles [OLE32.@]
2616 *
2617 * Waits for one or more handles to become signaled.
2618 *
2619 * PARAMS
2620 * dwFlags [I] Flags. See notes.
2621 * dwTimeout [I] Timeout in milliseconds.
2622 * cHandles [I] Number of handles pointed to by pHandles.
2623 * pHandles [I] Handles to wait for.
2624 * lpdwindex [O] Index of handle that was signaled.
2625 *
2626 * RETURNS
2627 * Success: S_OK.
2628 * Failure: RPC_S_CALLPENDING on timeout.
2629 *
2630 * NOTES
2631 *
2632 * The dwFlags parameter can be zero or more of the following:
2633 *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
2634 *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
2635 *
2636 * SEE ALSO
2637 * MsgWaitForMultipleObjects, WaitForMultipleObjects.
2638 */
2639 HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout,
2640 ULONG cHandles, const HANDLE* pHandles, LPDWORD lpdwindex)
2641 {
2642 HRESULT hr = S_OK;
2643 DWORD wait_flags = (dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0 |
2644 (dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0;
2645 DWORD start_time = GetTickCount();
2646
2647 TRACE("(0x%08lx, 0x%08lx, %ld, %p, %p)\n", dwFlags, dwTimeout, cHandles,
2648 pHandles, lpdwindex);
2649
2650 while (TRUE)
2651 {
2652 DWORD now = GetTickCount();
2653 DWORD res;
2654
2655 if ((dwTimeout != INFINITE) && (start_time + dwTimeout >= now))
2656 {
2657 hr = RPC_S_CALLPENDING;
2658 break;
2659 }
2660
2661 TRACE("waiting for rpc completion or window message\n");
2662
2663 res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
2664 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
2665 QS_ALLINPUT, wait_flags);
2666
2667 if (res == WAIT_OBJECT_0 + cHandles) /* messages available */
2668 {
2669 MSG msg;
2670 while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
2671 {
2672 /* FIXME: filter the messages here */
2673 TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
2674 TranslateMessage(&msg);
2675 DispatchMessageW(&msg);
2676 if (msg.message == WM_QUIT)
2677 {
2678 TRACE("resending WM_QUIT to outer message loop\n");
2679 PostQuitMessage(msg.wParam);
2680 goto done;
2681 }
2682 }
2683 }
2684 else if ((res >= WAIT_OBJECT_0) && (res < WAIT_OBJECT_0 + cHandles))
2685 {
2686 /* handle signaled, store index */
2687 *lpdwindex = (res - WAIT_OBJECT_0);
2688 break;
2689 }
2690 else if (res == WAIT_TIMEOUT)
2691 {
2692 hr = RPC_S_CALLPENDING;
2693 break;
2694 }
2695 else
2696 {
2697 ERR("Unexpected wait termination: %ld, %ld\n", res, GetLastError());
2698 hr = E_UNEXPECTED;
2699 break;
2700 }
2701 }
2702 done:
2703 TRACE("-- 0x%08lx\n", hr);
2704 return hr;
2705 }
2706
2707 /***********************************************************************
2708 * DllMain (OLE32.@)
2709 */
2710 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
2711 {
2712 TRACE("%p 0x%lx %p\n", hinstDLL, fdwReason, fImpLoad);
2713
2714 switch(fdwReason) {
2715 case DLL_PROCESS_ATTACH:
2716 OLE32_hInstance = hinstDLL;
2717 COMPOBJ_InitProcess();
2718 if (TRACE_ON(ole)) CoRegisterMallocSpy((LPVOID)-1);
2719 break;
2720
2721 case DLL_PROCESS_DETACH:
2722 if (TRACE_ON(ole)) CoRevokeMallocSpy();
2723 COMPOBJ_UninitProcess();
2724 OLE32_hInstance = 0;
2725 break;
2726
2727 case DLL_THREAD_DETACH:
2728 COM_TlsDestroy();
2729 break;
2730 }
2731 return TRUE;
2732 }
2733
2734 /* NOTE: DllRegisterServer and DllUnregisterServer are in regsvr.c */
A free Windows-compatible Operating System