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