dlls/ole32/moniker.c

   1 /*
   2  *      Monikers
   3  *
   4  *      Copyright 1998  Marcus Meissner
   5  *      Copyright 1999  Noomen Hamza
   6  *      Copyright 2005  Robert Shearman (for CodeWeavers)
   7  *      Copyright 2007  Robert Shearman
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #define COBJMACROS
  28
  29 #include "wine/list.h"
  30 #include "wine/debug.h"
  31
  32 #include "compobj_private.h"
  33 #include "moniker.h"
  34 #include "irot.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  37
  38 /* Combase exports */
  39 BOOL WINAPI InternalIsProcessInitialized(void);
  40 HRESULT WINAPI InternalIrotRegister(const MonikerComparisonData *moniker_data,
  41         const InterfaceData *object, const InterfaceData *moniker,
  42         const FILETIME *time, DWORD flags, IrotCookie *cookie, IrotContextHandle *ctxt_handle);
  43 HRESULT WINAPI InternalIrotIsRunning(const MonikerComparisonData *moniker_data);
  44 HRESULT WINAPI InternalIrotGetObject(const MonikerComparisonData *moniker_data, PInterfaceData *obj,
  45         IrotCookie *cookie);
  46 HRESULT WINAPI InternalIrotNoteChangeTime(IrotCookie cookie, const FILETIME *time);
  47 HRESULT WINAPI InternalIrotGetTimeOfLastChange(const MonikerComparisonData *moniker_data, FILETIME *time);
  48 HRESULT WINAPI InternalIrotEnumRunning(PInterfaceList *list);
  49 HRESULT WINAPI InternalIrotRevoke(IrotCookie cookie, IrotContextHandle *ctxt_handle, PInterfaceData *object,
  50         PInterfaceData *moniker);
  51
  52 /* define the structure of the running object table elements */
  53 struct rot_entry
  54 {
  55     struct list        entry;
  56     InterfaceData* object; /* marshaled running object*/
  57     MonikerComparisonData* moniker_data; /* moniker comparison data that identifies this object */
  58     DWORD              cookie; /* cookie identifying this object */
  59     FILETIME           last_modified;
  60     IrotContextHandle  ctxt_handle;
  61 };
  62
  63 /* define the RunningObjectTableImpl structure */
  64 typedef struct RunningObjectTableImpl
  65 {
  66     IRunningObjectTable IRunningObjectTable_iface;
  67     struct list rot; /* list of ROT entries */
  68     CRITICAL_SECTION lock;
  69 } RunningObjectTableImpl;
  70
  71 /* define the EnumMonikerImpl structure */
  72 typedef struct EnumMonikerImpl
  73 {
  74     IEnumMoniker IEnumMoniker_iface;
  75     LONG ref;
  76
  77     InterfaceList *moniker_list;
  78     ULONG pos;
  79 } EnumMonikerImpl;
  80
  81 static inline RunningObjectTableImpl *impl_from_IRunningObjectTable(IRunningObjectTable *iface)
  82 {
  83     return CONTAINING_RECORD(iface, RunningObjectTableImpl, IRunningObjectTable_iface);
  84 }
  85
  86 static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface)
  87 {
  88     return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
  89 }
  90
  91 /* IEnumMoniker Local functions*/
  92 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
  93     ULONG pos, IEnumMoniker **ppenumMoniker);
  94
  95 static HRESULT create_stream_on_mip_ro(const InterfaceData *mip, IStream **stream)
  96 {
  97     HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData);
  98     void *pv = GlobalLock(hglobal);
  99     memcpy(pv, mip->abData, mip->ulCntData);
 100     GlobalUnlock(hglobal);
 101     return CreateStreamOnHGlobal(hglobal, TRUE, stream);
 102 }
 103
 104 static void rot_entry_delete(struct rot_entry *rot_entry)
 105 {
 106     if (rot_entry->cookie)
 107     {
 108         InterfaceData *object = NULL;
 109         InterfaceData *moniker = NULL;
 110
 111         InternalIrotRevoke(rot_entry->cookie, &rot_entry->ctxt_handle, &object, &moniker);
 112         MIDL_user_free(object);
 113         if (moniker)
 114         {
 115             IStream *stream;
 116             HRESULT hr;
 117             hr = create_stream_on_mip_ro(moniker, &stream);
 118             if (hr == S_OK)
 119             {
 120                 CoReleaseMarshalData(stream);
 121                 IStream_Release(stream);
 122             }
 123         }
 124         MIDL_user_free(moniker);
 125     }
 126     if (rot_entry->object)
 127     {
 128         IStream *stream;
 129         HRESULT hr;
 130         hr = create_stream_on_mip_ro(rot_entry->object, &stream);
 131         if (hr == S_OK)
 132         {
 133             CoReleaseMarshalData(stream);
 134             IStream_Release(stream);
 135         }
 136     }
 137     HeapFree(GetProcessHeap(), 0, rot_entry->object);
 138     HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
 139     HeapFree(GetProcessHeap(), 0, rot_entry);
 140 }
 141
 142 /* moniker_data must be freed with HeapFree when no longer in use */
 143 static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MonikerComparisonData **moniker_data)
 144 {
 145     HRESULT hr;
 146     IROTData *pROTData = NULL;
 147     hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
 148     if (SUCCEEDED(hr))
 149     {
 150         ULONG size = ROT_COMPARE_MAX;
 151         *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[size]));
 152         if (!*moniker_data)
 153         {
 154             IROTData_Release(pROTData);
 155             return E_OUTOFMEMORY;
 156         }
 157         hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size);
 158         IROTData_Release(pROTData);
 159         if (hr != S_OK)
 160         {
 161             ERR("Failed to copy comparison data into buffer, hr = 0x%08x\n", hr);
 162             HeapFree(GetProcessHeap(), 0, *moniker_data);
 163             return hr;
 164         }
 165         (*moniker_data)->ulCntData = size;
 166     }
 167     else
 168     {
 169         IBindCtx *pbc;
 170         LPOLESTR pszDisplayName;
 171         CLSID clsid;
 172         int len;
 173
 174         TRACE("generating comparison data from display name\n");
 175
 176         hr = CreateBindCtx(0, &pbc);
 177         if (FAILED(hr))
 178             return hr;
 179         hr = IMoniker_GetDisplayName(pMoniker, pbc, NULL, &pszDisplayName);
 180         IBindCtx_Release(pbc);
 181         if (FAILED(hr))
 182             return hr;
 183         hr = IMoniker_GetClassID(pMoniker, &clsid);
 184         if (FAILED(hr))
 185         {
 186             CoTaskMemFree(pszDisplayName);
 187             return hr;
 188         }
 189
 190         len = lstrlenW(pszDisplayName);
 191         *moniker_data = HeapAlloc(GetProcessHeap(), 0,
 192             FIELD_OFFSET(MonikerComparisonData, abData[sizeof(CLSID) + (len+1)*sizeof(WCHAR)]));
 193         if (!*moniker_data)
 194         {
 195             CoTaskMemFree(pszDisplayName);
 196             return E_OUTOFMEMORY;
 197         }
 198         (*moniker_data)->ulCntData = sizeof(CLSID) + (len+1)*sizeof(WCHAR);
 199
 200         memcpy(&(*moniker_data)->abData[0], &clsid, sizeof(clsid));
 201         memcpy(&(*moniker_data)->abData[sizeof(clsid)], pszDisplayName, (len+1)*sizeof(WCHAR));
 202         CoTaskMemFree(pszDisplayName);
 203     }
 204     return S_OK;
 205 }
 206
 207 static HRESULT reduce_moniker(IMoniker *pmk, IBindCtx *pbc, IMoniker **pmkReduced)
 208 {
 209     IBindCtx *pbcNew = NULL;
 210     HRESULT hr;
 211     if (!pbc)
 212     {
 213         hr = CreateBindCtx(0, &pbcNew);
 214         if (FAILED(hr))
 215             return hr;
 216         pbc = pbcNew;
 217     }
 218     hr = IMoniker_Reduce(pmk, pbc, MKRREDUCE_ALL, NULL, pmkReduced);
 219     if (FAILED(hr))
 220         ERR("reducing moniker failed with error 0x%08x\n", hr);
 221     if (pbcNew) IBindCtx_Release(pbcNew);
 222     return hr;
 223 }
 224
 225 /***********************************************************************
 226  *        RunningObjectTable_QueryInterface
 227  */
 228 static HRESULT WINAPI
 229 RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface,
 230                                       REFIID riid,void** ppvObject)
 231 {
 232     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 233
 234     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 235
 236     /* validate arguments */
 237
 238     if (ppvObject==0)
 239         return E_INVALIDARG;
 240
 241     *ppvObject = 0;
 242
 243     if (IsEqualIID(&IID_IUnknown, riid) ||
 244         IsEqualIID(&IID_IRunningObjectTable, riid))
 245         *ppvObject = &This->IRunningObjectTable_iface;
 246
 247     if ((*ppvObject)==0)
 248         return E_NOINTERFACE;
 249
 250     IRunningObjectTable_AddRef(iface);
 251
 252     return S_OK;
 253 }
 254
 255 static ULONG WINAPI RunningObjectTableImpl_AddRef(IRunningObjectTable *iface)
 256 {
 257     TRACE("%p\n", iface);
 258
 259     return 2;
 260 }
 261
 262 static ULONG WINAPI RunningObjectTableImpl_Release(IRunningObjectTable *iface)
 263 {
 264     TRACE("%p\n", iface);
 265
 266     return 1;
 267 }
 268
 269 /***********************************************************************
 270  *        RunningObjectTable_Register
 271  *
 272  * PARAMS
 273  * grfFlags       [in] Registration options
 274  * punkObject     [in] the object being registered
 275  * pmkObjectName  [in] the moniker of the object being registered
 276  * pdwRegister    [out] the value identifying the registration
 277  */
 278 static HRESULT WINAPI
 279 RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD flags,
 280                IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
 281 {
 282     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 283     struct rot_entry *rot_entry;
 284     HRESULT hr = S_OK;
 285     IStream *pStream = NULL;
 286     DWORD mshlflags;
 287     IBindCtx *pbc;
 288     InterfaceData *moniker = NULL;
 289
 290     TRACE("%p, %#x, %p, %p, %p\n", This, flags, punkObject, pmkObjectName, pdwRegister);
 291
 292     if (flags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
 293     {
 294         ERR("Invalid flags: 0x%08x\n", flags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
 295         return E_INVALIDARG;
 296     }
 297
 298     if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL)
 299         return E_INVALIDARG;
 300
 301     rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
 302     if (!rot_entry)
 303         return E_OUTOFMEMORY;
 304
 305     /* marshal object */
 306     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 307     if (hr != S_OK)
 308     {
 309         rot_entry_delete(rot_entry);
 310         return hr;
 311     }
 312     mshlflags = flags & ROTFLAGS_REGISTRATIONKEEPSALIVE ? MSHLFLAGS_TABLESTRONG : MSHLFLAGS_TABLEWEAK;
 313     hr = CoMarshalInterface(pStream, &IID_IUnknown, punkObject, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, mshlflags);
 314     /* FIXME: a cleaner way would be to create an IStream class that writes
 315      * directly to an MInterfacePointer */
 316     if (hr == S_OK)
 317     {
 318         HGLOBAL hglobal;
 319         hr = GetHGlobalFromStream(pStream, &hglobal);
 320         if (hr == S_OK)
 321         {
 322             SIZE_T size = GlobalSize(hglobal);
 323             const void *pv = GlobalLock(hglobal);
 324             rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
 325             rot_entry->object->ulCntData = size;
 326             memcpy(rot_entry->object->abData, pv, size);
 327             GlobalUnlock(hglobal);
 328         }
 329     }
 330     IStream_Release(pStream);
 331     if (hr != S_OK)
 332     {
 333         rot_entry_delete(rot_entry);
 334         return hr;
 335     }
 336
 337     hr = CreateBindCtx(0, &pbc);
 338     if (FAILED(hr))
 339     {
 340         rot_entry_delete(rot_entry);
 341         return hr;
 342     }
 343
 344     hr = reduce_moniker(pmkObjectName, pbc, &pmkObjectName);
 345     if (FAILED(hr))
 346     {
 347         rot_entry_delete(rot_entry);
 348         IBindCtx_Release(pbc);
 349         return hr;
 350     }
 351
 352     hr = IMoniker_GetTimeOfLastChange(pmkObjectName, pbc, NULL,
 353                                       &rot_entry->last_modified);
 354     IBindCtx_Release(pbc);
 355     if (FAILED(hr))
 356     {
 357         CoFileTimeNow(&rot_entry->last_modified);
 358         hr = S_OK;
 359     }
 360
 361     hr = get_moniker_comparison_data(pmkObjectName,
 362                                      &rot_entry->moniker_data);
 363     if (hr != S_OK)
 364     {
 365         rot_entry_delete(rot_entry);
 366         IMoniker_Release(pmkObjectName);
 367         return hr;
 368     }
 369
 370     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 371     if (hr != S_OK)
 372     {
 373         rot_entry_delete(rot_entry);
 374         IMoniker_Release(pmkObjectName);
 375         return hr;
 376     }
 377     /* marshal moniker */
 378     hr = CoMarshalInterface(pStream, &IID_IMoniker, (IUnknown *)pmkObjectName,
 379                             MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG);
 380     /* FIXME: a cleaner way would be to create an IStream class that writes
 381      * directly to an MInterfacePointer */
 382     if (hr == S_OK)
 383     {
 384         HGLOBAL hglobal;
 385         hr = GetHGlobalFromStream(pStream, &hglobal);
 386         if (hr == S_OK)
 387         {
 388             SIZE_T size = GlobalSize(hglobal);
 389             const void *pv = GlobalLock(hglobal);
 390             moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[size]));
 391             moniker->ulCntData = size;
 392             memcpy(moniker->abData, pv, size);
 393             GlobalUnlock(hglobal);
 394         }
 395     }
 396     IStream_Release(pStream);
 397     IMoniker_Release(pmkObjectName);
 398     if (hr != S_OK)
 399     {
 400         HeapFree(GetProcessHeap(), 0, moniker);
 401         rot_entry_delete(rot_entry);
 402         return hr;
 403     }
 404
 405     hr = InternalIrotRegister(rot_entry->moniker_data, rot_entry->object, moniker,
 406             &rot_entry->last_modified, flags, &rot_entry->cookie, &rot_entry->ctxt_handle);
 407
 408     HeapFree(GetProcessHeap(), 0, moniker);
 409     if (FAILED(hr))
 410     {
 411         rot_entry_delete(rot_entry);
 412         return hr;
 413     }
 414
 415     /* gives a registration identifier to the registered object*/
 416     *pdwRegister = rot_entry->cookie;
 417
 418     EnterCriticalSection(&This->lock);
 419     list_add_tail(&This->rot, &rot_entry->entry);
 420     LeaveCriticalSection(&This->lock);
 421
 422     return hr;
 423 }
 424
 425 /***********************************************************************
 426  *        RunningObjectTable_Revoke
 427  *
 428  * PARAMS
 429  *  dwRegister [in] Value identifying registration to be revoked
 430  */
 431 static HRESULT WINAPI
 432 RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister)
 433 {
 434     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 435     struct rot_entry *rot_entry;
 436
 437     TRACE("(%p,%d)\n",This,dwRegister);
 438
 439     EnterCriticalSection(&This->lock);
 440     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 441     {
 442         if (rot_entry->cookie == dwRegister)
 443         {
 444             list_remove(&rot_entry->entry);
 445             LeaveCriticalSection(&This->lock);
 446
 447             rot_entry_delete(rot_entry);
 448             return S_OK;
 449         }
 450     }
 451     LeaveCriticalSection(&This->lock);
 452
 453     return E_INVALIDARG;
 454 }
 455
 456 /***********************************************************************
 457  *        RunningObjectTable_IsRunning
 458  *
 459  * PARAMS
 460  *  pmkObjectName [in]  moniker of the object whose status is desired
 461  */
 462 static HRESULT WINAPI
 463 RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName)
 464 {
 465     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 466     MonikerComparisonData *moniker_data;
 467     HRESULT hr;
 468     const struct rot_entry *rot_entry;
 469
 470     TRACE("(%p,%p)\n",This,pmkObjectName);
 471
 472     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 473     if (FAILED(hr))
 474         return hr;
 475     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 476     IMoniker_Release(pmkObjectName);
 477     if (hr != S_OK)
 478         return hr;
 479
 480     hr = S_FALSE;
 481     EnterCriticalSection(&This->lock);
 482     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
 483     {
 484         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 485             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 486         {
 487             hr = S_OK;
 488             break;
 489         }
 490     }
 491     LeaveCriticalSection(&This->lock);
 492
 493     if (hr == S_FALSE)
 494         hr = InternalIrotIsRunning(moniker_data);
 495
 496     HeapFree(GetProcessHeap(), 0, moniker_data);
 497
 498     return hr;
 499 }
 500
 501 /***********************************************************************
 502  *        RunningObjectTable_GetObject
 503  *
 504  * PARAMS
 505  * pmkObjectName [in] Pointer to the moniker on the object
 506  * ppunkObject   [out] variable that receives the IUnknown interface pointer
 507  */
 508 static HRESULT WINAPI
 509 RunningObjectTableImpl_GetObject( IRunningObjectTable* iface,
 510                      IMoniker *pmkObjectName, IUnknown **ppunkObject)
 511 {
 512     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 513     MonikerComparisonData *moniker_data;
 514     InterfaceData *object = NULL;
 515     IrotCookie cookie;
 516     HRESULT hr;
 517     struct rot_entry *rot_entry;
 518
 519     TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
 520
 521     if (ppunkObject == NULL)
 522         return E_POINTER;
 523
 524     *ppunkObject = NULL;
 525
 526     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 527     if (FAILED(hr))
 528         return hr;
 529     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 530     IMoniker_Release(pmkObjectName);
 531     if (hr != S_OK)
 532         return hr;
 533
 534     EnterCriticalSection(&This->lock);
 535     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 536     {
 537         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 538             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 539         {
 540             IStream *pStream;
 541             hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
 542             if (hr == S_OK)
 543             {
 544                 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
 545                 IStream_Release(pStream);
 546             }
 547
 548             LeaveCriticalSection(&This->lock);
 549             HeapFree(GetProcessHeap(), 0, moniker_data);
 550
 551             return hr;
 552         }
 553     }
 554     LeaveCriticalSection(&This->lock);
 555
 556     TRACE("moniker unavailable locally, calling SCM\n");
 557
 558     hr = InternalIrotGetObject(moniker_data, &object, &cookie);
 559     if (SUCCEEDED(hr))
 560     {
 561         IStream *pStream;
 562         hr = create_stream_on_mip_ro(object, &pStream);
 563         if (hr == S_OK)
 564         {
 565             hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
 566             IStream_Release(pStream);
 567         }
 568     }
 569     else
 570         WARN("Moniker unavailable, IrotGetObject returned 0x%08x\n", hr);
 571
 572     HeapFree(GetProcessHeap(), 0, moniker_data);
 573
 574     return hr;
 575 }
 576
 577 /***********************************************************************
 578  *        RunningObjectTable_NoteChangeTime
 579  *
 580  * PARAMS
 581  *  dwRegister [in] Value identifying registration being updated
 582  *  pfiletime  [in] Pointer to structure containing object's last change time
 583  */
 584 static HRESULT WINAPI
 585 RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface,
 586                                       DWORD dwRegister, FILETIME *pfiletime)
 587 {
 588     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 589     struct rot_entry *rot_entry;
 590     HRESULT hr = E_INVALIDARG;
 591
 592     TRACE("(%p,%d,%p)\n",This,dwRegister,pfiletime);
 593
 594     EnterCriticalSection(&This->lock);
 595     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 596     {
 597         if (rot_entry->cookie == dwRegister)
 598         {
 599             rot_entry->last_modified = *pfiletime;
 600             LeaveCriticalSection(&This->lock);
 601
 602             hr = InternalIrotNoteChangeTime(dwRegister, pfiletime);
 603
 604             goto done;
 605         }
 606     }
 607     LeaveCriticalSection(&This->lock);
 608
 609 done:
 610     TRACE("-- 0x08%x\n", hr);
 611     return hr;
 612 }
 613
 614 /***********************************************************************
 615  *        RunningObjectTable_GetTimeOfLastChange
 616  *
 617  * PARAMS
 618  *  pmkObjectName  [in]  moniker of the object whose status is desired
 619  *  pfiletime      [out] structure that receives object's last change time
 620  */
 621 static HRESULT WINAPI
 622 RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface,
 623                             IMoniker *pmkObjectName, FILETIME *pfiletime)
 624 {
 625     HRESULT hr = MK_E_UNAVAILABLE;
 626     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 627     MonikerComparisonData *moniker_data;
 628     const struct rot_entry *rot_entry;
 629
 630     TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
 631
 632     if (pmkObjectName==NULL || pfiletime==NULL)
 633         return E_INVALIDARG;
 634
 635     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 636     if (FAILED(hr))
 637         return hr;
 638     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 639     IMoniker_Release(pmkObjectName);
 640     if (hr != S_OK)
 641         return hr;
 642
 643     hr = MK_E_UNAVAILABLE;
 644
 645     EnterCriticalSection(&This->lock);
 646     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
 647     {
 648         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 649             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 650         {
 651             *pfiletime = rot_entry->last_modified;
 652             hr = S_OK;
 653             break;
 654         }
 655     }
 656     LeaveCriticalSection(&This->lock);
 657
 658     if (hr != S_OK)
 659         hr = InternalIrotGetTimeOfLastChange(moniker_data, pfiletime);
 660
 661     HeapFree(GetProcessHeap(), 0, moniker_data);
 662
 663     TRACE("-- 0x%08x\n", hr);
 664     return hr;
 665 }
 666
 667 /***********************************************************************
 668  *        RunningObjectTable_EnumRunning
 669  *
 670  * PARAMS
 671  *  ppenumMoniker  [out]  receives the IEnumMoniker interface pointer
 672  */
 673 static HRESULT WINAPI
 674 RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface,
 675                                    IEnumMoniker **ppenumMoniker)
 676 {
 677     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 678     InterfaceList *interface_list = NULL;
 679     HRESULT hr;
 680
 681     TRACE("(%p, %p)\n", This, ppenumMoniker);
 682
 683     *ppenumMoniker = NULL;
 684
 685     hr = InternalIrotEnumRunning(&interface_list);
 686     if (SUCCEEDED(hr))
 687         hr = EnumMonikerImpl_CreateEnumROTMoniker(interface_list, 0, ppenumMoniker);
 688
 689     return hr;
 690 }
 691
 692 /* Virtual function table for the IRunningObjectTable class. */
 693 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl =
 694 {
 695     RunningObjectTableImpl_QueryInterface,
 696     RunningObjectTableImpl_AddRef,
 697     RunningObjectTableImpl_Release,
 698     RunningObjectTableImpl_Register,
 699     RunningObjectTableImpl_Revoke,
 700     RunningObjectTableImpl_IsRunning,
 701     RunningObjectTableImpl_GetObject,
 702     RunningObjectTableImpl_NoteChangeTime,
 703     RunningObjectTableImpl_GetTimeOfLastChange,
 704     RunningObjectTableImpl_EnumRunning
 705 };
 706
 707 static RunningObjectTableImpl rot =
 708 {
 709     .IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl,
 710     .lock.LockCount = -1,
 711     .rot = LIST_INIT(rot.rot),
 712 };
 713
 714 /***********************************************************************
 715  *           GetRunningObjectTable (OLE32.@)
 716  */
 717 HRESULT WINAPI GetRunningObjectTable(DWORD reserved, IRunningObjectTable **ret)
 718 {
 719     TRACE("%#x, %p\n", reserved, ret);
 720
 721     if (reserved!=0)
 722         return E_UNEXPECTED;
 723
 724     if (!InternalIsProcessInitialized())
 725         return CO_E_NOTINITIALIZED;
 726
 727     *ret = &rot.IRunningObjectTable_iface;
 728     IRunningObjectTable_AddRef(*ret);
 729
 730     return S_OK;
 731 }
 732
 733 /***********************************************************************
 734  *        DestroyRunningObjectTable    (ole32.@)
 735 */
 736 void WINAPI DestroyRunningObjectTable(void)
 737 {
 738     struct rot_entry *rot_entry, *cursor2;
 739
 740     TRACE("\n");
 741
 742     EnterCriticalSection(&rot.lock);
 743     LIST_FOR_EACH_ENTRY_SAFE(rot_entry, cursor2, &rot.rot, struct rot_entry, entry)
 744     {
 745         list_remove(&rot_entry->entry);
 746         rot_entry_delete(rot_entry);
 747     }
 748     LeaveCriticalSection(&rot.lock);
 749 }
 750
 751 static HRESULT get_moniker_for_progid_display_name(LPBC pbc,
 752                                                    LPCOLESTR szDisplayName,
 753                                                    LPDWORD pchEaten,
 754                                                    LPMONIKER *ppmk)
 755 {
 756     CLSID clsid;
 757     HRESULT hr;
 758     LPWSTR progid;
 759     LPCWSTR start = szDisplayName;
 760     LPCWSTR end;
 761     int len;
 762     IMoniker *class_moniker;
 763
 764     if (*start == '@')
 765         start++;
 766
 767     /* find end delimiter */
 768     for (end = start; *end; end++)
 769         if (*end == ':')
 770             break;
 771
 772     len = end - start;
 773
 774     /* must start with '@' or have a ':' somewhere and mustn't be one character
 775      * long (since that looks like an absolute path) */
 776     if (((start == szDisplayName) && (*end == '\0')) || (len <= 1))
 777         return MK_E_SYNTAX;
 778
 779     progid = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 780     if (progid)
 781     {
 782         memcpy(progid, start, len * sizeof(WCHAR));
 783         progid[len] = '\0';
 784     }
 785     hr = CLSIDFromProgID(progid, &clsid);
 786     HeapFree(GetProcessHeap(), 0, progid);
 787     if (FAILED(hr))
 788         return MK_E_SYNTAX;
 789
 790     hr = CreateClassMoniker(&clsid, &class_moniker);
 791     if (SUCCEEDED(hr))
 792     {
 793         IParseDisplayName *pdn;
 794         hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
 795                                    &IID_IParseDisplayName, (void **)&pdn);
 796         /* fallback to using IClassFactory to get IParseDisplayName -
 797          * adsldp.dll depends on this */
 798         if (FAILED(hr))
 799         {
 800             IClassFactory *pcf;
 801             hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
 802                                        &IID_IClassFactory, (void **)&pcf);
 803             if (SUCCEEDED(hr))
 804             {
 805                 hr = IClassFactory_CreateInstance(pcf, NULL,
 806                                                   &IID_IParseDisplayName,
 807                                                   (void **)&pdn);
 808                 IClassFactory_Release(pcf);
 809             }
 810         }
 811         IMoniker_Release(class_moniker);
 812         if (SUCCEEDED(hr))
 813         {
 814             hr = IParseDisplayName_ParseDisplayName(pdn, pbc,
 815                                                     (LPOLESTR)szDisplayName,
 816                                                     pchEaten, ppmk);
 817             IParseDisplayName_Release(pdn);
 818         }
 819     }
 820     return hr;
 821 }
 822
 823 /******************************************************************************
 824  *              MkParseDisplayName        [OLE32.@]
 825  */
 826 HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
 827                                 LPDWORD pchEaten, LPMONIKER *ppmk)
 828 {
 829     HRESULT hr = MK_E_SYNTAX;
 830     static const WCHAR wszClsidColon[] = {'c','l','s','i','d',':'};
 831     IMoniker *moniker;
 832     DWORD chEaten;
 833
 834     TRACE("(%p, %s, %p, %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
 835
 836     if (!pbc || !IsValidInterface((LPUNKNOWN) pbc))
 837         return E_INVALIDARG;
 838
 839     if (!szDisplayName || !*szDisplayName)
 840         return E_INVALIDARG;
 841
 842     if (!pchEaten || !ppmk)
 843         return E_INVALIDARG;
 844
 845     *pchEaten = 0;
 846     *ppmk = NULL;
 847
 848     if (!wcsnicmp(szDisplayName, wszClsidColon, ARRAY_SIZE(wszClsidColon)))
 849     {
 850         hr = ClassMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
 851         if (FAILED(hr) && (hr != MK_E_SYNTAX))
 852             return hr;
 853     }
 854     else
 855     {
 856         hr = get_moniker_for_progid_display_name(pbc, szDisplayName, &chEaten, &moniker);
 857         if (FAILED(hr) && (hr != MK_E_SYNTAX))
 858             return hr;
 859     }
 860
 861     if (FAILED(hr))
 862     {
 863         hr = FileMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
 864         if (FAILED(hr) && (hr != MK_E_SYNTAX))
 865             return hr;
 866     }
 867
 868     if (SUCCEEDED(hr))
 869     {
 870         while (TRUE)
 871         {
 872             IMoniker *next_moniker;
 873             *pchEaten += chEaten;
 874             szDisplayName += chEaten;
 875             if (!*szDisplayName)
 876             {
 877                 *ppmk = moniker;
 878                 return S_OK;
 879             }
 880             chEaten = 0;
 881             hr = IMoniker_ParseDisplayName(moniker, pbc, NULL,
 882                                            (LPOLESTR)szDisplayName, &chEaten,
 883                                            &next_moniker);
 884             IMoniker_Release(moniker);
 885             if (FAILED(hr))
 886             {
 887                 *pchEaten = 0;
 888                 break;
 889             }
 890             moniker = next_moniker;
 891         }
 892     }
 893
 894     return hr;
 895 }
 896
 897 /***********************************************************************
 898  *        GetClassFile (OLE32.@)
 899  *
 900  * Retrieves the class ID associated with the given filename.
 901  *
 902  * PARAMS
 903  *  filePathName [I] Filename to retrieve the class ID for.
 904  *  pclsid       [O] Address that receives the class ID for the file.
 905  *
 906  * RETURNS
 907  *  Success: S_OK.
 908  *  Failure: Any HRESULT code.
 909  */
 910 HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid)
 911 {
 912     IStorage *pstg=0;
 913     HRESULT res;
 914     int nbElm, length, i;
 915     LONG sizeProgId, ret;
 916     LPOLESTR *pathDec=0,absFile=0,progId=0;
 917     LPWSTR extension;
 918     static const WCHAR bkslashW[] = {'\\',0};
 919     static const WCHAR dotW[] = {'.',0};
 920
 921     TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
 922
 923     /* if the file contain a storage object the return the CLSID written by IStorage_SetClass method*/
 924     if((StgIsStorageFile(filePathName))==S_OK){
 925
 926         res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
 927
 928         if (SUCCEEDED(res)) {
 929             res=ReadClassStg(pstg,pclsid);
 930             IStorage_Release(pstg);
 931         }
 932
 933         return res;
 934     }
 935     /* If the file is not a storage object then attempt to match various bits in the file against a
 936        pattern in the registry. This case is not frequently used, so I present only the pseudocode for
 937        this case.
 938
 939      for(i=0;i<nFileTypes;i++)
 940
 941         for(i=0;j<nPatternsForType;j++){
 942
 943             PATTERN pat;
 944             HANDLE  hFile;
 945
 946             pat=ReadPatternFromRegistry(i,j);
 947             hFile=CreateFileW(filePathName,,,,,,hFile);
 948             SetFilePosition(hFile,pat.offset);
 949             ReadFile(hFile,buf,pat.size,&r,NULL);
 950             if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
 951
 952                 *pclsid=ReadCLSIDFromRegistry(i);
 953                 return S_OK;
 954             }
 955         }
 956      */
 957
 958     /* if the above strategies fail then search for the extension key in the registry */
 959
 960     /* get the last element (absolute file) in the path name */
 961     nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
 962     absFile=pathDec[nbElm-1];
 963
 964     /* failed if the path represents a directory and not an absolute file name*/
 965     if (!wcscmp(absFile, bkslashW)) {
 966         CoTaskMemFree(pathDec);
 967         return MK_E_INVALIDEXTENSION;
 968     }
 969
 970     /* get the extension of the file */
 971     extension = NULL;
 972     length=lstrlenW(absFile);
 973     for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
 974         /* nothing */;
 975
 976     if (!extension || !wcscmp(extension, dotW)) {
 977         CoTaskMemFree(pathDec);
 978         return MK_E_INVALIDEXTENSION;
 979     }
 980
 981     ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
 982     if (!ret) {
 983         /* get the progId associated to the extension */
 984         progId = CoTaskMemAlloc(sizeProgId);
 985         ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
 986         if (!ret)
 987             /* return the clsid associated to the progId */
 988             res = CLSIDFromProgID(progId, pclsid);
 989         else
 990             res = HRESULT_FROM_WIN32(ret);
 991         CoTaskMemFree(progId);
 992     }
 993     else
 994         res = HRESULT_FROM_WIN32(ret);
 995
 996     for(i=0; pathDec[i]!=NULL;i++)
 997         CoTaskMemFree(pathDec[i]);
 998     CoTaskMemFree(pathDec);
 999
1000     return res != S_OK ? MK_E_INVALIDEXTENSION : res;
1001 }
1002
1003 /***********************************************************************
1004  *        EnumMoniker_QueryInterface
1005  */
1006 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1007 {
1008     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1009
1010     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
1011
1012     /* validate arguments */
1013     if (ppvObject == NULL)
1014         return E_INVALIDARG;
1015
1016     *ppvObject = NULL;
1017
1018     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
1019         *ppvObject = &This->IEnumMoniker_iface;
1020     else
1021         return E_NOINTERFACE;
1022
1023     IEnumMoniker_AddRef(iface);
1024     return S_OK;
1025 }
1026
1027 /***********************************************************************
1028  *        EnumMoniker_AddRef
1029  */
1030 static ULONG   WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1031 {
1032     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1033
1034     TRACE("(%p)\n",This);
1035
1036     return InterlockedIncrement(&This->ref);
1037 }
1038
1039 /***********************************************************************
1040  *        EnumMoniker_release
1041  */
1042 static ULONG   WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
1043 {
1044     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1045     ULONG ref;
1046
1047     TRACE("(%p)\n",This);
1048
1049     ref = InterlockedDecrement(&This->ref);
1050
1051     /* uninitialize ROT structure if there are no more references to it */
1052     if (ref == 0)
1053     {
1054         ULONG i;
1055
1056         TRACE("(%p) Deleting\n",This);
1057
1058         for (i = 0; i < This->moniker_list->size; i++)
1059             HeapFree(GetProcessHeap(), 0, This->moniker_list->interfaces[i]);
1060         HeapFree(GetProcessHeap(), 0, This->moniker_list);
1061         HeapFree(GetProcessHeap(), 0, This);
1062     }
1063
1064     return ref;
1065 }
1066 /***********************************************************************
1067  *        EnumMoniker_Next
1068  */
1069 static HRESULT   WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
1070 {
1071     ULONG i;
1072     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1073     HRESULT hr = S_OK;
1074
1075     TRACE("(%p) TabCurrentPos %d Tablastindx %d\n", This, This->pos, This->moniker_list->size);
1076
1077     /* retrieve the requested number of moniker from the current position */
1078     for(i = 0; (This->pos < This->moniker_list->size) && (i < celt); i++)
1079     {
1080         IStream *stream;
1081         hr = create_stream_on_mip_ro(This->moniker_list->interfaces[This->pos++], &stream);
1082         if (hr != S_OK) break;
1083         hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]);
1084         IStream_Release(stream);
1085         if (hr != S_OK) break;
1086     }
1087
1088     if (pceltFetched != NULL)
1089         *pceltFetched= i;
1090
1091     if (hr != S_OK)
1092         return hr;
1093
1094     if (i == celt)
1095         return S_OK;
1096     else
1097         return S_FALSE;
1098
1099 }
1100
1101 /***********************************************************************
1102  *        EnumMoniker_Skip
1103  */
1104 static HRESULT   WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
1105 {
1106     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1107
1108     TRACE("(%p)\n",This);
1109
1110     if  (This->pos + celt >= This->moniker_list->size)
1111         return S_FALSE;
1112
1113     This->pos += celt;
1114
1115     return S_OK;
1116 }
1117
1118 /***********************************************************************
1119  *        EnumMoniker_Reset
1120  */
1121 static HRESULT   WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
1122 {
1123     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1124
1125     This->pos = 0;      /* set back to start of list */
1126
1127     TRACE("(%p)\n",This);
1128
1129     return S_OK;
1130 }
1131
1132 /***********************************************************************
1133  *        EnumMoniker_Clone
1134  */
1135 static HRESULT   WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
1136 {
1137     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1138     InterfaceList *moniker_list;
1139     ULONG i;
1140
1141     TRACE("(%p)\n",This);
1142
1143     *ppenum = NULL;
1144
1145     moniker_list = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceList, interfaces[This->moniker_list->size]));
1146     if (!moniker_list)
1147         return E_OUTOFMEMORY;
1148
1149     moniker_list->size = This->moniker_list->size;
1150     for (i = 0; i < This->moniker_list->size; i++)
1151     {
1152         SIZE_T size = FIELD_OFFSET(InterfaceData, abData[This->moniker_list->interfaces[i]->ulCntData]);
1153         moniker_list->interfaces[i] = HeapAlloc(GetProcessHeap(), 0, size);
1154         if (!moniker_list->interfaces[i])
1155         {
1156             ULONG end = i;
1157             for (i = 0; i < end; i++)
1158                 HeapFree(GetProcessHeap(), 0, moniker_list->interfaces[i]);
1159             HeapFree(GetProcessHeap(), 0, moniker_list);
1160             return E_OUTOFMEMORY;
1161         }
1162         memcpy(moniker_list->interfaces[i], This->moniker_list->interfaces[i], size);
1163     }
1164
1165     /* copy the enum structure */
1166     return EnumMonikerImpl_CreateEnumROTMoniker(moniker_list, This->pos, ppenum);
1167 }
1168
1169 /* Virtual function table for the IEnumMoniker class. */
1170 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1171 {
1172     EnumMonikerImpl_QueryInterface,
1173     EnumMonikerImpl_AddRef,
1174     EnumMonikerImpl_Release,
1175     EnumMonikerImpl_Next,
1176     EnumMonikerImpl_Skip,
1177     EnumMonikerImpl_Reset,
1178     EnumMonikerImpl_Clone
1179 };
1180
1181 /***********************************************************************
1182  *        EnumMonikerImpl_CreateEnumROTMoniker
1183  *        Used by EnumRunning to create the structure and EnumClone
1184  *        to copy the structure
1185  */
1186 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
1187                                                  ULONG current_pos,
1188                                                  IEnumMoniker **ppenumMoniker)
1189 {
1190     EnumMonikerImpl* This = NULL;
1191
1192     if (!ppenumMoniker)
1193         return E_INVALIDARG;
1194
1195     This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1196     if (!This) return E_OUTOFMEMORY;
1197
1198     TRACE("(%p)\n", This);
1199
1200     /* initialize the virtual table function */
1201     This->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1202
1203     /* the initial reference is set to "1" */
1204     This->ref = 1;                      /* set the ref count to one         */
1205     This->pos = current_pos;            /* Set the list start posn */
1206     This->moniker_list = moniker_list;
1207
1208     *ppenumMoniker =  &This->IEnumMoniker_iface;
1209
1210     return S_OK;
1211 }
1212
1213
1214 /* Shared implementation of moniker marshaler based on saving and loading of
1215  * monikers */
1216
1217 typedef struct MonikerMarshal
1218 {
1219     IUnknown IUnknown_iface;
1220     IMarshal IMarshal_iface;
1221
1222     LONG ref;
1223     IMoniker *moniker;
1224 } MonikerMarshal;
1225
1226 static inline MonikerMarshal *impl_from_IUnknown(IUnknown *iface)
1227 {
1228     return CONTAINING_RECORD(iface, MonikerMarshal, IUnknown_iface);
1229 }
1230
1231 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
1232 {
1233     return CONTAINING_RECORD(iface, MonikerMarshal, IMarshal_iface);
1234 }
1235
1236 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
1237 {
1238     MonikerMarshal *This = impl_from_IUnknown(iface);
1239     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1240     *ppv = NULL;
1241     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
1242     {
1243         *ppv = &This->IMarshal_iface;
1244         IMarshal_AddRef(&This->IMarshal_iface);
1245         return S_OK;
1246     }
1247     FIXME("No interface for %s\n", debugstr_guid(riid));
1248     return E_NOINTERFACE;
1249 }
1250
1251 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1252 {
1253     MonikerMarshal *This = impl_from_IUnknown(iface);
1254     return InterlockedIncrement(&This->ref);
1255 }
1256
1257 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1258 {
1259     MonikerMarshal *This = impl_from_IUnknown(iface);
1260     ULONG ref = InterlockedDecrement(&This->ref);
1261
1262     if (!ref) HeapFree(GetProcessHeap(), 0, This);
1263     return ref;
1264 }
1265
1266 static const IUnknownVtbl VT_MonikerMarshalInner =
1267 {
1268     MonikerMarshalInner_QueryInterface,
1269     MonikerMarshalInner_AddRef,
1270     MonikerMarshalInner_Release
1271 };
1272
1273 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1274 {
1275     MonikerMarshal *This = impl_from_IMarshal(iface);
1276     return IMoniker_QueryInterface(This->moniker, riid, ppv);
1277 }
1278
1279 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1280 {
1281     MonikerMarshal *This = impl_from_IMarshal(iface);
1282     return IMoniker_AddRef(This->moniker);
1283 }
1284
1285 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1286 {
1287     MonikerMarshal *This = impl_from_IMarshal(iface);
1288     return IMoniker_Release(This->moniker);
1289 }
1290
1291 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1292   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1293   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1294 {
1295     MonikerMarshal *This = impl_from_IMarshal(iface);
1296
1297     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1298         dwDestContext, pvDestContext, mshlflags, pCid);
1299
1300     return IMoniker_GetClassID(This->moniker, pCid);
1301 }
1302
1303 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1304   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1305   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1306 {
1307     MonikerMarshal *This = impl_from_IMarshal(iface);
1308     HRESULT hr;
1309     ULARGE_INTEGER size;
1310
1311     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1312         dwDestContext, pvDestContext, mshlflags, pSize);
1313
1314     hr = IMoniker_GetSizeMax(This->moniker, &size);
1315     if (hr == S_OK)
1316         *pSize = (DWORD)size.QuadPart;
1317     return hr;
1318 }
1319
1320 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm,
1321     REFIID riid, void* pv, DWORD dwDestContext,
1322     void* pvDestContext, DWORD mshlflags)
1323 {
1324     MonikerMarshal *This = impl_from_IMarshal(iface);
1325
1326     TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1327         dwDestContext, pvDestContext, mshlflags);
1328
1329     return IMoniker_Save(This->moniker, pStm, FALSE);
1330 }
1331
1332 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1333 {
1334     MonikerMarshal *This = impl_from_IMarshal(iface);
1335     HRESULT hr;
1336
1337     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1338
1339     hr = IMoniker_Load(This->moniker, pStm);
1340     if (hr == S_OK)
1341         hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1342     return hr;
1343 }
1344
1345 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1346 {
1347     TRACE("()\n");
1348     /* can't release a state-based marshal as nothing on server side to
1349      * release */
1350     return S_OK;
1351 }
1352
1353 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1354 {
1355     TRACE("()\n");
1356     /* can't disconnect a state-based marshal as nothing on server side to
1357      * disconnect from */
1358     return S_OK;
1359 }
1360
1361 static const IMarshalVtbl VT_MonikerMarshal =
1362 {
1363     MonikerMarshal_QueryInterface,
1364     MonikerMarshal_AddRef,
1365     MonikerMarshal_Release,
1366     MonikerMarshal_GetUnmarshalClass,
1367     MonikerMarshal_GetMarshalSizeMax,
1368     MonikerMarshal_MarshalInterface,
1369     MonikerMarshal_UnmarshalInterface,
1370     MonikerMarshal_ReleaseMarshalData,
1371     MonikerMarshal_DisconnectObject
1372 };
1373
1374 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1375 {
1376     MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1377     if (!This) return E_OUTOFMEMORY;
1378
1379     This->IUnknown_iface.lpVtbl = &VT_MonikerMarshalInner;
1380     This->IMarshal_iface.lpVtbl = &VT_MonikerMarshal;
1381     This->ref = 1;
1382     This->moniker = inner;
1383
1384     *outer = &This->IUnknown_iface;
1385     return S_OK;
1386 }
1387
1388 void * __RPC_USER MIDL_user_allocate(SIZE_T size)
1389 {
1390     return HeapAlloc(GetProcessHeap(), 0, size);
1391 }
1392
1393 void __RPC_USER MIDL_user_free(void *p)
1394 {
1395     HeapFree(GetProcessHeap(), 0, p);
1396 }