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 <stdarg.h>
  22 #include <string.h>
  23
  24 #define COBJMACROS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "wine/debug.h"
  29 #include "moniker.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  32
  33 /* AntiMoniker data structure */
  34 typedef struct AntiMonikerImpl{
  35     IMoniker IMoniker_iface;
  36     IROTData IROTData_iface;
  37     LONG refcount;
  38     IUnknown *pMarshal; /* custom marshaler */
  39     DWORD count;
  40 } AntiMonikerImpl;
  41
  42 static inline AntiMonikerImpl *impl_from_IMoniker(IMoniker *iface)
  43 {
  44     return CONTAINING_RECORD(iface, AntiMonikerImpl, IMoniker_iface);
  45 }
  46
  47 static inline AntiMonikerImpl *impl_from_IROTData(IROTData *iface)
  48 {
  49     return CONTAINING_RECORD(iface, AntiMonikerImpl, IROTData_iface);
  50 }
  51
  52 static AntiMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface);
  53
  54 BOOL is_anti_moniker(IMoniker *iface, DWORD *order)
  55 {
  56     AntiMonikerImpl *moniker = unsafe_impl_from_IMoniker(iface);
  57
  58     if (!moniker)
  59     {
  60         *order = 0;
  61         return FALSE;
  62     }
  63
  64     *order = moniker->count;
  65
  66     return TRUE;
  67 }
  68
  69 /*******************************************************************************
  70  *        AntiMoniker_QueryInterface
  71  *******************************************************************************/
  72 static HRESULT WINAPI
  73 AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
  74 {
  75     AntiMonikerImpl *This = impl_from_IMoniker(iface);
  76
  77     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
  78
  79     if ( ppvObject==0 )
  80         return E_INVALIDARG;
  81
  82     *ppvObject = 0;
  83
  84     if (IsEqualIID(&IID_IUnknown, riid) ||
  85         IsEqualIID(&IID_IPersist, riid) ||
  86         IsEqualIID(&IID_IPersistStream, riid) ||
  87         IsEqualIID(&IID_IMoniker, riid) ||
  88         IsEqualGUID(&CLSID_AntiMoniker, riid))
  89     {
  90         *ppvObject = iface;
  91     }
  92     else if (IsEqualIID(&IID_IROTData, riid))
  93         *ppvObject = &This->IROTData_iface;
  94     else if (IsEqualIID(&IID_IMarshal, riid))
  95     {
  96         HRESULT hr = S_OK;
  97         if (!This->pMarshal)
  98             hr = MonikerMarshal_Create(iface, &This->pMarshal);
  99         if (hr != S_OK)
 100             return hr;
 101         return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
 102     }
 103
 104     if ((*ppvObject)==0)
 105         return E_NOINTERFACE;
 106
 107     IMoniker_AddRef(iface);
 108
 109     return S_OK;
 110 }
 111
 112 /******************************************************************************
 113  *        AntiMoniker_AddRef
 114  ******************************************************************************/
 115 static ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker *iface)
 116 {
 117     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 118     ULONG refcount = InterlockedIncrement(&moniker->refcount);
 119
 120     TRACE("%p, refcount %lu.\n", iface, refcount);
 121
 122     return refcount;
 123 }
 124
 125 /******************************************************************************
 126  *        AntiMoniker_Release
 127  ******************************************************************************/
 128 static ULONG WINAPI AntiMonikerImpl_Release(IMoniker *iface)
 129 {
 130     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 131     ULONG refcount = InterlockedDecrement(&moniker->refcount);
 132
 133     TRACE("%p, refcount %lu.\n", iface, refcount);
 134
 135     if (!refcount)
 136     {
 137         if (moniker->pMarshal) IUnknown_Release(moniker->pMarshal);
 138         free(moniker);
 139     }
 140
 141     return refcount;
 142 }
 143
 144 /******************************************************************************
 145  *        AntiMoniker_GetClassID
 146  ******************************************************************************/
 147 static HRESULT WINAPI
 148 AntiMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 149 {
 150     TRACE("(%p,%p)\n",iface,pClassID);
 151
 152     if (pClassID==NULL)
 153         return E_POINTER;
 154
 155     *pClassID = CLSID_AntiMoniker;
 156
 157     return S_OK;
 158 }
 159
 160 /******************************************************************************
 161  *        AntiMoniker_IsDirty
 162  ******************************************************************************/
 163 static HRESULT WINAPI
 164 AntiMonikerImpl_IsDirty(IMoniker* iface)
 165 {
 166     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 167        method in the OLE-provided moniker interfaces always return S_FALSE because
 168        their internal state never changes. */
 169
 170     TRACE("(%p)\n",iface);
 171
 172     return S_FALSE;
 173 }
 174
 175 /******************************************************************************
 176  *        AntiMoniker_Load
 177  ******************************************************************************/
 178 static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker *iface, IStream *stream)
 179 {
 180     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 181     DWORD count = 0;
 182     HRESULT hr;
 183
 184     TRACE("%p, %p.\n", iface, stream);
 185
 186     if (FAILED(hr = IStream_Read(stream, &count, sizeof(count), NULL)))
 187         return hr;
 188
 189     if (count > 0xfffff)
 190         return E_INVALIDARG;
 191
 192     moniker->count = count;
 193
 194     return S_OK;
 195 }
 196
 197 /******************************************************************************
 198  *        AntiMoniker_Save
 199  ******************************************************************************/
 200 static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker *iface, IStream *stream, BOOL clear_dirty)
 201 {
 202     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 203
 204     TRACE("%p, %p, %d.\n", iface, stream, clear_dirty);
 205
 206     return IStream_Write(stream, &moniker->count, sizeof(moniker->count), NULL);
 207 }
 208
 209 /******************************************************************************
 210  *        AntiMoniker_GetSizeMax
 211  *
 212  * PARAMS
 213  * pcbSize [out] Pointer to size of stream needed to save object
 214  ******************************************************************************/
 215 static HRESULT WINAPI
 216 AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
 217 {
 218     TRACE("(%p,%p)\n",iface,pcbSize);
 219
 220     if (!pcbSize)
 221         return E_POINTER;
 222
 223     /* for more details see AntiMonikerImpl_Save comments */
 224
 225     /*
 226      * Normally the sizemax must be sizeof DWORD, but
 227      * I tested this function it usually return 16 bytes
 228      * more than the number of bytes used by AntiMoniker::Save function
 229      */
 230     pcbSize->u.LowPart =  sizeof(DWORD)+16;
 231
 232     pcbSize->u.HighPart=0;
 233
 234     return S_OK;
 235 }
 236
 237 /******************************************************************************
 238  *                  AntiMoniker_BindToObject
 239  ******************************************************************************/
 240 static HRESULT WINAPI
 241 AntiMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 242                              REFIID riid, VOID** ppvResult)
 243 {
 244     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 245     return E_NOTIMPL;
 246 }
 247
 248 /******************************************************************************
 249  *        AntiMoniker_BindToStorage
 250  ******************************************************************************/
 251 static HRESULT WINAPI
 252 AntiMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 253                               REFIID riid, VOID** ppvResult)
 254 {
 255     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI
 260 AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 261                        IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 262 {
 263     TRACE("%p, %p, %ld, %p, %p.\n", iface, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
 264
 265     if (ppmkReduced==NULL)
 266         return E_POINTER;
 267
 268     AntiMonikerImpl_AddRef(iface);
 269
 270     *ppmkReduced=iface;
 271
 272     return MK_S_REDUCED_TO_SELF;
 273 }
 274 /******************************************************************************
 275  *        AntiMoniker_ComposeWith
 276  ******************************************************************************/
 277 static HRESULT WINAPI
 278 AntiMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
 279                             BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
 280 {
 281
 282     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 283
 284     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 285         return E_POINTER;
 286
 287     *ppmkComposite=0;
 288
 289     if (fOnlyIfNotGeneric)
 290         return MK_E_NEEDGENERIC;
 291     else
 292         return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 293 }
 294
 295 static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker *iface, BOOL forward, IEnumMoniker **ppenumMoniker)
 296 {
 297     TRACE("%p, %d, %p.\n", iface, forward, ppenumMoniker);
 298
 299     if (ppenumMoniker == NULL)
 300         return E_INVALIDARG;
 301
 302     *ppenumMoniker = NULL;
 303
 304     return S_OK;
 305 }
 306
 307 /******************************************************************************
 308  *        AntiMoniker_IsEqual
 309  ******************************************************************************/
 310 static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker *iface, IMoniker *other)
 311 {
 312     AntiMonikerImpl *moniker = impl_from_IMoniker(iface), *other_moniker;
 313
 314     TRACE("%p, %p.\n", iface, other);
 315
 316     if (!other)
 317         return E_INVALIDARG;
 318
 319     other_moniker = unsafe_impl_from_IMoniker(other);
 320     if (!other_moniker)
 321         return S_FALSE;
 322
 323     return moniker->count == other_moniker->count ? S_OK : S_FALSE;
 324 }
 325
 326 /******************************************************************************
 327  *        AntiMoniker_Hash
 328  ******************************************************************************/
 329 static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker *iface, DWORD *hash)
 330 {
 331     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 332
 333     TRACE("%p, %p.\n", iface, hash);
 334
 335     if (!hash)
 336         return E_POINTER;
 337
 338     *hash = 0x80000000 | moniker->count;
 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 AntiMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *other, IMoniker **prefix)
 402 {
 403     AntiMonikerImpl *moniker = impl_from_IMoniker(iface), *other_moniker;
 404     HRESULT hr;
 405
 406     TRACE("%p, %p, %p.\n", iface, other, prefix);
 407
 408     other_moniker = unsafe_impl_from_IMoniker(other);
 409     if (other_moniker)
 410     {
 411         if (moniker->count <= other_moniker->count)
 412         {
 413             *prefix = iface;
 414             hr = moniker->count == other_moniker->count ? MK_S_US : MK_S_ME;
 415         }
 416         else
 417         {
 418             *prefix = other;
 419             hr = MK_S_HIM;
 420         }
 421
 422         IMoniker_AddRef(*prefix);
 423         return hr;
 424     }
 425
 426     return MonikerCommonPrefixWith(iface, other, prefix);
 427 }
 428
 429 static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *other, IMoniker **result)
 430 {
 431     TRACE("%p, %p, %p.\n", iface, other, result);
 432
 433     if (!other || !result)
 434         return E_INVALIDARG;
 435
 436     IMoniker_AddRef(other);
 437     *result = other;
 438
 439     return MK_S_HIM;
 440 }
 441
 442 /******************************************************************************
 443  *        AntiMoniker_GetDisplayName
 444  ******************************************************************************/
 445 static HRESULT WINAPI
 446 AntiMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *displayname)
 447 {
 448     AntiMonikerImpl *moniker = impl_from_IMoniker(iface);
 449     static const WCHAR nameW[] = {'\\','.','.'};
 450     WCHAR *ptrW;
 451     int i;
 452
 453     TRACE("%p, %p, %p, %p.\n", iface, pbc, pmkToLeft, displayname);
 454
 455     if (!displayname)
 456         return E_POINTER;
 457
 458     if (pmkToLeft!=NULL){
 459         FIXME("() pmkToLeft!=NULL not implemented\n");
 460         return E_NOTIMPL;
 461     }
 462
 463     *displayname = ptrW = CoTaskMemAlloc((moniker->count * ARRAY_SIZE(nameW) + 1) * sizeof(WCHAR));
 464     if (!*displayname)
 465         return E_OUTOFMEMORY;
 466
 467     for (i = 0; i < moniker->count; ++i)
 468         memcpy(ptrW + i * ARRAY_SIZE(nameW), nameW, sizeof(nameW));
 469     ptrW[moniker->count * ARRAY_SIZE(nameW)] = 0;
 470
 471     return S_OK;
 472 }
 473
 474 /******************************************************************************
 475  *        AntiMoniker_ParseDisplayName
 476  ******************************************************************************/
 477 static HRESULT WINAPI
 478 AntiMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
 479                                  IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
 480                                  ULONG* pchEaten, IMoniker** ppmkOut)
 481 {
 482     TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 483     return E_NOTIMPL;
 484 }
 485
 486 /******************************************************************************
 487  *        AntiMoniker_IsSystemMoniker
 488  ******************************************************************************/
 489 static HRESULT WINAPI
 490 AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 491 {
 492     TRACE("(%p,%p)\n",iface,pwdMksys);
 493
 494     if (!pwdMksys)
 495         return E_POINTER;
 496
 497     (*pwdMksys)=MKSYS_ANTIMONIKER;
 498
 499     return S_OK;
 500 }
 501
 502 /*******************************************************************************
 503  *        AntiMonikerIROTData_QueryInterface
 504  *******************************************************************************/
 505 static HRESULT WINAPI
 506 AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
 507 {
 508     AntiMonikerImpl *This = impl_from_IROTData(iface);
 509
 510     TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
 511
 512     return AntiMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
 513 }
 514
 515 /***********************************************************************
 516  *        AntiMonikerIROTData_AddRef
 517  */
 518 static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
 519 {
 520     AntiMonikerImpl *This = impl_from_IROTData(iface);
 521
 522     TRACE("(%p)\n",iface);
 523
 524     return AntiMonikerImpl_AddRef(&This->IMoniker_iface);
 525 }
 526
 527 /***********************************************************************
 528  *        AntiMonikerIROTData_Release
 529  */
 530 static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
 531 {
 532     AntiMonikerImpl *This = impl_from_IROTData(iface);
 533
 534     TRACE("(%p)\n",iface);
 535
 536     return AntiMonikerImpl_Release(&This->IMoniker_iface);
 537 }
 538
 539 /******************************************************************************
 540  *        AntiMonikerIROTData_GetComparisonData
 541  ******************************************************************************/
 542 static HRESULT WINAPI
 543 AntiMonikerROTDataImpl_GetComparisonData(IROTData *iface, BYTE *data, ULONG data_len, ULONG *data_req)
 544 {
 545     AntiMonikerImpl *moniker = impl_from_IROTData(iface);
 546
 547     TRACE("%p, %p, %lu, %p.\n", iface, data, data_len, data_req);
 548
 549     *data_req = sizeof(CLSID) + sizeof(DWORD);
 550     if (data_len < *data_req)
 551         return E_OUTOFMEMORY;
 552
 553     memcpy(data, &CLSID_AntiMoniker, sizeof(CLSID));
 554     memcpy(data + sizeof(CLSID), &moniker->count, sizeof(moniker->count));
 555
 556     return S_OK;
 557 }
 558
 559 /********************************************************************************/
 560 /* Virtual function table for the AntiMonikerImpl class which  include IPersist,*/
 561 /* IPersistStream and IMoniker functions.                                       */
 562 static const IMonikerVtbl VT_AntiMonikerImpl =
 563 {
 564     AntiMonikerImpl_QueryInterface,
 565     AntiMonikerImpl_AddRef,
 566     AntiMonikerImpl_Release,
 567     AntiMonikerImpl_GetClassID,
 568     AntiMonikerImpl_IsDirty,
 569     AntiMonikerImpl_Load,
 570     AntiMonikerImpl_Save,
 571     AntiMonikerImpl_GetSizeMax,
 572     AntiMonikerImpl_BindToObject,
 573     AntiMonikerImpl_BindToStorage,
 574     AntiMonikerImpl_Reduce,
 575     AntiMonikerImpl_ComposeWith,
 576     AntiMonikerImpl_Enum,
 577     AntiMonikerImpl_IsEqual,
 578     AntiMonikerImpl_Hash,
 579     AntiMonikerImpl_IsRunning,
 580     AntiMonikerImpl_GetTimeOfLastChange,
 581     AntiMonikerImpl_Inverse,
 582     AntiMonikerImpl_CommonPrefixWith,
 583     AntiMonikerImpl_RelativePathTo,
 584     AntiMonikerImpl_GetDisplayName,
 585     AntiMonikerImpl_ParseDisplayName,
 586     AntiMonikerImpl_IsSystemMoniker
 587 };
 588
 589 static AntiMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface)
 590 {
 591     if (iface->lpVtbl != &VT_AntiMonikerImpl)
 592         return NULL;
 593     return CONTAINING_RECORD(iface, AntiMonikerImpl, IMoniker_iface);
 594 }
 595
 596 /********************************************************************************/
 597 /* Virtual function table for the IROTData class.                               */
 598 static const IROTDataVtbl VT_ROTDataImpl =
 599 {
 600     AntiMonikerROTDataImpl_QueryInterface,
 601     AntiMonikerROTDataImpl_AddRef,
 602     AntiMonikerROTDataImpl_Release,
 603     AntiMonikerROTDataImpl_GetComparisonData
 604 };
 605
 606 HRESULT create_anti_moniker(DWORD order, IMoniker **ret)
 607 {
 608     AntiMonikerImpl *moniker;
 609
 610     if (!(moniker = calloc(1, sizeof(*moniker))))
 611         return E_OUTOFMEMORY;
 612
 613     moniker->IMoniker_iface.lpVtbl = &VT_AntiMonikerImpl;
 614     moniker->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
 615     moniker->refcount = 1;
 616     moniker->count = order;
 617
 618     *ret = &moniker->IMoniker_iface;
 619
 620     return S_OK;
 621 }
 622
 623 /******************************************************************************
 624  *        CreateAntiMoniker     [OLE32.@]
 625  ******************************************************************************/
 626 HRESULT WINAPI CreateAntiMoniker(IMoniker **moniker)
 627 {
 628     TRACE("%p.\n", moniker);
 629
 630     return create_anti_moniker(1, moniker);
 631 }
 632
 633 HRESULT WINAPI AntiMoniker_CreateInstance(IClassFactory *iface,
 634     IUnknown *pUnk, REFIID riid, void **ppv)
 635 {
 636     IMoniker *pMoniker;
 637     HRESULT  hr;
 638
 639     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 640
 641     *ppv = NULL;
 642
 643     if (pUnk)
 644         return CLASS_E_NOAGGREGATION;
 645
 646     hr = CreateAntiMoniker(&pMoniker);
 647     if (FAILED(hr))
 648         return hr;
 649
 650     hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
 651     IMoniker_Release(pMoniker);
 652
 653     return hr;
 654 }