4 * Copyright 1998 Marcus Meissner
5 * Copyright 1999 Noomen Hamza
6 * Copyright 2005 Robert Shearman (for CodeWeavers)
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.
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.
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
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.
41 #include "wine/list.h"
42 #include "wine/debug.h"
44 #include "compobj_private.h"
46 WINE_DEFAULT_DEBUG_CHANNEL(ole);
48 /* define the structure of the running object table elements */
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;
59 /* define the RunningObjectTableImpl structure */
60 typedef struct RunningObjectTableImpl
62 const IRunningObjectTableVtbl *lpVtbl;
65 struct list rot; /* list of ROT entries */
66 CRITICAL_SECTION lock;
67 } RunningObjectTableImpl;
69 static RunningObjectTableImpl* runningObjectTableInstance = NULL;
73 static inline HRESULT WINAPI
74 IrotRegister(DWORD *cookie)
76 static LONG last_cookie = 1;
77 *cookie = InterlockedIncrement(&last_cookie);
81 /* define the EnumMonikerImpl structure */
82 typedef struct EnumMonikerImpl
84 const IEnumMonikerVtbl *lpVtbl;
87 MInterfacePointer **monikers;
93 /* IEnumMoniker Local functions*/
94 static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers,
95 ULONG moniker_count, ULONG pos, IEnumMoniker **ppenumMoniker);
97 static HRESULT create_stream_on_mip_ro(const MInterfacePointer *mip, IStream **stream)
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);
106 static inline void rot_entry_delete(struct rot_entry *rot_entry)
108 /* FIXME: revoke entry from rpcss's copy of the ROT */
109 if (rot_entry->object)
113 hr = create_stream_on_mip_ro(rot_entry->object, &stream);
116 CoReleaseMarshalData(stream);
117 IUnknown_Release(stream);
120 if (rot_entry->moniker)
124 hr = create_stream_on_mip_ro(rot_entry->moniker, &stream);
127 CoReleaseMarshalData(stream);
128 IUnknown_Release(stream);
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);
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)
141 IROTData *pROTData = NULL;
143 hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
146 ERR("Failed to query moniker for IROTData interface, hr = 0x%08lx\n", hr);
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);
155 ERR("Failed to copy comparison data into buffer, hr = 0x%08lx\n", hr);
156 HeapFree(GetProcessHeap(), 0, *moniker_data);
162 /***********************************************************************
163 * RunningObjectTable_QueryInterface
165 static HRESULT WINAPI
166 RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface,
167 REFIID riid,void** ppvObject)
169 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
171 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
173 /* validate arguments */
180 if (IsEqualIID(&IID_IUnknown, riid) ||
181 IsEqualIID(&IID_IRunningObjectTable, riid))
182 *ppvObject = (IRunningObjectTable*)This;
185 return E_NOINTERFACE;
187 IRunningObjectTable_AddRef(iface);
192 /***********************************************************************
193 * RunningObjectTable_AddRef
196 RunningObjectTableImpl_AddRef(IRunningObjectTable* iface)
198 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
200 TRACE("(%p)\n",This);
202 return InterlockedIncrement(&This->ref);
205 /***********************************************************************
206 * RunningObjectTable_Initialize
208 static HRESULT WINAPI
209 RunningObjectTableImpl_Destroy(void)
211 struct list *cursor, *cursor2;
215 if (runningObjectTableInstance==NULL)
218 /* free the ROT table memory */
219 LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot)
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);
226 /* free the ROT structure memory */
227 HeapFree(GetProcessHeap(),0,runningObjectTableInstance);
228 runningObjectTableInstance = NULL;
233 /***********************************************************************
234 * RunningObjectTable_Release
237 RunningObjectTableImpl_Release(IRunningObjectTable* iface)
239 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
242 TRACE("(%p)\n",This);
244 ref = InterlockedDecrement(&This->ref);
246 /* uninitialize ROT structure if there's no more references to it */
249 struct list *cursor, *cursor2;
250 LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot)
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);
256 /* RunningObjectTable data structure will be not destroyed here ! the destruction will be done only
257 * when RunningObjectTableImpl_UnInitialize function is called
264 /***********************************************************************
265 * RunningObjectTable_Register
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
273 static HRESULT WINAPI
274 RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD grfFlags,
275 IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
277 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
278 struct rot_entry *rot_entry;
280 IStream *pStream = NULL;
283 TRACE("(%p,%ld,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister);
286 * there's only two types of register : strong and or weak registration
287 * (only one must be passed on parameter)
289 if ( ( (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) || !(grfFlags & ROTFLAGS_ALLOWANYCLIENT)) &&
290 (!(grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) || (grfFlags & ROTFLAGS_ALLOWANYCLIENT)) &&
293 ERR("Invalid combination of ROTFLAGS: %lx\n", grfFlags);
297 if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL)
300 rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
302 return E_OUTOFMEMORY;
304 CoFileTimeNow(&rot_entry->last_modified);
307 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
310 rot_entry_delete(rot_entry);
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 */
320 hr = GetHGlobalFromStream(pStream, &hglobal);
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);
331 IStream_Release(pStream);
334 rot_entry_delete(rot_entry);
338 hr = get_moniker_comparison_data(pmkObjectName, &rot_entry->moniker_data);
341 rot_entry_delete(rot_entry);
345 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
348 rot_entry_delete(rot_entry);
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 */
358 hr = GetHGlobalFromStream(pStream, &hglobal);
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);
369 IStream_Release(pStream);
372 rot_entry_delete(rot_entry);
376 /* FIXME: not the right signature of IrotRegister function */
377 hr = IrotRegister(&rot_entry->cookie);
380 rot_entry_delete(rot_entry);
384 /* gives a registration identifier to the registered object*/
385 *pdwRegister = rot_entry->cookie;
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);
395 /***********************************************************************
396 * RunningObjectTable_Revoke
399 * dwRegister [in] Value identifying registration to be revoked
401 static HRESULT WINAPI
402 RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister)
404 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
405 struct rot_entry *rot_entry;
407 TRACE("(%p,%ld)\n",This,dwRegister);
409 EnterCriticalSection(&This->lock);
410 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
412 if (rot_entry->cookie == dwRegister)
414 list_remove(&rot_entry->entry);
415 LeaveCriticalSection(&This->lock);
417 rot_entry_delete(rot_entry);
421 LeaveCriticalSection(&This->lock);
426 /***********************************************************************
427 * RunningObjectTable_IsRunning
430 * pmkObjectName [in] moniker of the object whose status is desired
432 static HRESULT WINAPI
433 RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName)
435 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
436 MInterfacePointer *moniker_data;
438 struct rot_entry *rot_entry;
440 TRACE("(%p,%p)\n",This,pmkObjectName);
442 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
447 EnterCriticalSection(&This->lock);
448 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
450 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
451 !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
457 LeaveCriticalSection(&This->lock);
459 /* FIXME: call IrotIsRunning */
461 HeapFree(GetProcessHeap(), 0, moniker_data);
466 /***********************************************************************
467 * RunningObjectTable_GetObject
470 * pmkObjectName [in] Pointer to the moniker on the object
471 * ppunkObject [out] variable that receives the IUnknown interface pointer
473 static HRESULT WINAPI
474 RunningObjectTableImpl_GetObject( IRunningObjectTable* iface,
475 IMoniker *pmkObjectName, IUnknown **ppunkObject)
477 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
478 MInterfacePointer *moniker_data;
480 struct rot_entry *rot_entry;
482 TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
484 if (ppunkObject == NULL)
489 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
493 EnterCriticalSection(&This->lock);
494 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
496 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
497 !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
500 hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
503 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
504 IStream_Release(pStream);
507 LeaveCriticalSection(&This->lock);
508 HeapFree(GetProcessHeap(), 0, moniker_data);
513 LeaveCriticalSection(&This->lock);
515 /* FIXME: call IrotGetObject */
516 WARN("Moniker unavailable - app may require interprocess running object table\n");
517 hr = MK_E_UNAVAILABLE;
519 HeapFree(GetProcessHeap(), 0, moniker_data);
524 /***********************************************************************
525 * RunningObjectTable_NoteChangeTime
528 * dwRegister [in] Value identifying registration being updated
529 * pfiletime [in] Pointer to structure containing object's last change time
531 static HRESULT WINAPI
532 RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface,
533 DWORD dwRegister, FILETIME *pfiletime)
535 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
536 struct rot_entry *rot_entry;
538 TRACE("(%p,%ld,%p)\n",This,dwRegister,pfiletime);
540 EnterCriticalSection(&This->lock);
541 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
543 if (rot_entry->cookie == dwRegister)
545 rot_entry->last_modified = *pfiletime;
546 LeaveCriticalSection(&This->lock);
550 LeaveCriticalSection(&This->lock);
552 /* FIXME: call IrotNoteChangeTime */
557 /***********************************************************************
558 * RunningObjectTable_GetTimeOfLastChange
561 * pmkObjectName [in] moniker of the object whose status is desired
562 * pfiletime [out] structure that receives object's last change time
564 static HRESULT WINAPI
565 RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface,
566 IMoniker *pmkObjectName, FILETIME *pfiletime)
568 HRESULT hr = MK_E_UNAVAILABLE;
569 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
570 MInterfacePointer *moniker_data;
571 struct rot_entry *rot_entry;
573 TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
575 if (pmkObjectName==NULL || pfiletime==NULL)
578 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
582 hr = MK_E_UNAVAILABLE;
584 EnterCriticalSection(&This->lock);
585 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
587 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
588 !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData))
590 *pfiletime = rot_entry->last_modified;
595 LeaveCriticalSection(&This->lock);
597 /* FIXME: if (hr != S_OK) call IrotGetTimeOfLastChange */
599 HeapFree(GetProcessHeap(), 0, moniker_data);
603 /***********************************************************************
604 * RunningObjectTable_EnumRunning
607 * ppenumMoniker [out] receives the IEnumMoniker interface pointer
609 static HRESULT WINAPI
610 RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface,
611 IEnumMoniker **ppenumMoniker)
614 RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface;
615 MInterfacePointer **monikers;
616 ULONG moniker_count = 0;
617 const struct rot_entry *rot_entry;
620 EnterCriticalSection(&This->lock);
622 LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry )
625 monikers = HeapAlloc(GetProcessHeap(), 0, moniker_count * sizeof(*monikers));
627 LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry )
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);
635 LeaveCriticalSection(&This->lock);
637 /* FIXME: call IrotEnumRunning and append data */
639 hr = EnumMonikerImpl_CreateEnumROTMoniker(monikers, moniker_count, 0, ppenumMoniker);
644 /***********************************************************************
645 * GetRunningObjectTable (OLE32.@)
648 GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
650 IID riid=IID_IRunningObjectTable;
658 if(runningObjectTableInstance==NULL)
659 return CO_E_NOTINITIALIZED;
661 res = IRunningObjectTable_QueryInterface((IRunningObjectTable*)runningObjectTableInstance,&riid,(void**)pprot);
666 /******************************************************************************
669 HRESULT WINAPI OleRun(LPUNKNOWN pUnknown)
671 IRunnableObject *runable;
672 IRunnableObject *This = (IRunnableObject *)pUnknown;
675 ret = IRunnableObject_QueryInterface(This,&IID_IRunnableObject,(LPVOID*)&runable);
677 return 0; /* Appears to return no error. */
678 ret = IRunnableObject_Run(runable,NULL);
679 IRunnableObject_Release(runable);
683 /******************************************************************************
684 * MkParseDisplayName [OLE32.@]
686 HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName,
687 LPDWORD pchEaten, LPMONIKER *ppmk)
689 FIXME("(%p, %s, %p, %p): stub.\n", pbc, debugstr_w(szUserName), pchEaten, *ppmk);
691 if (!(IsValidInterface((LPUNKNOWN) pbc)))
697 /******************************************************************************
698 * CreateClassMoniker [OLE32.@]
700 HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, IMoniker ** ppmk)
702 FIXME("%s\n", debugstr_guid( rclsid ));
708 /* Virtual function table for the IRunningObjectTable class. */
709 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl =
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
723 /***********************************************************************
724 * RunningObjectTable_Initialize
726 HRESULT WINAPI RunningObjectTableImpl_Initialize(void)
730 /* create the unique instance of the RunningObjectTableImpl structure */
731 runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl));
733 if (!runningObjectTableInstance)
734 return E_OUTOFMEMORY;
736 /* initialize the virtual table function */
737 runningObjectTableInstance->lpVtbl = &VT_RunningObjectTableImpl;
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;
744 list_init(&runningObjectTableInstance->rot);
745 InitializeCriticalSection(&runningObjectTableInstance->lock);
750 /***********************************************************************
751 * RunningObjectTable_UnInitialize
753 HRESULT WINAPI RunningObjectTableImpl_UnInitialize()
757 if (runningObjectTableInstance==NULL)
760 RunningObjectTableImpl_Release((IRunningObjectTable*)runningObjectTableInstance);
762 RunningObjectTableImpl_Destroy();
767 /***********************************************************************
768 * EnumMoniker_QueryInterface
770 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
772 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
774 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
776 /* validate arguments */
777 if (ppvObject == NULL)
782 if (IsEqualIID(&IID_IUnknown, riid))
783 *ppvObject = (IEnumMoniker*)This;
785 if (IsEqualIID(&IID_IEnumMoniker, riid))
786 *ppvObject = (IEnumMoniker*)This;
788 if ((*ppvObject)==NULL)
789 return E_NOINTERFACE;
791 IEnumMoniker_AddRef(iface);
796 /***********************************************************************
799 static ULONG WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
801 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
803 TRACE("(%p)\n",This);
805 return InterlockedIncrement(&This->ref);
808 /***********************************************************************
809 * EnumMoniker_release
811 static ULONG WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
813 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
816 TRACE("(%p)\n",This);
818 ref = InterlockedDecrement(&This->ref);
820 /* unitialize rot structure if there's no more reference to it*/
825 TRACE("(%p) Deleting\n",This);
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);
835 /***********************************************************************
838 static HRESULT WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
841 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
844 TRACE("(%p) TabCurrentPos %ld Tablastindx %ld\n", This, This->pos, This->moniker_count);
846 /* retrieve the requested number of moniker from the current position */
847 for(i = 0; (This->pos < This->moniker_count) && (i < celt); i++)
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;
857 if (pceltFetched != NULL)
870 /***********************************************************************
873 static HRESULT WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
875 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
877 TRACE("(%p)\n",This);
879 if (This->pos + celt >= This->moniker_count)
887 /***********************************************************************
890 static HRESULT WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
892 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
894 This->pos = 0; /* set back to start of list */
896 TRACE("(%p)\n",This);
901 /***********************************************************************
904 static HRESULT WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
906 EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
907 MInterfacePointer **monikers = HeapAlloc(GetProcessHeap(), 0, sizeof(*monikers)*This->moniker_count);
910 TRACE("(%p)\n",This);
912 for (i = 0; i < This->moniker_count; i++)
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);
919 /* copy the enum structure */
920 return EnumMonikerImpl_CreateEnumROTMoniker(monikers, This->moniker_count,
924 /* Virtual function table for the IEnumMoniker class. */
925 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
927 EnumMonikerImpl_QueryInterface,
928 EnumMonikerImpl_AddRef,
929 EnumMonikerImpl_Release,
930 EnumMonikerImpl_Next,
931 EnumMonikerImpl_Skip,
932 EnumMonikerImpl_Reset,
933 EnumMonikerImpl_Clone
936 /***********************************************************************
937 * EnumMonikerImpl_CreateEnumROTMoniker
938 * Used by EnumRunning to create the structure and EnumClone
939 * to copy the structure
941 static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers,
944 IEnumMoniker **ppenumMoniker)
946 EnumMonikerImpl* This = NULL;
951 This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
952 if (!This) return E_OUTOFMEMORY;
954 TRACE("(%p)\n", This);
956 /* initialize the virtual table function */
957 This->lpVtbl = &VT_EnumMonikerImpl;
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;
965 *ppenumMoniker = (IEnumMoniker*)This;
971 /* Shared implementation of moniker marshaler based on saving and loading of
974 typedef struct MonikerMarshal
976 const IUnknownVtbl *lpVtbl;
977 const IMarshalVtbl *lpVtblMarshal;
983 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
985 return (MonikerMarshal *)((char*)iface - FIELD_OFFSET(MonikerMarshal, lpVtblMarshal));
988 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
990 MonikerMarshal *This = (MonikerMarshal *)iface;
991 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
993 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
995 *ppv = &This->lpVtblMarshal;
996 IUnknown_AddRef((IUnknown *)&This->lpVtblMarshal);
999 FIXME("No interface for %s\n", debugstr_guid(riid));
1000 return E_NOINTERFACE;
1003 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1005 MonikerMarshal *This = (MonikerMarshal *)iface;
1006 return InterlockedIncrement(&This->ref);
1009 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1011 MonikerMarshal *This = (MonikerMarshal *)iface;
1012 ULONG ref = InterlockedDecrement(&This->ref);
1014 if (!ref) HeapFree(GetProcessHeap(), 0, This);
1018 static const IUnknownVtbl VT_MonikerMarshalInner =
1020 MonikerMarshalInner_QueryInterface,
1021 MonikerMarshalInner_AddRef,
1022 MonikerMarshalInner_Release
1025 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1027 MonikerMarshal *This = impl_from_IMarshal(iface);
1028 return IMoniker_QueryInterface(This->moniker, riid, ppv);
1031 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1033 MonikerMarshal *This = impl_from_IMarshal(iface);
1034 return IMoniker_AddRef(This->moniker);
1037 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1039 MonikerMarshal *This = impl_from_IMarshal(iface);
1040 return IMoniker_Release(This->moniker);
1043 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1044 LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1045 void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1047 MonikerMarshal *This = impl_from_IMarshal(iface);
1049 TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv,
1050 dwDestContext, pvDestContext, mshlflags, pCid);
1052 return IMoniker_GetClassID(This->moniker, pCid);
1055 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1056 LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1057 void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1059 MonikerMarshal *This = impl_from_IMarshal(iface);
1061 ULARGE_INTEGER size;
1063 TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv,
1064 dwDestContext, pvDestContext, mshlflags, pSize);
1066 hr = IMoniker_GetSizeMax(This->moniker, &size);
1068 *pSize = (DWORD)size.QuadPart;
1072 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm,
1073 REFIID riid, void* pv, DWORD dwDestContext,
1074 void* pvDestContext, DWORD mshlflags)
1076 MonikerMarshal *This = impl_from_IMarshal(iface);
1078 TRACE("(%p, %s, %p, %lx, %p, %lx)\n", pStm, debugstr_guid(riid), pv,
1079 dwDestContext, pvDestContext, mshlflags);
1081 return IMoniker_Save(This->moniker, pStm, FALSE);
1084 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1086 MonikerMarshal *This = impl_from_IMarshal(iface);
1089 TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1091 hr = IMoniker_Load(This->moniker, pStm);
1093 hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1097 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1100 /* can't release a state-based marshal as nothing on server side to
1105 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1108 /* can't disconnect a state-based marshal as nothing on server side to
1109 * disconnect from */
1113 static const IMarshalVtbl VT_MonikerMarshal =
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
1126 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1128 MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1129 if (!This) return E_OUTOFMEMORY;
1131 This->lpVtbl = &VT_MonikerMarshalInner;
1132 This->lpVtblMarshal = &VT_MonikerMarshal;
1134 This->moniker = inner;
1136 *outer = (IUnknown *)&This->lpVtbl;