dlls/ole32/pointermoniker.c

   1 /*
   2  * Pointer and Objref Monikers 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 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "winuser.h"
  30 #include "objbase.h"
  31 #include "oleidl.h"
  32 #include "wine/debug.h"
  33 #include "moniker.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  36
  37 /* PointerMoniker data structure */
  38 typedef struct PointerMonikerImpl
  39 {
  40     IMoniker IMoniker_iface;
  41     IMarshal IMarshal_iface;
  42
  43     LONG refcount;
  44
  45     IUnknown *pObject;
  46 } PointerMonikerImpl;
  47
  48 static inline PointerMonikerImpl *impl_from_IMoniker(IMoniker *iface)
  49 {
  50     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMoniker_iface);
  51 }
  52
  53 static PointerMonikerImpl *impl_from_IMarshal(IMarshal *iface)
  54 {
  55     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMarshal_iface);
  56 }
  57
  58 static PointerMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface);
  59
  60 static HRESULT WINAPI PointerMonikerImpl_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
  61 {
  62     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
  63
  64     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppvObject);
  65
  66     if (!ppvObject)
  67         return E_INVALIDARG;
  68
  69     *ppvObject = 0;
  70
  71     if (IsEqualIID(&IID_IUnknown, riid) ||
  72         IsEqualIID(&IID_IPersist, riid) ||
  73         IsEqualIID(&IID_IPersistStream, riid) ||
  74         IsEqualIID(&IID_IMoniker, riid) ||
  75         IsEqualGUID(&CLSID_PointerMoniker, riid))
  76     {
  77         *ppvObject = iface;
  78     }
  79     else if (IsEqualIID(&IID_IMarshal, riid))
  80         *ppvObject = &moniker->IMarshal_iface;
  81
  82     if (!*ppvObject)
  83         return E_NOINTERFACE;
  84
  85     IMoniker_AddRef(iface);
  86
  87     return S_OK;
  88 }
  89
  90 static ULONG WINAPI PointerMonikerImpl_AddRef(IMoniker *iface)
  91 {
  92     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
  93     ULONG refcount = InterlockedIncrement(&moniker->refcount);
  94
  95     TRACE("%p, refcount %lu.\n", iface, refcount);
  96
  97     return refcount;
  98 }
  99
 100 static ULONG WINAPI PointerMonikerImpl_Release(IMoniker *iface)
 101 {
 102     PointerMonikerImpl *moniker = impl_from_IMoniker(iface);
 103     ULONG refcount = InterlockedDecrement(&moniker->refcount);
 104
 105     TRACE("%p, refcount %lu.\n", iface, refcount);
 106
 107     if (!refcount)
 108     {
 109         if (moniker->pObject) IUnknown_Release(moniker->pObject);
 110         free(moniker);
 111     }
 112
 113     return refcount;
 114 }
 115
 116 /******************************************************************************
 117  *        PointerMoniker_GetClassID
 118  ******************************************************************************/
 119 static HRESULT WINAPI
 120 PointerMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 121 {
 122     TRACE("(%p,%p)\n",iface,pClassID);
 123
 124     if (pClassID==NULL)
 125         return E_POINTER;
 126
 127     *pClassID = CLSID_PointerMoniker;
 128
 129     return S_OK;
 130 }
 131
 132 /******************************************************************************
 133  *        PointerMoniker_IsDirty
 134  ******************************************************************************/
 135 static HRESULT WINAPI
 136 PointerMonikerImpl_IsDirty(IMoniker* iface)
 137 {
 138     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 139        method in the OLE-provided moniker interfaces always return S_FALSE because
 140        their internal state never changes. */
 141
 142     TRACE("(%p)\n",iface);
 143
 144     return S_FALSE;
 145 }
 146
 147 /******************************************************************************
 148  *        PointerMoniker_Load
 149  ******************************************************************************/
 150 static HRESULT WINAPI
 151 PointerMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 152 {
 153     TRACE("(%p)\n", pStm);
 154
 155     return E_NOTIMPL;
 156 }
 157
 158 /******************************************************************************
 159  *        PointerMoniker_Save
 160  ******************************************************************************/
 161 static HRESULT WINAPI
 162 PointerMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
 163 {
 164     TRACE("(%p, %d)\n", pStm, fClearDirty);
 165
 166     return E_NOTIMPL;
 167 }
 168
 169 /******************************************************************************
 170  *        PointerMoniker_GetSizeMax
 171  *
 172  * PARAMS
 173  * pcbSize [out] Pointer to size of stream needed to save object
 174  ******************************************************************************/
 175 static HRESULT WINAPI
 176 PointerMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
 177 {
 178     TRACE("(%p,%p)\n",iface,pcbSize);
 179
 180     if (!pcbSize)
 181         return E_POINTER;
 182
 183     pcbSize->u.LowPart = 0;
 184     pcbSize->u.HighPart = 0;
 185
 186     return E_NOTIMPL;
 187 }
 188
 189 /******************************************************************************
 190  *                  PointerMoniker_BindToObject
 191  ******************************************************************************/
 192 static HRESULT WINAPI
 193 PointerMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 194                              REFIID riid, VOID** ppvResult)
 195 {
 196     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 197
 198     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 199
 200     if (!This->pObject)
 201         return E_UNEXPECTED;
 202
 203     return IUnknown_QueryInterface(This->pObject, riid, ppvResult);
 204 }
 205
 206 /******************************************************************************
 207  *        PointerMoniker_BindToStorage
 208  ******************************************************************************/
 209 static HRESULT WINAPI
 210 PointerMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 211                               REFIID riid, VOID** ppvResult)
 212 {
 213     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 214
 215     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 216
 217     if (!This->pObject)
 218         return E_UNEXPECTED;
 219
 220     return IUnknown_QueryInterface(This->pObject, riid, ppvResult);
 221 }
 222
 223 /******************************************************************************
 224  *        PointerMoniker_Reduce
 225  ******************************************************************************/
 226 static HRESULT WINAPI
 227 PointerMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 228                        IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 229 {
 230     TRACE("%p, %p, %ld, %p, %p.\n", iface, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
 231
 232     if (ppmkReduced==NULL)
 233         return E_POINTER;
 234
 235     PointerMonikerImpl_AddRef(iface);
 236
 237     *ppmkReduced=iface;
 238
 239     return MK_S_REDUCED_TO_SELF;
 240 }
 241
 242 static HRESULT WINAPI PointerMonikerImpl_ComposeWith(IMoniker *iface, IMoniker *right,
 243         BOOL only_if_not_generic, IMoniker **result)
 244 {
 245     DWORD order;
 246
 247     TRACE("%p, %p, %d, %p.\n", iface, right, only_if_not_generic, result);
 248
 249     if (!result || !right)
 250         return E_POINTER;
 251
 252     *result = NULL;
 253
 254     if (is_anti_moniker(right, &order))
 255         return order > 1 ? create_anti_moniker(order - 1, result) : S_OK;
 256
 257     return only_if_not_generic ? MK_E_NEEDGENERIC : CreateGenericComposite(iface, right, result);
 258 }
 259
 260 /******************************************************************************
 261  *        PointerMoniker_Enum
 262  ******************************************************************************/
 263 static HRESULT WINAPI PointerMonikerImpl_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
 264 {
 265     TRACE("%p, %d, %p.\n", iface, fForward, ppenumMoniker);
 266
 267     if (!ppenumMoniker)
 268         return E_POINTER;
 269
 270     *ppenumMoniker = NULL;
 271
 272     return E_NOTIMPL;
 273 }
 274
 275 /******************************************************************************
 276  *        PointerMoniker_IsEqual
 277  ******************************************************************************/
 278 static HRESULT WINAPI PointerMonikerImpl_IsEqual(IMoniker *iface, IMoniker *other)
 279 {
 280     PointerMonikerImpl *moniker = impl_from_IMoniker(iface), *other_moniker;
 281
 282     TRACE("%p, %p.\n", iface, other);
 283
 284     if (!other)
 285         return E_INVALIDARG;
 286
 287     other_moniker = unsafe_impl_from_IMoniker(other);
 288     if (!other_moniker)
 289         return S_FALSE;
 290
 291     return moniker->pObject == other_moniker->pObject ? S_OK : S_FALSE;
 292 }
 293
 294 /******************************************************************************
 295  *        PointerMoniker_Hash
 296  ******************************************************************************/
 297 static HRESULT WINAPI PointerMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 298 {
 299     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 300
 301     if (pdwHash==NULL)
 302         return E_POINTER;
 303
 304     *pdwHash = PtrToUlong(This->pObject);
 305
 306     return S_OK;
 307 }
 308
 309 /******************************************************************************
 310  *        PointerMoniker_IsRunning
 311  ******************************************************************************/
 312 static HRESULT WINAPI
 313 PointerMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
 314                           IMoniker* pmkNewlyRunning)
 315 {
 316     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 317
 318     return S_OK;
 319 }
 320
 321 /******************************************************************************
 322  *        PointerMoniker_GetTimeOfLastChange
 323  ******************************************************************************/
 324 static HRESULT WINAPI PointerMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 325                                                    IBindCtx* pbc,
 326                                                    IMoniker* pmkToLeft,
 327                                                    FILETIME* pAntiTime)
 328 {
 329     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
 330     return E_NOTIMPL;
 331 }
 332
 333 /******************************************************************************
 334  *        PointerMoniker_Inverse
 335  ******************************************************************************/
 336 static HRESULT WINAPI
 337 PointerMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 338 {
 339     TRACE("(%p,%p)\n",iface,ppmk);
 340
 341     return CreateAntiMoniker(ppmk);
 342 }
 343
 344 /******************************************************************************
 345  *        PointerMoniker_CommonPrefixWith
 346  ******************************************************************************/
 347 static HRESULT WINAPI PointerMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *other, IMoniker **prefix)
 348 {
 349     TRACE("%p, %p, %p.\n", iface, other, prefix);
 350
 351     if (!prefix || !other)
 352         return E_INVALIDARG;
 353
 354     *prefix = NULL;
 355
 356     if (PointerMonikerImpl_IsEqual(iface, other) == S_OK)
 357     {
 358         IMoniker_AddRef(iface);
 359
 360         *prefix = iface;
 361
 362         return MK_S_US;
 363     }
 364     else
 365         return MK_E_NOPREFIX;
 366 }
 367
 368 static HRESULT WINAPI PointerMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *other, IMoniker **result)
 369 {
 370     TRACE("%p, %p, %p.\n", iface, other, result);
 371
 372     if (!result)
 373         return E_INVALIDARG;
 374
 375     *result = NULL;
 376
 377     return other ? E_NOTIMPL : E_INVALIDARG;
 378 }
 379
 380 static HRESULT WINAPI PointerMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc,
 381         IMoniker *toleft, LPOLESTR *name)
 382 {
 383     TRACE("%p, %p, %p, %p.\n", iface, pbc, toleft, name);
 384
 385     if (!name || !pbc)
 386     {
 387         if (name) *name = NULL;
 388         return E_INVALIDARG;
 389     }
 390
 391     return E_NOTIMPL;
 392 }
 393
 394 /******************************************************************************
 395  *        PointerMoniker_ParseDisplayName
 396  ******************************************************************************/
 397 static HRESULT WINAPI
 398 PointerMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
 399                                  IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
 400                                  ULONG* pchEaten, IMoniker** ppmkOut)
 401 {
 402     PointerMonikerImpl *This = impl_from_IMoniker(iface);
 403     HRESULT hr;
 404     IParseDisplayName *pPDN;
 405
 406     TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 407
 408     if (pmkToLeft)
 409         return MK_E_SYNTAX;
 410
 411     if (!This->pObject)
 412         return E_UNEXPECTED;
 413
 414     hr = IUnknown_QueryInterface(This->pObject, &IID_IParseDisplayName, (void **)&pPDN);
 415     if (FAILED(hr))
 416         return hr;
 417
 418     hr = IParseDisplayName_ParseDisplayName(pPDN, pbc, pszDisplayName, pchEaten, ppmkOut);
 419     IParseDisplayName_Release(pPDN);
 420
 421     return hr;
 422 }
 423
 424 /******************************************************************************
 425  *        PointerMoniker_IsSystemMoniker
 426  ******************************************************************************/
 427 static HRESULT WINAPI
 428 PointerMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 429 {
 430     TRACE("(%p,%p)\n",iface,pwdMksys);
 431
 432     if (!pwdMksys)
 433         return E_POINTER;
 434
 435     *pwdMksys = MKSYS_POINTERMONIKER;
 436
 437     return S_OK;
 438 }
 439
 440 /********************************************************************************/
 441 /* Virtual function table for the PointerMonikerImpl class which  include IPersist,*/
 442 /* IPersistStream and IMoniker functions.                                       */
 443 static const IMonikerVtbl VT_PointerMonikerImpl =
 444 {
 445     PointerMonikerImpl_QueryInterface,
 446     PointerMonikerImpl_AddRef,
 447     PointerMonikerImpl_Release,
 448     PointerMonikerImpl_GetClassID,
 449     PointerMonikerImpl_IsDirty,
 450     PointerMonikerImpl_Load,
 451     PointerMonikerImpl_Save,
 452     PointerMonikerImpl_GetSizeMax,
 453     PointerMonikerImpl_BindToObject,
 454     PointerMonikerImpl_BindToStorage,
 455     PointerMonikerImpl_Reduce,
 456     PointerMonikerImpl_ComposeWith,
 457     PointerMonikerImpl_Enum,
 458     PointerMonikerImpl_IsEqual,
 459     PointerMonikerImpl_Hash,
 460     PointerMonikerImpl_IsRunning,
 461     PointerMonikerImpl_GetTimeOfLastChange,
 462     PointerMonikerImpl_Inverse,
 463     PointerMonikerImpl_CommonPrefixWith,
 464     PointerMonikerImpl_RelativePathTo,
 465     PointerMonikerImpl_GetDisplayName,
 466     PointerMonikerImpl_ParseDisplayName,
 467     PointerMonikerImpl_IsSystemMoniker
 468 };
 469
 470 static PointerMonikerImpl *unsafe_impl_from_IMoniker(IMoniker *iface)
 471 {
 472     if (iface->lpVtbl != &VT_PointerMonikerImpl)
 473         return NULL;
 474     return CONTAINING_RECORD(iface, PointerMonikerImpl, IMoniker_iface);
 475 }
 476
 477 static HRESULT WINAPI pointer_moniker_marshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
 478 {
 479     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 480
 481     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppv);
 482
 483     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 484 }
 485
 486 static ULONG WINAPI pointer_moniker_marshal_AddRef(IMarshal *iface)
 487 {
 488     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 489
 490     TRACE("%p.\n",iface);
 491
 492     return IMoniker_AddRef(&moniker->IMoniker_iface);
 493 }
 494
 495 static ULONG WINAPI pointer_moniker_marshal_Release(IMarshal *iface)
 496 {
 497     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 498
 499     TRACE("%p.\n",iface);
 500
 501     return IMoniker_Release(&moniker->IMoniker_iface);
 502 }
 503
 504 static HRESULT WINAPI pointer_moniker_marshal_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv,
 505         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *clsid)
 506 {
 507     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 508
 509     TRACE("%p, %s, %p, %lx, %p, %lx, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 510             mshlflags, clsid);
 511
 512     return IMoniker_GetClassID(&moniker->IMoniker_iface, clsid);
 513 }
 514
 515 static HRESULT WINAPI pointer_moniker_marshal_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv,
 516         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *size)
 517 {
 518     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 519
 520     TRACE("%p, %s, %p, %ld, %p, %#lx, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 521             mshlflags, size);
 522
 523     return CoGetMarshalSizeMax(size, &IID_IUnknown, moniker->pObject, dwDestContext, pvDestContext, mshlflags);
 524 }
 525
 526 static HRESULT WINAPI pointer_moniker_marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID riid,
 527         void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 528 {
 529     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 530
 531     TRACE("%p, %s, %p, %lx, %p, %lx.\n", stream, debugstr_guid(riid), pv,
 532         dwDestContext, pvDestContext, mshlflags);
 533
 534     return CoMarshalInterface(stream, &IID_IUnknown, moniker->pObject, dwDestContext,
 535                 pvDestContext, mshlflags);
 536 }
 537
 538 static HRESULT WINAPI pointer_moniker_marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
 539         REFIID riid, void **ppv)
 540 {
 541     PointerMonikerImpl *moniker = impl_from_IMarshal(iface);
 542     IUnknown *object;
 543     HRESULT hr;
 544
 545     TRACE("%p, %p, %s, %p.\n", iface, stream, debugstr_guid(riid), ppv);
 546
 547     hr = CoUnmarshalInterface(stream, &IID_IUnknown, (void **)&object);
 548     if (FAILED(hr))
 549     {
 550         ERR("Couldn't unmarshal moniker, hr = %#lx.\n", hr);
 551         return hr;
 552     }
 553
 554     if (moniker->pObject)
 555         IUnknown_Release(moniker->pObject);
 556     moniker->pObject = object;
 557
 558     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 559 }
 560
 561 static HRESULT WINAPI pointer_moniker_marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
 562 {
 563     TRACE("%p, %p.\n", iface, stream);
 564
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI pointer_moniker_marshal_DisconnectObject(IMarshal *iface, DWORD reserved)
 569 {
 570     TRACE("%p, %#lx.\n", iface, reserved);
 571
 572     return S_OK;
 573 }
 574
 575 static const IMarshalVtbl pointer_moniker_marshal_vtbl =
 576 {
 577     pointer_moniker_marshal_QueryInterface,
 578     pointer_moniker_marshal_AddRef,
 579     pointer_moniker_marshal_Release,
 580     pointer_moniker_marshal_GetUnmarshalClass,
 581     pointer_moniker_marshal_GetMarshalSizeMax,
 582     pointer_moniker_marshal_MarshalInterface,
 583     pointer_moniker_marshal_UnmarshalInterface,
 584     pointer_moniker_marshal_ReleaseMarshalData,
 585     pointer_moniker_marshal_DisconnectObject
 586 };
 587
 588 /***********************************************************************
 589  *           CreatePointerMoniker (OLE32.@)
 590  */
 591 HRESULT WINAPI CreatePointerMoniker(IUnknown *object, IMoniker **ret)
 592 {
 593     PointerMonikerImpl *moniker;
 594
 595     TRACE("(%p, %p)\n", object, ret);
 596
 597     if (!ret)
 598         return E_INVALIDARG;
 599
 600     if (!(moniker = calloc(1, sizeof(*moniker))))
 601     {
 602         *ret = NULL;
 603         return E_OUTOFMEMORY;
 604     }
 605
 606     moniker->IMoniker_iface.lpVtbl = &VT_PointerMonikerImpl;
 607     moniker->IMarshal_iface.lpVtbl = &pointer_moniker_marshal_vtbl;
 608     moniker->refcount = 1;
 609     moniker->pObject = object;
 610     if (moniker->pObject)
 611         IUnknown_AddRef(moniker->pObject);
 612
 613     *ret = &moniker->IMoniker_iface;
 614
 615     return S_OK;
 616 }
 617
 618 HRESULT WINAPI PointerMoniker_CreateInstance(IClassFactory *iface,
 619     IUnknown *pUnk, REFIID riid, void **ppv)
 620 {
 621     IMoniker *pMoniker;
 622     HRESULT  hr;
 623
 624     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 625
 626     *ppv = NULL;
 627
 628     if (pUnk)
 629         return CLASS_E_NOAGGREGATION;
 630
 631     hr = CreatePointerMoniker(NULL, &pMoniker);
 632     if (FAILED(hr))
 633         return hr;
 634
 635     hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
 636     IMoniker_Release(pMoniker);
 637
 638     return hr;
 639 }
 640
 641 /* ObjrefMoniker implementation */
 642
 643 typedef struct
 644 {
 645     IMoniker IMoniker_iface;
 646     IMarshal IMarshal_iface;
 647
 648     LONG refcount;
 649
 650     IUnknown *pObject;
 651 } ObjrefMonikerImpl;
 652
 653 static inline ObjrefMonikerImpl *objref_impl_from_IMoniker(IMoniker *iface)
 654 {
 655     return CONTAINING_RECORD(iface, ObjrefMonikerImpl, IMoniker_iface);
 656 }
 657
 658 static ObjrefMonikerImpl *objref_impl_from_IMarshal(IMarshal *iface)
 659 {
 660     return CONTAINING_RECORD(iface, ObjrefMonikerImpl, IMarshal_iface);
 661 }
 662
 663 static HRESULT WINAPI ObjrefMonikerImpl_QueryInterface(IMoniker *iface, REFIID iid, void **obj)
 664 {
 665     ObjrefMonikerImpl *moniker = objref_impl_from_IMoniker(iface);
 666
 667     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), obj);
 668
 669     if (!obj)
 670         return E_INVALIDARG;
 671
 672     *obj = 0;
 673
 674     if (IsEqualIID(iid, &IID_IUnknown) ||
 675         IsEqualIID(iid, &IID_IPersist) ||
 676         IsEqualIID(iid, &IID_IPersistStream) ||
 677         IsEqualIID(iid, &IID_IMoniker) ||
 678         IsEqualGUID(iid, &CLSID_ObjrefMoniker) ||
 679         IsEqualGUID(iid, &CLSID_PointerMoniker))
 680     {
 681         *obj = iface;
 682     }
 683     else if (IsEqualIID(iid, &IID_IMarshal))
 684         *obj = &moniker->IMarshal_iface;
 685     else
 686         return E_NOINTERFACE;
 687
 688     IMoniker_AddRef(iface);
 689
 690     return S_OK;
 691 }
 692
 693 static ULONG WINAPI ObjrefMonikerImpl_AddRef(IMoniker *iface)
 694 {
 695     ObjrefMonikerImpl *moniker = objref_impl_from_IMoniker(iface);
 696     ULONG refcount = InterlockedIncrement(&moniker->refcount);
 697
 698     TRACE("%p, refcount %lu\n", iface, refcount);
 699
 700     return refcount;
 701 }
 702
 703 static ULONG WINAPI ObjrefMonikerImpl_Release(IMoniker *iface)
 704 {
 705     ObjrefMonikerImpl *moniker = objref_impl_from_IMoniker(iface);
 706     ULONG refcount = InterlockedDecrement(&moniker->refcount);
 707
 708     TRACE("%p, refcount %lu\n", iface, refcount);
 709
 710     if (!refcount)
 711     {
 712         if (moniker->pObject) IUnknown_Release(moniker->pObject);
 713         free(moniker);
 714     }
 715
 716     return refcount;
 717 }
 718
 719 static HRESULT WINAPI ObjrefMonikerImpl_GetClassID(IMoniker *iface, CLSID *clsid)
 720 {
 721     TRACE("(%p,%p)\n", iface, clsid);
 722
 723     if (!clsid)
 724         return E_POINTER;
 725
 726     *clsid = CLSID_ObjrefMoniker;
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI ObjrefMonikerImpl_IsDirty(IMoniker *iface)
 731 {
 732     FIXME("(%p): stub\n", iface);
 733     return S_FALSE;
 734 }
 735
 736 static HRESULT WINAPI ObjrefMonikerImpl_Load(IMoniker *iface, IStream *stream)
 737 {
 738     FIXME("(%p,%p): stub\n", iface, stream);
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI ObjrefMonikerImpl_Save(IMoniker *iface, IStream *stream, BOOL dirty)
 743 {
 744     FIXME("(%p,%p,%d): stub\n", iface, stream, dirty);
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI ObjrefMonikerImpl_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *size)
 749 {
 750     FIXME("(%p,%p): stub\n", iface, size);
 751     return E_NOTIMPL;
 752 }
 753
 754 static HRESULT WINAPI ObjrefMonikerImpl_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *left,
 755         REFIID riid, void **result)
 756 {
 757     FIXME("(%p,%p,%p,%s,%p): stub\n", iface, pbc, left, debugstr_guid(riid), result);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI ObjrefMonikerImpl_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *left,
 762         REFIID riid, void **result)
 763 {
 764     FIXME("(%p,%p,%p,%s,%p): stub\n", iface, pbc, left, debugstr_guid(riid), result);
 765     return E_NOTIMPL;
 766 }
 767
 768 static HRESULT WINAPI ObjrefMonikerImpl_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD howfar,
 769         IMoniker **left, IMoniker **reduced)
 770 {
 771     FIXME("%p, %p, %ld, %p, %p: stub\n", iface, pbc, howfar, left, reduced);
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI ObjrefMonikerImpl_ComposeWith(IMoniker *iface, IMoniker *right,
 776         BOOL only_if_not_generic, IMoniker **result)
 777 {
 778     FIXME("(%p,%p,%d,%p): stub\n", iface, right, only_if_not_generic, result);
 779     return E_NOTIMPL;
 780 }
 781
 782 static HRESULT WINAPI ObjrefMonikerImpl_Enum(IMoniker *iface, BOOL forward, IEnumMoniker **enummoniker)
 783 {
 784     TRACE("(%p,%d,%p)\n", iface, forward, enummoniker);
 785
 786     if (!enummoniker)
 787         return E_POINTER;
 788
 789     *enummoniker = NULL;
 790     return S_OK;
 791 }
 792
 793 static HRESULT WINAPI ObjrefMonikerImpl_IsEqual(IMoniker *iface, IMoniker *other)
 794 {
 795     FIXME("(%p,%p): stub\n", iface, other);
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT WINAPI ObjrefMonikerImpl_Hash(IMoniker *iface, DWORD *hash)
 800 {
 801     ObjrefMonikerImpl *moniker = objref_impl_from_IMoniker(iface);
 802
 803     TRACE("(%p,%p)\n", iface, hash);
 804
 805     if (!hash)
 806         return E_POINTER;
 807
 808     *hash = PtrToUlong(moniker->pObject);
 809
 810     return S_OK;
 811 }
 812
 813 static HRESULT WINAPI ObjrefMonikerImpl_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *left,
 814         IMoniker *running)
 815 {
 816     FIXME("(%p,%p,%p,%p): stub\n", iface, pbc, left, running);
 817     return E_NOTIMPL;
 818 }
 819
 820 static HRESULT WINAPI ObjrefMonikerImpl_GetTimeOfLastChange(IMoniker *iface,
 821                                IBindCtx *pbc, IMoniker *left, FILETIME *time)
 822 {
 823     FIXME("(%p,%p,%p,%p): stub\n", iface, pbc, left, time);
 824     return MK_E_UNAVAILABLE;
 825 }
 826
 827 static HRESULT WINAPI ObjrefMonikerImpl_Inverse(IMoniker *iface, IMoniker **moniker)
 828 {
 829     FIXME("(%p,%p): stub\n", iface, moniker);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI ObjrefMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *other, IMoniker **prefix)
 834 {
 835     FIXME("(%p,%p,%p): stub\n", iface, other, prefix);
 836     return E_NOTIMPL;
 837 }
 838
 839 static HRESULT WINAPI ObjrefMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *other, IMoniker **result)
 840 {
 841     FIXME("(%p,%p,%p): stub\n", iface, other, result);
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI ObjrefMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc,
 846                                IMoniker *left, LPOLESTR *name)
 847 {
 848     FIXME("(%p,%p,%p,%p): stub\n", iface, pbc, left, name);
 849     return E_NOTIMPL;
 850 }
 851
 852 static HRESULT WINAPI ObjrefMonikerImpl_ParseDisplayName(IMoniker *iface, IBindCtx *pbc,
 853         IMoniker *left, LPOLESTR name, ULONG *eaten, IMoniker **out)
 854 {
 855     FIXME("(%p,%p,%p,%p,%p,%p): stub\n", iface, pbc, left, name, eaten, out);
 856     return E_NOTIMPL;
 857 }
 858
 859 static HRESULT WINAPI ObjrefMonikerImpl_IsSystemMoniker(IMoniker *iface, DWORD *mksys)
 860 {
 861     TRACE("(%p,%p)\n", iface, mksys);
 862
 863     if (!mksys)
 864         return E_POINTER;
 865
 866     *mksys = MKSYS_OBJREFMONIKER;
 867     return S_OK;
 868 }
 869
 870 static const IMonikerVtbl VT_ObjrefMonikerImpl =
 871 {
 872     ObjrefMonikerImpl_QueryInterface,
 873     ObjrefMonikerImpl_AddRef,
 874     ObjrefMonikerImpl_Release,
 875     ObjrefMonikerImpl_GetClassID,
 876     ObjrefMonikerImpl_IsDirty,
 877     ObjrefMonikerImpl_Load,
 878     ObjrefMonikerImpl_Save,
 879     ObjrefMonikerImpl_GetSizeMax,
 880     ObjrefMonikerImpl_BindToObject,
 881     ObjrefMonikerImpl_BindToStorage,
 882     ObjrefMonikerImpl_Reduce,
 883     ObjrefMonikerImpl_ComposeWith,
 884     ObjrefMonikerImpl_Enum,
 885     ObjrefMonikerImpl_IsEqual,
 886     ObjrefMonikerImpl_Hash,
 887     ObjrefMonikerImpl_IsRunning,
 888     ObjrefMonikerImpl_GetTimeOfLastChange,
 889     ObjrefMonikerImpl_Inverse,
 890     ObjrefMonikerImpl_CommonPrefixWith,
 891     ObjrefMonikerImpl_RelativePathTo,
 892     ObjrefMonikerImpl_GetDisplayName,
 893     ObjrefMonikerImpl_ParseDisplayName,
 894     ObjrefMonikerImpl_IsSystemMoniker
 895 };
 896
 897 static HRESULT WINAPI objref_moniker_marshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
 898 {
 899     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 900
 901     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 902
 903     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 904 }
 905
 906 static ULONG WINAPI objref_moniker_marshal_AddRef(IMarshal *iface)
 907 {
 908     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 909
 910     TRACE("(%p)\n", iface);
 911
 912     return IMoniker_AddRef(&moniker->IMoniker_iface);
 913 }
 914
 915 static ULONG WINAPI objref_moniker_marshal_Release(IMarshal *iface)
 916 {
 917     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 918
 919     TRACE("(%p)\n", iface);
 920
 921     return IMoniker_Release(&moniker->IMoniker_iface);
 922 }
 923
 924 static HRESULT WINAPI objref_moniker_marshal_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv,
 925         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *clsid)
 926 {
 927     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 928
 929     TRACE("%p, %s, %p, %#lx, %p, %#lx, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 930             mshlflags, clsid);
 931
 932     return IMoniker_GetClassID(&moniker->IMoniker_iface, clsid);
 933 }
 934
 935 static HRESULT WINAPI objref_moniker_marshal_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv,
 936         DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *size)
 937 {
 938     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 939
 940     TRACE("%p, %s, %p, %#lx, %p, %#lx, %p.\n", iface, debugstr_guid(riid), pv, dwDestContext, pvDestContext,
 941             mshlflags, size);
 942
 943     return CoGetMarshalSizeMax(size, &IID_IUnknown, moniker->pObject, dwDestContext, pvDestContext, mshlflags);
 944 }
 945
 946 static HRESULT WINAPI objref_moniker_marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID riid,
 947         void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 948 {
 949     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 950
 951     TRACE("%p, %s, %p, %#lx, %p, %#lx\n", stream, debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags);
 952
 953     return CoMarshalInterface(stream, &IID_IUnknown, moniker->pObject, dwDestContext, pvDestContext, mshlflags);
 954 }
 955
 956 static HRESULT WINAPI objref_moniker_marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
 957         REFIID riid, void **ppv)
 958 {
 959     ObjrefMonikerImpl *moniker = objref_impl_from_IMarshal(iface);
 960     IUnknown *object;
 961     HRESULT hr;
 962
 963     TRACE("(%p,%p,%s,%p)\n", iface, stream, debugstr_guid(riid), ppv);
 964
 965     hr = CoUnmarshalInterface(stream, &IID_IUnknown, (void **)&object);
 966     if (FAILED(hr))
 967     {
 968         ERR("Couldn't unmarshal moniker, hr = %#lx.\n", hr);
 969         return hr;
 970     }
 971
 972     if (moniker->pObject)
 973         IUnknown_Release(moniker->pObject);
 974     moniker->pObject = object;
 975
 976     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppv);
 977 }
 978
 979 static HRESULT WINAPI objref_moniker_marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
 980 {
 981     TRACE("(%p,%p)\n", iface, stream);
 982     return S_OK;
 983 }
 984
 985 static HRESULT WINAPI objref_moniker_marshal_DisconnectObject(IMarshal *iface, DWORD reserved)
 986 {
 987     TRACE("%p, %#lx.\n", iface, reserved);
 988     return S_OK;
 989 }
 990
 991 static const IMarshalVtbl objref_moniker_marshal_vtbl =
 992 {
 993     objref_moniker_marshal_QueryInterface,
 994     objref_moniker_marshal_AddRef,
 995     objref_moniker_marshal_Release,
 996     objref_moniker_marshal_GetUnmarshalClass,
 997     objref_moniker_marshal_GetMarshalSizeMax,
 998     objref_moniker_marshal_MarshalInterface,
 999     objref_moniker_marshal_UnmarshalInterface,
1000     objref_moniker_marshal_ReleaseMarshalData,
1001     objref_moniker_marshal_DisconnectObject
1002 };
1003
1004 /***********************************************************************
1005  *           CreateObjrefMoniker (OLE32.@)
1006  */
1007 HRESULT WINAPI CreateObjrefMoniker(IUnknown *obj, IMoniker **ret)
1008 {
1009     ObjrefMonikerImpl *moniker;
1010
1011     TRACE("(%p,%p)\n", obj, ret);
1012
1013     if (!ret)
1014         return E_INVALIDARG;
1015
1016     if (!(moniker = calloc(1, sizeof(*moniker))))
1017     {
1018         *ret = NULL;
1019         return E_OUTOFMEMORY;
1020     }
1021
1022     moniker->IMoniker_iface.lpVtbl = &VT_ObjrefMonikerImpl;
1023     moniker->IMarshal_iface.lpVtbl = &objref_moniker_marshal_vtbl;
1024     moniker->refcount = 1;
1025     moniker->pObject = obj;
1026     if (moniker->pObject)
1027         IUnknown_AddRef(moniker->pObject);
1028
1029     *ret = &moniker->IMoniker_iface;
1030
1031     return S_OK;
1032 }
1033
1034 HRESULT WINAPI ObjrefMoniker_CreateInstance(IClassFactory *iface, IUnknown *unk, REFIID iid, void **obj)
1035 {
1036     IMoniker *moniker;
1037     HRESULT  hr;
1038
1039     TRACE("(%p,%s,%p)\n", unk, debugstr_guid(iid), obj);
1040
1041     *obj = NULL;
1042
1043     if (unk)
1044         return CLASS_E_NOAGGREGATION;
1045
1046     hr = CreateObjrefMoniker(NULL, &moniker);
1047     if (FAILED(hr))
1048         return hr;
1049
1050     hr = IMoniker_QueryInterface(moniker, iid, obj);
1051     IMoniker_Release(moniker);
1052
1053     return hr;
1054 }