ole/compobj.c

   1 /*
   2  *      COMPOBJ library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  */
   6
   7 #define INITGUID
   8
   9 #include <ctype.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <time.h>
  13 #include "ole.h"
  14 #include "ole2.h"
  15 #include "winerror.h"
  16 #include "debug.h"
  17 #include "file.h"
  18 #include "compobj.h"
  19 #include "heap.h"
  20 #include "ldt.h"
  21 #include "interfaces.h"
  22 #include "shlobj.h"
  23 #include "ddraw.h"
  24 #include "dsound.h"
  25 #include "dinput.h"
  26 #include "d3d.h"
  27 #include "dplay.h"
  28
  29
  30 LPMALLOC16 currentMalloc16=NULL;
  31 LPMALLOC32 currentMalloc32=NULL;
  32
  33 HTASK16 hETask = 0;
  34 WORD Table_ETask[62];
  35
  36 /******************************************************************************
  37  *           CoBuildVersion [COMPOBJ.1]
  38  *
  39  * RETURNS
  40  *      Current built version, hiword is majornumber, loword is minornumber
  41  */
  42 DWORD WINAPI CoBuildVersion()
  43 {
  44     TRACE(ole,"(void)\n");
  45     return (rmm<<16)+rup;
  46 }
  47
  48 /******************************************************************************
  49  *              CoInitialize16  [COMPOBJ.2]
  50  * Set the win16 IMalloc used for memory management
  51  */
  52 HRESULT WINAPI CoInitialize16(
  53         LPMALLOC16 lpReserved   /* [in] pointer to win16 malloc interface */
  54 ) {
  55     currentMalloc16 = lpReserved;
  56     return S_OK;
  57 }
  58
  59 /******************************************************************************
  60  *              CoInitialize32  [OLE32.26]
  61  * Set the win32 IMalloc used for memorymanagement
  62  */
  63 HRESULT WINAPI CoInitialize32(
  64         LPMALLOC32 lpReserved   /* [in] pointer to win32 malloc interface */
  65 ) {
  66     currentMalloc32 = lpReserved;
  67     return S_OK;
  68 }
  69
  70 /***********************************************************************
  71  *           CoUnitialize   [COMPOBJ.3]
  72  * Don't know what it does.
  73  */
  74 void WINAPI CoUnitialize()
  75 {
  76     TRACE(ole,"(void)\n");
  77 }
  78
  79 /***********************************************************************
  80  *           CoGetMalloc16    [COMPOBJ.4]
  81  * RETURNS
  82  *      The current win16 IMalloc
  83  */
  84 HRESULT WINAPI CoGetMalloc16(
  85         DWORD dwMemContext,     /* [in] unknown */
  86         LPMALLOC16 * lpMalloc   /* [out] current win16 malloc interface */
  87 ) {
  88     if(!currentMalloc16)
  89         currentMalloc16 = IMalloc16_Constructor();
  90     *lpMalloc = currentMalloc16;
  91     return S_OK;
  92 }
  93
  94 /******************************************************************************
  95  *              CoGetMalloc32   [OLE32.20]
  96  *
  97  * RETURNS
  98  *      The current win32 IMalloc
  99  */
 100 HRESULT WINAPI CoGetMalloc32(
 101         DWORD dwMemContext,     /* [in] unknown */
 102         LPMALLOC32 *lpMalloc    /* [out] current win32 malloc interface */
 103 ) {
 104     if(!currentMalloc32)
 105         currentMalloc32 = IMalloc32_Constructor();
 106     *lpMalloc = currentMalloc32;
 107     return S_OK;
 108 }
 109
 110 /***********************************************************************
 111  *           CoCreateStandardMalloc16 [COMPOBJ.71]
 112  */
 113 OLESTATUS WINAPI CoCreateStandardMalloc16(DWORD dwMemContext,
 114                                           LPMALLOC16 *lpMalloc)
 115 {
 116     /* FIXME: docu says we shouldn't return the same allocator as in
 117      * CoGetMalloc16 */
 118     *lpMalloc = IMalloc16_Constructor();
 119     return S_OK;
 120 }
 121
 122 /******************************************************************************
 123  *              CoDisconnectObject      [COMPOBJ.15]
 124  */
 125 OLESTATUS WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
 126 {
 127     TRACE(ole,"%p %lx\n",lpUnk,reserved);
 128     return S_OK;
 129 }
 130
 131 /***********************************************************************
 132  *           IsEqualGUID [COMPOBJ.18]
 133  * Compares two Unique Identifiers
 134  * RETURNS
 135  *      TRUE if equal
 136  */
 137 BOOL16 WINAPI IsEqualGUID(
 138         GUID* g1,       /* [in] unique id 1 */
 139         GUID* g2        /* [in] unique id 2 */
 140 ) {
 141     return !memcmp( g1, g2, sizeof(GUID) );
 142 }
 143
 144 /******************************************************************************
 145  *              CLSIDFromString16       [COMPOBJ.20]
 146  * Converts a unique identifier from it's string representation into
 147  * the GUID struct.
 148  *
 149  * Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6]
 150  *
 151  * RETURNS
 152  *      the converted GUID
 153  */
 154 OLESTATUS WINAPI CLSIDFromString16(
 155         LPCOLESTR16 idstr,      /* [in] string representation of guid */
 156         CLSID *id               /* [out] GUID converted from string */
 157 ) {
 158   BYTE *s = (BYTE *) idstr;
 159   BYTE *p;
 160   int   i;
 161   BYTE table[256];
 162
 163   TRACE(ole,"%s -> %p\n", idstr, id);
 164
 165   /* quick lookup table */
 166   memset(table, 0, 256);
 167
 168   for (i = 0; i < 10; i++) {
 169     table['0' + i] = i;
 170   }
 171   for (i = 0; i < 6; i++) {
 172     table['A' + i] = i+10;
 173     table['a' + i] = i+10;
 174   }
 175
 176   /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
 177
 178   if (strlen(idstr) != 38)
 179     return OLE_ERROR_OBJECT;
 180
 181   p = (BYTE *) id;
 182
 183   s++;  /* skip leading brace  */
 184   for (i = 0; i < 4; i++) {
 185     p[3 - i] = table[*s]<<4 | table[*(s+1)];
 186     s += 2;
 187   }
 188   p += 4;
 189   s++;  /* skip - */
 190
 191   for (i = 0; i < 2; i++) {
 192     p[1-i] = table[*s]<<4 | table[*(s+1)];
 193     s += 2;
 194   }
 195   p += 2;
 196   s++;  /* skip - */
 197
 198   for (i = 0; i < 2; i++) {
 199     p[1-i] = table[*s]<<4 | table[*(s+1)];
 200     s += 2;
 201   }
 202   p += 2;
 203   s++;  /* skip - */
 204
 205   /* these are just sequential bytes */
 206   for (i = 0; i < 2; i++) {
 207     *p++ = table[*s]<<4 | table[*(s+1)];
 208     s += 2;
 209   }
 210   s++;  /* skip - */
 211
 212   for (i = 0; i < 6; i++) {
 213     *p++ = table[*s]<<4 | table[*(s+1)];
 214     s += 2;
 215   }
 216
 217   return S_OK;
 218 }
 219
 220 /******************************************************************************
 221  *              CoCreateGuid[OLE32.6]
 222  * Just a random 128-bit number?
 223  */
 224 HRESULT WINAPI CoCreateGuid(GUID *pguid) {
 225         FIXME(ole,"stub!\n");
 226         return S_OK;
 227 }
 228
 229 /******************************************************************************
 230  *              CLSIDFromString32       [OLE32.3]
 231  * Converts a unique identifier from it's string representation into
 232  * the GUID struct.
 233  * RETURNS
 234  *      the converted GUID
 235  */
 236 OLESTATUS WINAPI CLSIDFromString32(
 237         LPCOLESTR32 idstr,      /* [in] string representation of GUID */
 238         CLSID *id               /* [out] GUID represented by above string */
 239 ) {
 240     LPOLESTR16      xid = HEAP_strdupWtoA(GetProcessHeap(),0,idstr);
 241     OLESTATUS       ret = CLSIDFromString16(xid,id);
 242
 243     HeapFree(GetProcessHeap(),0,xid);
 244     return ret;
 245 }
 246
 247 /******************************************************************************
 248  *              WINE_StringFromCLSID    [???]
 249  * Converts a GUID into the respective string representation.
 250  *
 251  * NOTES
 252  *    Why is this WINAPI?
 253  *
 254  * RETURNS
 255  *      the string representation and OLESTATUS
 256  */
 257 OLESTATUS WINAPI WINE_StringFromCLSID(
 258         const CLSID *id,        /* [in] GUID to be converted */
 259         LPSTR idstr             /* [out] pointer to buffer to contain converted guid */
 260 ) {
 261   static const char *hex = "0123456789ABCDEF";
 262   char *s;
 263   int   i;
 264
 265   if (!id)
 266         { ERR(ole,"called with id=Null\n");
 267           *idstr = 0x00;
 268           return E_FAIL;
 269         }
 270
 271   sprintf(idstr, "{%08lx-%04x-%04x-%02x%02x-",
 272           id->Data1, id->Data2, id->Data3,
 273           id->Data4[0], id->Data4[1]);
 274   s = &idstr[25];
 275
 276   /* 6 hex bytes */
 277   for (i = 2; i < 8; i++) {
 278     *s++ = hex[id->Data4[i]>>4];
 279     *s++ = hex[id->Data4[i] & 0xf];
 280   }
 281
 282   *s++ = '}';
 283   *s++ = '\0';
 284
 285   for (i = strlen(idstr)-1; i >= 0; i--) {
 286     idstr[i] = toupper(idstr[i]);
 287   }
 288
 289   TRACE(ole,"%p->%s\n", id, idstr);
 290
 291   return OLE_OK;
 292 }
 293
 294 /******************************************************************************
 295  *              StringFromCLSID16       [COMPOBJ.19]
 296  * Converts a GUID into the respective string representation.
 297  * The target string is allocated using the OLE IMalloc.
 298  * RETURNS
 299  *      the string representation and OLESTATUS
 300  */
 301 OLESTATUS WINAPI StringFromCLSID16(
 302         const CLSID *id,        /* [in] the GUID to be converted */
 303         LPOLESTR16 *idstr       /* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
 304
 305 ) {
 306     LPMALLOC16  mllc;
 307     OLESTATUS   ret;
 308     DWORD       args[2];
 309
 310     ret = CoGetMalloc16(0,&mllc);
 311     if (ret) return ret;
 312
 313     args[0] = (DWORD)mllc;
 314     args[1] = 40;
 315
 316     /* No need for a Callback entry, we have WOWCallback16Ex which does
 317      * everything we need.
 318      */
 319     if (!WOWCallback16Ex(
 320         (FARPROC16)((LPMALLOC16_VTABLE)PTR_SEG_TO_LIN(
 321                 ((LPMALLOC16)PTR_SEG_TO_LIN(mllc))->lpvtbl)
 322         )->fnAlloc,
 323         WCB16_CDECL,
 324         2,
 325         (LPVOID)args,
 326         (LPDWORD)idstr
 327     )) {
 328         WARN(ole,"CallTo16 IMalloc16 failed\n");
 329         return E_FAIL;
 330     }
 331     return WINE_StringFromCLSID(id,PTR_SEG_TO_LIN(*idstr));
 332 }
 333
 334 /******************************************************************************
 335  *              StringFromCLSID32       [OLE32.151]
 336  * Converts a GUID into the respective string representation.
 337  * The target string is allocated using the OLE IMalloc.
 338  * RETURNS
 339  *      the string representation and OLESTATUS
 340  */
 341 OLESTATUS WINAPI StringFromCLSID32(
 342         const CLSID *id,        /* [in] the GUID to be converted */
 343         LPOLESTR32 *idstr       /* [out] a pointer to a to-be-allocated pointer pointing to the resulting string */
 344 ) {
 345         char            buf[80];
 346         OLESTATUS       ret;
 347         LPMALLOC32      mllc;
 348
 349         if ((ret=CoGetMalloc32(0,&mllc)))
 350                 return ret;
 351
 352         ret=WINE_StringFromCLSID(id,buf);
 353         if (!ret) {
 354                 *idstr = mllc->lpvtbl->fnAlloc(mllc,strlen(buf)*2+2);
 355                 lstrcpyAtoW(*idstr,buf);
 356         }
 357         return ret;
 358 }
 359
 360 /******************************************************************************
 361  *              StringFromGUID2 [COMPOBJ.76] [OLE32.152]
 362  *
 363  * Converts a global unique identifier into a string of an API-
 364  * specified fixed format. (The usual {.....} stuff.)
 365  *
 366  * RETURNS
 367  *      The (UNICODE) string representation of the GUID in 'str'
 368  *      The length of the resulting string, 0 if there was any problem.
 369  */
 370 INT32 WINAPI
 371 StringFromGUID2(REFGUID id, LPOLESTR32 str, INT32 cmax)
 372 {
 373   char          xguid[80];
 374
 375   if (WINE_StringFromCLSID(id,xguid))
 376         return 0;
 377   if (strlen(xguid)>=cmax)
 378         return 0;
 379   lstrcpyAtoW(str,xguid);
 380   return strlen(xguid);
 381 }
 382
 383 /******************************************************************************
 384  *              CLSIDFromProgID16       [COMPOBJ.61]
 385  * Converts a program id into the respective GUID. (By using a registry lookup)
 386  * RETURNS
 387  *      riid associated with the progid
 388  */
 389 OLESTATUS WINAPI CLSIDFromProgID16(
 390         LPCOLESTR16 progid,     /* [in] program id as found in registry */
 391         LPCLSID riid            /* [out] associated CLSID */
 392 ) {
 393         char    *buf,buf2[80];
 394         DWORD   buf2len;
 395         HRESULT err;
 396         HKEY    xhkey;
 397
 398         buf = HeapAlloc(GetProcessHeap(),0,strlen(progid)+8);
 399         sprintf(buf,"%s\\CLSID",progid);
 400         if ((err=RegOpenKey32A(HKEY_CLASSES_ROOT,buf,&xhkey))) {
 401                 HeapFree(GetProcessHeap(),0,buf);
 402                 return OLE_ERROR_GENERIC;
 403         }
 404         HeapFree(GetProcessHeap(),0,buf);
 405         buf2len = sizeof(buf2);
 406         if ((err=RegQueryValue32A(xhkey,NULL,buf2,&buf2len))) {
 407                 RegCloseKey(xhkey);
 408                 return OLE_ERROR_GENERIC;
 409         }
 410         RegCloseKey(xhkey);
 411         return CLSIDFromString16(buf2,riid);
 412 }
 413
 414 /******************************************************************************
 415  *              CLSIDFromProgID32       [OLE32.2]
 416  * Converts a program id into the respective GUID. (By using a registry lookup)
 417  * RETURNS
 418  *      riid associated with the progid
 419  */
 420 OLESTATUS WINAPI CLSIDFromProgID32(
 421         LPCOLESTR32 progid,     /* [in] program id as found in registry */
 422         LPCLSID riid            /* [out] associated CLSID */
 423 ) {
 424         LPOLESTR16 pid = HEAP_strdupWtoA(GetProcessHeap(),0,progid);
 425         OLESTATUS       ret = CLSIDFromProgID16(pid,riid);
 426
 427         HeapFree(GetProcessHeap(),0,pid);
 428         return ret;
 429 }
 430
 431 /***********************************************************************
 432  *           LookupETask (COMPOBJ.94)
 433  */
 434 OLESTATUS WINAPI LookupETask(HTASK16 *hTask,LPVOID p) {
 435         FIXME(ole,"(%p,%p),stub!\n",hTask,p);
 436         if ((*hTask = GetCurrentTask()) == hETask) {
 437                 memcpy(p, Table_ETask, sizeof(Table_ETask));
 438         }
 439         return 0;
 440 }
 441
 442 /***********************************************************************
 443  *           SetETask (COMPOBJ.95)
 444  */
 445 OLESTATUS WINAPI SetETask(HTASK16 hTask, LPVOID p) {
 446         FIXME(ole,"(%04x,%p),stub!\n",hTask,p);
 447         hETask = hTask;
 448         return 0;
 449 }
 450
 451 /***********************************************************************
 452  *           CallObjectInWOW (COMPOBJ.201)
 453  */
 454 OLESTATUS WINAPI CallObjectInWOW(LPVOID p1,LPVOID p2) {
 455         FIXME(ole,"(%p,%p),stub!\n",p1,p2);
 456         return 0;
 457 }
 458
 459 /******************************************************************************
 460  *              CoRegisterClassObject16 [COMPOBJ.5]
 461  *
 462  * Don't know where it registers it ...
 463  */
 464 OLESTATUS WINAPI CoRegisterClassObject16(
 465         REFCLSID rclsid,
 466         LPUNKNOWN pUnk,
 467         DWORD dwClsContext,
 468         DWORD flags,
 469         LPDWORD lpdwRegister
 470 ) {
 471         char    buf[80];
 472
 473         WINE_StringFromCLSID(rclsid,buf);
 474
 475         FIXME(ole,"(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
 476                 buf,pUnk,dwClsContext,flags,lpdwRegister
 477         );
 478         return 0;
 479 }
 480
 481 /******************************************************************************
 482  *              CoRegisterClassObject32 [OLE32.36]
 483  *
 484  * Don't know where it registers it ...
 485  */
 486 OLESTATUS WINAPI CoRegisterClassObject32(
 487         REFCLSID rclsid,
 488         LPUNKNOWN pUnk,
 489         DWORD dwClsContext,
 490         DWORD flags,
 491         LPDWORD lpdwRegister
 492 ) {
 493     char buf[80];
 494
 495     WINE_StringFromCLSID(rclsid,buf);
 496
 497     FIXME(ole,"(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
 498             buf,pUnk,dwClsContext,flags,lpdwRegister
 499     );
 500     return 0;
 501 }
 502
 503 /***********************************************************************
 504  *           CoGetClassObject [COMPOBJ.7]
 505  */
 506 HRESULT WINAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext,
 507                         LPVOID pvReserved, REFIID iid, LPVOID *ppv)
 508 {
 509     char xclsid[50],xiid[50];
 510     LPCLASSFACTORY lpclf;
 511     HRESULT hres = E_UNEXPECTED;
 512
 513     WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
 514     WINE_StringFromCLSID((LPCLSID)iid,xiid);
 515     TRACE(ole,"\n\tCLSID:\t%s,\n\tIID:\t%s\n",xclsid,xiid);
 516
 517     *ppv = NULL;
 518     lpclf = IClassFactory_Constructor();
 519     if (lpclf)
 520     {
 521         hres = lpclf->lpvtbl->fnQueryInterface(lpclf,iid, ppv);
 522         lpclf->lpvtbl->fnRelease(lpclf);
 523     }
 524     return hres;
 525 }
 526
 527 /******************************************************************************
 528  *              CoRegisterMessageFilter16       [COMPOBJ.27]
 529  */
 530 OLESTATUS WINAPI CoRegisterMessageFilter16(
 531         LPMESSAGEFILTER lpMessageFilter,
 532         LPMESSAGEFILTER *lplpMessageFilter
 533 ) {
 534         FIXME(ole,"(%p,%p),stub!\n",lpMessageFilter,lplpMessageFilter);
 535         return 0;
 536 }
 537
 538 /***********************************************************************
 539  *           CoCreateInstance [COMPOBJ.13, OLE32.7]
 540  */
 541 HRESULT WINAPI CoCreateInstance(
 542         REFCLSID rclsid,
 543         LPUNKNOWN pUnkOuter,
 544         DWORD dwClsContext,
 545         REFIID iid,
 546         LPVOID *ppv
 547 ) {
 548 #if 0
 549         char buf[80],xbuf[80];
 550
 551         if (rclsid)
 552                 WINE_StringFromCLSID(rclsid,buf);
 553         else
 554                 sprintf(buf,"<rclsid-0x%08lx>",(DWORD)rclsid);
 555         if (iid)
 556                 WINE_StringFromCLSID(iid,xbuf);
 557         else
 558                 sprintf(xbuf,"<iid-0x%08lx>",(DWORD)iid);
 559
 560         FIXME(ole,"(%s,%p,0x%08lx,%s,%p): stub !\n",buf,pUnkOuter,dwClsContext,xbuf,ppv);
 561         *ppv = NULL;
 562 #else
 563         HRESULT hres;
 564         LPCLASSFACTORY lpclf = 0;
 565
 566         CoGetClassObject(rclsid, dwClsContext, NULL, &IID_IClassFactory, (LPVOID)&lpclf);
 567         hres = lpclf->lpvtbl->fnCreateInstance(lpclf, pUnkOuter, iid, ppv);
 568         lpclf->lpvtbl->fnRelease(lpclf);
 569         return hres;
 570 #endif
 571 }
 572
 573 /***********************************************************************
 574  *           CoFreeUnusedLibraries [COMPOBJ.17]
 575  */
 576 void WINAPI CoFreeUnusedLibraries()
 577 {
 578         FIXME(ole,"(), stub !\n");
 579 }
 580
 581 /***********************************************************************
 582  *           CoFileTimeNow [COMPOBJ.82, OLE32.10]
 583  * RETURNS
 584  *      the current system time in lpFileTime
 585  */
 586 HRESULT WINAPI CoFileTimeNow(
 587         FILETIME *lpFileTime    /* [out] the current time */
 588 ) {
 589         DOSFS_UnixTimeToFileTime(time(NULL), lpFileTime, 0);
 590         return S_OK;
 591 }
 592
 593 /***********************************************************************
 594  *           CoTaskMemAlloc (OLE32.43)
 595  * RETURNS
 596  *      pointer to newly allocated block
 597  */
 598 LPVOID WINAPI CoTaskMemAlloc(
 599         ULONG size      /* [in] size of memoryblock to be allocated */
 600 ) {
 601     LPMALLOC32  lpmalloc;
 602     HRESULT     ret = CoGetMalloc32(0,&lpmalloc);
 603
 604     if (ret)
 605         return NULL;
 606     return lpmalloc->lpvtbl->fnAlloc(lpmalloc,size);
 607 }
 608
 609 /***********************************************************************
 610  *           CoTaskMemFree (OLE32.44)
 611  */
 612 VOID WINAPI CoTaskMemFree(
 613         LPVOID ptr      /* [in] pointer to be freed */
 614 ) {
 615     LPMALLOC32  lpmalloc;
 616     HRESULT     ret = CoGetMalloc32(0,&lpmalloc);
 617
 618     if (ret) return;
 619     return lpmalloc->lpvtbl->fnFree(lpmalloc,ptr);
 620 }
 621
 622 /***********************************************************************
 623  *           CoInitializeWOW (OLE32.27)
 624  */
 625 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) {
 626     FIXME(ole,"(0x%08lx,0x%08lx),stub!\n",x,y);
 627     return 0;
 628 }
 629
 630 /******************************************************************************
 631  *              CoLockObjectExternal16  [COMPOBJ.63]
 632  */
 633 HRESULT WINAPI CoLockObjectExternal16(
 634     LPUNKNOWN pUnk,             /* [in] object to be locked */
 635     BOOL16 fLock,               /* [in] do lock */
 636     BOOL16 fLastUnlockReleases  /* [in] ? */
 637 ) {
 638     FIXME(ole,"(%p,%d,%d),stub!\n",pUnk,fLock,fLastUnlockReleases);
 639     return S_OK;
 640 }
 641
 642 /******************************************************************************
 643  *              CoLockObjectExternal32  [OLE32.31]
 644  */
 645 HRESULT WINAPI CoLockObjectExternal32(
 646     LPUNKNOWN pUnk,             /* [in] object to be locked */
 647     BOOL32 fLock,               /* [in] do lock */
 648     BOOL32 fLastUnlockReleases  /* [in] ? */
 649 ) {
 650     FIXME(ole,"(%p,%d,%d),stub!\n",pUnk,fLock,fLastUnlockReleases);
 651     return S_OK;
 652 }
 653
 654 /***********************************************************************
 655  *           CoGetState16 [COMPOBJ.115]
 656  */
 657 HRESULT WINAPI CoGetState16(LPDWORD state)
 658 {
 659     FIXME(ole, "(%p),stub!\n", state);
 660     *state = 0;
 661     return S_OK;
 662 }
 663 /***********************************************************************
 664  *           CoSetState32 [COM32.42]
 665  */
 666 HRESULT WINAPI CoSetState32(LPDWORD state)
 667 {
 668     FIXME(ole, "(%p),stub!\n", state);
 669     *state = 0;
 670     return S_OK;
 671 }