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