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