dlls/ole32/antimoniker.c

   1 /*
   2  *                            AntiMonikers implementation
   3  *
   4  *               Copyright 1999  Noomen Hamza
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winerror.h"
  32 #include "objbase.h"
  33 #include "wine/debug.h"
  34 #include "moniker.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  37
  38 /* AntiMoniker data structure */
  39 typedef struct AntiMonikerImpl{
  40
  41     const IMonikerVtbl*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
  42
  43     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
  44      * two monikers are equal. That's whay IROTData interface is implemented by monikers.
  45      */
  46     const IROTDataVtbl*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
  47
  48     LONG ref; /* reference counter for this object */
  49
  50     IUnknown *pMarshal; /* custom marshaler */
  51 } AntiMonikerImpl;
  52
  53 static inline IMoniker *impl_from_IROTData( IROTData *iface )
  54 {
  55     return (IMoniker *)((char*)iface - FIELD_OFFSET(AntiMonikerImpl, lpvtbl2));
  56 }
  57
  58
  59 /*******************************************************************************
  60  *        AntiMoniker_QueryInterface
  61  *******************************************************************************/
  62 static HRESULT WINAPI
  63 AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
  64 {
  65     AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
  66
  67     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
  68
  69     /* Perform a sanity check on the parameters.*/
  70     if ( (This==0) || (ppvObject==0) )
  71         return E_INVALIDARG;
  72
  73     /* Initialize the return parameter */
  74     *ppvObject = 0;
  75
  76     /* Compare the riid with the interface IDs implemented by this object.*/
  77     if (IsEqualIID(&IID_IUnknown, riid) ||
  78         IsEqualIID(&IID_IPersist, riid) ||
  79         IsEqualIID(&IID_IPersistStream, riid) ||
  80         IsEqualIID(&IID_IMoniker, riid))
  81         *ppvObject = iface;
  82     else if (IsEqualIID(&IID_IROTData, riid))
  83         *ppvObject = (IROTData*)&(This->lpvtbl2);
  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)==0)
  96         return E_NOINTERFACE;
  97
  98     /* always increase the reference count by one when it is successful */
  99     IMoniker_AddRef(iface);
 100
 101     return S_OK;
 102 }
 103
 104 /******************************************************************************
 105  *        AntiMoniker_AddRef
 106  ******************************************************************************/
 107 static ULONG WINAPI
 108 AntiMonikerImpl_AddRef(IMoniker* iface)
 109 {
 110     AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
 111
 112     TRACE("(%p)\n",This);
 113
 114     return InterlockedIncrement(&This->ref);
 115 }
 116
 117 /******************************************************************************
 118  *        AntiMoniker_Release
 119  ******************************************************************************/
 120 static ULONG WINAPI
 121 AntiMonikerImpl_Release(IMoniker* iface)
 122 {
 123     AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
 124     ULONG ref;
 125
 126     TRACE("(%p)\n",This);
 127
 128     ref = InterlockedDecrement(&This->ref);
 129
 130     /* destroy the object if there's no more reference on it */
 131     if (ref == 0)
 132     {
 133         if (This->pMarshal) IUnknown_Release(This->pMarshal);
 134         HeapFree(GetProcessHeap(),0,This);
 135     }
 136
 137     return ref;
 138 }
 139
 140 /******************************************************************************
 141  *        AntiMoniker_GetClassID
 142  ******************************************************************************/
 143 static HRESULT WINAPI
 144 AntiMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 145 {
 146     TRACE("(%p,%p)\n",iface,pClassID);
 147
 148     if (pClassID==NULL)
 149         return E_POINTER;
 150
 151     *pClassID = CLSID_AntiMoniker;
 152
 153     return S_OK;
 154 }
 155
 156 /******************************************************************************
 157  *        AntiMoniker_IsDirty
 158  ******************************************************************************/
 159 static HRESULT WINAPI
 160 AntiMonikerImpl_IsDirty(IMoniker* iface)
 161 {
 162     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 163        method in the OLE-provided moniker interfaces always return S_FALSE because
 164        their internal state never changes. */
 165
 166     TRACE("(%p)\n",iface);
 167
 168     return S_FALSE;
 169 }
 170
 171 /******************************************************************************
 172  *        AntiMoniker_Load
 173  ******************************************************************************/
 174 static HRESULT WINAPI
 175 AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 176 {
 177     DWORD constant=1,dwbuffer;
 178     HRESULT res;
 179
 180     /* data read by this function is only a DWORD constant (must be 1) ! */
 181     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
 182
 183     if (SUCCEEDED(res)&& dwbuffer!=constant)
 184         return E_FAIL;
 185
 186     return res;
 187 }
 188
 189 /******************************************************************************
 190  *        AntiMoniker_Save
 191  ******************************************************************************/
 192 static HRESULT WINAPI
 193 AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
 194 {
 195     DWORD constant=1;
 196     HRESULT res;
 197
 198     /* data written by this function is only a DWORD constant set to 1 ! */
 199     res=IStream_Write(pStm,&constant,sizeof(constant),NULL);
 200
 201     return res;
 202 }
 203
 204 /******************************************************************************
 205  *        AntiMoniker_GetSizeMax
 206  *
 207  * PARAMS
 208  * pcbSize [out] Pointer to size of stream needed to save object
 209  ******************************************************************************/
 210 static HRESULT WINAPI
 211 AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
 212 {
 213     TRACE("(%p,%p)\n",iface,pcbSize);
 214
 215     if (!pcbSize)
 216         return E_POINTER;
 217
 218     /* for more details see AntiMonikerImpl_Save comments */
 219
 220     /*
 221      * Normally the sizemax must be sizeof DWORD, but
 222      * I tested this function it usually return 16 bytes
 223      * more than the number of bytes used by AntiMoniker::Save function
 224      */
 225     pcbSize->u.LowPart =  sizeof(DWORD)+16;
 226
 227     pcbSize->u.HighPart=0;
 228
 229     return S_OK;
 230 }
 231
 232 /******************************************************************************
 233  *                  AntiMoniker_BindToObject
 234  ******************************************************************************/
 235 static HRESULT WINAPI
 236 AntiMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 237                              REFIID riid, VOID** ppvResult)
 238 {
 239     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 240     return E_NOTIMPL;
 241 }
 242
 243 /******************************************************************************
 244  *        AntiMoniker_BindToStorage
 245  ******************************************************************************/
 246 static HRESULT WINAPI
 247 AntiMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 248                               REFIID riid, VOID** ppvResult)
 249 {
 250     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 251     return E_NOTIMPL;
 252 }
 253
 254 /******************************************************************************
 255  *        AntiMoniker_Reduce
 256  ******************************************************************************/
 257 static HRESULT WINAPI
 258 AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 259                        IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 260 {
 261     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 262
 263     if (ppmkReduced==NULL)
 264         return E_POINTER;
 265
 266     AntiMonikerImpl_AddRef(iface);
 267
 268     *ppmkReduced=iface;
 269
 270     return MK_S_REDUCED_TO_SELF;
 271 }
 272 /******************************************************************************
 273  *        AntiMoniker_ComposeWith
 274  ******************************************************************************/
 275 static HRESULT WINAPI
 276 AntiMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
 277                             BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
 278 {
 279
 280     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 281
 282     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 283         return E_POINTER;
 284
 285     *ppmkComposite=0;
 286
 287     if (fOnlyIfNotGeneric)
 288         return MK_E_NEEDGENERIC;
 289     else
 290         return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 291 }
 292
 293 /******************************************************************************
 294  *        AntiMoniker_Enum
 295  ******************************************************************************/
 296 static HRESULT WINAPI
 297 AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 298 {
 299     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 300
 301     if (ppenumMoniker == NULL)
 302         return E_POINTER;
 303
 304     *ppenumMoniker = NULL;
 305
 306     return S_OK;
 307 }
 308
 309 /******************************************************************************
 310  *        AntiMoniker_IsEqual
 311  ******************************************************************************/
 312 static HRESULT WINAPI
 313 AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 314 {
 315     DWORD mkSys;
 316
 317     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
 318
 319     if (pmkOtherMoniker==NULL)
 320         return S_FALSE;
 321
 322     IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
 323
 324     if (mkSys==MKSYS_ANTIMONIKER)
 325         return S_OK;
 326     else
 327         return S_FALSE;
 328 }
 329
 330 /******************************************************************************
 331  *        AntiMoniker_Hash
 332  ******************************************************************************/
 333 static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 334 {
 335     if (pdwHash==NULL)
 336         return E_POINTER;
 337
 338     *pdwHash = 0x80000001;
 339
 340     return S_OK;
 341 }
 342
 343 /******************************************************************************
 344  *        AntiMoniker_IsRunning
 345  ******************************************************************************/
 346 static HRESULT WINAPI
 347 AntiMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 348                           IMoniker* pmkNewlyRunning)
 349 {
 350     IRunningObjectTable* rot;
 351     HRESULT res;
 352
 353     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 354
 355     if (pbc==NULL)
 356         return E_INVALIDARG;
 357
 358     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 359
 360     if (FAILED(res))
 361         return res;
 362
 363     res = IRunningObjectTable_IsRunning(rot,iface);
 364
 365     IRunningObjectTable_Release(rot);
 366
 367     return res;
 368 }
 369
 370 /******************************************************************************
 371  *        AntiMoniker_GetTimeOfLastChange
 372  ******************************************************************************/
 373 static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 374                                                    IBindCtx* pbc,
 375                                                    IMoniker* pmkToLeft,
 376                                                    FILETIME* pAntiTime)
 377 {
 378     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
 379     return E_NOTIMPL;
 380 }
 381
 382 /******************************************************************************
 383  *        AntiMoniker_Inverse
 384  ******************************************************************************/
 385 static HRESULT WINAPI
 386 AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 387 {
 388     TRACE("(%p,%p)\n",iface,ppmk);
 389
 390     if (ppmk==NULL)
 391         return E_POINTER;
 392
 393     *ppmk=0;
 394
 395     return MK_E_NOINVERSE;
 396 }
 397
 398 /******************************************************************************
 399  *        AntiMoniker_CommonPrefixWith
 400  ******************************************************************************/
 401 static HRESULT WINAPI
 402 AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 403 {
 404     DWORD mkSys;
 405
 406     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
 407
 408     if(mkSys==MKSYS_ANTIMONIKER){
 409
 410         IMoniker_AddRef(iface);
 411
 412         *ppmkPrefix=iface;
 413
 414         IMoniker_AddRef(iface);
 415
 416         return MK_S_US;
 417     }
 418     else
 419         return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
 420 }
 421
 422 /******************************************************************************
 423  *        AntiMoniker_RelativePathTo
 424  ******************************************************************************/
 425 static HRESULT WINAPI
 426 AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 427 {
 428     TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
 429
 430     if (ppmkRelPath==NULL)
 431         return E_POINTER;
 432
 433     IMoniker_AddRef(pmOther);
 434
 435     *ppmkRelPath=pmOther;
 436
 437     return MK_S_HIM;
 438 }
 439
 440 /******************************************************************************
 441  *        AntiMoniker_GetDisplayName
 442  ******************************************************************************/
 443 static HRESULT WINAPI
 444 AntiMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
 445                                IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
 446 {
 447     static const WCHAR back[]={'\\','.','.',0};
 448
 449     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
 450
 451     if (ppszDisplayName==NULL)
 452         return E_POINTER;
 453
 454     if (pmkToLeft!=NULL){
 455         FIXME("() pmkToLeft!=NULL not implemented\n");
 456         return E_NOTIMPL;
 457     }
 458
 459     *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
 460
 461     if (*ppszDisplayName==NULL)
 462         return E_OUTOFMEMORY;
 463
 464     lstrcpyW(*ppszDisplayName,back);
 465
 466     return S_OK;
 467 }
 468
 469 /******************************************************************************
 470  *        AntiMoniker_ParseDisplayName
 471  ******************************************************************************/
 472 static HRESULT WINAPI
 473 AntiMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
 474                                  IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
 475                                  ULONG* pchEaten, IMoniker** ppmkOut)
 476 {
 477     TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 478     return E_NOTIMPL;
 479 }
 480
 481 /******************************************************************************
 482  *        AntiMoniker_IsSystemMoniker
 483  ******************************************************************************/
 484 static HRESULT WINAPI
 485 AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 486 {
 487     TRACE("(%p,%p)\n",iface,pwdMksys);
 488
 489     if (!pwdMksys)
 490         return E_POINTER;
 491
 492     (*pwdMksys)=MKSYS_ANTIMONIKER;
 493
 494     return S_OK;
 495 }
 496
 497 /*******************************************************************************
 498  *        AntiMonikerIROTData_QueryInterface
 499  *******************************************************************************/
 500 static HRESULT WINAPI
 501 AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
 502 {
 503     IMoniker *This = impl_from_IROTData(iface);
 504
 505     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
 506
 507     return AntiMonikerImpl_QueryInterface(This, riid, ppvObject);
 508 }
 509
 510 /***********************************************************************
 511  *        AntiMonikerIROTData_AddRef
 512  */
 513 static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
 514 {
 515     IMoniker *This = impl_from_IROTData(iface);
 516
 517     TRACE("(%p)\n",iface);
 518
 519     return AntiMonikerImpl_AddRef(This);
 520 }
 521
 522 /***********************************************************************
 523  *        AntiMonikerIROTData_Release
 524  */
 525 static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
 526 {
 527     IMoniker *This = impl_from_IROTData(iface);
 528
 529     TRACE("(%p)\n",iface);
 530
 531     return AntiMonikerImpl_Release(This);
 532 }
 533
 534 /******************************************************************************
 535  *        AntiMonikerIROTData_GetComparisonData
 536  ******************************************************************************/
 537 static HRESULT WINAPI
 538 AntiMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData,
 539                                           ULONG cbMax, ULONG* pcbData)
 540 {
 541     DWORD constant = 1;
 542
 543     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
 544
 545     *pcbData = sizeof(CLSID) + sizeof(DWORD);
 546     if (cbMax < *pcbData)
 547         return E_OUTOFMEMORY;
 548
 549     memcpy(pbData, &CLSID_AntiMoniker, sizeof(CLSID));
 550     memcpy(pbData+sizeof(CLSID), &constant, sizeof(DWORD));
 551
 552     return S_OK;
 553 }
 554
 555 /********************************************************************************/
 556 /* Virtual function table for the AntiMonikerImpl class which  include IPersist,*/
 557 /* IPersistStream and IMoniker functions.                                       */
 558 static const IMonikerVtbl VT_AntiMonikerImpl =
 559 {
 560     AntiMonikerImpl_QueryInterface,
 561     AntiMonikerImpl_AddRef,
 562     AntiMonikerImpl_Release,
 563     AntiMonikerImpl_GetClassID,
 564     AntiMonikerImpl_IsDirty,
 565     AntiMonikerImpl_Load,
 566     AntiMonikerImpl_Save,
 567     AntiMonikerImpl_GetSizeMax,
 568     AntiMonikerImpl_BindToObject,
 569     AntiMonikerImpl_BindToStorage,
 570     AntiMonikerImpl_Reduce,
 571     AntiMonikerImpl_ComposeWith,
 572     AntiMonikerImpl_Enum,
 573     AntiMonikerImpl_IsEqual,
 574     AntiMonikerImpl_Hash,
 575     AntiMonikerImpl_IsRunning,
 576     AntiMonikerImpl_GetTimeOfLastChange,
 577     AntiMonikerImpl_Inverse,
 578     AntiMonikerImpl_CommonPrefixWith,
 579     AntiMonikerImpl_RelativePathTo,
 580     AntiMonikerImpl_GetDisplayName,
 581     AntiMonikerImpl_ParseDisplayName,
 582     AntiMonikerImpl_IsSystemMoniker
 583 };
 584
 585 /********************************************************************************/
 586 /* Virtual function table for the IROTData class.                               */
 587 static const IROTDataVtbl VT_ROTDataImpl =
 588 {
 589     AntiMonikerROTDataImpl_QueryInterface,
 590     AntiMonikerROTDataImpl_AddRef,
 591     AntiMonikerROTDataImpl_Release,
 592     AntiMonikerROTDataImpl_GetComparisonData
 593 };
 594
 595 /******************************************************************************
 596  *         AntiMoniker_Construct (local function)
 597  *******************************************************************************/
 598 static HRESULT AntiMonikerImpl_Construct(AntiMonikerImpl* This)
 599 {
 600
 601     TRACE("(%p)\n",This);
 602
 603     /* Initialize the virtual function table. */
 604     This->lpvtbl1      = &VT_AntiMonikerImpl;
 605     This->lpvtbl2      = &VT_ROTDataImpl;
 606     This->ref          = 0;
 607     This->pMarshal     = NULL;
 608
 609     return S_OK;
 610 }
 611
 612 /******************************************************************************
 613  *        CreateAntiMoniker     [OLE32.@]
 614  ******************************************************************************/
 615 HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk)
 616 {
 617     AntiMonikerImpl* newAntiMoniker = 0;
 618     HRESULT        hr = S_OK;
 619     IID riid=IID_IMoniker;
 620
 621     TRACE("(%p)\n",ppmk);
 622
 623     newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
 624
 625     if (newAntiMoniker == 0)
 626         return STG_E_INSUFFICIENTMEMORY;
 627
 628     hr = AntiMonikerImpl_Construct(newAntiMoniker);
 629     if (FAILED(hr))
 630     {
 631         HeapFree(GetProcessHeap(),0,newAntiMoniker);
 632         return hr;
 633     }
 634
 635     hr = AntiMonikerImpl_QueryInterface((IMoniker*)newAntiMoniker,&riid,(void**)ppmk);
 636
 637     return hr;
 638 }
 639
 640 static HRESULT WINAPI AntiMonikerCF_QueryInterface(LPCLASSFACTORY iface,
 641                                                   REFIID riid, LPVOID *ppv)
 642 {
 643     *ppv = NULL;
 644     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
 645     {
 646         *ppv = iface;
 647         IUnknown_AddRef(iface);
 648         return S_OK;
 649     }
 650     return E_NOINTERFACE;
 651 }
 652
 653 static ULONG WINAPI AntiMonikerCF_AddRef(LPCLASSFACTORY iface)
 654 {
 655     return 2; /* non-heap based object */
 656 }
 657
 658 static ULONG WINAPI AntiMonikerCF_Release(LPCLASSFACTORY iface)
 659 {
 660     return 1; /* non-heap based object */
 661 }
 662
 663 static HRESULT WINAPI AntiMonikerCF_CreateInstance(LPCLASSFACTORY iface,
 664     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
 665 {
 666     IMoniker *pMoniker;
 667     HRESULT  hr;
 668
 669     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 670
 671     *ppv = NULL;
 672
 673     if (pUnk)
 674         return CLASS_E_NOAGGREGATION;
 675
 676     hr = CreateAntiMoniker(&pMoniker);
 677     if (FAILED(hr))
 678         return hr;
 679
 680         hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
 681
 682     if (FAILED(hr))
 683         IMoniker_Release(pMoniker);
 684
 685     return hr;
 686 }
 687
 688 static HRESULT WINAPI AntiMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
 689 {
 690     FIXME("(%d), stub!\n",fLock);
 691     return S_OK;
 692 }
 693
 694 static const IClassFactoryVtbl AntiMonikerCFVtbl =
 695 {
 696     AntiMonikerCF_QueryInterface,
 697     AntiMonikerCF_AddRef,
 698     AntiMonikerCF_Release,
 699     AntiMonikerCF_CreateInstance,
 700     AntiMonikerCF_LockServer
 701 };
 702 static const IClassFactoryVtbl *AntiMonikerCF = &AntiMonikerCFVtbl;
 703
 704 HRESULT AntiMonikerCF_Create(REFIID riid, LPVOID *ppv)
 705 {
 706     return IClassFactory_QueryInterface((IClassFactory *)&AntiMonikerCF, riid, ppv);
 707 }