dlls/ole32/pointermoniker.c

   1 /*
   2  * Pointer Moniker Implementation
   3  *
   4  * Copyright 1999 Noomen Hamza
   5  * Copyright 2008 Robert Shearman (for CodeWeavers)
   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 <stdarg.h>
  23 #include <string.h>
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "winuser.h"
  32 #include "objbase.h"
  33 #include "oleidl.h"
  34 #include "wine/debug.h"
  35 #include "wine/heap.h"
  36 #include "moniker.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  39
  40 /* PointerMoniker data structure */
  41 typedef struct PointerMonikerImpl
  42 {
  43     IMoniker IMoniker_iface;
  44     IMarshal IMarshal_iface;
  45
  46     LONG refcount;
  47
  48     IUnknown *pObject;
  49 } PointerMonikerImpl;
  50
  51 static inline PointerMonikerImpl *impl_from_IMoniker(IMoniker *iface)
  52 {
  53     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMoniker_iface);
  54 }
  55
  56 static PointerMonikerImpl *impl_from_IMarshal(IMarshal *iface)
  57 {
  58     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMarshal_iface);
  59 }
  60
  61 static PointerMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface);
  62
  63 static HRESULT WINAPI PointerMonikerImpl_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
  64 {
  65     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
  66
  67     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppvObject);
  68
  69     if (!ppvObject)
  70         return E_INVALIDARG;
  71
  72     *ppvObject = 0;
  73
  74     if (IsEqualIID(&IID_IUnknown, riid) ||
  75         IsEqualIID(&IID_IPersist, riid) ||
  76         IsEqualIID(&IID_IPersistStream, riid) ||
  77         IsEqualIID(&IID_IMoniker, riid) ||
  78         IsEqualGUID(&CLSID_PointerMoniker, riid))
  79     {
  80         *ppvObject = iface;
  81     }
  82     else if (IsEqualIID(&IID_IMarshal, riid))
  83         *ppvObject = &moniker->IMarshal_iface;
  84
  85     if (!*ppvObject)
  86         return E_NOINTERFACE;
  87
  88     IMoniker_AddRef(iface);
  89
  90     return S_OK;
  91 }
  92
  93 static ULONG WINAPI PointerMonikerImpl_AddRef(IMoniker *iface)
  94 {
  95     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
  96     ULONG refcount = InterlockedIncrement(&moniker->refcount);
  97
  98     TRACE("%p, refcount %u.\n", iface, refcount);
  99
 100     return refcount;
 101 }
 102
 103 static ULONG WINAPI PointerMonikerImpl_Release(IMoniker *iface)
 104 {
 105     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
 106     ULONG refcount = InterlockedDecrement(&moniker->refcount);
 107
 108     TRACE("%p, refcount %u.\n", iface, refcount);
 109
 110     if (!refcount)
 111     {
 112         if (moniker->pObject) IUnknown_Release(moniker->pObject);
 113         heap_free(moniker);
 114     }
 115
 116     return refcount;
 117 }
 118
 119 /******************************************************************************
 120  *        PointerMoniker_GetClassID
 121  ******************************************************************************/
 122 static HRESULT WINAPI
 123 PointerMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 124 {
 125     TRACE("(%p,%p)\n",iface,pClassID);
 126
 127     if (pClassID==NULL)
 128         return E_POINTER;
 129
 130     *pClassID = CLSID_PointerMoniker;
 131
 132     return S_OK;
 133 }
 134
 135 /******************************************************************************
 136  *        PointerMoniker_IsDirty
 137  ******************************************************************************/
 138 static HRESULT WINAPI
 139 PointerMonikerImpl_IsDirty(IMoniker* iface)
 140 {
 141     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 142        method in the OLE-provided moniker interfaces always return S_FALSE because
 143        their internal state never changes. */
 144
 145     TRACE("(%p)\n",iface);
 146
 147     return S_FALSE;
 148 }
 149
 150 /******************************************************************************
 151  *        PointerMoniker_Load
 152  ******************************************************************************/
 153 static HRESULT WINAPI
 154 PointerMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 155 {
 156     TRACE("(%p)\n", pStm);
 157
 158     return E_NOTIMPL;
 159 }
 160
 161 /******************************************************************************
 162  *        PointerMoniker_Save
 163  ******************************************************************************/
 164 static HRESULT WINAPI
 165 PointerMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
 166 {
 167     TRACE("(%p, %d)\n", pStm, fClearDirty);
 168
 169     return E_NOTIMPL;
 170 }
 171
 172 /******************************************************************************
 173  *        PointerMoniker_GetSizeMax
 174  *
 175  * PARAMS
 176  * pcbSize [out] Pointer to size of stream needed to save object
 177  ******************************************************************************/
 178 static HRESULT WINAPI
 179 PointerMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
 180 {
 181     TRACE("(%p,%p)\n",iface,pcbSize);
 182
 183     if (!pcbSize)
 184         return E_POINTER;
 185
 186     pcbSize->u.LowPart = 0;
 187     pcbSize->u.HighPart = 0;
 188
 189     return E_NOTIMPL;
 190 }
 191
 192 /******************************************************************************
 193  *                  PointerMoniker_BindToObject
 194  ******************************************************************************/
 195 static HRESULT WINAPI
 196 PointerMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 197                              REFIID riid, VOID** ppvResult)
 198 {
 199     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 200
 201     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 202
 203     if (!This->pObject)
 204         return E_UNEXPECTED;
 205
 206     return IUnknown_QueryInterface(This->pObject, riid, ppvResult);
 207 }
 208
 209 /******************************************************************************
 210  *        PointerMoniker_BindToStorage
 211  ******************************************************************************/
 212 static HRESULT WINAPI
 213 PointerMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 214                               REFIID riid, VOID** ppvResult)
 215 {
 216     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 217
 218     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 219
 220     if (!This->pObject)
 221         return E_UNEXPECTED;
 222
 223     return IUnknown_QueryInterface(This->pObject, riid, ppvResult);
 224 }
 225
 226 /******************************************************************************
 227  *        PointerMoniker_Reduce
 228  ******************************************************************************/
 229 static HRESULT WINAPI
 230 PointerMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 231                        IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 232 {
 233     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 234
 235     if (ppmkReduced==NULL)
 236         return E_POINTER;
 237
 238     PointerMonikerImpl_AddRef(iface);
 239
 240     *ppmkReduced=iface;
 241
 242     return MK_S_REDUCED_TO_SELF;
 243 }
 244 /******************************************************************************
 245  *        PointerMoniker_ComposeWith
 246  ******************************************************************************/
 247 static HRESULT WINAPI
 248 PointerMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
 249                             BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
 250 {
 251
 252     HRESULT res=S_OK;
 253     DWORD mkSys,mkSys2, order;
 254     IEnumMoniker* penumMk=0;
 255     IMoniker *pmostLeftMk=0;
 256     IMoniker* tempMkComposite=0;
 257
 258     TRACE("(%p,%d,%p)\n", pmkRight, fOnlyIfNotGeneric, ppmkComposite);
 259
 260     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 261         return E_POINTER;
 262
 263     *ppmkComposite=0;
 264
 265     if (is_anti_moniker(pmkRight, &order))
 266     {
 267         return order > 1 ? create_anti_moniker(order - 1, ppmkComposite) : S_OK;
 268     }
 269     else
 270     {
 271         /* if pmkRight is a composite whose leftmost component is an anti-moniker,           */
 272         /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
 273         IMoniker_IsSystemMoniker(pmkRight,&mkSys);
 274
 275          if(mkSys==MKSYS_GENERICCOMPOSITE){
 276
 277             res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
 278
 279             if (FAILED(res))
 280                 return res;
 281
 282             res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
 283
 284             IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
 285
 286             if(mkSys2==MKSYS_ANTIMONIKER){
 287
 288                 IMoniker_Release(pmostLeftMk);
 289
 290                 tempMkComposite=iface;
 291                 IMoniker_AddRef(iface);
 292
 293                 while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
 294
 295                     res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
 296
 297                     IMoniker_Release(tempMkComposite);
 298                     IMoniker_Release(pmostLeftMk);
 299
 300                     tempMkComposite=*ppmkComposite;
 301                     IMoniker_AddRef(tempMkComposite);
 302                 }
 303                 return res;
 304             }
 305             else
 306                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 307          }
 308          /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
 309           composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
 310           a NULL moniker and a return value of MK_E_NEEDGENERIC */
 311           else
 312             if (!fOnlyIfNotGeneric)
 313                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 314
 315             else
 316                 return MK_E_NEEDGENERIC;
 317     }
 318 }
 319
 320 /******************************************************************************
 321  *        PointerMoniker_Enum
 322  ******************************************************************************/
 323 static HRESULT WINAPI PointerMonikerImpl_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
 324 {
 325     TRACE("%p, %d, %p.\n", iface, fForward, ppenumMoniker);
 326
 327     if (!ppenumMoniker)
 328         return E_POINTER;
 329
 330     *ppenumMoniker = NULL;
 331
 332     return E_NOTIMPL;
 333 }
 334
 335 /******************************************************************************
 336  *        PointerMoniker_IsEqual
 337  ******************************************************************************/
 338 static HRESULT WINAPI PointerMonikerImpl_IsEqual(IMoniker *iface, IMoniker *other)
 339 {
 340     PointerMonikerImpl *moniker = impl_from_IMoniker(iface), *other_moniker;
 341
 342     TRACE("%p, %p.\n", iface, other);
 343
 344     if (!other)
 345         return E_INVALIDARG;
 346
 347     other_moniker = unsafe_impl_from_IMoniker(other);
 348     if (!other_moniker)
 349         return S_FALSE;
 350
 351     return moniker->pObject == other_moniker->pObject ? S_OK : S_FALSE;
 352 }
 353
 354 /******************************************************************************
 355  *        PointerMoniker_Hash
 356  ******************************************************************************/
 357 static HRESULT WINAPI PointerMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 358 {
 359     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 360
 361     if (pdwHash==NULL)
 362         return E_POINTER;
 363
 364     *pdwHash = PtrToUlong(This->pObject);
 365
 366     return S_OK;
 367 }
 368
 369 /******************************************************************************
 370  *        PointerMoniker_IsRunning
 371  ******************************************************************************/
 372 static HRESULT WINAPI
 373 PointerMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 374                           IMoniker* pmkNewlyRunning)
 375 {
 376     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 377
 378     return S_OK;
 379 }
 380
 381 /******************************************************************************
 382  *        PointerMoniker_GetTimeOfLastChange
 383  ******************************************************************************/
 384 static HRESULT WINAPI PointerMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 385                                                    IBindCtx* pbc,
 386                                                    IMoniker* pmkToLeft,
 387                                                    FILETIME* pAntiTime)
 388 {
 389     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
 390     return E_NOTIMPL;
 391 }
 392
 393 /******************************************************************************
 394  *        PointerMoniker_Inverse
 395  ******************************************************************************/
 396 static HRESULT WINAPI
 397 PointerMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 398 {
 399     TRACE("(%p,%p)\n",iface,ppmk);
 400
 401     return CreateAntiMoniker(ppmk);
 402 }
 403
 404 /******************************************************************************
 405  *        PointerMoniker_CommonPrefixWith
 406  ******************************************************************************/
 407 static HRESULT WINAPI PointerMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *other, IMoniker **prefix)
 408 {
 409     TRACE("%p, %p, %p.\n", iface, other, prefix);
 410
 411     if (!prefix || !other)
 412         return E_INVALIDARG;
 413
 414     *prefix = NULL;
 415
 416     if (PointerMonikerImpl_IsEqual(iface, other) == S_OK)
 417     {
 418         IMoniker_AddRef(iface);
 419
 420         *prefix = iface;
 421
 422         return MK_S_US;
 423     }
 424     else
 425         return MK_E_NOPREFIX;
 426 }
 427
 428 /******************************************************************************
 429  *        PointerMoniker_RelativePathTo
 430  ******************************************************************************/
 431 static HRESULT WINAPI
 432 PointerMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 433 {
 434     TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
 435
 436     if (ppmkRelPath==NULL)
 437         return E_POINTER;
 438
 439     *ppmkRelPath = NULL;
 440
 441     return E_NOTIMPL;
 442 }
 443
 444 /******************************************************************************
 445  *        PointerMoniker_GetDisplayName
 446  ******************************************************************************/
 447 static HRESULT WINAPI
 448 PointerMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
 449                                IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
 450 {
 451     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
 452
 453     if (ppszDisplayName==NULL)
 454         return E_POINTER;
 455
 456     *ppszDisplayName = NULL;
 457     return E_NOTIMPL;
 458 }
 459
 460 /******************************************************************************
 461  *        PointerMoniker_ParseDisplayName
 462  ******************************************************************************/
 463 static HRESULT WINAPI
 464 PointerMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
 465                                  IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
 466                                  ULONG* pchEaten, IMoniker** ppmkOut)
 467 {
 468     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 469     HRESULT hr;
 470     IParseDisplayName *pPDN;
 471
 472     TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 473
 474     if (pmkToLeft)
 475         return MK_E_SYNTAX;
 476
 477     if (!This->pObject)
 478         return E_UNEXPECTED;
 479
 480     hr = IUnknown_QueryInterface(This->pObject, &IID_IParseDisplayName, (void **)&pPDN);
 481     if (FAILED(hr))
 482         return hr;
 483
 484     hr = IParseDisplayName_ParseDisplayName(pPDN, pbc, pszDisplayName, pchEaten, ppmkOut);
 485     IParseDisplayName_Release(pPDN);
 486
 487     return hr;
 488 }
 489
 490 /******************************************************************************
 491  *        PointerMoniker_IsSystemMoniker
 492  ******************************************************************************/
 493 static HRESULT WINAPI
 494 PointerMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 495 {
 496     TRACE("(%p,%p)\n",iface,pwdMksys);
 497
 498     if (!pwdMksys)
 499         return E_POINTER;
 500
 501     *pwdMksys = MKSYS_POINTERMONIKER;
 502
 503     return S_OK;
 504 }
 505
 506 /********************************************************************************/
 507 /* Virtual function table for the PointerMonikerImpl class which  include IPersist,*/
 508 /* IPersistStream and IMoniker functions.                                       */
 509 static const IMonikerVtbl VT_PointerMonikerImpl =
 510 {
 511     PointerMonikerImpl_QueryInterface,
 512     PointerMonikerImpl_AddRef,
 513     PointerMonikerImpl_Release,
 514     PointerMonikerImpl_GetClassID,
 515     PointerMonikerImpl_IsDirty,
 516     PointerMonikerImpl_Load,
 517     PointerMonikerImpl_Save,
 518     PointerMonikerImpl_GetSizeMax,
 519     PointerMonikerImpl_BindToObject,
 520     PointerMonikerImpl_BindToStorage,
 521     PointerMonikerImpl_Reduce,
 522     PointerMonikerImpl_ComposeWith,
 523     PointerMonikerImpl_Enum,
 524     PointerMonikerImpl_IsEqual,
 525     PointerMonikerImpl_Hash,
 526     PointerMonikerImpl_IsRunning,
 527     PointerMonikerImpl_GetTimeOfLastChange,
 528     PointerMonikerImpl_Inverse,
 529     PointerMonikerImpl_CommonPrefixWith,
 530     PointerMonikerImpl_RelativePathTo,
 531     PointerMonikerImpl_GetDisplayName,
 532     PointerMonikerImpl_ParseDisplayName,
 533     PointerMonikerImpl_IsSystemMoniker
 534 };
 535
 536 static PointerMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface)
 537 {
 538     if (iface->lpVtbl != &VT_PointerMonikerImpl)
 539         return NULL;
 540     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMoniker_iface);
 541 }
 542
 543 static HRESULT WINAPI pointer_moniker_marshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
 544 {
 545     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 546
 547     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppv);
 548
 549     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 550 }
 551
 552 static ULONG WINAPI pointer_moniker_marshal_AddRef(IMarshal *iface)
 553 {
 554     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 555
 556     TRACE("%p.\n",iface);
 557
 558     return IMoniker_AddRef(&moniker->IMoniker_iface);
 559 }
 560
 561 static ULONG WINAPI pointer_moniker_marshal_Release(IMarshal *iface)
 562 {
 563     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 564
 565     TRACE("%p.\n",iface);
 566
 567     return IMoniker_Release(&moniker->IMoniker_iface);
 568 }
 569
 570 static HRESULT WINAPI pointer_moniker_marshal_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv,
 571         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *clsid)
 572 {
 573     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 574
 575     TRACE("%p, %s, %p, %x, %p, %x, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 576             mshlflags, clsid);
 577
 578     return IMoniker_GetClassID(&moniker->IMoniker_iface, clsid);
 579 }
 580
 581 static HRESULT WINAPI pointer_moniker_marshal_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv,
 582         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *size)
 583 {
 584     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 585
 586     TRACE("%p, %s, %p, %d, %p, %#x, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 587             mshlflags, size);
 588
 589     return CoGetMarshalSizeMax(size, &IID_IUnknown, moniker->pObject, dwDestContext, pvDestContext, mshlflags);
 590 }
 591
 592 static HRESULT WINAPI pointer_moniker_marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID riid,
 593         void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 594 {
 595     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 596
 597     TRACE("%p, %s, %p, %x, %p, %x.\n", stream, debugstr_guid(riid), pv,
 598         dwDestContext, pvDestContext, mshlflags);
 599
 600     return CoMarshalInterface(stream, &IID_IUnknown, moniker->pObject, dwDestContext,
 601                 pvDestContext, mshlflags);
 602 }
 603
 604 static HRESULT WINAPI pointer_moniker_marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
 605         REFIID riid, void **ppv)
 606 {
 607     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 608     IUnknown *object;
 609     HRESULT hr;
 610
 611     TRACE("%p, %p, %s, %p.\n", iface, stream, debugstr_guid(riid), ppv);
 612
 613     hr = CoUnmarshalInterface(stream, &IID_IUnknown, (void **)&object);
 614     if (FAILED(hr))
 615     {
 616         ERR("Couldn't unmarshal moniker, hr = %#x.\n", hr);
 617         return hr;
 618     }
 619
 620     if (moniker->pObject)
 621         IUnknown_Release(moniker->pObject);
 622     moniker->pObject = object;
 623
 624     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 625 }
 626
 627 static HRESULT WINAPI pointer_moniker_marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
 628 {
 629     TRACE("%p, %p.\n", iface, stream);
 630
 631     return S_OK;
 632 }
 633
 634 static HRESULT WINAPI pointer_moniker_marshal_DisconnectObject(IMarshal *iface, DWORD reserved)
 635 {
 636     TRACE("%p, %#x.\n", iface, reserved);
 637
 638     return S_OK;
 639 }
 640
 641 static const IMarshalVtbl pointer_moniker_marshal_vtbl =
 642 {
 643     pointer_moniker_marshal_QueryInterface,
 644     pointer_moniker_marshal_AddRef,
 645     pointer_moniker_marshal_Release,
 646     pointer_moniker_marshal_GetUnmarshalClass,
 647     pointer_moniker_marshal_GetMarshalSizeMax,
 648     pointer_moniker_marshal_MarshalInterface,
 649     pointer_moniker_marshal_UnmarshalInterface,
 650     pointer_moniker_marshal_ReleaseMarshalData,
 651     pointer_moniker_marshal_DisconnectObject
 652 };
 653
 654 /***********************************************************************
 655  *           CreatePointerMoniker (OLE32.@)
 656  */
 657 HRESULT WINAPI CreatePointerMoniker(IUnknown *object, IMoniker **ret)
 658 {
 659     PointerMonikerImpl *moniker;
 660
 661     TRACE("(%p, %p)\n", object, ret);
 662
 663     if (!ret)
 664         return E_INVALIDARG;
 665
 666     moniker = heap_alloc(sizeof(*moniker));
 667     if (!moniker)
 668     {
 669         *ret = NULL;
 670         return E_OUTOFMEMORY;
 671     }
 672
 673     moniker->IMoniker_iface.lpVtbl = &VT_PointerMonikerImpl;
 674     moniker->IMarshal_iface.lpVtbl = &pointer_moniker_marshal_vtbl;
 675     moniker->refcount = 1;
 676     moniker->pObject = object;
 677     if (moniker->pObject)
 678         IUnknown_AddRef(moniker->pObject);
 679
 680     *ret = &moniker->IMoniker_iface;
 681
 682     return S_OK;
 683 }
 684
 685 HRESULT WINAPI PointerMoniker_CreateInstance(IClassFactory *iface,
 686     IUnknown *pUnk, REFIID riid, void **ppv)
 687 {
 688     IMoniker *pMoniker;
 689     HRESULT  hr;
 690
 691     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 692
 693     *ppv = NULL;
 694
 695     if (pUnk)
 696         return CLASS_E_NOAGGREGATION;
 697
 698     hr = CreatePointerMoniker(NULL, &pMoniker);
 699     if (FAILED(hr))
 700         return hr;
 701
 702     hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
 703     IMoniker_Release(pMoniker);
 704
 705     return hr;
 706 }