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