Fixed some issues found by winapi_check.
[wine] / dlls / ole32 / compobj.c
1 /*
2  *      COMPOBJ library
3  *
4  *      Copyright 1995  Martin von Loewis
5  *      Copyright 1998  Justin Bradford
6  *      Copyright 1999  Francis Beaudet
7  *  Copyright 1999  Sylvain St-Germain
8  */
9
10 #include "config.h"
11
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <assert.h>
16 #include "windef.h"
17 #include "wtypes.h"
18 #include "wingdi.h"
19 #include "wine/winbase16.h"
20 #include "winerror.h"
21 #include "wownt32.h"
22 #include "ole2ver.h"
23 #include "debugtools.h"
24 #include "heap.h"
25 #include "winreg.h"
26 #include "rpc.h"
27
28 #include "wine/obj_base.h"
29 #include "wine/obj_misc.h"
30 #include "wine/obj_storage.h"
31 #include "wine/obj_clientserver.h"
32
33 #include "ole.h"
34 #include "ifs.h"
35 #include "compobj_private.h"
36
37 DEFAULT_DEBUG_CHANNEL(ole);
38
39 /****************************************************************************
40  *  COM External Lock structures and methods declaration
41  *
42  *  This api provides a linked list to managed external references to 
43  *  COM objects.  
44  *
45  *  The public interface consists of three calls: 
46  *      COM_ExternalLockAddRef
47  *      COM_ExternalLockRelease
48  *      COM_ExternalLockFreeList
49  */
50
51 #define EL_END_OF_LIST 0
52 #define EL_NOT_FOUND   0
53
54 /*
55  * Declaration of the static structure that manage the 
56  * external lock to COM  objects.
57  */
58 typedef struct COM_ExternalLock     COM_ExternalLock;
59 typedef struct COM_ExternalLockList COM_ExternalLockList;
60
61 struct COM_ExternalLock
62 {
63   IUnknown         *pUnk;     /* IUnknown referenced */
64   ULONG            uRefCount; /* external lock counter to IUnknown object*/
65   COM_ExternalLock *next;     /* Pointer to next element in list */
66 };
67
68 struct COM_ExternalLockList
69 {
70   COM_ExternalLock *head;     /* head of list */
71 };
72
73 /*
74  * Declaration and initialization of the static structure that manages
75  * the external lock to COM objects.
76  */
77 static COM_ExternalLockList elList = { EL_END_OF_LIST };
78
79 /*
80  * Public Interface to the external lock list   
81  */
82 static void COM_ExternalLockFreeList();
83 static void COM_ExternalLockAddRef(IUnknown *pUnk);
84 static void COM_ExternalLockRelease(IUnknown *pUnk, BOOL bRelAll);
85 void COM_ExternalLockDump(); /* testing purposes, not static to avoid warning */
86
87 /*
88  * Private methods used to managed the linked list   
89  */
90 static BOOL COM_ExternalLockInsert(
91   IUnknown *pUnk);
92
93 static void COM_ExternalLockDelete(
94   COM_ExternalLock *element);
95
96 static COM_ExternalLock* COM_ExternalLockFind(
97   IUnknown *pUnk);
98
99 static COM_ExternalLock* COM_ExternalLockLocate(
100   COM_ExternalLock *element,
101   IUnknown         *pUnk);
102
103 /****************************************************************************
104  * This section defines variables internal to the COM module.
105  *
106  * TODO: Most of these things will have to be made thread-safe.
107  */
108 HINSTANCE16     COMPOBJ_hInstance = 0;
109 HINSTANCE       COMPOBJ_hInstance32 = 0;
110 static int      COMPOBJ_Attach = 0;
111
112 LPMALLOC16 currentMalloc16=NULL;
113 LPMALLOC currentMalloc32=NULL;
114
115 HTASK16 hETask = 0;
116 WORD Table_ETask[62];
117
118 /*
119  * This lock count counts the number of times CoInitialize is called. It is
120  * decreased every time CoUninitialize is called. When it hits 0, the COM
121  * libraries are freed
122  */
123 static ULONG s_COMLockCount = 0;
124
125 /*
126  * This linked list contains the list of registered class objects. These
127  * are mostly used to register the factories for out-of-proc servers of OLE
128  * objects.
129  *
130  * TODO: Make this data structure aware of inter-process communication. This
131  *       means that parts of this will be exported to the Wine Server.
132  */
133 typedef struct tagRegisteredClass
134 {
135   CLSID     classIdentifier;
136   LPUNKNOWN classObject;
137   DWORD     runContext;
138   DWORD     connectFlags;
139   DWORD     dwCookie;
140   struct tagRegisteredClass* nextClass;
141 } RegisteredClass;
142
143 static RegisteredClass* firstRegisteredClass = NULL;
144
145 /* this open DLL table belongs in a per process table, but my guess is that
146  * it shouldn't live in the kernel, so I'll put them out here in DLL
147  * space assuming that there is one OLE32 per process.
148  */
149 typedef struct tagOpenDll {
150   HINSTANCE hLibrary;       
151   struct tagOpenDll *next;
152 } OpenDll;
153
154 static OpenDll *openDllList = NULL; /* linked list of open dlls */
155
156 /*****************************************************************************
157  * This section contains prototypes to internal methods for this
158  * module
159  */
160 static HRESULT COM_GetRegisteredClassObject(REFCLSID    rclsid,
161                                             DWORD       dwClsContext,
162                                             LPUNKNOWN*  ppUnk);
163
164 static void COM_RevokeAllClasses();
165
166
167 /******************************************************************************
168  *           CoBuildVersion [COMPOBJ.1]
169  *
170  * RETURNS
171  *      Current build version, hiword is majornumber, loword is minornumber
172  */
173 DWORD WINAPI CoBuildVersion(void)
174 {
175     TRACE("Returning version %d, build %d.\n", rmm, rup);
176     return (rmm<<16)+rup;
177 }
178
179 /******************************************************************************
180  *              CoInitialize16  [COMPOBJ.2]
181  * Set the win16 IMalloc used for memory management
182  */
183 HRESULT WINAPI CoInitialize16(
184         LPVOID lpReserved       /* [in] pointer to win16 malloc interface */
185 ) {
186     currentMalloc16 = (LPMALLOC16)lpReserved;
187     return S_OK;
188 }
189
190 /******************************************************************************
191  *              CoInitialize    [OLE32.26]
192  *
193  * Initializes the COM libraries.
194  *
195  * See CoInitializeEx
196  */
197 HRESULT WINAPI CoInitialize(
198         LPVOID lpReserved       /* [in] pointer to win32 malloc interface
199                                    (obsolete, should be NULL) */
200
201 {
202   /*
203    * Just delegate to the newer method.
204    */
205   return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
206 }
207
208 /******************************************************************************
209  *              CoInitializeEx  [OLE32.163]
210  *
211  * Initializes the COM libraries. The behavior used to set the win32 IMalloc
212  * used for memory management is obsolete.
213  *
214  * RETURNS
215  *  S_OK               if successful,
216  *  S_FALSE            if this function was called already.
217  *  RPC_E_CHANGED_MODE if a previous call to CoInitialize specified another
218  *                      threading model.
219  *
220  * BUGS
221  * Only the single threaded model is supported. As a result RPC_E_CHANGED_MODE 
222  * is never returned.
223  *
224  * See the windows documentation for more details.
225  */
226 HRESULT WINAPI CoInitializeEx(
227         LPVOID lpReserved,      /* [in] pointer to win32 malloc interface
228                                    (obsolete, should be NULL) */
229         DWORD dwCoInit          /* [in] A value from COINIT specifies the threading model */
230
231 {
232   HRESULT hr;
233
234   TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
235
236   if (lpReserved!=NULL)
237   {
238     ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
239   }
240
241   /*
242    * Check for unsupported features.
243    */
244   if (dwCoInit!=COINIT_APARTMENTTHREADED) 
245   {
246     FIXME(":(%p,%x): unsupported flag %x\n", lpReserved, (int)dwCoInit, (int)dwCoInit);
247     /* Hope for the best and continue anyway */
248   }
249
250   /*
251    * Check the lock count. If this is the first time going through the initialize
252    * process, we have to initialize the libraries.
253    */
254   if (s_COMLockCount==0)
255   {
256     /*
257      * Initialize the various COM libraries and data structures.
258      */
259     TRACE("() - Initializing the COM libraries\n");
260
261     RunningObjectTableImpl_Initialize();
262
263     hr = S_OK;
264   }
265   else
266     hr = S_FALSE;
267
268   /*
269    * Crank-up that lock count.
270    */
271   s_COMLockCount++;
272
273   return hr;
274 }
275
276 /***********************************************************************
277  *           CoUninitialize16   [COMPOBJ.3]
278  * Don't know what it does. 
279  * 3-Nov-98 -- this was originally misspelled, I changed it to what I
280  *   believe is the correct spelling
281  */
282 void WINAPI CoUninitialize16(void)
283 {
284   TRACE("()\n");
285   CoFreeAllLibraries();
286 }
287
288 /***********************************************************************
289  *           CoUninitialize   [OLE32.47]
290  *
291  * This method will release the COM libraries.
292  *
293  * See the windows documentation for more details.
294  */
295 void WINAPI CoUninitialize(void)
296 {
297   TRACE("()\n");
298   
299   /*
300    * Decrease the reference count.
301    */
302   s_COMLockCount--;
303   
304   /*
305    * If we are back to 0 locks on the COM library, make sure we free
306    * all the associated data structures.
307    */
308   if (s_COMLockCount==0)
309   {
310     /*
311      * Release the various COM libraries and data structures.
312      */
313     TRACE("() - Releasing the COM libraries\n");
314
315     RunningObjectTableImpl_UnInitialize();
316     /*
317      * Release the references to the registered class objects.
318      */
319     COM_RevokeAllClasses();
320
321     /*
322      * This will free the loaded COM Dlls.
323      */
324     CoFreeAllLibraries();
325
326     /*
327      * This will free list of external references to COM objects.
328      */
329     COM_ExternalLockFreeList();
330 }
331 }
332
333 /***********************************************************************
334  *           CoGetMalloc16    [COMPOBJ.4]
335  * RETURNS
336  *      The current win16 IMalloc
337  */
338 HRESULT WINAPI CoGetMalloc16(
339         DWORD dwMemContext,     /* [in] unknown */
340         LPMALLOC16 * lpMalloc   /* [out] current win16 malloc interface */
341 ) {
342     if(!currentMalloc16)
343         currentMalloc16 = IMalloc16_Constructor();
344     *lpMalloc = currentMalloc16;
345     return S_OK;
346 }
347
348 /******************************************************************************
349  *              CoGetMalloc     [OLE32.20]
350  *
351  * RETURNS
352  *      The current win32 IMalloc
353  */
354 HRESULT WINAPI CoGetMalloc(
355         DWORD dwMemContext,     /* [in] unknown */
356         LPMALLOC *lpMalloc      /* [out] current win32 malloc interface */
357 ) {
358     if(!currentMalloc32)
359         currentMalloc32 = IMalloc_Constructor();
360     *lpMalloc = currentMalloc32;
361     return S_OK;
362 }
363
364 /***********************************************************************
365  *           CoCreateStandardMalloc16 [COMPOBJ.71]
366  */
367 HRESULT WINAPI CoCreateStandardMalloc16(DWORD dwMemContext,
368                                           LPMALLOC16 *lpMalloc)
369 {
370     /* FIXME: docu says we shouldn't return the same allocator as in
371      * CoGetMalloc16 */
372     *lpMalloc = IMalloc16_Constructor();
373     return S_OK;
374 }
375
376 /******************************************************************************
377  *              CoDisconnectObject      [COMPOBJ.15]
378  */
379 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
380 {
381     TRACE("(%p, %lx)\n",lpUnk,reserved);
382     return S_OK;
383 }
384
385 /***********************************************************************
386  *           IsEqualGUID16 [COMPOBJ.18]
387  *
388  * Compares two Unique Identifiers.
389  *
390  * RETURNS
391  *      TRUE if equal
392  */
393 BOOL16 WINAPI IsEqualGUID16(
394         GUID* g1,       /* [in] unique id 1 */
395         GUID* g2        /* [in] unique id 2 */
396 ) {
397     return !memcmp( g1, g2, sizeof(GUID) );
398 }
399
400 /******************************************************************************
401  *              CLSIDFromString16       [COMPOBJ.20]
402  * Converts a unique identifier from its string representation into 
403  * the GUID struct.
404  *
405  * Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6] 
406  *
407  * RETURNS
408  *      the converted GUID
409  */
410 HRESULT WINAPI CLSIDFromString16(
411         LPCOLESTR16 idstr,      /* [in] string representation of guid */
412         CLSID *id               /* [out] GUID converted from string */
413 ) {
414   BYTE *s = (BYTE *) idstr;
415   BYTE *p;
416   int   i;
417   BYTE table[256];
418
419   if (!s)
420           s = "{00000000-0000-0000-0000-000000000000}";
421   else {  /* validate the CLSID string */
422
423       if (strlen(s) != 38)
424           return CO_E_CLASSSTRING;
425
426       if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
427           return CO_E_CLASSSTRING;
428
429       for (i=1; i<37; i++)
430       {
431           if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
432           if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
433                 ((s[i] >= 'a') && (s[i] <= 'f'))  ||
434                 ((s[i] >= 'A') && (s[i] <= 'F')))
435              )
436               return CO_E_CLASSSTRING;
437       }
438   }
439
440   TRACE("%s -> %p\n", s, id);
441
442   /* quick lookup table */
443   memset(table, 0, 256);
444
445   for (i = 0; i < 10; i++) {
446     table['0' + i] = i;
447   }
448   for (i = 0; i < 6; i++) {
449     table['A' + i] = i+10;
450     table['a' + i] = i+10;
451   }
452
453   /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
454
455   p = (BYTE *) id;
456
457   s++;  /* skip leading brace  */
458   for (i = 0; i < 4; i++) {
459     p[3 - i] = table[*s]<<4 | table[*(s+1)];
460     s += 2;
461   }
462   p += 4;
463   s++;  /* skip - */
464
465   for (i = 0; i < 2; i++) {
466     p[1-i] = table[*s]<<4 | table[*(s+1)];
467     s += 2;
468   }
469   p += 2;
470   s++;  /* skip - */
471
472   for (i = 0; i < 2; i++) {
473     p[1-i] = table[*s]<<4 | table[*(s+1)];
474     s += 2;
475   }
476   p += 2;
477   s++;  /* skip - */
478
479   /* these are just sequential bytes */
480   for (i = 0; i < 2; i++) {
481     *p++ = table[*s]<<4 | table[*(s+1)];
482     s += 2;
483   }
484   s++;  /* skip - */
485
486   for (i = 0; i < 6; i++) {
487     *p++ = table[*s]<<4 | table[*(s+1)];
488     s += 2;
489   }
490
491   return S_OK;
492 }
493
494 /******************************************************************************
495  *              CoCreateGuid[OLE32.6]
496  *
497  */
498 HRESULT WINAPI CoCreateGuid(
499         GUID *pguid /* [out] points to the GUID to initialize */
500 ) {
501     return UuidCreate(pguid);
502 }
503
504 /******************************************************************************
505  *              CLSIDFromString [OLE32.3]
506  * Converts a unique identifier from its string representation into 
507  * the GUID struct.
508  *
509  * UNDOCUMENTED
510  *      If idstr is not a valid CLSID string then it gets treated as a ProgID
511  *
512  * RETURNS
513  *      the converted GUID
514  */
515 HRESULT WINAPI CLSIDFromString(
516         LPCOLESTR idstr,        /* [in] string representation of GUID */
517         CLSID *id               /* [out] GUID represented by above string */
518 ) {
519     LPOLESTR16      xid = HEAP_strdupWtoA(GetProcessHeap(),0,idstr);
520     HRESULT       ret = CLSIDFromString16(xid,id);
521
522     HeapFree(GetProcessHeap(),0,xid);
523     if(ret != S_OK) { /* It appears a ProgID is also valid */
524         ret = CLSIDFromProgID(idstr, id);
525     }
526     return ret;
527 }
528
529 /******************************************************************************
530  *              WINE_StringFromCLSID    [Internal]
531  * Converts a GUID into the respective string representation.
532  *
533  * NOTES
534  *
535  * RETURNS
536  *      the string representation and HRESULT
537  */
538 static HRESULT WINE_StringFromCLSID(
539         const CLSID *id,        /* [in] GUID to be converted */
540         LPSTR idstr             /* [out] pointer to buffer to contain converted guid */
541 ) {
542   static const char *hex = "0123456789ABCDEF";
543   char *s;
544   int   i;
545
546   if (!id)
547         { ERR("called with id=Null\n");
548           *idstr = 0x00;
549           return E_FAIL;
550         }
551         
552   sprintf(idstr, "{%08lX-%04X-%04X-%02X%02X-",
553           id->Data1, id->Data2, id->Data3,
554           id->Data4[0], id->Data4[1]);
555   s = &idstr[25];
556
557   /* 6 hex bytes */
558   for (i = 2; i < 8; i++) {
559     *s++ = hex[id->Data4[i]>>4];
560     *s++ = hex[id->Data4[i] & 0xf];
561   }
562
563   *s++ = '}';
564   *s++ = '\0';
565
566   TRACE("%p->%s\n", id, idstr);
567
568   return S_OK;
569 }
570
571 /******************************************************************************
572  *              StringFromCLSID16       [COMPOBJ.19]
573  * Converts a GUID into the respective string representation.
574  * The target string is allocated using the OLE IMalloc.
575  * RETURNS
576  *      the string representation and HRESULT
577  */
578 HRESULT WINAPI StringFromCLSID16(
579         REFCLSID id,            /* [in] the GUID to be converted */
580         LPOLESTR16 *idstr       /* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
581
582 ) {
583     extern BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
584                                            DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode );
585     LPMALLOC16  mllc;
586     HRESULT     ret;
587     DWORD       args[2];
588
589     ret = CoGetMalloc16(0,&mllc);
590     if (ret) return ret;
591
592     args[0] = (DWORD)mllc;
593     args[1] = 40;
594
595     /* No need for a Callback entry, we have WOWCallback16Ex which does
596      * everything we need.
597      */
598     if (!K32WOWCallback16Ex(
599         (DWORD)((ICOM_VTABLE(IMalloc16)*)MapSL(
600             (SEGPTR)ICOM_VTBL(((LPMALLOC16)MapSL((SEGPTR)mllc))))
601         )->Alloc,
602         WCB16_CDECL,
603         2*sizeof(DWORD),
604         (LPVOID)args,
605         (LPDWORD)idstr
606     )) {
607         WARN("CallTo16 IMalloc16 failed\n");
608         return E_FAIL;
609     }
610     return WINE_StringFromCLSID(id,MapSL((SEGPTR)*idstr));
611 }
612
613 /******************************************************************************
614  *              StringFromCLSID [OLE32.151]
615  * Converts a GUID into the respective string representation.
616  * The target string is allocated using the OLE IMalloc.
617  * RETURNS
618  *      the string representation and HRESULT
619  */
620 HRESULT WINAPI StringFromCLSID(
621         REFCLSID id,            /* [in] the GUID to be converted */
622         LPOLESTR *idstr /* [out] a pointer to a to-be-allocated pointer pointing to the resulting string */
623 ) {
624         char            buf[80];
625         HRESULT       ret;
626         LPMALLOC        mllc;
627
628         if ((ret=CoGetMalloc(0,&mllc)))
629                 return ret;
630
631         ret=WINE_StringFromCLSID(id,buf);
632         if (!ret) {
633             DWORD len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
634             *idstr = IMalloc_Alloc( mllc, len * sizeof(WCHAR) );
635             MultiByteToWideChar( CP_ACP, 0, buf, -1, *idstr, len );
636         }
637         return ret;
638 }
639
640 /******************************************************************************
641  *              StringFromGUID2 [COMPOBJ.76] [OLE32.152]
642  *
643  * Converts a global unique identifier into a string of an API-
644  * specified fixed format. (The usual {.....} stuff.)
645  *
646  * RETURNS
647  *      The (UNICODE) string representation of the GUID in 'str'
648  *      The length of the resulting string, 0 if there was any problem.
649  */
650 INT WINAPI
651 StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
652 {
653   char          xguid[80];
654
655   if (WINE_StringFromCLSID(id,xguid))
656         return 0;
657   return MultiByteToWideChar( CP_ACP, 0, xguid, -1, str, cmax );
658 }
659
660 /******************************************************************************
661  * ProgIDFromCLSID [OLE32.133]
662  * Converts a class id into the respective Program ID. (By using a registry lookup)
663  * RETURNS S_OK on success
664  * riid associated with the progid
665  */
666
667 HRESULT WINAPI ProgIDFromCLSID(
668   REFCLSID clsid, /* [in] class id as found in registry */
669   LPOLESTR *lplpszProgID/* [out] associated Prog ID */
670 )
671 {
672   char     strCLSID[50], *buf, *buf2;
673   DWORD    buf2len;
674   HKEY     xhkey;
675   LPMALLOC mllc;
676   HRESULT  ret = S_OK;
677
678   WINE_StringFromCLSID(clsid, strCLSID);
679
680   buf = HeapAlloc(GetProcessHeap(), 0, strlen(strCLSID)+14);
681   sprintf(buf,"CLSID\\%s\\ProgID", strCLSID);
682   if (RegOpenKeyA(HKEY_CLASSES_ROOT, buf, &xhkey))
683     ret = REGDB_E_CLASSNOTREG;
684
685   HeapFree(GetProcessHeap(), 0, buf);
686
687   if (ret == S_OK)
688   {
689     buf2 = HeapAlloc(GetProcessHeap(), 0, 255);
690     buf2len = 255;
691     if (RegQueryValueA(xhkey, NULL, buf2, &buf2len))
692       ret = REGDB_E_CLASSNOTREG;
693
694     if (ret == S_OK)
695     {
696       if (CoGetMalloc(0,&mllc))
697         ret = E_OUTOFMEMORY;
698       else
699       {
700           DWORD len = MultiByteToWideChar( CP_ACP, 0, buf2, -1, NULL, 0 );
701           *lplpszProgID = IMalloc_Alloc(mllc, len * sizeof(WCHAR) );
702           MultiByteToWideChar( CP_ACP, 0, buf2, -1, *lplpszProgID, len );
703       }
704     }
705     HeapFree(GetProcessHeap(), 0, buf2);
706   }
707
708   RegCloseKey(xhkey);
709   return ret;
710 }
711
712 /******************************************************************************
713  *              CLSIDFromProgID16       [COMPOBJ.61]
714  * Converts a program id into the respective GUID. (By using a registry lookup)
715  * RETURNS
716  *      riid associated with the progid
717  */
718 HRESULT WINAPI CLSIDFromProgID16(
719         LPCOLESTR16 progid,     /* [in] program id as found in registry */
720         LPCLSID riid            /* [out] associated CLSID */
721 ) {
722         char    *buf,buf2[80];
723         DWORD   buf2len;
724         HRESULT err;
725         HKEY    xhkey;
726
727         buf = HeapAlloc(GetProcessHeap(),0,strlen(progid)+8);
728         sprintf(buf,"%s\\CLSID",progid);
729         if ((err=RegOpenKeyA(HKEY_CLASSES_ROOT,buf,&xhkey))) {
730                 HeapFree(GetProcessHeap(),0,buf);
731                 return CO_E_CLASSSTRING;
732         }
733         HeapFree(GetProcessHeap(),0,buf);
734         buf2len = sizeof(buf2);
735         if ((err=RegQueryValueA(xhkey,NULL,buf2,&buf2len))) {
736                 RegCloseKey(xhkey);
737                 return CO_E_CLASSSTRING;
738         }
739         RegCloseKey(xhkey);
740         return CLSIDFromString16(buf2,riid);
741 }
742
743 /******************************************************************************
744  *              CLSIDFromProgID [OLE32.2]
745  * Converts a program id into the respective GUID. (By using a registry lookup)
746  * RETURNS
747  *      riid associated with the progid
748  */
749 HRESULT WINAPI CLSIDFromProgID(
750         LPCOLESTR progid,       /* [in] program id as found in registry */
751         LPCLSID riid            /* [out] associated CLSID */
752 ) {
753         LPOLESTR16 pid = HEAP_strdupWtoA(GetProcessHeap(),0,progid);
754         HRESULT       ret = CLSIDFromProgID16(pid,riid);
755
756         HeapFree(GetProcessHeap(),0,pid);
757         return ret;
758 }
759
760
761
762 /*****************************************************************************
763  *             CoGetPSClsid [OLE32.22]
764  *
765  * This function returns the CLSID of the DLL that implements the proxy and stub
766  * for the specified interface. 
767  *
768  * It determines this by searching the 
769  * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32 in the registry
770  * and any interface id registered by CoRegisterPSClsid within the current process.
771  * 
772  * FIXME: We only search the registry, not ids registered with CoRegisterPSClsid.
773  */
774 HRESULT WINAPI CoGetPSClsid(
775           REFIID riid,     /* [in]  Interface whose proxy/stub CLSID is to be returned */
776           CLSID *pclsid )    /* [out] Where to store returned proxy/stub CLSID */
777 {
778     char *buf, buf2[40];
779     DWORD buf2len;
780     HKEY xhkey;
781
782     TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
783
784     /* Get the input iid as a string */
785     WINE_StringFromCLSID(riid, buf2);
786     /* Allocate memory for the registry key we will construct.
787        (length of iid string plus constant length of static text */
788     buf = HeapAlloc(GetProcessHeap(), 0, strlen(buf2)+27);
789     if (buf == NULL)
790     {
791        return (E_OUTOFMEMORY);
792     }
793
794     /* Construct the registry key we want */
795     sprintf(buf,"Interface\\%s\\ProxyStubClsid32", buf2);
796
797     /* Open the key.. */
798     if (RegOpenKeyA(HKEY_CLASSES_ROOT, buf, &xhkey))
799     {
800        HeapFree(GetProcessHeap(),0,buf);
801        return (E_INVALIDARG);
802     }
803     HeapFree(GetProcessHeap(),0,buf);
804
805     /* ... Once we have the key, query the registry to get the
806        value of CLSID as a string, and convert it into a 
807        proper CLSID structure to be passed back to the app */
808     buf2len = sizeof(buf2);
809     if ( (RegQueryValueA(xhkey,NULL,buf2,&buf2len)) )
810     {
811        RegCloseKey(xhkey);
812        return E_INVALIDARG;
813     }
814     RegCloseKey(xhkey);
815
816     /* We have the CLSid we want back from the registry as a string, so
817        lets convert it into a CLSID structure */
818     if ( (CLSIDFromString16(buf2,pclsid)) != NOERROR)
819     {
820        return E_INVALIDARG;
821     }
822
823     TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
824     return (S_OK);
825 }
826
827
828
829 /***********************************************************************
830  *              WriteClassStm (OLE32.159)
831  *
832  * This function write a CLSID on stream
833  */
834 HRESULT WINAPI WriteClassStm(IStream *pStm,REFCLSID rclsid)
835 {
836     TRACE("(%p,%p)\n",pStm,rclsid);
837
838     if (rclsid==NULL)
839         return E_INVALIDARG;
840
841     return IStream_Write(pStm,rclsid,sizeof(CLSID),NULL);
842 }
843
844 /***********************************************************************
845  *              ReadClassStm (OLE32.135)
846  *
847  * This function read a CLSID from a stream
848  */
849 HRESULT WINAPI ReadClassStm(IStream *pStm,REFCLSID rclsid)
850 {
851     ULONG nbByte;
852     HRESULT res;
853     
854     TRACE("(%p,%p)\n",pStm,rclsid);
855
856     if (rclsid==NULL)
857         return E_INVALIDARG;
858     
859     res = IStream_Read(pStm,(void*)rclsid,sizeof(CLSID),&nbByte);
860
861     if (FAILED(res))
862         return res;
863     
864     if (nbByte != sizeof(CLSID))
865         return S_FALSE;
866     else
867         return S_OK;
868 }
869
870 /* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
871 /***********************************************************************
872  *           LookupETask (COMPOBJ.94)
873  */
874 HRESULT WINAPI LookupETask16(HTASK16 *hTask,LPVOID p) {
875         FIXME("(%p,%p),stub!\n",hTask,p);
876         if ((*hTask = GetCurrentTask()) == hETask) {
877                 memcpy(p, Table_ETask, sizeof(Table_ETask));
878         }
879         return 0;
880 }
881
882 /* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
883 /***********************************************************************
884  *           SetETask (COMPOBJ.95)
885  */
886 HRESULT WINAPI SetETask16(HTASK16 hTask, LPVOID p) {
887         FIXME("(%04x,%p),stub!\n",hTask,p);
888         hETask = hTask;
889         return 0;
890 }
891
892 /* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
893 /***********************************************************************
894  *           CallObjectInWOW (COMPOBJ.201)
895  */
896 HRESULT WINAPI CallObjectInWOW(LPVOID p1,LPVOID p2) {
897         FIXME("(%p,%p),stub!\n",p1,p2);
898         return 0;
899 }
900
901 /******************************************************************************
902  *              CoRegisterClassObject16 [COMPOBJ.5]
903  *
904  * Don't know where it registers it ...
905  */
906 HRESULT WINAPI CoRegisterClassObject16(
907         REFCLSID rclsid,
908         LPUNKNOWN pUnk,
909         DWORD dwClsContext, /* [in] CLSCTX flags indicating the context in which to run the executable */
910         DWORD flags,        /* [in] REGCLS flags indicating how connections are made */
911         LPDWORD lpdwRegister
912 ) {
913         char    buf[80];
914
915         WINE_StringFromCLSID(rclsid,buf);
916
917         FIXME("(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
918                 buf,pUnk,dwClsContext,flags,lpdwRegister
919         );
920         return 0;
921 }
922
923
924 /******************************************************************************
925  *      CoRevokeClassObject16 [COMPOBJ.6]
926  *
927  */
928 HRESULT WINAPI CoRevokeClassObject16(DWORD dwRegister) /* [in] token on class obj */
929 {
930     FIXME("(0x%08lx),stub!\n", dwRegister);
931     return 0;
932 }
933
934 /******************************************************************************
935  *      CoFileTimeToDosDateTime [COMPOBJ.30]
936  */
937 BOOL16 WINAPI CoFileTimeToDosDateTime16(const FILETIME *ft, LPWORD lpDosDate, LPWORD lpDosTime)
938 {
939     return FileTimeToDosDateTime(ft, lpDosDate, lpDosTime);
940 }
941
942 /******************************************************************************
943  *      CoDosDateTimeToFileTime [COMPOBJ.31]
944  */
945 BOOL16 WINAPI CoDosDateTimeToFileTime16(WORD wDosDate, WORD wDosTime, FILETIME *ft)
946 {
947     return DosDateTimeToFileTime(wDosDate, wDosTime, ft);
948 }
949
950 /***
951  * COM_GetRegisteredClassObject
952  *
953  * This internal method is used to scan the registered class list to 
954  * find a class object.
955  *
956  * Params: 
957  *   rclsid        Class ID of the class to find.
958  *   dwClsContext  Class context to match.
959  *   ppv           [out] returns a pointer to the class object. Complying
960  *                 to normal COM usage, this method will increase the
961  *                 reference count on this object.
962  */
963 static HRESULT COM_GetRegisteredClassObject(
964         REFCLSID    rclsid,
965         DWORD       dwClsContext,
966         LPUNKNOWN*  ppUnk)
967 {
968   RegisteredClass* curClass;
969
970   /*
971    * Sanity check
972    */
973   assert(ppUnk!=0);
974
975   /*
976    * Iterate through the whole list and try to match the class ID.
977    */
978   curClass = firstRegisteredClass;
979
980   while (curClass != 0)
981   {
982     /*
983      * Check if we have a match on the class ID.
984      */
985     if (IsEqualGUID(&(curClass->classIdentifier), rclsid))
986     {
987       /*
988        * Since we don't do out-of process or DCOM just right away, let's ignore the
989        * class context.
990        */
991
992       /*
993        * We have a match, return the pointer to the class object.
994        */
995       *ppUnk = curClass->classObject;
996
997       IUnknown_AddRef(curClass->classObject);
998
999       return S_OK;
1000     }
1001
1002     /*
1003      * Step to the next class in the list.
1004      */
1005     curClass = curClass->nextClass;
1006   }
1007
1008   /*
1009    * If we get to here, we haven't found our class.
1010    */
1011   return S_FALSE;
1012 }
1013
1014 /******************************************************************************
1015  *              CoRegisterClassObject   [OLE32.36]
1016  *
1017  * This method will register the class object for a given class ID.
1018  *
1019  * See the Windows documentation for more details.
1020  */
1021 HRESULT WINAPI CoRegisterClassObject(
1022         REFCLSID rclsid,
1023         LPUNKNOWN pUnk,
1024         DWORD dwClsContext, /* [in] CLSCTX flags indicating the context in which to run the executable */
1025         DWORD flags,        /* [in] REGCLS flags indicating how connections are made */
1026         LPDWORD lpdwRegister
1027
1028 {
1029   RegisteredClass* newClass;
1030   LPUNKNOWN        foundObject;
1031   HRESULT          hr;
1032     char buf[80];
1033
1034     WINE_StringFromCLSID(rclsid,buf);
1035
1036   TRACE("(%s,%p,0x%08lx,0x%08lx,%p)\n",
1037         buf,pUnk,dwClsContext,flags,lpdwRegister);
1038
1039   /*
1040    * Perform a sanity check on the parameters
1041    */
1042   if ( (lpdwRegister==0) || (pUnk==0) )
1043   {
1044     return E_INVALIDARG;
1045 }
1046
1047   /*
1048    * Initialize the cookie (out parameter)
1049    */
1050   *lpdwRegister = 0;
1051
1052   /*
1053    * First, check if the class is already registered.
1054    * If it is, this should cause an error.
1055    */
1056   hr = COM_GetRegisteredClassObject(rclsid, dwClsContext, &foundObject);
1057
1058   if (hr == S_OK)
1059   {
1060     /*
1061      * The COM_GetRegisteredClassObject increased the reference count on the
1062      * object so it has to be released.
1063      */
1064     IUnknown_Release(foundObject);
1065
1066     return CO_E_OBJISREG;
1067   }
1068     
1069   /*
1070    * If it is not registered, we must create a new entry for this class and
1071    * append it to the registered class list.
1072    * We use the address of the chain node as the cookie since we are sure it's
1073    * unique.
1074    */
1075   newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
1076
1077   /*
1078    * Initialize the node.
1079    */
1080   newClass->classIdentifier = *rclsid;
1081   newClass->runContext      = dwClsContext;
1082   newClass->connectFlags    = flags;
1083   newClass->dwCookie        = (DWORD)newClass;
1084   newClass->nextClass       = firstRegisteredClass;
1085
1086   /*
1087    * Since we're making a copy of the object pointer, we have to increase its
1088    * reference count.
1089    */
1090   newClass->classObject     = pUnk;
1091   IUnknown_AddRef(newClass->classObject);
1092
1093   firstRegisteredClass = newClass;
1094
1095   /*
1096    * Assign the out parameter (cookie)
1097    */
1098   *lpdwRegister = newClass->dwCookie;
1099     
1100   /*
1101    * We're successful Yippee!
1102    */
1103   return S_OK;
1104 }
1105
1106 /***********************************************************************
1107  *           CoRevokeClassObject [OLE32.40]
1108  *
1109  * This method will remove a class object from the class registry
1110  *
1111  * See the Windows documentation for more details.
1112  */
1113 HRESULT WINAPI CoRevokeClassObject(
1114         DWORD dwRegister) 
1115 {
1116   RegisteredClass** prevClassLink;
1117   RegisteredClass*  curClass;
1118
1119   TRACE("(%08lx)\n",dwRegister);
1120
1121   /*
1122    * Iterate through the whole list and try to match the cookie.
1123    */
1124   curClass      = firstRegisteredClass;
1125   prevClassLink = &firstRegisteredClass;
1126
1127   while (curClass != 0)
1128   {
1129     /*
1130      * Check if we have a match on the cookie.
1131      */
1132     if (curClass->dwCookie == dwRegister)
1133     {
1134       /*
1135        * Remove the class from the chain.
1136        */
1137       *prevClassLink = curClass->nextClass;
1138
1139       /*
1140        * Release the reference to the class object.
1141        */
1142       IUnknown_Release(curClass->classObject);
1143
1144       /*
1145        * Free the memory used by the chain node.
1146  */
1147       HeapFree(GetProcessHeap(), 0, curClass);
1148
1149     return S_OK;
1150 }
1151
1152     /*
1153      * Step to the next class in the list.
1154      */
1155     prevClassLink = &(curClass->nextClass);
1156     curClass      = curClass->nextClass;
1157   }
1158
1159   /*
1160    * If we get to here, we haven't found our class.
1161    */
1162   return E_INVALIDARG;
1163 }
1164
1165 /***********************************************************************
1166  *           CoGetClassObject [COMPOBJ.7]
1167  */
1168 HRESULT WINAPI CoGetClassObject(
1169     REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
1170     REFIID iid, LPVOID *ppv
1171 ) {
1172     LPUNKNOWN   regClassObject;
1173     HRESULT     hres = E_UNEXPECTED;
1174     char        xclsid[80];
1175     WCHAR dllName[MAX_PATH+1];
1176     DWORD dllNameLen = sizeof(dllName);
1177     HINSTANCE hLibrary;
1178     typedef HRESULT CALLBACK (*DllGetClassObjectFunc)(REFCLSID clsid, 
1179                              REFIID iid, LPVOID *ppv);
1180     DllGetClassObjectFunc DllGetClassObject;
1181
1182     WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
1183
1184     TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n",
1185         debugstr_guid(rclsid),
1186         debugstr_guid(iid)
1187     );
1188
1189     if (pServerInfo) {
1190         FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo->pwszName));
1191         FIXME("\t\tpAuthInfo=%p\n",pServerInfo->pAuthInfo);
1192     }
1193
1194     /*
1195      * First, try and see if we can't match the class ID with one of the 
1196      * registered classes.
1197      */
1198     if (S_OK == COM_GetRegisteredClassObject(rclsid, dwClsContext, &regClassObject))
1199     {
1200       /*
1201        * Get the required interface from the retrieved pointer.
1202        */
1203       hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
1204
1205       /*
1206        * Since QI got another reference on the pointer, we want to release the
1207        * one we already have. If QI was unsuccessful, this will release the object. This
1208        * is good since we are not returning it in the "out" parameter.
1209        */
1210       IUnknown_Release(regClassObject);
1211
1212       return hres;
1213     }
1214
1215     /* out of process and remote servers not supported yet */
1216     if (     ((CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER) & dwClsContext)
1217         && !((CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER) & dwClsContext)
1218     ){
1219         FIXME("%s %s not supported!\n",
1220                 (dwClsContext&CLSCTX_LOCAL_SERVER)?"CLSCTX_LOCAL_SERVER":"",
1221                 (dwClsContext&CLSCTX_REMOTE_SERVER)?"CLSCTX_REMOTE_SERVER":""
1222         );
1223         return E_ACCESSDENIED;
1224     }
1225
1226     if ((CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER) & dwClsContext) {
1227         HKEY key;
1228         char buf[200];
1229
1230         sprintf(buf,"CLSID\\%s\\InprocServer32",xclsid);
1231         hres = RegOpenKeyExA(HKEY_CLASSES_ROOT, buf, 0, KEY_READ, &key);
1232
1233         if (hres != ERROR_SUCCESS) {
1234             return REGDB_E_CLASSNOTREG;
1235         }
1236
1237         memset(dllName,0,sizeof(dllName));
1238         hres= RegQueryValueExW(key,NULL,NULL,NULL,(LPBYTE)dllName,&dllNameLen);
1239         if (hres)
1240                 return REGDB_E_CLASSNOTREG; /* FIXME: check retval */
1241         RegCloseKey(key);
1242         TRACE("found InprocServer32 dll %s\n", debugstr_w(dllName));
1243
1244         /* open dll, call DllGetClassObject */
1245         hLibrary = CoLoadLibrary(dllName, TRUE);
1246         if (hLibrary == 0) {
1247             FIXME("couldn't load InprocServer32 dll %s\n", debugstr_w(dllName));
1248             return E_ACCESSDENIED; /* or should this be CO_E_DLLNOTFOUND? */
1249         }
1250         DllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(hLibrary, "DllGetClassObject");
1251         if (!DllGetClassObject) {
1252             /* not sure if this should be called here CoFreeLibrary(hLibrary);*/
1253             FIXME("couldn't find function DllGetClassObject in %s\n", debugstr_w(dllName));
1254             return E_ACCESSDENIED;
1255         }
1256
1257         /*
1258          * Ask the DLL for its class object. (there was a note here about class
1259          * factories but this is good.
1260          */
1261         return DllGetClassObject(rclsid, iid, ppv);
1262     }
1263     return hres;
1264 }
1265
1266 /***********************************************************************
1267  *        CoResumeClassObjects (OLE32.173)
1268  *
1269  * Resumes classobjects registered with REGCLS suspended
1270  */
1271 HRESULT WINAPI CoResumeClassObjects(void)
1272 {
1273         FIXME("\n");
1274         return S_OK;
1275 }
1276
1277 /***********************************************************************
1278  *        GetClassFile (OLE32.67)
1279  *
1280  * This function supplies the CLSID associated with the given filename.
1281  */
1282 HRESULT WINAPI GetClassFile(LPOLESTR filePathName,CLSID *pclsid)
1283 {
1284     IStorage *pstg=0;
1285     HRESULT res;
1286     int nbElm=0,length=0,i=0;
1287     LONG sizeProgId=20;
1288     LPOLESTR *pathDec=0,absFile=0,progId=0;
1289     WCHAR extention[100]={0};
1290
1291     TRACE("()\n");
1292
1293     /* if the file contain a storage object the return the CLSID writen by IStorage_SetClass method*/
1294     if((StgIsStorageFile(filePathName))==S_OK){
1295
1296         res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
1297
1298         if (SUCCEEDED(res))
1299             res=ReadClassStg(pstg,pclsid);
1300
1301         IStorage_Release(pstg);
1302
1303         return res;
1304     }
1305     /* if the file is not a storage object then attemps to match various bits in the file against a
1306        pattern in the registry. this case is not frequently used ! so I present only the psodocode for
1307        this case
1308        
1309      for(i=0;i<nFileTypes;i++)
1310
1311         for(i=0;j<nPatternsForType;j++){
1312
1313             PATTERN pat;
1314             HANDLE  hFile;
1315
1316             pat=ReadPatternFromRegistry(i,j);
1317             hFile=CreateFileW(filePathName,,,,,,hFile);
1318             SetFilePosition(hFile,pat.offset);
1319             ReadFile(hFile,buf,pat.size,NULL,NULL);
1320             if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
1321
1322                 *pclsid=ReadCLSIDFromRegistry(i);
1323                 return S_OK;
1324             }
1325         }
1326      */
1327
1328     /* if the obove strategies fail then search for the extension key in the registry */
1329
1330     /* get the last element (absolute file) in the path name */
1331     nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
1332     absFile=pathDec[nbElm-1];
1333
1334     /* failed if the path represente a directory and not an absolute file name*/
1335     if (lstrcmpW(absFile,(LPOLESTR)"\\"))
1336         return MK_E_INVALIDEXTENSION;
1337
1338     /* get the extension of the file */
1339     length=lstrlenW(absFile);
1340     for(i=length-1; ( (i>=0) && (extention[i]=absFile[i]) );i--);
1341         
1342     /* get the progId associated to the extension */
1343     progId=CoTaskMemAlloc(sizeProgId);
1344
1345     res=RegQueryValueW(HKEY_CLASSES_ROOT,extention,progId,&sizeProgId);
1346
1347     if (res==ERROR_MORE_DATA){
1348
1349         progId = CoTaskMemRealloc(progId,sizeProgId);
1350         res=RegQueryValueW(HKEY_CLASSES_ROOT,extention,progId,&sizeProgId);
1351     }
1352     if (res==ERROR_SUCCESS)
1353         /* return the clsid associated to the progId */
1354         res= CLSIDFromProgID(progId,pclsid);
1355
1356     for(i=0; pathDec[i]!=NULL;i++)
1357         CoTaskMemFree(pathDec[i]);
1358     CoTaskMemFree(pathDec);
1359
1360     CoTaskMemFree(progId);
1361
1362     if (res==ERROR_SUCCESS)
1363         return res;
1364
1365     return MK_E_INVALIDEXTENSION;
1366 }
1367 /******************************************************************************
1368  *              CoRegisterMessageFilter16       [COMPOBJ.27]
1369  */
1370 HRESULT WINAPI CoRegisterMessageFilter16(
1371         LPMESSAGEFILTER lpMessageFilter,
1372         LPMESSAGEFILTER *lplpMessageFilter
1373 ) {
1374         FIXME("(%p,%p),stub!\n",lpMessageFilter,lplpMessageFilter);
1375         return 0;
1376 }
1377
1378 /***********************************************************************
1379  *           CoCreateInstance [COMPOBJ.13, OLE32.7]
1380  */
1381 HRESULT WINAPI CoCreateInstance(
1382         REFCLSID rclsid,
1383         LPUNKNOWN pUnkOuter,
1384         DWORD dwClsContext,
1385         REFIID iid,
1386         LPVOID *ppv) 
1387 {
1388         HRESULT hres;
1389         LPCLASSFACTORY lpclf = 0;
1390
1391   /*
1392    * Sanity check
1393    */
1394   if (ppv==0)
1395     return E_POINTER;
1396
1397   /*
1398    * Initialize the "out" parameter
1399    */
1400   *ppv = 0;
1401   
1402   /*
1403    * Get a class factory to construct the object we want.
1404    */
1405   hres = CoGetClassObject(rclsid,
1406                           dwClsContext,
1407                           NULL,
1408                           &IID_IClassFactory,
1409                           (LPVOID)&lpclf);
1410
1411   if (FAILED(hres)) {
1412     FIXME("no instance created for %s, hres is 0x%08lx\n",debugstr_guid(iid),hres);
1413     return hres;
1414   }
1415
1416   /*
1417    * Create the object and don't forget to release the factory
1418    */
1419         hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
1420         IClassFactory_Release(lpclf);
1421
1422         return hres;
1423 }
1424
1425 /***********************************************************************
1426  *           CoCreateInstanceEx [OLE32.165]
1427  */
1428 HRESULT WINAPI CoCreateInstanceEx(
1429   REFCLSID      rclsid, 
1430   LPUNKNOWN     pUnkOuter,
1431   DWORD         dwClsContext, 
1432   COSERVERINFO* pServerInfo,
1433   ULONG         cmq,
1434   MULTI_QI*     pResults)
1435 {
1436   IUnknown* pUnk = NULL;
1437   HRESULT   hr;
1438   ULONG     index;
1439   int       successCount = 0;
1440
1441   /*
1442    * Sanity check
1443    */
1444   if ( (cmq==0) || (pResults==NULL))
1445     return E_INVALIDARG;
1446
1447   if (pServerInfo!=NULL)
1448     FIXME("() non-NULL pServerInfo not supported!\n");
1449
1450   /*
1451    * Initialize all the "out" parameters.
1452    */
1453   for (index = 0; index < cmq; index++)
1454   {
1455     pResults[index].pItf = NULL;
1456     pResults[index].hr   = E_NOINTERFACE;
1457   }
1458
1459   /*
1460    * Get the object and get its IUnknown pointer.
1461    */
1462   hr = CoCreateInstance(rclsid, 
1463                         pUnkOuter,
1464                         dwClsContext,
1465                         &IID_IUnknown,
1466                         (VOID**)&pUnk);
1467
1468   if (hr)
1469     return hr;
1470
1471   /*
1472    * Then, query for all the interfaces requested.
1473    */
1474   for (index = 0; index < cmq; index++)
1475   {
1476     pResults[index].hr = IUnknown_QueryInterface(pUnk,
1477                                                  pResults[index].pIID,
1478                                                  (VOID**)&(pResults[index].pItf));
1479
1480     if (pResults[index].hr == S_OK)
1481       successCount++;
1482   }
1483
1484   /*
1485    * Release our temporary unknown pointer.
1486    */
1487   IUnknown_Release(pUnk);
1488
1489   if (successCount == 0)
1490     return E_NOINTERFACE;
1491
1492   if (successCount!=cmq)
1493     return CO_S_NOTALLINTERFACES;
1494
1495   return S_OK;
1496 }
1497
1498 /***********************************************************************
1499  *           CoFreeLibrary [COMPOBJ.13]
1500  */
1501 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
1502 {
1503     OpenDll *ptr, *prev;
1504     OpenDll *tmp;
1505
1506     /* lookup library in linked list */
1507     prev = NULL;
1508     for (ptr = openDllList; ptr != NULL; ptr=ptr->next) {
1509         if (ptr->hLibrary == hLibrary) {
1510             break;
1511         }
1512         prev = ptr;
1513     }
1514
1515     if (ptr == NULL) {
1516         /* shouldn't happen if user passed in a valid hLibrary */
1517         return;
1518     }
1519     /* assert: ptr points to the library entry to free */
1520
1521     /* free library and remove node from list */
1522     FreeLibrary(hLibrary);
1523     if (ptr == openDllList) {
1524         tmp = openDllList->next;
1525         HeapFree(GetProcessHeap(), 0, openDllList);
1526         openDllList = tmp;
1527     } else {
1528         tmp = ptr->next;
1529         HeapFree(GetProcessHeap(), 0, ptr);
1530         prev->next = tmp;
1531     }
1532
1533 }
1534
1535
1536 /***********************************************************************
1537  *           CoFreeAllLibraries [COMPOBJ.12]
1538  */
1539 void WINAPI CoFreeAllLibraries(void)
1540 {
1541     OpenDll *ptr, *tmp;
1542
1543     for (ptr = openDllList; ptr != NULL; ) {
1544         tmp=ptr->next;
1545         CoFreeLibrary(ptr->hLibrary);
1546         ptr = tmp;
1547     }
1548 }
1549
1550
1551
1552 /***********************************************************************
1553  *           CoFreeUnusedLibraries [COMPOBJ.17]
1554  */
1555 void WINAPI CoFreeUnusedLibraries(void)
1556 {
1557     OpenDll *ptr, *tmp;
1558     typedef HRESULT(*DllCanUnloadNowFunc)(void);
1559     DllCanUnloadNowFunc DllCanUnloadNow;
1560
1561     for (ptr = openDllList; ptr != NULL; ) {
1562         DllCanUnloadNow = (DllCanUnloadNowFunc)
1563             GetProcAddress(ptr->hLibrary, "DllCanUnloadNow");
1564         
1565         if ( (DllCanUnloadNow != NULL) &&
1566              (DllCanUnloadNow() == S_OK) ) {
1567             tmp=ptr->next;
1568             CoFreeLibrary(ptr->hLibrary);
1569             ptr = tmp;
1570         } else {
1571             ptr=ptr->next;
1572         }
1573     }
1574 }
1575
1576 /***********************************************************************
1577  *           CoFileTimeNow [COMPOBJ.82, OLE32.10]
1578  * RETURNS
1579  *      the current system time in lpFileTime
1580  */
1581 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime ) /* [out] the current time */
1582 {
1583     GetSystemTimeAsFileTime( lpFileTime );
1584     return S_OK;
1585 }
1586
1587 /***********************************************************************
1588  *           CoTaskMemAlloc (OLE32.43)
1589  * RETURNS
1590  *      pointer to newly allocated block
1591  */
1592 LPVOID WINAPI CoTaskMemAlloc(
1593         ULONG size      /* [in] size of memoryblock to be allocated */
1594 ) {
1595     LPMALLOC    lpmalloc;
1596     HRESULT     ret = CoGetMalloc(0,&lpmalloc);
1597
1598     if (FAILED(ret)) 
1599         return NULL;
1600
1601     return IMalloc_Alloc(lpmalloc,size);
1602 }
1603 /***********************************************************************
1604  *           CoTaskMemFree (OLE32.44)
1605  */
1606 VOID WINAPI CoTaskMemFree(
1607         LPVOID ptr      /* [in] pointer to be freed */
1608 ) {
1609     LPMALLOC    lpmalloc;
1610     HRESULT     ret = CoGetMalloc(0,&lpmalloc);
1611
1612     if (FAILED(ret)) 
1613       return;
1614
1615     IMalloc_Free(lpmalloc, ptr);
1616 }
1617
1618 /***********************************************************************
1619  *           CoTaskMemRealloc (OLE32.45)
1620  * RETURNS
1621  *      pointer to newly allocated block
1622  */
1623 LPVOID WINAPI CoTaskMemRealloc(
1624   LPVOID pvOld,
1625   ULONG  size)  /* [in] size of memoryblock to be allocated */
1626 {
1627   LPMALLOC lpmalloc;
1628   HRESULT  ret = CoGetMalloc(0,&lpmalloc);
1629   
1630   if (FAILED(ret)) 
1631     return NULL;
1632
1633   return IMalloc_Realloc(lpmalloc, pvOld, size);
1634 }
1635
1636 /***********************************************************************
1637  *           CoLoadLibrary (OLE32.30)
1638  */
1639 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
1640 {
1641     HINSTANCE hLibrary;
1642     OpenDll *ptr;
1643     OpenDll *tmp;
1644   
1645     TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
1646
1647     hLibrary = LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
1648
1649     if (!bAutoFree)
1650         return hLibrary;
1651
1652     if (openDllList == NULL) {
1653         /* empty list -- add first node */
1654         openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
1655         openDllList->hLibrary=hLibrary;
1656         openDllList->next = NULL;
1657     } else {
1658         /* search for this dll */
1659         int found = FALSE;
1660         for (ptr = openDllList; ptr->next != NULL; ptr=ptr->next) {
1661             if (ptr->hLibrary == hLibrary) {
1662                 found = TRUE;
1663                 break;
1664             }
1665         }
1666         if (!found) {
1667             /* dll not found, add it */
1668             tmp = openDllList;
1669             openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
1670             openDllList->hLibrary = hLibrary;
1671             openDllList->next = tmp;
1672         }
1673     }
1674      
1675     return hLibrary;
1676 }
1677
1678 /***********************************************************************
1679  *           CoInitializeWOW (OLE32.27)
1680  */
1681 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) {
1682     FIXME("(0x%08lx,0x%08lx),stub!\n",x,y);
1683     return 0;
1684 }
1685
1686 /******************************************************************************
1687  *              CoLockObjectExternal16  [COMPOBJ.63]
1688  */
1689 HRESULT WINAPI CoLockObjectExternal16(
1690     LPUNKNOWN pUnk,             /* [in] object to be locked */
1691     BOOL16 fLock,               /* [in] do lock */
1692     BOOL16 fLastUnlockReleases  /* [in] ? */
1693 ) {
1694     FIXME("(%p,%d,%d),stub!\n",pUnk,fLock,fLastUnlockReleases);
1695     return S_OK;
1696 }
1697
1698 /******************************************************************************
1699  *              CoLockObjectExternal    [OLE32.31]
1700  */
1701 HRESULT WINAPI CoLockObjectExternal(
1702     LPUNKNOWN pUnk,             /* [in] object to be locked */
1703     BOOL fLock,         /* [in] do lock */
1704     BOOL fLastUnlockReleases) /* [in] unlock all */
1705 {
1706
1707   if (fLock) 
1708   {
1709     /* 
1710      * Increment the external lock coutner, COM_ExternalLockAddRef also
1711      * increment the object's internal lock counter.
1712      */
1713     COM_ExternalLockAddRef( pUnk); 
1714   }
1715   else
1716   {
1717     /* 
1718      * Decrement the external lock coutner, COM_ExternalLockRelease also
1719      * decrement the object's internal lock counter.
1720      */
1721     COM_ExternalLockRelease( pUnk, fLastUnlockReleases);
1722   }
1723
1724     return S_OK;
1725 }
1726
1727 /***********************************************************************
1728  *           CoGetState16 [COMPOBJ.115]
1729  */
1730 HRESULT WINAPI CoGetState16(LPDWORD state)
1731 {
1732     FIXME("(%p),stub!\n", state);
1733     *state = 0;
1734     return S_OK;
1735 }
1736 /***********************************************************************
1737  *           CoSetState [OLE32.42]
1738  */
1739 HRESULT WINAPI CoSetState(LPDWORD state)
1740 {
1741     FIXME("(%p),stub!\n", state);
1742     if (state) *state = 0;
1743     return S_OK;
1744 }
1745 /***********************************************************************
1746  *          CoCreateFreeThreadedMarshaler [OLE32.5]
1747  */
1748 HRESULT WINAPI CoCreateFreeThreadedMarshaler (LPUNKNOWN punkOuter, LPUNKNOWN* ppunkMarshal)
1749 {
1750    FIXME ("(%p %p): stub\n", punkOuter, ppunkMarshal);
1751     
1752    return S_OK;
1753 }
1754
1755
1756 /***********************************************************************
1757  *           DllGetClassObject [OLE32.63]
1758  */
1759 HRESULT WINAPI OLE32_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
1760 {       
1761         FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
1762         *ppv = NULL;
1763         return CLASS_E_CLASSNOTAVAILABLE;
1764 }
1765
1766
1767 /***
1768  * COM_RevokeAllClasses
1769  *
1770  * This method is called when the COM libraries are uninitialized to 
1771  * release all the references to the class objects registered with
1772  * the library
1773  */
1774 static void COM_RevokeAllClasses()
1775 {
1776   while (firstRegisteredClass!=0)
1777   {
1778     CoRevokeClassObject(firstRegisteredClass->dwCookie);
1779   }
1780 }
1781
1782 /****************************************************************************
1783  *  COM External Lock methods implementation
1784  */
1785
1786 /****************************************************************************
1787  * Public - Method that increments the count for a IUnknown* in the linked 
1788  * list.  The item is inserted if not already in the list.
1789  */
1790 static void COM_ExternalLockAddRef(
1791   IUnknown *pUnk)
1792 {
1793   COM_ExternalLock *externalLock = COM_ExternalLockFind(pUnk);
1794
1795   /*
1796    * Add an external lock to the object. If it was already externally
1797    * locked, just increase the reference count. If it was not.
1798    * add the item to the list.
1799    */
1800   if ( externalLock == EL_NOT_FOUND )
1801     COM_ExternalLockInsert(pUnk);
1802   else
1803     externalLock->uRefCount++;
1804
1805   /*
1806    * Add an internal lock to the object
1807    */
1808   IUnknown_AddRef(pUnk); 
1809 }
1810
1811 /****************************************************************************
1812  * Public - Method that decrements the count for a IUnknown* in the linked 
1813  * list.  The item is removed from the list if its count end up at zero or if
1814  * bRelAll is TRUE.
1815  */
1816 static void COM_ExternalLockRelease(
1817   IUnknown *pUnk,
1818   BOOL   bRelAll)
1819 {
1820   COM_ExternalLock *externalLock = COM_ExternalLockFind(pUnk);
1821
1822   if ( externalLock != EL_NOT_FOUND )
1823   {
1824     do
1825     {
1826       externalLock->uRefCount--;  /* release external locks      */
1827       IUnknown_Release(pUnk);     /* release local locks as well */
1828
1829       if ( bRelAll == FALSE ) 
1830         break;  /* perform single release */
1831
1832     } while ( externalLock->uRefCount > 0 );  
1833
1834     if ( externalLock->uRefCount == 0 )  /* get rid of the list entry */
1835       COM_ExternalLockDelete(externalLock);
1836   }
1837 }
1838 /****************************************************************************
1839  * Public - Method that frees the content of the list.
1840  */
1841 static void COM_ExternalLockFreeList()
1842 {
1843   COM_ExternalLock *head;
1844
1845   head = elList.head;                 /* grab it by the head             */
1846   while ( head != EL_END_OF_LIST )
1847   {
1848     COM_ExternalLockDelete(head);     /* get rid of the head stuff       */
1849
1850     head = elList.head;               /* get the new head...             */ 
1851   }
1852 }
1853
1854 /****************************************************************************
1855  * Public - Method that dump the content of the list.
1856  */
1857 void COM_ExternalLockDump()
1858 {
1859   COM_ExternalLock *current = elList.head;
1860
1861   DPRINTF("\nExternal lock list contains:\n");
1862
1863   while ( current != EL_END_OF_LIST )
1864   {
1865       DPRINTF( "\t%p with %lu references count.\n", current->pUnk, current->uRefCount);
1866  
1867     /* Skip to the next item */ 
1868     current = current->next;
1869   } 
1870
1871 }
1872
1873 /****************************************************************************
1874  * Internal - Find a IUnknown* in the linked list
1875  */
1876 static COM_ExternalLock* COM_ExternalLockFind(
1877   IUnknown *pUnk)
1878 {
1879   return COM_ExternalLockLocate(elList.head, pUnk);
1880 }
1881
1882 /****************************************************************************
1883  * Internal - Recursivity agent for IUnknownExternalLockList_Find
1884  */
1885 static COM_ExternalLock* COM_ExternalLockLocate(
1886   COM_ExternalLock *element,
1887   IUnknown         *pUnk)
1888 {
1889   if ( element == EL_END_OF_LIST )  
1890     return EL_NOT_FOUND;
1891
1892   else if ( element->pUnk == pUnk )    /* We found it */
1893     return element;
1894
1895   else                                 /* Not the right guy, keep on looking */ 
1896     return COM_ExternalLockLocate( element->next, pUnk);
1897 }
1898
1899 /****************************************************************************
1900  * Internal - Insert a new IUnknown* to the linked list
1901  */
1902 static BOOL COM_ExternalLockInsert(
1903   IUnknown *pUnk)
1904 {
1905   COM_ExternalLock *newLock      = NULL;
1906   COM_ExternalLock *previousHead = NULL;
1907
1908   /*
1909    * Allocate space for the new storage object
1910    */
1911   newLock = HeapAlloc(GetProcessHeap(), 0, sizeof(COM_ExternalLock));
1912
1913   if (newLock!=NULL)
1914   {
1915     if ( elList.head == EL_END_OF_LIST ) 
1916     {
1917       elList.head = newLock;    /* The list is empty */
1918     }
1919     else 
1920     {
1921       /* 
1922        * insert does it at the head
1923        */
1924       previousHead  = elList.head;
1925       elList.head = newLock;
1926     }
1927
1928     /*
1929      * Set new list item data member 
1930      */
1931     newLock->pUnk      = pUnk;
1932     newLock->uRefCount = 1;
1933     newLock->next      = previousHead;
1934     
1935     return TRUE;
1936   }
1937   else
1938     return FALSE;
1939 }
1940
1941 /****************************************************************************
1942  * Internal - Method that removes an item from the linked list.
1943  */
1944 static void COM_ExternalLockDelete(
1945   COM_ExternalLock *itemList)
1946 {
1947   COM_ExternalLock *current = elList.head;
1948
1949   if ( current == itemList )
1950   {
1951     /* 
1952      * this section handles the deletion of the first node 
1953      */
1954     elList.head = itemList->next;
1955     HeapFree( GetProcessHeap(), 0, itemList);  
1956   }
1957   else
1958   {
1959     do 
1960     {
1961       if ( current->next == itemList )   /* We found the item to free  */
1962       {
1963         current->next = itemList->next;  /* readjust the list pointers */
1964   
1965         HeapFree( GetProcessHeap(), 0, itemList);  
1966         break; 
1967       }
1968  
1969       /* Skip to the next item */ 
1970       current = current->next;
1971   
1972     } while ( current != EL_END_OF_LIST );
1973   }
1974 }
1975
1976 /***********************************************************************
1977  *      COMPOBJ_DllEntryPoint                   [COMPOBJ.entry]
1978  *
1979  *    Initialization code for the COMPOBJ DLL
1980  *
1981  * RETURNS:
1982  */
1983 BOOL WINAPI COMPOBJ_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst, WORD ds, WORD HeapSize, DWORD res1, WORD res2)
1984 {
1985         TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n", Reason, hInst, ds, HeapSize,
1986  res1, res2);
1987         switch(Reason)
1988         {
1989         case DLL_PROCESS_ATTACH:
1990                 if (!COMPOBJ_Attach++) COMPOBJ_hInstance = hInst;
1991                 break;
1992
1993         case DLL_PROCESS_DETACH:
1994                 if(!--COMPOBJ_Attach)
1995                         COMPOBJ_hInstance = 0;
1996                 break;
1997         }
1998         return TRUE;
1999 }
2000
2001 /******************************************************************************
2002  *              OleGetAutoConvert        [OLE32.104]
2003  */
2004 HRESULT WINAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
2005 {
2006     HKEY hkey = 0;
2007     char buf[200];
2008     WCHAR wbuf[200];
2009     DWORD len;
2010     HRESULT res = S_OK;
2011
2012     sprintf(buf,"CLSID\\");WINE_StringFromCLSID(clsidOld,&buf[6]);
2013     if (RegOpenKeyA(HKEY_CLASSES_ROOT,buf,&hkey))
2014     {
2015         res = REGDB_E_CLASSNOTREG;
2016         goto done;
2017     }
2018     len = 200;
2019     /* we can just query for the default value of AutoConvertTo key like that,
2020        without opening the AutoConvertTo key and querying for NULL (default) */
2021     if (RegQueryValueA(hkey,"AutoConvertTo",buf,&len))
2022     {
2023         res = REGDB_E_KEYMISSING;
2024         goto done;
2025     }
2026     MultiByteToWideChar( CP_ACP, 0, buf, -1, wbuf, sizeof(wbuf)/sizeof(WCHAR) );
2027     CLSIDFromString(wbuf,pClsidNew);
2028 done:
2029   if (hkey) RegCloseKey(hkey);
2030
2031   return res;
2032 }
2033
2034 /******************************************************************************
2035  *              OleSetAutoConvert        [OLE32.126]
2036  */
2037 HRESULT WINAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
2038 {
2039     HKEY hkey = 0, hkeyConvert = 0;
2040     char buf[200], szClsidNew[200];
2041     HRESULT res = S_OK;
2042
2043     TRACE("(%p,%p);\n", clsidOld, clsidNew);
2044     sprintf(buf,"CLSID\\");WINE_StringFromCLSID(clsidOld,&buf[6]);
2045     WINE_StringFromCLSID(clsidNew, szClsidNew);
2046     if (RegOpenKeyA(HKEY_CLASSES_ROOT,buf,&hkey))
2047     {
2048         res = REGDB_E_CLASSNOTREG;
2049         goto done;
2050     }
2051     if (RegCreateKeyA(hkey, "AutoConvertTo", &hkeyConvert))
2052     {
2053         res = REGDB_E_WRITEREGDB;
2054         goto done;
2055     }
2056     if (RegSetValueExA(hkeyConvert, NULL, 0,
2057                             REG_SZ, (LPBYTE)szClsidNew, strlen(szClsidNew)+1))
2058     {
2059         res = REGDB_E_WRITEREGDB;
2060         goto done;
2061     }
2062
2063 done:
2064     if (hkeyConvert) RegCloseKey(hkeyConvert);
2065     if (hkey) RegCloseKey(hkey);
2066
2067     return res;
2068 }
2069
2070 /***********************************************************************
2071  *           IsEqualGUID [OLE32.76]
2072  *
2073  * Compares two Unique Identifiers.
2074  *
2075  * RETURNS
2076  *      TRUE if equal
2077  */
2078 #undef IsEqualGUID
2079 BOOL WINAPI IsEqualGUID(
2080      REFGUID rguid1, /* [in] unique id 1 */
2081      REFGUID rguid2  /* [in] unique id 2 */
2082      )
2083 {
2084     return !memcmp(rguid1,rguid2,sizeof(GUID));
2085 }