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 "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <string.h>
  29
  30 #define COBJMACROS
  31
  32 #include "winerror.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winuser.h"
  36 #include "wtypes.h"
  37 #include "ole2.h"
  38
  39 #include "wine/list.h"
  40 #include "wine/debug.h"
  41 #include "wine/unicode.h"
  42 #include "wine/exception.h"
  43
  44 #include "compobj_private.h"
  45 #include "moniker.h"
  46 #include "irot.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  49
  50 /* see MSDN docs for IROTData::GetComparisonData, which states what this
  51  * constant is
  52  */
  53 #define MAX_COMPARISON_DATA 2048
  54
  55 static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
  56 {
  57     return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode);
  58 }
  59
  60 /* define the structure of the running object table elements */
  61 struct rot_entry
  62 {
  63     struct list        entry;
  64     InterfaceData* object; /* marshaled running object*/
  65     MonikerComparisonData* moniker_data; /* moniker comparison data that identifies this object */
  66     DWORD              cookie; /* cookie identifying this object */
  67     FILETIME           last_modified;
  68     IrotContextHandle  ctxt_handle;
  69 };
  70
  71 /* define the RunningObjectTableImpl structure */
  72 typedef struct RunningObjectTableImpl
  73 {
  74     IRunningObjectTable IRunningObjectTable_iface;
  75     LONG ref;
  76
  77     struct list rot; /* list of ROT entries */
  78     CRITICAL_SECTION lock;
  79 } RunningObjectTableImpl;
  80
  81 static RunningObjectTableImpl* runningObjectTableInstance = NULL;
  82 static IrotHandle irot_handle;
  83
  84 /* define the EnumMonikerImpl structure */
  85 typedef struct EnumMonikerImpl
  86 {
  87     IEnumMoniker IEnumMoniker_iface;
  88     LONG ref;
  89
  90     InterfaceList *moniker_list;
  91     ULONG pos;
  92 } EnumMonikerImpl;
  93
  94 static inline RunningObjectTableImpl *impl_from_IRunningObjectTable(IRunningObjectTable *iface)
  95 {
  96     return CONTAINING_RECORD(iface, RunningObjectTableImpl, IRunningObjectTable_iface);
  97 }
  98
  99 static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface)
 100 {
 101     return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
 102 }
 103
 104 /* IEnumMoniker Local functions*/
 105 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
 106     ULONG pos, IEnumMoniker **ppenumMoniker);
 107
 108 static IrotHandle get_irot_handle(void)
 109 {
 110     if (!irot_handle)
 111     {
 112         RPC_STATUS status;
 113         RPC_WSTR binding;
 114         IrotHandle new_handle;
 115         unsigned short ncacn_np[] = IROT_PROTSEQ;
 116         unsigned short endpoint[] = IROT_ENDPOINT;
 117         status = RpcStringBindingComposeW(NULL, ncacn_np, NULL, endpoint, NULL, &binding);
 118         if (status == RPC_S_OK)
 119         {
 120             status = RpcBindingFromStringBindingW(binding, &new_handle);
 121             RpcStringFreeW(&binding);
 122         }
 123         if (status != RPC_S_OK)
 124             return NULL;
 125         if (InterlockedCompareExchangePointer(&irot_handle, new_handle, NULL))
 126             /* another thread beat us to it */
 127             RpcBindingFree(&new_handle);
 128     }
 129     return irot_handle;
 130 }
 131
 132 static BOOL start_rpcss(void)
 133 {
 134     PROCESS_INFORMATION pi;
 135     STARTUPINFOW si;
 136     WCHAR cmd[MAX_PATH];
 137     static const WCHAR rpcss[] = {'\\','r','p','c','s','s','.','e','x','e',0};
 138     BOOL rslt;
 139     void *redir;
 140
 141     TRACE("\n");
 142
 143     ZeroMemory(&si, sizeof(STARTUPINFOA));
 144     si.cb = sizeof(STARTUPINFOA);
 145     GetSystemDirectoryW( cmd, MAX_PATH - sizeof(rpcss)/sizeof(WCHAR) );
 146     strcatW( cmd, rpcss );
 147
 148     Wow64DisableWow64FsRedirection( &redir );
 149     rslt = CreateProcessW( cmd, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi );
 150     Wow64RevertWow64FsRedirection( redir );
 151
 152     if (rslt)
 153     {
 154         CloseHandle(pi.hProcess);
 155         CloseHandle(pi.hThread);
 156         Sleep(100);
 157     }
 158
 159     return rslt;
 160 }
 161
 162 static HRESULT create_stream_on_mip_ro(const InterfaceData *mip, IStream **stream)
 163 {
 164     HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData);
 165     void *pv = GlobalLock(hglobal);
 166     memcpy(pv, mip->abData, mip->ulCntData);
 167     GlobalUnlock(hglobal);
 168     return CreateStreamOnHGlobal(hglobal, TRUE, stream);
 169 }
 170
 171 static void rot_entry_delete(struct rot_entry *rot_entry)
 172 {
 173     if (rot_entry->cookie)
 174     {
 175         InterfaceData *object = NULL;
 176         InterfaceData *moniker = NULL;
 177         __TRY
 178         {
 179             IrotRevoke(get_irot_handle(), rot_entry->cookie,
 180                        &rot_entry->ctxt_handle, &object, &moniker);
 181         }
 182         __EXCEPT(rpc_filter)
 183         {
 184         }
 185         __ENDTRY
 186         MIDL_user_free(object);
 187         if (moniker)
 188         {
 189             IStream *stream;
 190             HRESULT hr;
 191             hr = create_stream_on_mip_ro(moniker, &stream);
 192             if (hr == S_OK)
 193             {
 194                 CoReleaseMarshalData(stream);
 195                 IStream_Release(stream);
 196             }
 197         }
 198         MIDL_user_free(moniker);
 199     }
 200     if (rot_entry->object)
 201     {
 202         IStream *stream;
 203         HRESULT hr;
 204         hr = create_stream_on_mip_ro(rot_entry->object, &stream);
 205         if (hr == S_OK)
 206         {
 207             CoReleaseMarshalData(stream);
 208             IStream_Release(stream);
 209         }
 210     }
 211     HeapFree(GetProcessHeap(), 0, rot_entry->object);
 212     HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
 213     HeapFree(GetProcessHeap(), 0, rot_entry);
 214 }
 215
 216 /* moniker_data must be freed with HeapFree when no longer in use */
 217 static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MonikerComparisonData **moniker_data)
 218 {
 219     HRESULT hr;
 220     IROTData *pROTData = NULL;
 221     hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
 222     if (SUCCEEDED(hr))
 223     {
 224         ULONG size = MAX_COMPARISON_DATA;
 225         *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[size]));
 226         if (!*moniker_data)
 227         {
 228             IROTData_Release(pROTData);
 229             return E_OUTOFMEMORY;
 230         }
 231         hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size);
 232         IROTData_Release(pROTData);
 233         if (hr != S_OK)
 234         {
 235             ERR("Failed to copy comparison data into buffer, hr = 0x%08x\n", hr);
 236             HeapFree(GetProcessHeap(), 0, *moniker_data);
 237             return hr;
 238         }
 239         (*moniker_data)->ulCntData = size;
 240     }
 241     else
 242     {
 243         IBindCtx *pbc;
 244         LPOLESTR pszDisplayName;
 245         CLSID clsid;
 246         int len;
 247
 248         TRACE("generating comparison data from display name\n");
 249
 250         hr = CreateBindCtx(0, &pbc);
 251         if (FAILED(hr))
 252             return hr;
 253         hr = IMoniker_GetDisplayName(pMoniker, pbc, NULL, &pszDisplayName);
 254         IBindCtx_Release(pbc);
 255         if (FAILED(hr))
 256             return hr;
 257         hr = IMoniker_GetClassID(pMoniker, &clsid);
 258         if (FAILED(hr))
 259         {
 260             CoTaskMemFree(pszDisplayName);
 261             return hr;
 262         }
 263
 264         len = strlenW(pszDisplayName);
 265         *moniker_data = HeapAlloc(GetProcessHeap(), 0,
 266             FIELD_OFFSET(MonikerComparisonData, abData[sizeof(CLSID) + (len+1)*sizeof(WCHAR)]));
 267         if (!*moniker_data)
 268         {
 269             CoTaskMemFree(pszDisplayName);
 270             return E_OUTOFMEMORY;
 271         }
 272         (*moniker_data)->ulCntData = sizeof(CLSID) + (len+1)*sizeof(WCHAR);
 273
 274         memcpy(&(*moniker_data)->abData[0], &clsid, sizeof(clsid));
 275         memcpy(&(*moniker_data)->abData[sizeof(clsid)], pszDisplayName, (len+1)*sizeof(WCHAR));
 276         CoTaskMemFree(pszDisplayName);
 277     }
 278     return S_OK;
 279 }
 280
 281 static HRESULT reduce_moniker(IMoniker *pmk, IBindCtx *pbc, IMoniker **pmkReduced)
 282 {
 283     IBindCtx *pbcNew = NULL;
 284     HRESULT hr;
 285     if (!pbc)
 286     {
 287         hr = CreateBindCtx(0, &pbcNew);
 288         if (FAILED(hr))
 289             return hr;
 290         pbc = pbcNew;
 291     }
 292     hr = IMoniker_Reduce(pmk, pbc, MKRREDUCE_ALL, NULL, pmkReduced);
 293     if (FAILED(hr))
 294         ERR("reducing moniker failed with error 0x%08x\n", hr);
 295     if (pbcNew) IBindCtx_Release(pbcNew);
 296     return hr;
 297 }
 298
 299 /***********************************************************************
 300  *        RunningObjectTable_QueryInterface
 301  */
 302 static HRESULT WINAPI
 303 RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface,
 304                                       REFIID riid,void** ppvObject)
 305 {
 306     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 307
 308     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
 309
 310     /* validate arguments */
 311
 312     if (ppvObject==0)
 313         return E_INVALIDARG;
 314
 315     *ppvObject = 0;
 316
 317     if (IsEqualIID(&IID_IUnknown, riid) ||
 318         IsEqualIID(&IID_IRunningObjectTable, riid))
 319         *ppvObject = &This->IRunningObjectTable_iface;
 320
 321     if ((*ppvObject)==0)
 322         return E_NOINTERFACE;
 323
 324     IRunningObjectTable_AddRef(iface);
 325
 326     return S_OK;
 327 }
 328
 329 /***********************************************************************
 330  *        RunningObjectTable_AddRef
 331  */
 332 static ULONG WINAPI
 333 RunningObjectTableImpl_AddRef(IRunningObjectTable* iface)
 334 {
 335     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 336
 337     TRACE("(%p)\n",This);
 338
 339     return InterlockedIncrement(&This->ref);
 340 }
 341
 342 /***********************************************************************
 343  *        RunningObjectTable_Destroy
 344  */
 345 static HRESULT
 346 RunningObjectTableImpl_Destroy(void)
 347 {
 348     struct list *cursor, *cursor2;
 349     IrotHandle old_handle;
 350
 351     TRACE("()\n");
 352
 353     if (runningObjectTableInstance==NULL)
 354         return E_INVALIDARG;
 355
 356     /* free the ROT table memory */
 357     LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot)
 358     {
 359         struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
 360         list_remove(&rot_entry->entry);
 361         rot_entry_delete(rot_entry);
 362     }
 363
 364     DEBUG_CLEAR_CRITSEC_NAME(&runningObjectTableInstance->lock);
 365     DeleteCriticalSection(&runningObjectTableInstance->lock);
 366
 367     /* free the ROT structure memory */
 368     HeapFree(GetProcessHeap(),0,runningObjectTableInstance);
 369     runningObjectTableInstance = NULL;
 370
 371     old_handle = irot_handle;
 372     irot_handle = NULL;
 373     if (old_handle)
 374         RpcBindingFree(&old_handle);
 375
 376     return S_OK;
 377 }
 378
 379 /***********************************************************************
 380  *        RunningObjectTable_Release
 381  */
 382 static ULONG WINAPI
 383 RunningObjectTableImpl_Release(IRunningObjectTable* iface)
 384 {
 385     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 386     ULONG ref;
 387
 388     TRACE("(%p)\n",This);
 389
 390     ref = InterlockedDecrement(&This->ref);
 391
 392     /* uninitialize ROT structure if there are no more references to it */
 393     if (ref == 0)
 394     {
 395         struct list *cursor, *cursor2;
 396         LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot)
 397         {
 398             struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
 399             list_remove(&rot_entry->entry);
 400             rot_entry_delete(rot_entry);
 401         }
 402         /*  RunningObjectTable data structure will be not destroyed here ! the destruction will be done only
 403          *  when RunningObjectTableImpl_UnInitialize function is called
 404          */
 405     }
 406
 407     return ref;
 408 }
 409
 410 /***********************************************************************
 411  *        RunningObjectTable_Register
 412  *
 413  * PARAMS
 414  * grfFlags       [in] Registration options
 415  * punkObject     [in] the object being registered
 416  * pmkObjectName  [in] the moniker of the object being registered
 417  * pdwRegister    [out] the value identifying the registration
 418  */
 419 static HRESULT WINAPI
 420 RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD grfFlags,
 421                IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
 422 {
 423     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 424     struct rot_entry *rot_entry;
 425     HRESULT hr = S_OK;
 426     IStream *pStream = NULL;
 427     DWORD mshlflags;
 428     IBindCtx *pbc;
 429     InterfaceData *moniker = NULL;
 430
 431     TRACE("(%p,%d,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister);
 432
 433     if (grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
 434     {
 435         ERR("Invalid grfFlags: 0x%08x\n", grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
 436         return E_INVALIDARG;
 437     }
 438
 439     if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL)
 440         return E_INVALIDARG;
 441
 442     rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
 443     if (!rot_entry)
 444         return E_OUTOFMEMORY;
 445
 446     /* marshal object */
 447     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 448     if (hr != S_OK)
 449     {
 450         rot_entry_delete(rot_entry);
 451         return hr;
 452     }
 453     mshlflags = (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) ? MSHLFLAGS_TABLESTRONG : MSHLFLAGS_TABLEWEAK;
 454     hr = CoMarshalInterface(pStream, &IID_IUnknown, punkObject, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, mshlflags);
 455     /* FIXME: a cleaner way would be to create an IStream class that writes
 456      * directly to an MInterfacePointer */
 457     if (hr == S_OK)
 458     {
 459         HGLOBAL hglobal;
 460         hr = GetHGlobalFromStream(pStream, &hglobal);
 461         if (hr == S_OK)
 462         {
 463             SIZE_T size = GlobalSize(hglobal);
 464             const void *pv = GlobalLock(hglobal);
 465             rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
 466             rot_entry->object->ulCntData = size;
 467             memcpy(rot_entry->object->abData, pv, size);
 468             GlobalUnlock(hglobal);
 469         }
 470     }
 471     IStream_Release(pStream);
 472     if (hr != S_OK)
 473     {
 474         rot_entry_delete(rot_entry);
 475         return hr;
 476     }
 477
 478     hr = CreateBindCtx(0, &pbc);
 479     if (FAILED(hr))
 480     {
 481         rot_entry_delete(rot_entry);
 482         return hr;
 483     }
 484
 485     hr = reduce_moniker(pmkObjectName, pbc, &pmkObjectName);
 486     if (FAILED(hr))
 487     {
 488         rot_entry_delete(rot_entry);
 489         IBindCtx_Release(pbc);
 490         return hr;
 491     }
 492
 493     hr = IMoniker_GetTimeOfLastChange(pmkObjectName, pbc, NULL,
 494                                       &rot_entry->last_modified);
 495     IBindCtx_Release(pbc);
 496     if (FAILED(hr))
 497     {
 498         CoFileTimeNow(&rot_entry->last_modified);
 499         hr = S_OK;
 500     }
 501
 502     hr = get_moniker_comparison_data(pmkObjectName,
 503                                      &rot_entry->moniker_data);
 504     if (hr != S_OK)
 505     {
 506         rot_entry_delete(rot_entry);
 507         IMoniker_Release(pmkObjectName);
 508         return hr;
 509     }
 510
 511     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 512     if (hr != S_OK)
 513     {
 514         rot_entry_delete(rot_entry);
 515         IMoniker_Release(pmkObjectName);
 516         return hr;
 517     }
 518     /* marshal moniker */
 519     hr = CoMarshalInterface(pStream, &IID_IMoniker, (IUnknown *)pmkObjectName,
 520                             MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG);
 521     /* FIXME: a cleaner way would be to create an IStream class that writes
 522      * directly to an MInterfacePointer */
 523     if (hr == S_OK)
 524     {
 525         HGLOBAL hglobal;
 526         hr = GetHGlobalFromStream(pStream, &hglobal);
 527         if (hr == S_OK)
 528         {
 529             SIZE_T size = GlobalSize(hglobal);
 530             const void *pv = GlobalLock(hglobal);
 531             moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[size]));
 532             moniker->ulCntData = size;
 533             memcpy(moniker->abData, pv, size);
 534             GlobalUnlock(hglobal);
 535         }
 536     }
 537     IStream_Release(pStream);
 538     IMoniker_Release(pmkObjectName);
 539     if (hr != S_OK)
 540     {
 541         HeapFree(GetProcessHeap(), 0, moniker);
 542         rot_entry_delete(rot_entry);
 543         return hr;
 544     }
 545
 546
 547     while (TRUE)
 548     {
 549         __TRY
 550         {
 551             hr = IrotRegister(get_irot_handle(), rot_entry->moniker_data,
 552                               rot_entry->object, moniker,
 553                               &rot_entry->last_modified, grfFlags,
 554                               &rot_entry->cookie, &rot_entry->ctxt_handle);
 555         }
 556         __EXCEPT(rpc_filter)
 557         {
 558             hr = HRESULT_FROM_WIN32(GetExceptionCode());
 559         }
 560         __ENDTRY
 561         if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 562         {
 563             if (start_rpcss())
 564                 continue;
 565         }
 566         break;
 567     }
 568     HeapFree(GetProcessHeap(), 0, moniker);
 569     if (FAILED(hr))
 570     {
 571         rot_entry_delete(rot_entry);
 572         return hr;
 573     }
 574
 575     /* gives a registration identifier to the registered object*/
 576     *pdwRegister = rot_entry->cookie;
 577
 578     EnterCriticalSection(&This->lock);
 579     list_add_tail(&This->rot, &rot_entry->entry);
 580     LeaveCriticalSection(&This->lock);
 581
 582     return hr;
 583 }
 584
 585 /***********************************************************************
 586  *        RunningObjectTable_Revoke
 587  *
 588  * PARAMS
 589  *  dwRegister [in] Value identifying registration to be revoked
 590  */
 591 static HRESULT WINAPI
 592 RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister)
 593 {
 594     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 595     struct rot_entry *rot_entry;
 596
 597     TRACE("(%p,%d)\n",This,dwRegister);
 598
 599     EnterCriticalSection(&This->lock);
 600     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 601     {
 602         if (rot_entry->cookie == dwRegister)
 603         {
 604             list_remove(&rot_entry->entry);
 605             LeaveCriticalSection(&This->lock);
 606
 607             rot_entry_delete(rot_entry);
 608             return S_OK;
 609         }
 610     }
 611     LeaveCriticalSection(&This->lock);
 612
 613     return E_INVALIDARG;
 614 }
 615
 616 /***********************************************************************
 617  *        RunningObjectTable_IsRunning
 618  *
 619  * PARAMS
 620  *  pmkObjectName [in]  moniker of the object whose status is desired
 621  */
 622 static HRESULT WINAPI
 623 RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName)
 624 {
 625     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 626     MonikerComparisonData *moniker_data;
 627     HRESULT hr;
 628     const struct rot_entry *rot_entry;
 629
 630     TRACE("(%p,%p)\n",This,pmkObjectName);
 631
 632     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 633     if (FAILED(hr))
 634         return hr;
 635     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 636     IMoniker_Release(pmkObjectName);
 637     if (hr != S_OK)
 638         return hr;
 639
 640     hr = S_FALSE;
 641     EnterCriticalSection(&This->lock);
 642     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
 643     {
 644         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 645             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 646         {
 647             hr = S_OK;
 648             break;
 649         }
 650     }
 651     LeaveCriticalSection(&This->lock);
 652
 653     if (hr == S_FALSE)
 654     {
 655         while (TRUE)
 656         {
 657             __TRY
 658             {
 659                 hr = IrotIsRunning(get_irot_handle(), moniker_data);
 660             }
 661             __EXCEPT(rpc_filter)
 662             {
 663                 hr = HRESULT_FROM_WIN32(GetExceptionCode());
 664             }
 665             __ENDTRY
 666             if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 667             {
 668                 if (start_rpcss())
 669                     continue;
 670             }
 671             break;
 672         }
 673     }
 674
 675     HeapFree(GetProcessHeap(), 0, moniker_data);
 676
 677     return hr;
 678 }
 679
 680 /***********************************************************************
 681  *        RunningObjectTable_GetObject
 682  *
 683  * PARAMS
 684  * pmkObjectName [in] Pointer to the moniker on the object
 685  * ppunkObject   [out] variable that receives the IUnknown interface pointer
 686  */
 687 static HRESULT WINAPI
 688 RunningObjectTableImpl_GetObject( IRunningObjectTable* iface,
 689                      IMoniker *pmkObjectName, IUnknown **ppunkObject)
 690 {
 691     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 692     MonikerComparisonData *moniker_data;
 693     InterfaceData *object = NULL;
 694     IrotCookie cookie;
 695     HRESULT hr;
 696     struct rot_entry *rot_entry;
 697
 698     TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
 699
 700     if (ppunkObject == NULL)
 701         return E_POINTER;
 702
 703     *ppunkObject = NULL;
 704
 705     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 706     if (FAILED(hr))
 707         return hr;
 708     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 709     IMoniker_Release(pmkObjectName);
 710     if (hr != S_OK)
 711         return hr;
 712
 713     EnterCriticalSection(&This->lock);
 714     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 715     {
 716         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 717             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 718         {
 719             IStream *pStream;
 720             hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
 721             if (hr == S_OK)
 722             {
 723                 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
 724                 IStream_Release(pStream);
 725             }
 726
 727             LeaveCriticalSection(&This->lock);
 728             HeapFree(GetProcessHeap(), 0, moniker_data);
 729
 730             return hr;
 731         }
 732     }
 733     LeaveCriticalSection(&This->lock);
 734
 735     TRACE("moniker unavailable locally, calling SCM\n");
 736
 737     while (TRUE)
 738     {
 739         __TRY
 740         {
 741             hr = IrotGetObject(get_irot_handle(), moniker_data, &object, &cookie);
 742         }
 743         __EXCEPT(rpc_filter)
 744         {
 745             hr = HRESULT_FROM_WIN32(GetExceptionCode());
 746         }
 747         __ENDTRY
 748         if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 749         {
 750             if (start_rpcss())
 751                 continue;
 752         }
 753         break;
 754     }
 755
 756     if (SUCCEEDED(hr))
 757     {
 758         IStream *pStream;
 759         hr = create_stream_on_mip_ro(object, &pStream);
 760         if (hr == S_OK)
 761         {
 762             hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
 763             IStream_Release(pStream);
 764         }
 765     }
 766     else
 767         WARN("Moniker unavailable, IrotGetObject returned 0x%08x\n", hr);
 768
 769     HeapFree(GetProcessHeap(), 0, moniker_data);
 770
 771     return hr;
 772 }
 773
 774 /***********************************************************************
 775  *        RunningObjectTable_NoteChangeTime
 776  *
 777  * PARAMS
 778  *  dwRegister [in] Value identifying registration being updated
 779  *  pfiletime  [in] Pointer to structure containing object's last change time
 780  */
 781 static HRESULT WINAPI
 782 RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface,
 783                                       DWORD dwRegister, FILETIME *pfiletime)
 784 {
 785     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 786     struct rot_entry *rot_entry;
 787     HRESULT hr = E_INVALIDARG;
 788
 789     TRACE("(%p,%d,%p)\n",This,dwRegister,pfiletime);
 790
 791     EnterCriticalSection(&This->lock);
 792     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
 793     {
 794         if (rot_entry->cookie == dwRegister)
 795         {
 796             rot_entry->last_modified = *pfiletime;
 797             LeaveCriticalSection(&This->lock);
 798
 799             while (TRUE)
 800             {
 801                 __TRY
 802                 {
 803                     hr = IrotNoteChangeTime(get_irot_handle(), dwRegister, pfiletime);
 804                 }
 805                 __EXCEPT(rpc_filter)
 806                 {
 807                     hr = HRESULT_FROM_WIN32(GetExceptionCode());
 808                 }
 809                 __ENDTRY
 810                 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 811                 {
 812                     if (start_rpcss())
 813                         continue;
 814                 }
 815                 break;
 816             }
 817
 818             goto done;
 819         }
 820     }
 821     LeaveCriticalSection(&This->lock);
 822
 823 done:
 824     TRACE("-- 0x08%x\n", hr);
 825     return hr;
 826 }
 827
 828 /***********************************************************************
 829  *        RunningObjectTable_GetTimeOfLastChange
 830  *
 831  * PARAMS
 832  *  pmkObjectName  [in]  moniker of the object whose status is desired
 833  *  pfiletime      [out] structure that receives object's last change time
 834  */
 835 static HRESULT WINAPI
 836 RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface,
 837                             IMoniker *pmkObjectName, FILETIME *pfiletime)
 838 {
 839     HRESULT hr = MK_E_UNAVAILABLE;
 840     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 841     MonikerComparisonData *moniker_data;
 842     const struct rot_entry *rot_entry;
 843
 844     TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
 845
 846     if (pmkObjectName==NULL || pfiletime==NULL)
 847         return E_INVALIDARG;
 848
 849     hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
 850     if (FAILED(hr))
 851         return hr;
 852     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
 853     IMoniker_Release(pmkObjectName);
 854     if (hr != S_OK)
 855         return hr;
 856
 857     hr = MK_E_UNAVAILABLE;
 858
 859     EnterCriticalSection(&This->lock);
 860     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
 861     {
 862         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
 863             !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
 864         {
 865             *pfiletime = rot_entry->last_modified;
 866             hr = S_OK;
 867             break;
 868         }
 869     }
 870     LeaveCriticalSection(&This->lock);
 871
 872     if (hr != S_OK)
 873     {
 874         while (TRUE)
 875         {
 876             __TRY
 877             {
 878                 hr = IrotGetTimeOfLastChange(get_irot_handle(), moniker_data, pfiletime);
 879             }
 880             __EXCEPT(rpc_filter)
 881             {
 882                 hr = HRESULT_FROM_WIN32(GetExceptionCode());
 883             }
 884             __ENDTRY
 885             if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 886             {
 887                 if (start_rpcss())
 888                     continue;
 889             }
 890             break;
 891         }
 892     }
 893
 894     HeapFree(GetProcessHeap(), 0, moniker_data);
 895
 896     TRACE("-- 0x%08x\n", hr);
 897     return hr;
 898 }
 899
 900 /***********************************************************************
 901  *        RunningObjectTable_EnumRunning
 902  *
 903  * PARAMS
 904  *  ppenumMoniker  [out]  receives the IEnumMoniker interface pointer
 905  */
 906 static HRESULT WINAPI
 907 RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface,
 908                                    IEnumMoniker **ppenumMoniker)
 909 {
 910     RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 911     InterfaceList *interface_list = NULL;
 912     HRESULT hr;
 913
 914     TRACE("(%p, %p)\n", This, ppenumMoniker);
 915
 916     *ppenumMoniker = NULL;
 917
 918     while (TRUE)
 919     {
 920         __TRY
 921         {
 922             hr = IrotEnumRunning(get_irot_handle(), &interface_list);
 923         }
 924         __EXCEPT(rpc_filter)
 925         {
 926             hr = HRESULT_FROM_WIN32(GetExceptionCode());
 927         }
 928         __ENDTRY
 929         if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
 930         {
 931             if (start_rpcss())
 932                 continue;
 933         }
 934         break;
 935     }
 936
 937     if (SUCCEEDED(hr))
 938         hr = EnumMonikerImpl_CreateEnumROTMoniker(interface_list,
 939                                                   0, ppenumMoniker);
 940
 941     return hr;
 942 }
 943
 944 /* Virtual function table for the IRunningObjectTable class. */
 945 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl =
 946 {
 947     RunningObjectTableImpl_QueryInterface,
 948     RunningObjectTableImpl_AddRef,
 949     RunningObjectTableImpl_Release,
 950     RunningObjectTableImpl_Register,
 951     RunningObjectTableImpl_Revoke,
 952     RunningObjectTableImpl_IsRunning,
 953     RunningObjectTableImpl_GetObject,
 954     RunningObjectTableImpl_NoteChangeTime,
 955     RunningObjectTableImpl_GetTimeOfLastChange,
 956     RunningObjectTableImpl_EnumRunning
 957 };
 958
 959 /***********************************************************************
 960  *        RunningObjectTable_Initialize
 961  */
 962 HRESULT WINAPI RunningObjectTableImpl_Initialize(void)
 963 {
 964     TRACE("\n");
 965
 966     /* create the unique instance of the RunningObjectTableImpl structure */
 967     runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl));
 968
 969     if (!runningObjectTableInstance)
 970         return E_OUTOFMEMORY;
 971
 972     /* initialize the virtual table function */
 973     runningObjectTableInstance->IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl;
 974
 975     /* the initial reference is set to "1" so that it isn't destroyed after its
 976      * first use until the process is destroyed, as the running object table is
 977      * a process-wide cache of a global table */
 978     runningObjectTableInstance->ref = 1;
 979
 980     list_init(&runningObjectTableInstance->rot);
 981     InitializeCriticalSection(&runningObjectTableInstance->lock);
 982     DEBUG_SET_CRITSEC_NAME(&runningObjectTableInstance->lock, "RunningObjectTableImpl.lock");
 983
 984     return S_OK;
 985 }
 986
 987 /***********************************************************************
 988  *        RunningObjectTable_UnInitialize
 989  */
 990 HRESULT WINAPI RunningObjectTableImpl_UnInitialize(void)
 991 {
 992     TRACE("\n");
 993
 994     if (runningObjectTableInstance==NULL)
 995         return E_POINTER;
 996
 997     RunningObjectTableImpl_Release(&runningObjectTableInstance->IRunningObjectTable_iface);
 998
 999     RunningObjectTableImpl_Destroy();
1000
1001     return S_OK;
1002 }
1003
1004 /***********************************************************************
1005  *           GetRunningObjectTable (OLE32.@)
1006  *
1007  * Retrieves the global running object table.
1008  *
1009  * PARAMS
1010  *  reserved [I] Reserved. Set to 0.
1011  *  pprot    [O] Address that receives the pointer to the running object table.
1012  *
1013  * RETURNS
1014  *  Success: S_OK.
1015  *  Failure: Any HRESULT code.
1016  */
1017 HRESULT WINAPI
1018 GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
1019 {
1020     IID riid=IID_IRunningObjectTable;
1021     HRESULT res;
1022
1023     TRACE("()\n");
1024
1025     if (reserved!=0)
1026         return E_UNEXPECTED;
1027
1028     if(runningObjectTableInstance==NULL)
1029         return CO_E_NOTINITIALIZED;
1030
1031     res = IRunningObjectTable_QueryInterface(&runningObjectTableInstance->IRunningObjectTable_iface,
1032                                              &riid,(void**)pprot);
1033
1034     return res;
1035 }
1036
1037 static HRESULT get_moniker_for_progid_display_name(LPBC pbc,
1038                                                    LPCOLESTR szDisplayName,
1039                                                    LPDWORD pchEaten,
1040                                                    LPMONIKER *ppmk)
1041 {
1042     CLSID clsid;
1043     HRESULT hr;
1044     LPWSTR progid;
1045     LPCWSTR start = szDisplayName;
1046     LPCWSTR end;
1047     int len;
1048     IMoniker *class_moniker;
1049
1050     if (*start == '@')
1051         start++;
1052
1053     /* find end delimiter */
1054     for (end = start; *end; end++)
1055         if (*end == ':')
1056             break;
1057
1058     len = end - start;
1059
1060     /* must start with '@' or have a ':' somewhere and mustn't be one character
1061      * long (since that looks like an absolute path) */
1062     if (((start == szDisplayName) && (*end == '\0')) || (len <= 1))
1063         return MK_E_SYNTAX;
1064
1065     progid = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1066     if (progid)
1067     {
1068         memcpy(progid, start, len * sizeof(WCHAR));
1069         progid[len] = '\0';
1070     }
1071     hr = CLSIDFromProgID(progid, &clsid);
1072     HeapFree(GetProcessHeap(), 0, progid);
1073     if (FAILED(hr))
1074         return MK_E_SYNTAX;
1075
1076     hr = CreateClassMoniker(&clsid, &class_moniker);
1077     if (SUCCEEDED(hr))
1078     {
1079         IParseDisplayName *pdn;
1080         hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
1081                                    &IID_IParseDisplayName, (void **)&pdn);
1082         /* fallback to using IClassFactory to get IParseDisplayName -
1083          * adsldp.dll depends on this */
1084         if (FAILED(hr))
1085         {
1086             IClassFactory *pcf;
1087             hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
1088                                        &IID_IClassFactory, (void **)&pcf);
1089             if (SUCCEEDED(hr))
1090             {
1091                 hr = IClassFactory_CreateInstance(pcf, NULL,
1092                                                   &IID_IParseDisplayName,
1093                                                   (void **)&pdn);
1094                 IClassFactory_Release(pcf);
1095             }
1096         }
1097         IMoniker_Release(class_moniker);
1098         if (SUCCEEDED(hr))
1099         {
1100             hr = IParseDisplayName_ParseDisplayName(pdn, pbc,
1101                                                     (LPOLESTR)szDisplayName,
1102                                                     pchEaten, ppmk);
1103             IParseDisplayName_Release(pdn);
1104         }
1105     }
1106     return hr;
1107 }
1108
1109 /******************************************************************************
1110  *              MkParseDisplayName        [OLE32.@]
1111  */
1112 HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
1113                                 LPDWORD pchEaten, LPMONIKER *ppmk)
1114 {
1115     HRESULT hr = MK_E_SYNTAX;
1116     static const WCHAR wszClsidColon[] = {'c','l','s','i','d',':'};
1117     IMoniker *moniker;
1118     DWORD chEaten;
1119
1120     TRACE("(%p, %s, %p, %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
1121
1122     if (!pbc || !IsValidInterface((LPUNKNOWN) pbc))
1123         return E_INVALIDARG;
1124
1125     if (!szDisplayName || !*szDisplayName)
1126         return E_INVALIDARG;
1127
1128     if (!pchEaten || !ppmk)
1129         return E_INVALIDARG;
1130
1131     *pchEaten = 0;
1132     *ppmk = NULL;
1133
1134     if (!strncmpiW(szDisplayName, wszClsidColon, sizeof(wszClsidColon)/sizeof(wszClsidColon[0])))
1135     {
1136         hr = ClassMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
1137         if (FAILED(hr) && (hr != MK_E_SYNTAX))
1138             return hr;
1139     }
1140     else
1141     {
1142         hr = get_moniker_for_progid_display_name(pbc, szDisplayName, &chEaten, &moniker);
1143         if (FAILED(hr) && (hr != MK_E_SYNTAX))
1144             return hr;
1145     }
1146
1147     if (FAILED(hr))
1148     {
1149         hr = FileMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
1150         if (FAILED(hr) && (hr != MK_E_SYNTAX))
1151             return hr;
1152     }
1153
1154     if (SUCCEEDED(hr))
1155     {
1156         while (TRUE)
1157         {
1158             IMoniker *next_moniker;
1159             *pchEaten += chEaten;
1160             szDisplayName += chEaten;
1161             if (!*szDisplayName)
1162             {
1163                 *ppmk = moniker;
1164                 return S_OK;
1165             }
1166             chEaten = 0;
1167             hr = IMoniker_ParseDisplayName(moniker, pbc, NULL,
1168                                            (LPOLESTR)szDisplayName, &chEaten,
1169                                            &next_moniker);
1170             IMoniker_Release(moniker);
1171             if (FAILED(hr))
1172             {
1173                 *pchEaten = 0;
1174                 break;
1175             }
1176             moniker = next_moniker;
1177         }
1178     }
1179
1180     return hr;
1181 }
1182
1183 /***********************************************************************
1184  *        GetClassFile (OLE32.@)
1185  *
1186  * Retrieves the class ID associated with the given filename.
1187  *
1188  * PARAMS
1189  *  filePathName [I] Filename to retrieve the class ID for.
1190  *  pclsid       [O] Address that receives the class ID for the file.
1191  *
1192  * RETURNS
1193  *  Success: S_OK.
1194  *  Failure: Any HRESULT code.
1195  */
1196 HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid)
1197 {
1198     IStorage *pstg=0;
1199     HRESULT res;
1200     int nbElm, length, i;
1201     LONG sizeProgId, ret;
1202     LPOLESTR *pathDec=0,absFile=0,progId=0;
1203     LPWSTR extension;
1204     static const WCHAR bkslashW[] = {'\\',0};
1205     static const WCHAR dotW[] = {'.',0};
1206
1207     TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
1208
1209     /* if the file contain a storage object the return the CLSID written by IStorage_SetClass method*/
1210     if((StgIsStorageFile(filePathName))==S_OK){
1211
1212         res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
1213
1214         if (SUCCEEDED(res))
1215             res=ReadClassStg(pstg,pclsid);
1216
1217         IStorage_Release(pstg);
1218
1219         return res;
1220     }
1221     /* If the file is not a storage object then attempt to match various bits in the file against a
1222        pattern in the registry. This case is not frequently used, so I present only the pseudocode for
1223        this case.
1224
1225      for(i=0;i<nFileTypes;i++)
1226
1227         for(i=0;j<nPatternsForType;j++){
1228
1229             PATTERN pat;
1230             HANDLE  hFile;
1231
1232             pat=ReadPatternFromRegistry(i,j);
1233             hFile=CreateFileW(filePathName,,,,,,hFile);
1234             SetFilePosition(hFile,pat.offset);
1235             ReadFile(hFile,buf,pat.size,&r,NULL);
1236             if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
1237
1238                 *pclsid=ReadCLSIDFromRegistry(i);
1239                 return S_OK;
1240             }
1241         }
1242      */
1243
1244     /* if the above strategies fail then search for the extension key in the registry */
1245
1246     /* get the last element (absolute file) in the path name */
1247     nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
1248     absFile=pathDec[nbElm-1];
1249
1250     /* failed if the path represents a directory and not an absolute file name*/
1251     if (!lstrcmpW(absFile, bkslashW)) {
1252         CoTaskMemFree(pathDec);
1253         return MK_E_INVALIDEXTENSION;
1254     }
1255
1256     /* get the extension of the file */
1257     extension = NULL;
1258     length=lstrlenW(absFile);
1259     for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
1260         /* nothing */;
1261
1262     if (!extension || !lstrcmpW(extension, dotW)) {
1263         CoTaskMemFree(pathDec);
1264         return MK_E_INVALIDEXTENSION;
1265     }
1266
1267     ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
1268
1269     /* get the progId associated to the extension */
1270     progId = CoTaskMemAlloc(sizeProgId);
1271     ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
1272     if (!ret)
1273         /* return the clsid associated to the progId */
1274         res = CLSIDFromProgID(progId,pclsid);
1275     else
1276         res = HRESULT_FROM_WIN32(ret);
1277
1278     for(i=0; pathDec[i]!=NULL;i++)
1279         CoTaskMemFree(pathDec[i]);
1280     CoTaskMemFree(pathDec);
1281
1282     CoTaskMemFree(progId);
1283     return res != S_OK ? MK_E_INVALIDEXTENSION : res;
1284 }
1285
1286 /***********************************************************************
1287  *        EnumMoniker_QueryInterface
1288  */
1289 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1290 {
1291     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1292
1293     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1294
1295     /* validate arguments */
1296     if (ppvObject == NULL)
1297         return E_INVALIDARG;
1298
1299     *ppvObject = NULL;
1300
1301     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
1302         *ppvObject = &This->IEnumMoniker_iface;
1303     else
1304         return E_NOINTERFACE;
1305
1306     IEnumMoniker_AddRef(iface);
1307     return S_OK;
1308 }
1309
1310 /***********************************************************************
1311  *        EnumMoniker_AddRef
1312  */
1313 static ULONG   WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1314 {
1315     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1316
1317     TRACE("(%p)\n",This);
1318
1319     return InterlockedIncrement(&This->ref);
1320 }
1321
1322 /***********************************************************************
1323  *        EnumMoniker_release
1324  */
1325 static ULONG   WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
1326 {
1327     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1328     ULONG ref;
1329
1330     TRACE("(%p)\n",This);
1331
1332     ref = InterlockedDecrement(&This->ref);
1333
1334     /* uninitialize ROT structure if there are no more references to it */
1335     if (ref == 0)
1336     {
1337         ULONG i;
1338
1339         TRACE("(%p) Deleting\n",This);
1340
1341         for (i = 0; i < This->moniker_list->size; i++)
1342             HeapFree(GetProcessHeap(), 0, This->moniker_list->interfaces[i]);
1343         HeapFree(GetProcessHeap(), 0, This->moniker_list);
1344         HeapFree(GetProcessHeap(), 0, This);
1345     }
1346
1347     return ref;
1348 }
1349 /***********************************************************************
1350  *        EnumMoniker_Next
1351  */
1352 static HRESULT   WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
1353 {
1354     ULONG i;
1355     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1356     HRESULT hr = S_OK;
1357
1358     TRACE("(%p) TabCurrentPos %d Tablastindx %d\n", This, This->pos, This->moniker_list->size);
1359
1360     /* retrieve the requested number of moniker from the current position */
1361     for(i = 0; (This->pos < This->moniker_list->size) && (i < celt); i++)
1362     {
1363         IStream *stream;
1364         hr = create_stream_on_mip_ro(This->moniker_list->interfaces[This->pos++], &stream);
1365         if (hr != S_OK) break;
1366         hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]);
1367         IStream_Release(stream);
1368         if (hr != S_OK) break;
1369     }
1370
1371     if (pceltFetched != NULL)
1372         *pceltFetched= i;
1373
1374     if (hr != S_OK)
1375         return hr;
1376
1377     if (i == celt)
1378         return S_OK;
1379     else
1380         return S_FALSE;
1381
1382 }
1383
1384 /***********************************************************************
1385  *        EnumMoniker_Skip
1386  */
1387 static HRESULT   WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
1388 {
1389     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1390
1391     TRACE("(%p)\n",This);
1392
1393     if  (This->pos + celt >= This->moniker_list->size)
1394         return S_FALSE;
1395
1396     This->pos += celt;
1397
1398     return S_OK;
1399 }
1400
1401 /***********************************************************************
1402  *        EnumMoniker_Reset
1403  */
1404 static HRESULT   WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
1405 {
1406     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1407
1408     This->pos = 0;      /* set back to start of list */
1409
1410     TRACE("(%p)\n",This);
1411
1412     return S_OK;
1413 }
1414
1415 /***********************************************************************
1416  *        EnumMoniker_Clone
1417  */
1418 static HRESULT   WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
1419 {
1420     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1421     InterfaceList *moniker_list;
1422     ULONG i;
1423
1424     TRACE("(%p)\n",This);
1425
1426     *ppenum = NULL;
1427
1428     moniker_list = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceList, interfaces[This->moniker_list->size]));
1429     if (!moniker_list)
1430         return E_OUTOFMEMORY;
1431
1432     moniker_list->size = This->moniker_list->size;
1433     for (i = 0; i < This->moniker_list->size; i++)
1434     {
1435         SIZE_T size = FIELD_OFFSET(InterfaceData, abData[This->moniker_list->interfaces[i]->ulCntData]);
1436         moniker_list->interfaces[i] = HeapAlloc(GetProcessHeap(), 0, size);
1437         if (!moniker_list->interfaces[i])
1438         {
1439             ULONG end = i;
1440             for (i = 0; i < end; i++)
1441                 HeapFree(GetProcessHeap(), 0, moniker_list->interfaces[i]);
1442             HeapFree(GetProcessHeap(), 0, moniker_list);
1443             return E_OUTOFMEMORY;
1444         }
1445         memcpy(moniker_list->interfaces[i], This->moniker_list->interfaces[i], size);
1446     }
1447
1448     /* copy the enum structure */
1449     return EnumMonikerImpl_CreateEnumROTMoniker(moniker_list, This->pos, ppenum);
1450 }
1451
1452 /* Virtual function table for the IEnumMoniker class. */
1453 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1454 {
1455     EnumMonikerImpl_QueryInterface,
1456     EnumMonikerImpl_AddRef,
1457     EnumMonikerImpl_Release,
1458     EnumMonikerImpl_Next,
1459     EnumMonikerImpl_Skip,
1460     EnumMonikerImpl_Reset,
1461     EnumMonikerImpl_Clone
1462 };
1463
1464 /***********************************************************************
1465  *        EnumMonikerImpl_CreateEnumROTMoniker
1466  *        Used by EnumRunning to create the structure and EnumClone
1467  *        to copy the structure
1468  */
1469 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
1470                                                  ULONG current_pos,
1471                                                  IEnumMoniker **ppenumMoniker)
1472 {
1473     EnumMonikerImpl* This = NULL;
1474
1475     if (!ppenumMoniker)
1476         return E_INVALIDARG;
1477
1478     This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1479     if (!This) return E_OUTOFMEMORY;
1480
1481     TRACE("(%p)\n", This);
1482
1483     /* initialize the virtual table function */
1484     This->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1485
1486     /* the initial reference is set to "1" */
1487     This->ref = 1;                      /* set the ref count to one         */
1488     This->pos = current_pos;            /* Set the list start posn */
1489     This->moniker_list = moniker_list;
1490
1491     *ppenumMoniker =  &This->IEnumMoniker_iface;
1492
1493     return S_OK;
1494 }
1495
1496
1497 /* Shared implementation of moniker marshaler based on saving and loading of
1498  * monikers */
1499
1500 typedef struct MonikerMarshal
1501 {
1502     IUnknown IUnknown_iface;
1503     IMarshal IMarshal_iface;
1504
1505     LONG ref;
1506     IMoniker *moniker;
1507 } MonikerMarshal;
1508
1509 static inline MonikerMarshal *impl_from_IUnknown(IUnknown *iface)
1510 {
1511     return CONTAINING_RECORD(iface, MonikerMarshal, IUnknown_iface);
1512 }
1513
1514 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
1515 {
1516     return CONTAINING_RECORD(iface, MonikerMarshal, IMarshal_iface);
1517 }
1518
1519 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
1520 {
1521     MonikerMarshal *This = impl_from_IUnknown(iface);
1522     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1523     *ppv = NULL;
1524     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
1525     {
1526         *ppv = &This->IMarshal_iface;
1527         IUnknown_AddRef((IUnknown *)&This->IMarshal_iface);
1528         return S_OK;
1529     }
1530     FIXME("No interface for %s\n", debugstr_guid(riid));
1531     return E_NOINTERFACE;
1532 }
1533
1534 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1535 {
1536     MonikerMarshal *This = impl_from_IUnknown(iface);
1537     return InterlockedIncrement(&This->ref);
1538 }
1539
1540 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1541 {
1542     MonikerMarshal *This = impl_from_IUnknown(iface);
1543     ULONG ref = InterlockedDecrement(&This->ref);
1544
1545     if (!ref) HeapFree(GetProcessHeap(), 0, This);
1546     return ref;
1547 }
1548
1549 static const IUnknownVtbl VT_MonikerMarshalInner =
1550 {
1551     MonikerMarshalInner_QueryInterface,
1552     MonikerMarshalInner_AddRef,
1553     MonikerMarshalInner_Release
1554 };
1555
1556 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1557 {
1558     MonikerMarshal *This = impl_from_IMarshal(iface);
1559     return IMoniker_QueryInterface(This->moniker, riid, ppv);
1560 }
1561
1562 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1563 {
1564     MonikerMarshal *This = impl_from_IMarshal(iface);
1565     return IMoniker_AddRef(This->moniker);
1566 }
1567
1568 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1569 {
1570     MonikerMarshal *This = impl_from_IMarshal(iface);
1571     return IMoniker_Release(This->moniker);
1572 }
1573
1574 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1575   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1576   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1577 {
1578     MonikerMarshal *This = impl_from_IMarshal(iface);
1579
1580     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1581         dwDestContext, pvDestContext, mshlflags, pCid);
1582
1583     return IMoniker_GetClassID(This->moniker, pCid);
1584 }
1585
1586 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1587   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1588   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1589 {
1590     MonikerMarshal *This = impl_from_IMarshal(iface);
1591     HRESULT hr;
1592     ULARGE_INTEGER size;
1593
1594     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1595         dwDestContext, pvDestContext, mshlflags, pSize);
1596
1597     hr = IMoniker_GetSizeMax(This->moniker, &size);
1598     if (hr == S_OK)
1599         *pSize = (DWORD)size.QuadPart;
1600     return hr;
1601 }
1602
1603 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm,
1604     REFIID riid, void* pv, DWORD dwDestContext,
1605     void* pvDestContext, DWORD mshlflags)
1606 {
1607     MonikerMarshal *This = impl_from_IMarshal(iface);
1608
1609     TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1610         dwDestContext, pvDestContext, mshlflags);
1611
1612     return IMoniker_Save(This->moniker, pStm, FALSE);
1613 }
1614
1615 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1616 {
1617     MonikerMarshal *This = impl_from_IMarshal(iface);
1618     HRESULT hr;
1619
1620     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1621
1622     hr = IMoniker_Load(This->moniker, pStm);
1623     if (hr == S_OK)
1624         hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1625     return hr;
1626 }
1627
1628 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1629 {
1630     TRACE("()\n");
1631     /* can't release a state-based marshal as nothing on server side to
1632      * release */
1633     return S_OK;
1634 }
1635
1636 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1637 {
1638     TRACE("()\n");
1639     /* can't disconnect a state-based marshal as nothing on server side to
1640      * disconnect from */
1641     return S_OK;
1642 }
1643
1644 static const IMarshalVtbl VT_MonikerMarshal =
1645 {
1646     MonikerMarshal_QueryInterface,
1647     MonikerMarshal_AddRef,
1648     MonikerMarshal_Release,
1649     MonikerMarshal_GetUnmarshalClass,
1650     MonikerMarshal_GetMarshalSizeMax,
1651     MonikerMarshal_MarshalInterface,
1652     MonikerMarshal_UnmarshalInterface,
1653     MonikerMarshal_ReleaseMarshalData,
1654     MonikerMarshal_DisconnectObject
1655 };
1656
1657 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1658 {
1659     MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1660     if (!This) return E_OUTOFMEMORY;
1661
1662     This->IUnknown_iface.lpVtbl = &VT_MonikerMarshalInner;
1663     This->IMarshal_iface.lpVtbl = &VT_MonikerMarshal;
1664     This->ref = 1;
1665     This->moniker = inner;
1666
1667     *outer = &This->IUnknown_iface;
1668     return S_OK;
1669 }
1670
1671 void * __RPC_USER MIDL_user_allocate(SIZE_T size)
1672 {
1673     return HeapAlloc(GetProcessHeap(), 0, size);
1674 }
1675
1676 void __RPC_USER MIDL_user_free(void *p)
1677 {
1678     HeapFree(GetProcessHeap(), 0, p);
1679 }