iphlpapi: Clean up memory allocation.
[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  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  * TODO:
23  * - IRunningObjectTable should work interprocess, but currently doesn't.
24  *   Native (on Win2k at least) uses an undocumented RPC interface, IROT, to
25  *   communicate with RPCSS which contains the table of marshalled data.
26  */
27
28 #include <assert.h>
29 #include <stdarg.h>
30 #include <string.h>
31
32 #define COBJMACROS
33
34 #include "winerror.h"
35 #include "windef.h"
36 #include "winbase.h"
37 #include "winuser.h"
38 #include "wtypes.h"
39 #include "ole2.h"
40
41 #include "wine/list.h"
42 #include "wine/debug.h"
43
44 #include "compobj_private.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(ole);
47
48 /* define the structure of the running object table elements */
49 struct rot_entry
50 {
51     struct list        entry;
52     MInterfacePointer* object; /* marshaled running object*/
53     MInterfacePointer* moniker; /* marshaled moniker that identifies this object */
54     MInterfacePointer* moniker_data; /* moniker comparison data that identifies this object */
55     DWORD              cookie; /* cookie identifying this object */
56     FILETIME           last_modified;
57 };
58
59 /* define the RunningObjectTableImpl structure */
60 typedef struct RunningObjectTableImpl
61 {
62     const IRunningObjectTableVtbl *lpVtbl;
63     LONG ref;
64
65     struct list rot; /* list of ROT entries */
66     CRITICAL_SECTION lock;
67 } RunningObjectTableImpl;
68
69 static RunningObjectTableImpl* runningObjectTableInstance = NULL;
70
71
72
73 static inline HRESULT WINAPI
74 IrotRegister(DWORD *cookie)
75 {
76     static LONG last_cookie = 1;
77     *cookie = InterlockedIncrement(&last_cookie);
78     return S_OK;
79 }
80
81 /* define the EnumMonikerImpl structure */
82 typedef struct EnumMonikerImpl
83 {
84     const IEnumMonikerVtbl *lpVtbl;
85     LONG ref;
86
87     MInterfacePointer **monikers;
88     ULONG moniker_count;
89     ULONG pos;
90 } EnumMonikerImpl;
91
92
93 /* IEnumMoniker Local functions*/
94 static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers,
95     ULONG moniker_count, ULONG pos, IEnumMoniker **ppenumMoniker);
96
97 static HRESULT create_stream_on_mip_ro(const MInterfacePointer *mip, IStream **stream)
98 {
99     HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData);
100     void *pv = GlobalLock(hglobal);
101     memcpy(pv, mip->abData, mip->ulCntData);
102     GlobalUnlock(hglobal);
103     return CreateStreamOnHGlobal(hglobal, TRUE, stream);
104 }
105
106 static inline void rot_entry_delete(struct rot_entry *rot_entry)
107 {
108     /* FIXME: revoke entry from rpcss's copy of the ROT */
109     if (rot_entry->object)
110     {
111         IStream *stream;
112         HRESULT hr;
113         hr = create_stream_on_mip_ro(rot_entry->object, &stream);
114         if (hr == S_OK)
115         {
116             CoReleaseMarshalData(stream);
117             IUnknown_Release(stream);
118         }
119     }
120     if (rot_entry->moniker)
121     {
122         IStream *stream;
123         HRESULT hr;
124         hr = create_stream_on_mip_ro(rot_entry->moniker, &stream);
125         if (hr == S_OK)
126         {
127             CoReleaseMarshalData(stream);
128             IUnknown_Release(stream);
129         }
130     }
131     HeapFree(GetProcessHeap(), 0, rot_entry->object);
132     HeapFree(GetProcessHeap(), 0, rot_entry->moniker);
133     HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
134     HeapFree(GetProcessHeap(), 0, rot_entry);
135 }
136
137 /* moniker_data must be freed with HeapFree when no longer in use */
138 static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MInterfacePointer **moniker_data)
139 {
140     HRESULT hr;
141     IROTData *pROTData = NULL;
142     ULONG size = 0;
143     hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
144     if (hr != S_OK)
145     {
146         ERR("Failed to query moniker for IROTData interface, hr = 0x%08lx\n", hr);
147         return hr;
148     }
149     IROTData_GetComparisonData(pROTData, NULL, 0, &size);
150     *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
151     (*moniker_data)->ulCntData = size;
152     hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size);
153     if (hr != S_OK)
154     {
155         ERR("Failed to copy comparison data into buffer, hr = 0x%08lx\n", hr);
156         HeapFree(GetProcessHeap(), 0, *moniker_data);
157         return hr;
158     }
159     return S_OK;
160 }
161
162 /***********************************************************************
163  *        RunningObjectTable_QueryInterface
164  */
165 static HRESULT WINAPI
166 RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface,
167                                       REFIID riid,void** ppvObject)
168 {
169     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
170
171     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
172
173     /* validate arguments */
174
175     if (ppvObject==0)
176         return E_INVALIDARG;
177
178     *ppvObject = 0;
179
180     if (IsEqualIID(&IID_IUnknown, riid) ||
181         IsEqualIID(&IID_IRunningObjectTable, riid))
182         *ppvObject = (IRunningObjectTable*)This;
183
184     if ((*ppvObject)==0)
185         return E_NOINTERFACE;
186
187     IRunningObjectTable_AddRef(iface);
188
189     return S_OK;
190 }
191
192 /***********************************************************************
193  *        RunningObjectTable_AddRef
194  */
195 static ULONG WINAPI
196 RunningObjectTableImpl_AddRef(IRunningObjectTable* iface)
197 {
198     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
199
200     TRACE("(%p)\n",This);
201
202     return InterlockedIncrement(&This->ref);
203 }
204
205 /***********************************************************************
206  *        RunningObjectTable_Initialize
207  */
208 static HRESULT WINAPI
209 RunningObjectTableImpl_Destroy(void)
210 {
211     struct list *cursor, *cursor2;
212
213     TRACE("()\n");
214
215     if (runningObjectTableInstance==NULL)
216         return E_INVALIDARG;
217
218     /* free the ROT table memory */
219     LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot)
220     {
221         struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
222         list_remove(&rot_entry->entry);
223         rot_entry_delete(rot_entry);
224     }
225
226     /* free the ROT structure memory */
227     HeapFree(GetProcessHeap(),0,runningObjectTableInstance);
228     runningObjectTableInstance = NULL;
229
230     return S_OK;
231 }
232
233 /***********************************************************************
234  *        RunningObjectTable_Release
235  */
236 static ULONG WINAPI
237 RunningObjectTableImpl_Release(IRunningObjectTable* iface)
238 {
239     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
240     ULONG ref;
241
242     TRACE("(%p)\n",This);
243
244     ref = InterlockedDecrement(&This->ref);
245
246     /* uninitialize ROT structure if there's no more references to it */
247     if (ref == 0)
248     {
249         struct list *cursor, *cursor2;
250         LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot)
251         {
252             struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
253             list_remove(&rot_entry->entry);
254             rot_entry_delete(rot_entry);
255         }
256         /*  RunningObjectTable data structure will be not destroyed here ! the destruction will be done only
257          *  when RunningObjectTableImpl_UnInitialize function is called
258          */
259     }
260
261     return ref;
262 }
263
264 /***********************************************************************
265  *        RunningObjectTable_Register
266  *
267  * PARAMS
268  * grfFlags       [in] Registration options 
269  * punkObject     [in] the object being registered
270  * pmkObjectName  [in] the moniker of the object being registered
271  * pdwRegister    [in] the value identifying the registration
272  */
273 static HRESULT WINAPI
274 RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD grfFlags,
275                IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
276 {
277     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
278     struct rot_entry *rot_entry;
279     HRESULT hr = S_OK;
280     IStream *pStream = NULL;
281     DWORD mshlflags;
282
283     TRACE("(%p,%ld,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister);
284
285     /*
286      * there's only two types of register : strong and or weak registration
287      * (only one must be passed on parameter)
288      */
289     if ( ( (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) || !(grfFlags & ROTFLAGS_ALLOWANYCLIENT)) &&
290          (!(grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) ||  (grfFlags & ROTFLAGS_ALLOWANYCLIENT)) &&
291          (grfFlags) )
292     {
293         ERR("Invalid combination of ROTFLAGS: %lx\n", grfFlags);
294         return E_INVALIDARG;
295     }
296
297     if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL)
298         return E_INVALIDARG;
299
300     rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
301     if (!rot_entry)
302         return E_OUTOFMEMORY;
303
304     CoFileTimeNow(&rot_entry->last_modified);
305
306     /* marshal object */
307     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
308     if (hr != S_OK)
309     {
310         rot_entry_delete(rot_entry);
311         return hr;
312     }
313     mshlflags = (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) ? MSHLFLAGS_TABLESTRONG : MSHLFLAGS_TABLEWEAK;
314     hr = CoMarshalInterface(pStream, &IID_IUnknown, punkObject, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, mshlflags);
315     /* FIXME: a cleaner way would be to create an IStream class that writes
316      * directly to an MInterfacePointer */
317     if (hr == S_OK)
318     {
319         HGLOBAL hglobal;
320         hr = GetHGlobalFromStream(pStream, &hglobal);
321         if (hr == S_OK)
322         {
323             SIZE_T size = GlobalSize(hglobal);
324             const void *pv = GlobalLock(hglobal);
325             rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
326             rot_entry->object->ulCntData = size;
327             memcpy(&rot_entry->object->abData, pv, size);
328             GlobalUnlock(hglobal);
329         }
330     }
331     IStream_Release(pStream);
332     if (hr != S_OK)
333     {
334         rot_entry_delete(rot_entry);
335         return hr;
336     }
337
338     hr = get_moniker_comparison_data(pmkObjectName, &rot_entry->moniker_data);
339     if (hr != S_OK)
340     {
341         rot_entry_delete(rot_entry);
342         return hr;
343     }
344
345     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
346     if (hr != S_OK)
347     {
348         rot_entry_delete(rot_entry);
349         return hr;
350     }
351     /* marshal moniker */
352     hr = CoMarshalInterface(pStream, &IID_IMoniker, (IUnknown *)pmkObjectName, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG);
353     /* FIXME: a cleaner way would be to create an IStream class that writes
354      * directly to an MInterfacePointer */
355     if (hr == S_OK)
356     {
357         HGLOBAL hglobal;
358         hr = GetHGlobalFromStream(pStream, &hglobal);
359         if (hr == S_OK)
360         {
361             SIZE_T size = GlobalSize(hglobal);
362             const void *pv = GlobalLock(hglobal);
363             rot_entry->moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
364             rot_entry->moniker->ulCntData = size;
365             memcpy(&rot_entry->moniker->abData, pv, size);
366             GlobalUnlock(hglobal);
367         }
368     }
369     IStream_Release(pStream);
370     if (hr != S_OK)
371     {
372         rot_entry_delete(rot_entry);
373         return hr;
374     }
375
376     /* FIXME: not the right signature of IrotRegister function */
377     hr = IrotRegister(&rot_entry->cookie);
378     if (hr != S_OK)
379     {
380         rot_entry_delete(rot_entry);
381         return hr;
382     }
383
384     /* gives a registration identifier to the registered object*/
385     *pdwRegister = rot_entry->cookie;
386
387     EnterCriticalSection(&This->lock);
388     /* FIXME: see if object was registered before and return MK_S_MONIKERALREADYREGISTERED */
389     list_add_tail(&This->rot, &rot_entry->entry);
390     LeaveCriticalSection(&This->lock);
391
392     return hr;
393 }
394
395 /***********************************************************************
396  *        RunningObjectTable_Revoke
397  *
398  * PARAMS
399  *  dwRegister [in] Value identifying registration to be revoked
400  */
401 static HRESULT WINAPI
402 RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister) 
403 {
404     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
405     struct rot_entry *rot_entry;
406
407     TRACE("(%p,%ld)\n",This,dwRegister);
408
409     EnterCriticalSection(&This->lock);
410     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
411     {
412         if (rot_entry->cookie == dwRegister)
413         {
414             list_remove(&rot_entry->entry);
415             LeaveCriticalSection(&This->lock);
416
417             rot_entry_delete(rot_entry);
418             return S_OK;
419         }
420     }
421     LeaveCriticalSection(&This->lock);
422
423     return E_INVALIDARG;
424 }
425
426 /***********************************************************************
427  *        RunningObjectTable_IsRunning
428  *
429  * PARAMS
430  *  pmkObjectName [in]  moniker of the object whose status is desired 
431  */
432 static HRESULT WINAPI
433 RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName)
434 {
435     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
436     MInterfacePointer *moniker_data;
437     HRESULT hr;
438     struct rot_entry *rot_entry;
439
440     TRACE("(%p,%p)\n",This,pmkObjectName);
441
442     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
443     if (hr != S_OK)
444         return hr;
445
446     hr = S_FALSE;
447     EnterCriticalSection(&This->lock);
448     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
449     {
450         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
451             !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
452         {
453             hr = S_OK;
454             break;
455         }
456     }
457     LeaveCriticalSection(&This->lock);
458
459     /* FIXME: call IrotIsRunning */
460
461     HeapFree(GetProcessHeap(), 0, moniker_data);
462
463     return hr;
464 }
465
466 /***********************************************************************
467  *        RunningObjectTable_GetObject
468  *
469  * PARAMS
470  * pmkObjectName [in] Pointer to the moniker on the object 
471  * ppunkObject   [out] variable that receives the IUnknown interface pointer
472  */
473 static HRESULT WINAPI
474 RunningObjectTableImpl_GetObject( IRunningObjectTable* iface,
475                      IMoniker *pmkObjectName, IUnknown **ppunkObject)
476 {
477     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
478     MInterfacePointer *moniker_data;
479     HRESULT hr;
480     struct rot_entry *rot_entry;
481
482     TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
483
484     if (ppunkObject == NULL)
485         return E_POINTER;
486
487     *ppunkObject = NULL;
488
489     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
490     if (hr != S_OK)
491         return hr;
492
493     EnterCriticalSection(&This->lock);
494     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
495     {
496         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
497             !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
498         {
499             IStream *pStream;
500             hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
501             if (hr == S_OK)
502             {
503                 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
504                 IStream_Release(pStream);
505             }
506
507             LeaveCriticalSection(&This->lock);
508             HeapFree(GetProcessHeap(), 0, moniker_data);
509
510             return hr;
511         }
512     }
513     LeaveCriticalSection(&This->lock);
514
515     /* FIXME: call IrotGetObject */
516     WARN("Moniker unavailable - app may require interprocess running object table\n");
517     hr = MK_E_UNAVAILABLE;
518
519     HeapFree(GetProcessHeap(), 0, moniker_data);
520
521     return hr;
522 }
523
524 /***********************************************************************
525  *        RunningObjectTable_NoteChangeTime
526  *
527  * PARAMS
528  *  dwRegister [in] Value identifying registration being updated
529  *  pfiletime  [in] Pointer to structure containing object's last change time
530  */
531 static HRESULT WINAPI
532 RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface,
533                                       DWORD dwRegister, FILETIME *pfiletime)
534 {
535     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
536     struct rot_entry *rot_entry;
537
538     TRACE("(%p,%ld,%p)\n",This,dwRegister,pfiletime);
539
540     EnterCriticalSection(&This->lock);
541     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
542     {
543         if (rot_entry->cookie == dwRegister)
544         {
545             rot_entry->last_modified = *pfiletime;
546             LeaveCriticalSection(&This->lock);
547             return S_OK;
548         }
549     }
550     LeaveCriticalSection(&This->lock);
551
552     /* FIXME: call IrotNoteChangeTime */
553
554     return E_INVALIDARG;
555 }
556
557 /***********************************************************************
558  *        RunningObjectTable_GetTimeOfLastChange
559  *
560  * PARAMS
561  *  pmkObjectName  [in]  moniker of the object whose status is desired 
562  *  pfiletime      [out] structure that receives object's last change time
563  */
564 static HRESULT WINAPI
565 RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface,
566                             IMoniker *pmkObjectName, FILETIME *pfiletime)
567 {
568     HRESULT hr = MK_E_UNAVAILABLE;
569     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
570     MInterfacePointer *moniker_data;
571     struct rot_entry *rot_entry;
572
573     TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
574
575     if (pmkObjectName==NULL || pfiletime==NULL)
576         return E_INVALIDARG;
577
578     hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
579     if (hr != S_OK)
580         return hr;
581
582     hr = MK_E_UNAVAILABLE;
583
584     EnterCriticalSection(&This->lock);
585     LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
586     {
587         if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
588             !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
589         {
590             *pfiletime = rot_entry->last_modified;
591             hr = S_OK;
592             break;
593         }
594     }
595     LeaveCriticalSection(&This->lock);
596
597     /* FIXME: if (hr != S_OK) call IrotGetTimeOfLastChange */
598
599     HeapFree(GetProcessHeap(), 0, moniker_data);
600     return hr;
601 }
602
603 /***********************************************************************
604  *        RunningObjectTable_EnumRunning
605  *
606  * PARAMS
607  *  ppenumMoniker  [out]  receives the IEnumMoniker interface pointer 
608  */
609 static HRESULT WINAPI
610 RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface,
611                                    IEnumMoniker **ppenumMoniker)
612 {
613     HRESULT hr;
614     RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
615     MInterfacePointer **monikers;
616     ULONG moniker_count = 0;
617     const struct rot_entry *rot_entry;
618     ULONG i = 0;
619
620     EnterCriticalSection(&This->lock);
621
622     LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry )
623         moniker_count++;
624
625     monikers = HeapAlloc(GetProcessHeap(), 0, moniker_count * sizeof(*monikers));
626
627     LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry )
628     {
629         SIZE_T size = FIELD_OFFSET(MInterfacePointer, abData[rot_entry->moniker->ulCntData]);
630         monikers[i] = HeapAlloc(GetProcessHeap(), 0, size);
631         memcpy(monikers[i], rot_entry->moniker, size);
632         i++;
633     }
634
635     LeaveCriticalSection(&This->lock);
636     
637     /* FIXME: call IrotEnumRunning and append data */
638
639     hr = EnumMonikerImpl_CreateEnumROTMoniker(monikers, moniker_count, 0, ppenumMoniker);
640
641     return hr;
642 }
643
644 /***********************************************************************
645  *           GetRunningObjectTable (OLE32.@)
646  */
647 HRESULT WINAPI
648 GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
649 {
650     IID riid=IID_IRunningObjectTable;
651     HRESULT res;
652
653     TRACE("()\n");
654
655     if (reserved!=0)
656         return E_UNEXPECTED;
657
658     if(runningObjectTableInstance==NULL)
659         return CO_E_NOTINITIALIZED;
660
661     res = IRunningObjectTable_QueryInterface((IRunningObjectTable*)runningObjectTableInstance,&riid,(void**)pprot);
662
663     return res;
664 }
665
666 /******************************************************************************
667  *              OleRun        [OLE32.@]
668  */
669 HRESULT WINAPI OleRun(LPUNKNOWN pUnknown)
670 {
671     IRunnableObject *runable;
672     IRunnableObject *This = (IRunnableObject *)pUnknown;
673     LRESULT ret;
674
675     ret = IRunnableObject_QueryInterface(This,&IID_IRunnableObject,(LPVOID*)&runable);
676     if (ret)
677         return 0; /* Appears to return no error. */
678     ret = IRunnableObject_Run(runable,NULL);
679     IRunnableObject_Release(runable);
680     return ret;
681 }
682
683 /******************************************************************************
684  *              MkParseDisplayName        [OLE32.@]
685  */
686 HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName,
687                                 LPDWORD pchEaten, LPMONIKER *ppmk)
688 {
689     FIXME("(%p, %s, %p, %p): stub.\n", pbc, debugstr_w(szUserName), pchEaten, *ppmk);
690
691     if (!(IsValidInterface((LPUNKNOWN) pbc)))
692         return E_INVALIDARG;
693
694     return MK_E_SYNTAX;
695 }
696
697 /******************************************************************************
698  *              CreateClassMoniker        [OLE32.@]
699  */
700 HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, IMoniker ** ppmk)
701 {
702     FIXME("%s\n", debugstr_guid( rclsid ));
703     if( ppmk )
704         *ppmk = NULL;
705     return E_NOTIMPL;
706 }
707
708 /* Virtual function table for the IRunningObjectTable class. */
709 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl =
710 {
711     RunningObjectTableImpl_QueryInterface,
712     RunningObjectTableImpl_AddRef,
713     RunningObjectTableImpl_Release,
714     RunningObjectTableImpl_Register,
715     RunningObjectTableImpl_Revoke,
716     RunningObjectTableImpl_IsRunning,
717     RunningObjectTableImpl_GetObject,
718     RunningObjectTableImpl_NoteChangeTime,
719     RunningObjectTableImpl_GetTimeOfLastChange,
720     RunningObjectTableImpl_EnumRunning
721 };
722
723 /***********************************************************************
724  *        RunningObjectTable_Initialize
725  */
726 HRESULT WINAPI RunningObjectTableImpl_Initialize(void)
727 {
728     TRACE("\n");
729
730     /* create the unique instance of the RunningObjectTableImpl structure */
731     runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl));
732
733     if (!runningObjectTableInstance)
734         return E_OUTOFMEMORY;
735
736     /* initialize the virtual table function */
737     runningObjectTableInstance->lpVtbl = &VT_RunningObjectTableImpl;
738
739     /* the initial reference is set to "1" ! because if set to "0" it will be not practis when */
740     /* the ROT referred many times not in the same time (all the objects in the ROT will  */
741     /* be removed every time the ROT is removed ) */
742     runningObjectTableInstance->ref = 1;
743
744     list_init(&runningObjectTableInstance->rot);
745     InitializeCriticalSection(&runningObjectTableInstance->lock);
746
747     return S_OK;
748 }
749
750 /***********************************************************************
751  *        RunningObjectTable_UnInitialize
752  */
753 HRESULT WINAPI RunningObjectTableImpl_UnInitialize()
754 {
755     TRACE("\n");
756
757     if (runningObjectTableInstance==NULL)
758         return E_POINTER;
759
760     RunningObjectTableImpl_Release((IRunningObjectTable*)runningObjectTableInstance);
761
762     RunningObjectTableImpl_Destroy();
763
764     return S_OK;
765 }
766
767 /***********************************************************************
768  *        EnumMoniker_QueryInterface
769  */
770 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
771 {
772     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
773
774     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
775
776     /* validate arguments */
777     if (ppvObject == NULL)
778         return E_INVALIDARG;
779
780     *ppvObject = NULL;
781
782     if (IsEqualIID(&IID_IUnknown, riid))
783         *ppvObject = (IEnumMoniker*)This;
784     else
785         if (IsEqualIID(&IID_IEnumMoniker, riid))
786             *ppvObject = (IEnumMoniker*)This;
787
788     if ((*ppvObject)==NULL)
789         return E_NOINTERFACE;
790
791     IEnumMoniker_AddRef(iface);
792
793     return S_OK;
794 }
795
796 /***********************************************************************
797  *        EnumMoniker_AddRef
798  */
799 static ULONG   WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
800 {
801     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
802
803     TRACE("(%p)\n",This);
804
805     return InterlockedIncrement(&This->ref);
806 }
807
808 /***********************************************************************
809  *        EnumMoniker_release
810  */
811 static ULONG   WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
812 {
813     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
814     ULONG ref;
815
816     TRACE("(%p)\n",This);
817
818     ref = InterlockedDecrement(&This->ref);
819
820     /* unitialize rot structure if there's no more reference to it*/
821     if (ref == 0)
822     {
823         ULONG i;
824
825         TRACE("(%p) Deleting\n",This);
826
827         for (i = 0; i < This->moniker_count; i++)
828             HeapFree(GetProcessHeap(), 0, This->monikers[i]);
829         HeapFree(GetProcessHeap(), 0, This->monikers);
830         HeapFree(GetProcessHeap(), 0, This);
831     }
832
833     return ref;
834 }
835 /***********************************************************************
836  *        EnmumMoniker_Next
837  */
838 static HRESULT   WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
839 {
840     ULONG i;
841     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
842     HRESULT hr = S_OK;
843
844     TRACE("(%p) TabCurrentPos %ld Tablastindx %ld\n", This, This->pos, This->moniker_count);
845
846     /* retrieve the requested number of moniker from the current position */
847     for(i = 0; (This->pos < This->moniker_count) && (i < celt); i++)
848     {
849         IStream *stream;
850         hr = create_stream_on_mip_ro(This->monikers[This->pos++], &stream);
851         if (hr != S_OK) break;
852         hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]);
853         IStream_Release(stream);
854         if (hr != S_OK) break;
855     }
856
857     if (pceltFetched != NULL)
858         *pceltFetched= i;
859
860     if (hr != S_OK)
861         return hr;
862
863     if (i == celt)
864         return S_OK;
865     else
866         return S_FALSE;
867
868 }
869
870 /***********************************************************************
871  *        EnmumMoniker_Skip
872  */
873 static HRESULT   WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
874 {
875     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
876
877     TRACE("(%p)\n",This);
878
879     if  (This->pos + celt >= This->moniker_count)
880         return S_FALSE;
881
882     This->pos += celt;
883
884     return S_OK;
885 }
886
887 /***********************************************************************
888  *        EnmumMoniker_Reset
889  */
890 static HRESULT   WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
891 {
892     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
893
894     This->pos = 0;      /* set back to start of list */
895
896     TRACE("(%p)\n",This);
897
898     return S_OK;
899 }
900
901 /***********************************************************************
902  *        EnmumMoniker_Clone
903  */
904 static HRESULT   WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
905 {
906     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
907     MInterfacePointer **monikers = HeapAlloc(GetProcessHeap(), 0, sizeof(*monikers)*This->moniker_count);
908     ULONG i;
909
910     TRACE("(%p)\n",This);
911
912     for (i = 0; i < This->moniker_count; i++)
913     {
914         SIZE_T size = FIELD_OFFSET(MInterfacePointer, abData[This->monikers[i]->ulCntData]);
915         monikers[i] = HeapAlloc(GetProcessHeap(), 0, size);
916         memcpy(monikers[i], This->monikers[i], size);
917     }
918
919     /* copy the enum structure */ 
920     return EnumMonikerImpl_CreateEnumROTMoniker(monikers, This->moniker_count,
921         This->pos, ppenum);
922 }
923
924 /* Virtual function table for the IEnumMoniker class. */
925 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
926 {
927     EnumMonikerImpl_QueryInterface,
928     EnumMonikerImpl_AddRef,
929     EnumMonikerImpl_Release,
930     EnumMonikerImpl_Next,
931     EnumMonikerImpl_Skip,
932     EnumMonikerImpl_Reset,
933     EnumMonikerImpl_Clone
934 };
935
936 /***********************************************************************
937  *        EnumMonikerImpl_CreateEnumROTMoniker
938  *        Used by EnumRunning to create the structure and EnumClone
939  *        to copy the structure
940  */
941 static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers,
942                                                  ULONG moniker_count,
943                                                  ULONG current_pos,
944                                                  IEnumMoniker **ppenumMoniker)
945 {
946     EnumMonikerImpl* This = NULL;
947
948     if (!ppenumMoniker)
949         return E_INVALIDARG;
950
951     This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
952     if (!This) return E_OUTOFMEMORY;
953
954     TRACE("(%p)\n", This);
955
956     /* initialize the virtual table function */
957     This->lpVtbl = &VT_EnumMonikerImpl;
958
959     /* the initial reference is set to "1" */
960     This->ref = 1;                      /* set the ref count to one         */
961     This->pos = current_pos;            /* Set the list start posn */
962     This->moniker_count = moniker_count; /* Need the same size table as ROT */
963     This->monikers = monikers;
964
965     *ppenumMoniker =  (IEnumMoniker*)This;
966
967     return S_OK;
968 }
969
970
971 /* Shared implementation of moniker marshaler based on saving and loading of
972  * monikers */
973
974 typedef struct MonikerMarshal
975 {
976     const IUnknownVtbl *lpVtbl;
977     const IMarshalVtbl *lpVtblMarshal;
978     
979     LONG ref;
980     IMoniker *moniker;
981 } MonikerMarshal;
982
983 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
984 {
985     return (MonikerMarshal *)((char*)iface - FIELD_OFFSET(MonikerMarshal, lpVtblMarshal));
986 }
987
988 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
989 {
990     MonikerMarshal *This = (MonikerMarshal *)iface;
991     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
992     *ppv = NULL;
993     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
994     {
995         *ppv = &This->lpVtblMarshal;
996         IUnknown_AddRef((IUnknown *)&This->lpVtblMarshal);
997         return S_OK;
998     }
999     FIXME("No interface for %s\n", debugstr_guid(riid));
1000     return E_NOINTERFACE;
1001 }
1002
1003 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1004 {
1005     MonikerMarshal *This = (MonikerMarshal *)iface;
1006     return InterlockedIncrement(&This->ref);
1007 }
1008
1009 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1010 {
1011     MonikerMarshal *This = (MonikerMarshal *)iface;
1012     ULONG ref = InterlockedDecrement(&This->ref);
1013
1014     if (!ref) HeapFree(GetProcessHeap(), 0, This);
1015     return ref;
1016 }
1017
1018 static const IUnknownVtbl VT_MonikerMarshalInner =
1019 {
1020     MonikerMarshalInner_QueryInterface,
1021     MonikerMarshalInner_AddRef,
1022     MonikerMarshalInner_Release
1023 };
1024
1025 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1026 {
1027     MonikerMarshal *This = impl_from_IMarshal(iface);
1028     return IMoniker_QueryInterface(This->moniker, riid, ppv);
1029 }
1030
1031 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1032 {
1033     MonikerMarshal *This = impl_from_IMarshal(iface);
1034     return IMoniker_AddRef(This->moniker);
1035 }
1036
1037 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1038 {
1039     MonikerMarshal *This = impl_from_IMarshal(iface);
1040     return IMoniker_Release(This->moniker);
1041 }
1042
1043 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1044   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1045   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1046 {
1047     MonikerMarshal *This = impl_from_IMarshal(iface);
1048
1049     TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv,
1050         dwDestContext, pvDestContext, mshlflags, pCid);
1051
1052     return IMoniker_GetClassID(This->moniker, pCid);
1053 }
1054
1055 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1056   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1057   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1058 {
1059     MonikerMarshal *This = impl_from_IMarshal(iface);
1060     HRESULT hr;
1061     ULARGE_INTEGER size;
1062
1063     TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv,
1064         dwDestContext, pvDestContext, mshlflags, pSize);
1065
1066     hr = IMoniker_GetSizeMax(This->moniker, &size);
1067     if (hr == S_OK)
1068         *pSize = (DWORD)size.QuadPart;
1069     return hr;
1070 }
1071
1072 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm, 
1073     REFIID riid, void* pv, DWORD dwDestContext,
1074     void* pvDestContext, DWORD mshlflags)
1075 {
1076     MonikerMarshal *This = impl_from_IMarshal(iface);
1077
1078     TRACE("(%p, %s, %p, %lx, %p, %lx)\n", pStm, debugstr_guid(riid), pv,
1079         dwDestContext, pvDestContext, mshlflags);
1080
1081     return IMoniker_Save(This->moniker, pStm, FALSE);
1082 }
1083
1084 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1085 {
1086     MonikerMarshal *This = impl_from_IMarshal(iface);
1087     HRESULT hr;
1088
1089     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1090
1091     hr = IMoniker_Load(This->moniker, pStm);
1092     if (hr == S_OK)
1093         hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1094     return hr;
1095 }
1096
1097 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1098 {
1099     TRACE("()\n");
1100     /* can't release a state-based marshal as nothing on server side to
1101      * release */
1102     return S_OK;
1103 }
1104
1105 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1106 {
1107     TRACE("()\n");
1108     /* can't disconnect a state-based marshal as nothing on server side to
1109      * disconnect from */
1110     return S_OK;
1111 }
1112
1113 static const IMarshalVtbl VT_MonikerMarshal =
1114 {
1115     MonikerMarshal_QueryInterface,
1116     MonikerMarshal_AddRef,
1117     MonikerMarshal_Release,
1118     MonikerMarshal_GetUnmarshalClass,
1119     MonikerMarshal_GetMarshalSizeMax,
1120     MonikerMarshal_MarshalInterface,
1121     MonikerMarshal_UnmarshalInterface,
1122     MonikerMarshal_ReleaseMarshalData,
1123     MonikerMarshal_DisconnectObject
1124 };
1125
1126 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1127 {
1128     MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1129     if (!This) return E_OUTOFMEMORY;
1130
1131     This->lpVtbl = &VT_MonikerMarshalInner;
1132     This->lpVtblMarshal = &VT_MonikerMarshal;
1133     This->ref = 1;
1134     This->moniker = inner;
1135
1136     *outer = (IUnknown *)&This->lpVtbl;
1137     return S_OK;
1138 }