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