dll/win32/ole32/classmoniker.c

   1 /*
   2  *                            Class Monikers
   3  *
   4  *           Copyright 1999  Noomen Hamza
   5  *           Copyright 2005-2007  Robert Shearman
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "precomp.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  25
  26 #define CHARS_IN_GUID 39
  27
  28 /* ClassMoniker data structure */
  29 typedef struct ClassMoniker
  30 {
  31     IMoniker IMoniker_iface;
  32     IROTData IROTData_iface;
  33     LONG ref;
  34     CLSID clsid; /* clsid identified by this moniker */
  35     IUnknown *pMarshal; /* custom marshaler */
  36 } ClassMoniker;
  37
  38 static inline ClassMoniker *impl_from_IMoniker(IMoniker *iface)
  39 {
  40     return CONTAINING_RECORD(iface, ClassMoniker, IMoniker_iface);
  41 }
  42
  43 static inline ClassMoniker *impl_from_IROTData(IROTData *iface)
  44 {
  45     return CONTAINING_RECORD(iface, ClassMoniker, IROTData_iface);
  46 }
  47
  48 /*******************************************************************************
  49  *        ClassMoniker_QueryInterface
  50  *******************************************************************************/
  51 static HRESULT WINAPI ClassMoniker_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
  52 {
  53     ClassMoniker *This = impl_from_IMoniker(iface);
  54
  55     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
  56
  57     /* Perform a sanity check on the parameters.*/
  58     if (!ppvObject)
  59         return E_POINTER;
  60
  61     /* Initialize the return parameter */
  62     *ppvObject = 0;
  63
  64     /* Compare the riid with the interface IDs implemented by this object.*/
  65     if (IsEqualIID(&IID_IUnknown, riid) ||
  66         IsEqualIID(&IID_IPersist, riid) ||
  67         IsEqualIID(&IID_IPersistStream, riid) ||
  68         IsEqualIID(&IID_IMoniker, riid))
  69     {
  70         *ppvObject = iface;
  71     }
  72     else if (IsEqualIID(&IID_IROTData, riid))
  73         *ppvObject = &This->IROTData_iface;
  74     else if (IsEqualIID(&IID_IMarshal, riid))
  75     {
  76         HRESULT hr = S_OK;
  77         if (!This->pMarshal)
  78             hr = MonikerMarshal_Create(iface, &This->pMarshal);
  79         if (hr != S_OK)
  80             return hr;
  81         return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
  82     }
  83
  84     /* Check that we obtained an interface.*/
  85     if (!*ppvObject)
  86         return E_NOINTERFACE;
  87
  88     /* Query Interface always increases the reference count by one when it is successful */
  89     IMoniker_AddRef(iface);
  90
  91     return S_OK;
  92 }
  93
  94 /******************************************************************************
  95  *        ClassMoniker_AddRef
  96  ******************************************************************************/
  97 static ULONG WINAPI ClassMoniker_AddRef(IMoniker* iface)
  98 {
  99     ClassMoniker *This = impl_from_IMoniker(iface);
 100
 101     TRACE("(%p)\n",This);
 102
 103     return InterlockedIncrement(&This->ref);
 104 }
 105
 106 /******************************************************************************
 107  *        ClassMoniker_Release
 108  ******************************************************************************/
 109 static ULONG WINAPI ClassMoniker_Release(IMoniker* iface)
 110 {
 111     ClassMoniker *This = impl_from_IMoniker(iface);
 112     ULONG ref;
 113
 114     TRACE("(%p)\n",This);
 115
 116     ref = InterlockedDecrement(&This->ref);
 117
 118     /* destroy the object if there are no more references to it */
 119     if (ref == 0)
 120     {
 121         if (This->pMarshal) IUnknown_Release(This->pMarshal);
 122         HeapFree(GetProcessHeap(),0,This);
 123     }
 124
 125     return ref;
 126 }
 127
 128 /******************************************************************************
 129  *        ClassMoniker_GetClassID
 130  ******************************************************************************/
 131 static HRESULT WINAPI ClassMoniker_GetClassID(IMoniker* iface,CLSID *pClassID)
 132 {
 133     TRACE("(%p,%p),stub!\n",iface,pClassID);
 134
 135     if (pClassID==NULL)
 136         return E_POINTER;
 137
 138     *pClassID = CLSID_ClassMoniker;
 139
 140     return S_OK;
 141 }
 142
 143 /******************************************************************************
 144  *        ClassMoniker_IsDirty
 145  ******************************************************************************/
 146 static HRESULT WINAPI ClassMoniker_IsDirty(IMoniker* iface)
 147 {
 148     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 149        method in the OLE-provided moniker interfaces always return S_FALSE because
 150        their internal state never changes. */
 151
 152     TRACE("(%p)\n",iface);
 153
 154     return S_FALSE;
 155 }
 156
 157 /******************************************************************************
 158  *        ClassMoniker_Load
 159  ******************************************************************************/
 160 static HRESULT WINAPI ClassMoniker_Load(IMoniker* iface,IStream* pStm)
 161 {
 162     ClassMoniker *This = impl_from_IMoniker(iface);
 163     HRESULT hr;
 164     DWORD zero;
 165
 166     TRACE("(%p)\n", pStm);
 167
 168     hr = IStream_Read(pStm, &This->clsid, sizeof(This->clsid), NULL);
 169     if (hr != S_OK) return STG_E_READFAULT;
 170
 171     hr = IStream_Read(pStm, &zero, sizeof(zero), NULL);
 172     if ((hr != S_OK) || (zero != 0)) return STG_E_READFAULT;
 173
 174     return S_OK;
 175 }
 176
 177 /******************************************************************************
 178  *        ClassMoniker_Save
 179  ******************************************************************************/
 180 static HRESULT WINAPI ClassMoniker_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
 181 {
 182     ClassMoniker *This = impl_from_IMoniker(iface);
 183     HRESULT hr;
 184     DWORD zero = 0;
 185
 186     TRACE("(%p, %s)\n", pStm, fClearDirty ? "TRUE" : "FALSE");
 187
 188     hr = IStream_Write(pStm, &This->clsid, sizeof(This->clsid), NULL);
 189     if (FAILED(hr)) return hr;
 190
 191     return IStream_Write(pStm, &zero, sizeof(zero), NULL);
 192 }
 193
 194 /******************************************************************************
 195  *        ClassMoniker_GetSizeMax
 196  ******************************************************************************/
 197 static HRESULT WINAPI ClassMoniker_GetSizeMax(IMoniker* iface,
 198                                           ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
 199 {
 200     TRACE("(%p)\n", pcbSize);
 201
 202     pcbSize->QuadPart = sizeof(CLSID) + sizeof(DWORD);
 203
 204     return S_OK;
 205 }
 206
 207 /******************************************************************************
 208  *                  ClassMoniker_BindToObject
 209  ******************************************************************************/
 210 static HRESULT WINAPI ClassMoniker_BindToObject(IMoniker* iface,
 211                                             IBindCtx* pbc,
 212                                             IMoniker* pmkToLeft,
 213                                             REFIID riid,
 214                                             VOID** ppvResult)
 215 {
 216     ClassMoniker *This = impl_from_IMoniker(iface);
 217     BIND_OPTS2 bindopts;
 218     IClassActivator *pActivator;
 219     HRESULT hr;
 220
 221     TRACE("(%p,%p,%p,%p)\n", pbc, pmkToLeft, riid, ppvResult);
 222
 223     bindopts.cbStruct = sizeof(bindopts);
 224     IBindCtx_GetBindOptions(pbc, (BIND_OPTS *)&bindopts);
 225
 226     if (!pmkToLeft)
 227         return CoGetClassObject(&This->clsid, bindopts.dwClassContext, NULL,
 228                                 riid, ppvResult);
 229     else
 230     {
 231         hr = IMoniker_BindToObject(pmkToLeft, pbc, NULL, &IID_IClassActivator,
 232                                    (void **)&pActivator);
 233         if (FAILED(hr)) return hr;
 234
 235         hr = IClassActivator_GetClassObject(pActivator, &This->clsid,
 236                                             bindopts.dwClassContext,
 237                                             bindopts.locale, riid, ppvResult);
 238
 239         IClassActivator_Release(pActivator);
 240
 241         return hr;
 242     }
 243 }
 244
 245 /******************************************************************************
 246  *        ClassMoniker_BindToStorage
 247  ******************************************************************************/
 248 static HRESULT WINAPI ClassMoniker_BindToStorage(IMoniker* iface,
 249                                              IBindCtx* pbc,
 250                                              IMoniker* pmkToLeft,
 251                                              REFIID riid,
 252                                              VOID** ppvResult)
 253 {
 254     TRACE("(%p,%p,%p,%p)\n",pbc, pmkToLeft, riid, ppvResult);
 255     return IMoniker_BindToObject(iface, pbc, pmkToLeft, riid, ppvResult);
 256 }
 257
 258 /******************************************************************************
 259  *        ClassMoniker_Reduce
 260  ******************************************************************************/
 261 static HRESULT WINAPI ClassMoniker_Reduce(IMoniker* iface,
 262                                       IBindCtx* pbc,
 263                                       DWORD dwReduceHowFar,
 264                                       IMoniker** ppmkToLeft,
 265                                       IMoniker** ppmkReduced)
 266 {
 267     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 268
 269     if (!ppmkReduced)
 270         return E_POINTER;
 271
 272     IMoniker_AddRef(iface);
 273
 274     *ppmkReduced = iface;
 275
 276     return MK_S_REDUCED_TO_SELF;
 277 }
 278 /******************************************************************************
 279  *        ClassMoniker_ComposeWith
 280  ******************************************************************************/
 281 static HRESULT WINAPI ClassMoniker_ComposeWith(IMoniker* iface,
 282                                            IMoniker* pmkRight,
 283                                            BOOL fOnlyIfNotGeneric,
 284                                            IMoniker** ppmkComposite)
 285 {
 286     HRESULT res=S_OK;
 287     DWORD mkSys,mkSys2;
 288     IEnumMoniker* penumMk=0;
 289     IMoniker *pmostLeftMk=0;
 290     IMoniker* tempMkComposite=0;
 291
 292     TRACE("(%p,%d,%p)\n", pmkRight, fOnlyIfNotGeneric, ppmkComposite);
 293
 294     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 295         return E_POINTER;
 296
 297     *ppmkComposite=0;
 298
 299     IMoniker_IsSystemMoniker(pmkRight,&mkSys);
 300
 301     /* If pmkRight is an anti-moniker, the returned moniker is NULL */
 302     if(mkSys==MKSYS_ANTIMONIKER)
 303         return res;
 304
 305     else
 306         /* if pmkRight is a composite whose leftmost component is an anti-moniker,           */
 307         /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
 308
 309          if(mkSys==MKSYS_GENERICCOMPOSITE){
 310
 311             res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
 312
 313             if (FAILED(res))
 314                 return res;
 315
 316             res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
 317
 318             IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
 319
 320             if(mkSys2==MKSYS_ANTIMONIKER){
 321
 322                 IMoniker_Release(pmostLeftMk);
 323
 324                 tempMkComposite=iface;
 325                 IMoniker_AddRef(iface);
 326
 327                 while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
 328
 329                     res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
 330
 331                     IMoniker_Release(tempMkComposite);
 332                     IMoniker_Release(pmostLeftMk);
 333
 334                     tempMkComposite=*ppmkComposite;
 335                     IMoniker_AddRef(tempMkComposite);
 336                 }
 337                 return res;
 338             }
 339             else
 340                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 341          }
 342          /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
 343           composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
 344           a NULL moniker and a return value of MK_E_NEEDGENERIC */
 345           else
 346             if (!fOnlyIfNotGeneric)
 347                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 348
 349             else
 350                 return MK_E_NEEDGENERIC;
 351 }
 352
 353 /******************************************************************************
 354  *        ClassMoniker_Enum
 355  ******************************************************************************/
 356 static HRESULT WINAPI ClassMoniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 357 {
 358     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 359
 360     if (ppenumMoniker == NULL)
 361         return E_POINTER;
 362
 363     *ppenumMoniker = NULL;
 364
 365     return S_OK;
 366 }
 367
 368 /******************************************************************************
 369  *        ClassMoniker_IsEqual
 370  ******************************************************************************/
 371 static HRESULT WINAPI ClassMoniker_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 372 {
 373
 374     CLSID clsid;
 375     LPOLESTR dispName1,dispName2;
 376     IBindCtx* bind;
 377     HRESULT res = S_FALSE;
 378
 379     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
 380
 381     if (!pmkOtherMoniker) return S_FALSE;
 382
 383
 384     /* check if both are ClassMoniker */
 385     if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
 386     if(!IsEqualCLSID(&clsid,&CLSID_ClassMoniker)) return S_FALSE;
 387
 388     /* check if both displaynames are the same */
 389     if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
 390         if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
 391             if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
 392                 if(lstrcmpW(dispName1,dispName2)==0) res = S_OK;
 393                 CoTaskMemFree(dispName2);
 394             }
 395             CoTaskMemFree(dispName1);
 396         }
 397     }
 398     return res;
 399 }
 400
 401 /******************************************************************************
 402  *        ClassMoniker_Hash
 403  ******************************************************************************/
 404 static HRESULT WINAPI ClassMoniker_Hash(IMoniker* iface,DWORD* pdwHash)
 405 {
 406     ClassMoniker *This = impl_from_IMoniker(iface);
 407
 408     TRACE("(%p)\n", pdwHash);
 409
 410     *pdwHash = This->clsid.Data1;
 411
 412     return S_OK;
 413 }
 414
 415 /******************************************************************************
 416  *        ClassMoniker_IsRunning
 417  ******************************************************************************/
 418 static HRESULT WINAPI ClassMoniker_IsRunning(IMoniker* iface,
 419                                          IBindCtx* pbc,
 420                                          IMoniker* pmkToLeft,
 421                                          IMoniker* pmkNewlyRunning)
 422 {
 423     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pmkNewlyRunning);
 424
 425     /* as in native */
 426     return E_NOTIMPL;
 427 }
 428
 429 /******************************************************************************
 430  *        ClassMoniker_GetTimeOfLastChange
 431  ******************************************************************************/
 432 static HRESULT WINAPI ClassMoniker_GetTimeOfLastChange(IMoniker* iface,
 433                                                    IBindCtx* pbc,
 434                                                    IMoniker* pmkToLeft,
 435                                                    FILETIME* pItemTime)
 436 {
 437     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pItemTime);
 438
 439     return MK_E_UNAVAILABLE;
 440 }
 441
 442 /******************************************************************************
 443  *        ClassMoniker_Inverse
 444  ******************************************************************************/
 445 static HRESULT WINAPI ClassMoniker_Inverse(IMoniker* iface,IMoniker** ppmk)
 446 {
 447     TRACE("(%p)\n",ppmk);
 448
 449     if (!ppmk)
 450         return E_POINTER;
 451
 452     return CreateAntiMoniker(ppmk);
 453 }
 454
 455 /******************************************************************************
 456  *        ClassMoniker_CommonPrefixWith
 457  ******************************************************************************/
 458 static HRESULT WINAPI ClassMoniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 459 {
 460     DWORD mkSys;
 461
 462     TRACE("(%p, %p)\n", pmkOther, ppmkPrefix);
 463
 464     *ppmkPrefix = NULL;
 465
 466     IMoniker_IsSystemMoniker(pmkOther, &mkSys);
 467
 468     /* If the other moniker is an class moniker that is equal to this moniker, this method sets *ppmkPrefix */
 469     /* to this moniker and returns MK_S_US */
 470
 471     if (mkSys == MKSYS_CLASSMONIKER)
 472     {
 473         if (IMoniker_IsEqual(iface, pmkOther) == S_OK)
 474         {
 475             *ppmkPrefix = iface;
 476
 477             IMoniker_AddRef(iface);
 478
 479             return MK_S_US;
 480         }
 481         else
 482             return MK_E_NOPREFIX;
 483     }
 484     else
 485         /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
 486         /* the case where the other moniker is a generic composite. */
 487         return MonikerCommonPrefixWith(iface, pmkOther, ppmkPrefix);
 488 }
 489
 490 /******************************************************************************
 491  *        ClassMoniker_RelativePathTo
 492  ******************************************************************************/
 493 static HRESULT WINAPI ClassMoniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 494 {
 495     TRACE("(%p, %p)\n",pmOther,ppmkRelPath);
 496
 497     if (!ppmkRelPath)
 498         return E_POINTER;
 499
 500     *ppmkRelPath = NULL;
 501
 502     return MK_E_NOTBINDABLE;
 503 }
 504
 505 /******************************************************************************
 506  *        ClassMoniker_GetDisplayName
 507  ******************************************************************************/
 508 static HRESULT WINAPI ClassMoniker_GetDisplayName(IMoniker* iface,
 509                                               IBindCtx* pbc,
 510                                               IMoniker* pmkToLeft,
 511                                               LPOLESTR *ppszDisplayName)
 512 {
 513     ClassMoniker *This = impl_from_IMoniker(iface);
 514     static const WCHAR wszClsidPrefix[] = {'c','l','s','i','d',':',0};
 515
 516     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, ppszDisplayName);
 517
 518     if (!ppszDisplayName)
 519         return E_POINTER;
 520
 521     if (pmkToLeft)
 522         return E_INVALIDARG;
 523
 524     *ppszDisplayName = CoTaskMemAlloc(sizeof(wszClsidPrefix) + (CHARS_IN_GUID-2) * sizeof(WCHAR));
 525
 526     StringFromGUID2(&This->clsid, *ppszDisplayName+sizeof(wszClsidPrefix)/sizeof(WCHAR)-2, CHARS_IN_GUID);
 527
 528     /* note: this overwrites the opening curly bracket of the CLSID string generated above */
 529     memcpy(*ppszDisplayName, wszClsidPrefix, sizeof(wszClsidPrefix)-sizeof(WCHAR));
 530
 531     /* note: this overwrites the closing curly bracket of the CLSID string generated above */
 532     (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-2] = ':';
 533     (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-1] = '\0';
 534
 535     TRACE("string is %s\n", debugstr_w(*ppszDisplayName));
 536     return S_OK;
 537 }
 538
 539 /******************************************************************************
 540  *        ClassMoniker_ParseDisplayName
 541  ******************************************************************************/
 542 static HRESULT WINAPI ClassMoniker_ParseDisplayName(IMoniker* iface,
 543                                                 IBindCtx* pbc,
 544                                                 IMoniker* pmkToLeft,
 545                                                 LPOLESTR pszDisplayName,
 546                                                 ULONG* pchEaten,
 547                                                 IMoniker** ppmkOut)
 548 {
 549     FIXME("(%p, %p, %s, %p, %p)\n", pbc, pmkToLeft, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
 550     return E_NOTIMPL;
 551 }
 552
 553 /******************************************************************************
 554  *        ClassMoniker_IsSystemMoniker
 555  ******************************************************************************/
 556 static HRESULT WINAPI ClassMoniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 557 {
 558     TRACE("(%p,%p)\n",iface,pwdMksys);
 559
 560     if (!pwdMksys)
 561         return E_POINTER;
 562
 563     *pwdMksys = MKSYS_CLASSMONIKER;
 564
 565     return S_OK;
 566 }
 567
 568 /*******************************************************************************
 569  *        ClassMonikerIROTData_QueryInterface
 570  *******************************************************************************/
 571 static HRESULT WINAPI ClassMonikerROTData_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
 572 {
 573
 574     ClassMoniker *This = impl_from_IROTData(iface);
 575
 576     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
 577
 578     return IMoniker_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
 579 }
 580
 581 /***********************************************************************
 582  *        ClassMonikerIROTData_AddRef
 583  */
 584 static ULONG WINAPI ClassMonikerROTData_AddRef(IROTData *iface)
 585 {
 586     ClassMoniker *This = impl_from_IROTData(iface);
 587
 588     TRACE("(%p)\n",iface);
 589
 590     return IMoniker_AddRef(&This->IMoniker_iface);
 591 }
 592
 593 /***********************************************************************
 594  *        ClassMonikerIROTData_Release
 595  */
 596 static ULONG WINAPI ClassMonikerROTData_Release(IROTData* iface)
 597 {
 598     ClassMoniker *This = impl_from_IROTData(iface);
 599
 600     TRACE("(%p)\n",iface);
 601
 602     return IMoniker_Release(&This->IMoniker_iface);
 603 }
 604
 605 /******************************************************************************
 606  *        ClassMonikerIROTData_GetComparisonData
 607  ******************************************************************************/
 608 static HRESULT WINAPI ClassMonikerROTData_GetComparisonData(IROTData* iface,
 609                                                          BYTE* pbData,
 610                                                          ULONG cbMax,
 611                                                          ULONG* pcbData)
 612 {
 613     ClassMoniker *This = impl_from_IROTData(iface);
 614
 615     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
 616
 617     *pcbData = 2*sizeof(CLSID);
 618     if (cbMax < *pcbData)
 619         return E_OUTOFMEMORY;
 620
 621     /* write CLSID of the moniker */
 622     memcpy(pbData, &CLSID_ClassMoniker, sizeof(CLSID));
 623     /* write CLSID the moniker represents */
 624     memcpy(pbData+sizeof(CLSID), &This->clsid, sizeof(CLSID));
 625
 626     return S_OK;
 627 }
 628
 629 /********************************************************************************/
 630 /* Virtual function table for the ClassMoniker class which  include IPersist,*/
 631 /* IPersistStream and IMoniker functions.                                       */
 632 static const IMonikerVtbl ClassMonikerVtbl =
 633 {
 634     ClassMoniker_QueryInterface,
 635     ClassMoniker_AddRef,
 636     ClassMoniker_Release,
 637     ClassMoniker_GetClassID,
 638     ClassMoniker_IsDirty,
 639     ClassMoniker_Load,
 640     ClassMoniker_Save,
 641     ClassMoniker_GetSizeMax,
 642     ClassMoniker_BindToObject,
 643     ClassMoniker_BindToStorage,
 644     ClassMoniker_Reduce,
 645     ClassMoniker_ComposeWith,
 646     ClassMoniker_Enum,
 647     ClassMoniker_IsEqual,
 648     ClassMoniker_Hash,
 649     ClassMoniker_IsRunning,
 650     ClassMoniker_GetTimeOfLastChange,
 651     ClassMoniker_Inverse,
 652     ClassMoniker_CommonPrefixWith,
 653     ClassMoniker_RelativePathTo,
 654     ClassMoniker_GetDisplayName,
 655     ClassMoniker_ParseDisplayName,
 656     ClassMoniker_IsSystemMoniker
 657 };
 658
 659 /********************************************************************************/
 660 /* Virtual function table for the IROTData class.                               */
 661 static const IROTDataVtbl ROTDataVtbl =
 662 {
 663     ClassMonikerROTData_QueryInterface,
 664     ClassMonikerROTData_AddRef,
 665     ClassMonikerROTData_Release,
 666     ClassMonikerROTData_GetComparisonData
 667 };
 668
 669 /******************************************************************************
 670  *         ClassMoniker_Construct (local function)
 671  *******************************************************************************/
 672 static HRESULT ClassMoniker_Construct(ClassMoniker* This, REFCLSID rclsid)
 673 {
 674     TRACE("(%p,%s)\n",This,debugstr_guid(rclsid));
 675
 676     /* Initialize the virtual function table. */
 677     This->IMoniker_iface.lpVtbl = &ClassMonikerVtbl;
 678     This->IROTData_iface.lpVtbl = &ROTDataVtbl;
 679     This->ref           = 0;
 680     This->clsid         = *rclsid;
 681     This->pMarshal      = NULL;
 682
 683     return S_OK;
 684 }
 685
 686 /******************************************************************************
 687  *        CreateClassMoniker    [OLE32.@]
 688  ******************************************************************************/
 689 HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, IMoniker **ppmk)
 690 {
 691     ClassMoniker* newClassMoniker;
 692     HRESULT       hr;
 693
 694     TRACE("(%s,%p)\n", debugstr_guid(rclsid), ppmk);
 695
 696     newClassMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ClassMoniker));
 697
 698     if (!newClassMoniker)
 699         return STG_E_INSUFFICIENTMEMORY;
 700
 701     hr = ClassMoniker_Construct(newClassMoniker, rclsid);
 702
 703     if (FAILED(hr))
 704     {
 705         HeapFree(GetProcessHeap(), 0, newClassMoniker);
 706         return hr;
 707     }
 708
 709     return ClassMoniker_QueryInterface(&newClassMoniker->IMoniker_iface, &IID_IMoniker,
 710                                        (void**)ppmk);
 711 }
 712
 713 HRESULT ClassMoniker_CreateFromDisplayName(LPBC pbc, LPCOLESTR szDisplayName, LPDWORD pchEaten,
 714                                            IMoniker **ppmk)
 715 {
 716     HRESULT hr;
 717     LPCWSTR s = strchrW(szDisplayName, ':');
 718     LPCWSTR end;
 719     CLSID clsid;
 720     BYTE table[256];
 721     int i;
 722
 723     if (!s)
 724         return MK_E_SYNTAX;
 725
 726     s++;
 727
 728     for (end = s; *end && (*end != ':'); end++)
 729         ;
 730
 731     TRACE("parsing %s\n", debugstr_wn(s, end - s));
 732
 733     /* validate the CLSID string */
 734     if (s[0] == '{')
 735     {
 736         if ((end - s != 38) || (s[37] != '}'))
 737             return MK_E_SYNTAX;
 738         s++;
 739     }
 740     else
 741     {
 742         if (end - s != 36)
 743             return MK_E_SYNTAX;
 744     }
 745
 746     for (i=0; i<36; i++)
 747     {
 748         if ((i == 8)||(i == 13)||(i == 18)||(i == 23))
 749         {
 750             if (s[i] != '-')
 751                 return MK_E_SYNTAX;
 752             continue;
 753         }
 754         if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
 755               ((s[i] >= 'a') && (s[i] <= 'f'))  ||
 756               ((s[i] >= 'A') && (s[i] <= 'F'))))
 757             return MK_E_SYNTAX;
 758     }
 759
 760     /* quick lookup table */
 761     memset(table, 0, 256);
 762
 763     for (i = 0; i < 10; i++)
 764         table['0' + i] = i;
 765     for (i = 0; i < 6; i++)
 766     {
 767         table['A' + i] = i+10;
 768         table['a' + i] = i+10;
 769     }
 770
 771     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
 772
 773     clsid.Data1 = (table[s[0]] << 28 | table[s[1]] << 24 | table[s[2]] << 20 | table[s[3]] << 16 |
 774                    table[s[4]] << 12 | table[s[5]] << 8  | table[s[6]] << 4  | table[s[7]]);
 775     clsid.Data2 = table[s[9]] << 12  | table[s[10]] << 8 | table[s[11]] << 4 | table[s[12]];
 776     clsid.Data3 = table[s[14]] << 12 | table[s[15]] << 8 | table[s[16]] << 4 | table[s[17]];
 777
 778     /* these are just sequential bytes */
 779     clsid.Data4[0] = table[s[19]] << 4 | table[s[20]];
 780     clsid.Data4[1] = table[s[21]] << 4 | table[s[22]];
 781     clsid.Data4[2] = table[s[24]] << 4 | table[s[25]];
 782     clsid.Data4[3] = table[s[26]] << 4 | table[s[27]];
 783     clsid.Data4[4] = table[s[28]] << 4 | table[s[29]];
 784     clsid.Data4[5] = table[s[30]] << 4 | table[s[31]];
 785     clsid.Data4[6] = table[s[32]] << 4 | table[s[33]];
 786     clsid.Data4[7] = table[s[34]] << 4 | table[s[35]];
 787
 788     hr = CreateClassMoniker(&clsid, ppmk);
 789     if (SUCCEEDED(hr))
 790         *pchEaten = (*end == ':' ? end + 1 : end) - szDisplayName;
 791     return hr;
 792 }
 793
 794 static HRESULT WINAPI ClassMonikerCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 795 {
 796     *ppv = NULL;
 797     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
 798     {
 799         *ppv = iface;
 800         IClassFactory_AddRef(iface);
 801         return S_OK;
 802     }
 803     return E_NOINTERFACE;
 804 }
 805
 806 static ULONG WINAPI ClassMonikerCF_AddRef(LPCLASSFACTORY iface)
 807 {
 808     return 2; /* non-heap based object */
 809 }
 810
 811 static ULONG WINAPI ClassMonikerCF_Release(LPCLASSFACTORY iface)
 812 {
 813     return 1; /* non-heap based object */
 814 }
 815
 816 static HRESULT WINAPI ClassMonikerCF_CreateInstance(LPCLASSFACTORY iface,
 817     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
 818 {
 819     HRESULT hr;
 820     IMoniker *pmk;
 821
 822     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 823
 824     *ppv = NULL;
 825
 826     if (pUnk)
 827         return CLASS_E_NOAGGREGATION;
 828
 829     hr = CreateClassMoniker(&CLSID_NULL, &pmk);
 830     if (FAILED(hr)) return hr;
 831
 832     hr = IMoniker_QueryInterface(pmk, riid, ppv);
 833     IMoniker_Release(pmk);
 834
 835     return hr;
 836 }
 837
 838 static HRESULT WINAPI ClassMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
 839 {
 840     FIXME("(%d), stub!\n",fLock);
 841     return S_OK;
 842 }
 843
 844 static const IClassFactoryVtbl ClassMonikerCFVtbl =
 845 {
 846     ClassMonikerCF_QueryInterface,
 847     ClassMonikerCF_AddRef,
 848     ClassMonikerCF_Release,
 849     ClassMonikerCF_CreateInstance,
 850     ClassMonikerCF_LockServer
 851 };
 852
 853 static IClassFactory ClassMonikerCF = { &ClassMonikerCFVtbl };
 854
 855 HRESULT ClassMonikerCF_Create(REFIID riid, LPVOID *ppv)
 856 {
 857     return IClassFactory_QueryInterface(&ClassMonikerCF, riid, ppv);
 858 }