mshtml: Store style filter in HTMLStyle object.
[wine] / 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, 0, 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 inline 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                 IUnknown_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             IUnknown_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;
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's 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;
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         return MK_E_INVALIDEXTENSION;
1253
1254     /* get the extension of the file */
1255     extension = NULL;
1256     length=lstrlenW(absFile);
1257     for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
1258         /* nothing */;
1259
1260     if (!extension || !lstrcmpW(extension, dotW))
1261         return MK_E_INVALIDEXTENSION;
1262
1263     res=RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
1264
1265     /* get the progId associated to the extension */
1266     progId = CoTaskMemAlloc(sizeProgId);
1267     res = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
1268
1269     if (res==ERROR_SUCCESS)
1270         /* return the clsid associated to the progId */
1271         res= CLSIDFromProgID(progId,pclsid);
1272
1273     for(i=0; pathDec[i]!=NULL;i++)
1274         CoTaskMemFree(pathDec[i]);
1275     CoTaskMemFree(pathDec);
1276
1277     CoTaskMemFree(progId);
1278
1279     if (res==ERROR_SUCCESS)
1280         return res;
1281
1282     return MK_E_INVALIDEXTENSION;
1283 }
1284
1285 /***********************************************************************
1286  *        EnumMoniker_QueryInterface
1287  */
1288 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1289 {
1290     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1291
1292     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1293
1294     /* validate arguments */
1295     if (ppvObject == NULL)
1296         return E_INVALIDARG;
1297
1298     *ppvObject = NULL;
1299
1300     if (IsEqualIID(&IID_IUnknown, riid))
1301         *ppvObject = This;
1302     else
1303         if (IsEqualIID(&IID_IEnumMoniker, riid))
1304             *ppvObject = This;
1305
1306     if ((*ppvObject)==NULL)
1307         return E_NOINTERFACE;
1308
1309     IEnumMoniker_AddRef(iface);
1310
1311     return S_OK;
1312 }
1313
1314 /***********************************************************************
1315  *        EnumMoniker_AddRef
1316  */
1317 static ULONG   WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1318 {
1319     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1320
1321     TRACE("(%p)\n",This);
1322
1323     return InterlockedIncrement(&This->ref);
1324 }
1325
1326 /***********************************************************************
1327  *        EnumMoniker_release
1328  */
1329 static ULONG   WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
1330 {
1331     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1332     ULONG ref;
1333
1334     TRACE("(%p)\n",This);
1335
1336     ref = InterlockedDecrement(&This->ref);
1337
1338     /* uninitialize rot structure if there's no more reference to it*/
1339     if (ref == 0)
1340     {
1341         ULONG i;
1342
1343         TRACE("(%p) Deleting\n",This);
1344
1345         for (i = 0; i < This->moniker_list->size; i++)
1346             HeapFree(GetProcessHeap(), 0, This->moniker_list->interfaces[i]);
1347         HeapFree(GetProcessHeap(), 0, This->moniker_list);
1348         HeapFree(GetProcessHeap(), 0, This);
1349     }
1350
1351     return ref;
1352 }
1353 /***********************************************************************
1354  *        EnumMoniker_Next
1355  */
1356 static HRESULT   WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
1357 {
1358     ULONG i;
1359     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1360     HRESULT hr = S_OK;
1361
1362     TRACE("(%p) TabCurrentPos %d Tablastindx %d\n", This, This->pos, This->moniker_list->size);
1363
1364     /* retrieve the requested number of moniker from the current position */
1365     for(i = 0; (This->pos < This->moniker_list->size) && (i < celt); i++)
1366     {
1367         IStream *stream;
1368         hr = create_stream_on_mip_ro(This->moniker_list->interfaces[This->pos++], &stream);
1369         if (hr != S_OK) break;
1370         hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]);
1371         IStream_Release(stream);
1372         if (hr != S_OK) break;
1373     }
1374
1375     if (pceltFetched != NULL)
1376         *pceltFetched= i;
1377
1378     if (hr != S_OK)
1379         return hr;
1380
1381     if (i == celt)
1382         return S_OK;
1383     else
1384         return S_FALSE;
1385
1386 }
1387
1388 /***********************************************************************
1389  *        EnumMoniker_Skip
1390  */
1391 static HRESULT   WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
1392 {
1393     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1394
1395     TRACE("(%p)\n",This);
1396
1397     if  (This->pos + celt >= This->moniker_list->size)
1398         return S_FALSE;
1399
1400     This->pos += celt;
1401
1402     return S_OK;
1403 }
1404
1405 /***********************************************************************
1406  *        EnumMoniker_Reset
1407  */
1408 static HRESULT   WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
1409 {
1410     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1411
1412     This->pos = 0;      /* set back to start of list */
1413
1414     TRACE("(%p)\n",This);
1415
1416     return S_OK;
1417 }
1418
1419 /***********************************************************************
1420  *        EnumMoniker_Clone
1421  */
1422 static HRESULT   WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
1423 {
1424     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1425     InterfaceList *moniker_list;
1426     ULONG i;
1427
1428     TRACE("(%p)\n",This);
1429
1430     *ppenum = NULL;
1431
1432     moniker_list = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceList, interfaces[This->moniker_list->size]));
1433     if (!moniker_list)
1434         return E_OUTOFMEMORY;
1435
1436     moniker_list->size = This->moniker_list->size;
1437     for (i = 0; i < This->moniker_list->size; i++)
1438     {
1439         SIZE_T size = FIELD_OFFSET(InterfaceData, abData[This->moniker_list->interfaces[i]->ulCntData]);
1440         moniker_list->interfaces[i] = HeapAlloc(GetProcessHeap(), 0, size);
1441         if (!moniker_list->interfaces[i])
1442         {
1443             ULONG end = i;
1444             for (i = 0; i < end; i++)
1445                 HeapFree(GetProcessHeap(), 0, moniker_list->interfaces[i]);
1446             HeapFree(GetProcessHeap(), 0, moniker_list);
1447             return E_OUTOFMEMORY;
1448         }
1449         memcpy(moniker_list->interfaces[i], This->moniker_list->interfaces[i], size);
1450     }
1451
1452     /* copy the enum structure */ 
1453     return EnumMonikerImpl_CreateEnumROTMoniker(moniker_list, This->pos, ppenum);
1454 }
1455
1456 /* Virtual function table for the IEnumMoniker class. */
1457 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1458 {
1459     EnumMonikerImpl_QueryInterface,
1460     EnumMonikerImpl_AddRef,
1461     EnumMonikerImpl_Release,
1462     EnumMonikerImpl_Next,
1463     EnumMonikerImpl_Skip,
1464     EnumMonikerImpl_Reset,
1465     EnumMonikerImpl_Clone
1466 };
1467
1468 /***********************************************************************
1469  *        EnumMonikerImpl_CreateEnumROTMoniker
1470  *        Used by EnumRunning to create the structure and EnumClone
1471  *        to copy the structure
1472  */
1473 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
1474                                                  ULONG current_pos,
1475                                                  IEnumMoniker **ppenumMoniker)
1476 {
1477     EnumMonikerImpl* This = NULL;
1478
1479     if (!ppenumMoniker)
1480         return E_INVALIDARG;
1481
1482     This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1483     if (!This) return E_OUTOFMEMORY;
1484
1485     TRACE("(%p)\n", This);
1486
1487     /* initialize the virtual table function */
1488     This->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1489
1490     /* the initial reference is set to "1" */
1491     This->ref = 1;                      /* set the ref count to one         */
1492     This->pos = current_pos;            /* Set the list start posn */
1493     This->moniker_list = moniker_list;
1494
1495     *ppenumMoniker =  &This->IEnumMoniker_iface;
1496
1497     return S_OK;
1498 }
1499
1500
1501 /* Shared implementation of moniker marshaler based on saving and loading of
1502  * monikers */
1503
1504 typedef struct MonikerMarshal
1505 {
1506     IUnknown IUnknown_iface;
1507     IMarshal IMarshal_iface;
1508
1509     LONG ref;
1510     IMoniker *moniker;
1511 } MonikerMarshal;
1512
1513 static inline MonikerMarshal *impl_from_IUnknown(IUnknown *iface)
1514 {
1515     return CONTAINING_RECORD(iface, MonikerMarshal, IUnknown_iface);
1516 }
1517
1518 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
1519 {
1520     return CONTAINING_RECORD(iface, MonikerMarshal, IMarshal_iface);
1521 }
1522
1523 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
1524 {
1525     MonikerMarshal *This = impl_from_IUnknown(iface);
1526     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1527     *ppv = NULL;
1528     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
1529     {
1530         *ppv = &This->IMarshal_iface;
1531         IUnknown_AddRef((IUnknown *)&This->IMarshal_iface);
1532         return S_OK;
1533     }
1534     FIXME("No interface for %s\n", debugstr_guid(riid));
1535     return E_NOINTERFACE;
1536 }
1537
1538 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1539 {
1540     MonikerMarshal *This = impl_from_IUnknown(iface);
1541     return InterlockedIncrement(&This->ref);
1542 }
1543
1544 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1545 {
1546     MonikerMarshal *This = impl_from_IUnknown(iface);
1547     ULONG ref = InterlockedDecrement(&This->ref);
1548
1549     if (!ref) HeapFree(GetProcessHeap(), 0, This);
1550     return ref;
1551 }
1552
1553 static const IUnknownVtbl VT_MonikerMarshalInner =
1554 {
1555     MonikerMarshalInner_QueryInterface,
1556     MonikerMarshalInner_AddRef,
1557     MonikerMarshalInner_Release
1558 };
1559
1560 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1561 {
1562     MonikerMarshal *This = impl_from_IMarshal(iface);
1563     return IMoniker_QueryInterface(This->moniker, riid, ppv);
1564 }
1565
1566 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1567 {
1568     MonikerMarshal *This = impl_from_IMarshal(iface);
1569     return IMoniker_AddRef(This->moniker);
1570 }
1571
1572 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1573 {
1574     MonikerMarshal *This = impl_from_IMarshal(iface);
1575     return IMoniker_Release(This->moniker);
1576 }
1577
1578 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1579   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1580   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1581 {
1582     MonikerMarshal *This = impl_from_IMarshal(iface);
1583
1584     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1585         dwDestContext, pvDestContext, mshlflags, pCid);
1586
1587     return IMoniker_GetClassID(This->moniker, pCid);
1588 }
1589
1590 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1591   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1592   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1593 {
1594     MonikerMarshal *This = impl_from_IMarshal(iface);
1595     HRESULT hr;
1596     ULARGE_INTEGER size;
1597
1598     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1599         dwDestContext, pvDestContext, mshlflags, pSize);
1600
1601     hr = IMoniker_GetSizeMax(This->moniker, &size);
1602     if (hr == S_OK)
1603         *pSize = (DWORD)size.QuadPart;
1604     return hr;
1605 }
1606
1607 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm, 
1608     REFIID riid, void* pv, DWORD dwDestContext,
1609     void* pvDestContext, DWORD mshlflags)
1610 {
1611     MonikerMarshal *This = impl_from_IMarshal(iface);
1612
1613     TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1614         dwDestContext, pvDestContext, mshlflags);
1615
1616     return IMoniker_Save(This->moniker, pStm, FALSE);
1617 }
1618
1619 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1620 {
1621     MonikerMarshal *This = impl_from_IMarshal(iface);
1622     HRESULT hr;
1623
1624     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1625
1626     hr = IMoniker_Load(This->moniker, pStm);
1627     if (hr == S_OK)
1628         hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1629     return hr;
1630 }
1631
1632 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1633 {
1634     TRACE("()\n");
1635     /* can't release a state-based marshal as nothing on server side to
1636      * release */
1637     return S_OK;
1638 }
1639
1640 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1641 {
1642     TRACE("()\n");
1643     /* can't disconnect a state-based marshal as nothing on server side to
1644      * disconnect from */
1645     return S_OK;
1646 }
1647
1648 static const IMarshalVtbl VT_MonikerMarshal =
1649 {
1650     MonikerMarshal_QueryInterface,
1651     MonikerMarshal_AddRef,
1652     MonikerMarshal_Release,
1653     MonikerMarshal_GetUnmarshalClass,
1654     MonikerMarshal_GetMarshalSizeMax,
1655     MonikerMarshal_MarshalInterface,
1656     MonikerMarshal_UnmarshalInterface,
1657     MonikerMarshal_ReleaseMarshalData,
1658     MonikerMarshal_DisconnectObject
1659 };
1660
1661 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1662 {
1663     MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1664     if (!This) return E_OUTOFMEMORY;
1665
1666     This->IUnknown_iface.lpVtbl = &VT_MonikerMarshalInner;
1667     This->IMarshal_iface.lpVtbl = &VT_MonikerMarshal;
1668     This->ref = 1;
1669     This->moniker = inner;
1670
1671     *outer = &This->IUnknown_iface;
1672     return S_OK;
1673 }
1674
1675 void * __RPC_USER MIDL_user_allocate(SIZE_T size)
1676 {
1677     return HeapAlloc(GetProcessHeap(), 0, size);
1678 }
1679
1680 void __RPC_USER MIDL_user_free(void *p)
1681 {
1682     HeapFree(GetProcessHeap(), 0, p);
1683 }