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