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