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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 /* Virtual function table for the IRunningObjectTable class. */
698 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl
=
700 RunningObjectTableImpl_QueryInterface
,
701 RunningObjectTableImpl_AddRef
,
702 RunningObjectTableImpl_Release
,
703 RunningObjectTableImpl_Register
,
704 RunningObjectTableImpl_Revoke
,
705 RunningObjectTableImpl_IsRunning
,
706 RunningObjectTableImpl_GetObject
,
707 RunningObjectTableImpl_NoteChangeTime
,
708 RunningObjectTableImpl_GetTimeOfLastChange
,
709 RunningObjectTableImpl_EnumRunning
712 /***********************************************************************
713 * RunningObjectTable_Initialize
715 HRESULT WINAPI
RunningObjectTableImpl_Initialize(void)
719 /* create the unique instance of the RunningObjectTableImpl structure */
720 runningObjectTableInstance
= HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl
));
722 if (!runningObjectTableInstance
)
723 return E_OUTOFMEMORY
;
725 /* initialize the virtual table function */
726 runningObjectTableInstance
->lpVtbl
= &VT_RunningObjectTableImpl
;
728 /* the initial reference is set to "1" ! because if set to "0" it will be not practis when */
729 /* the ROT referred many times not in the same time (all the objects in the ROT will */
730 /* be removed every time the ROT is removed ) */
731 runningObjectTableInstance
->ref
= 1;
733 list_init(&runningObjectTableInstance
->rot
);
734 InitializeCriticalSection(&runningObjectTableInstance
->lock
);
739 /***********************************************************************
740 * RunningObjectTable_UnInitialize
742 HRESULT WINAPI
RunningObjectTableImpl_UnInitialize()
746 if (runningObjectTableInstance
==NULL
)
749 RunningObjectTableImpl_Release((IRunningObjectTable
*)runningObjectTableInstance
);
751 RunningObjectTableImpl_Destroy();
756 /***********************************************************************
757 * EnumMoniker_QueryInterface
759 static HRESULT WINAPI
EnumMonikerImpl_QueryInterface(IEnumMoniker
* iface
,REFIID riid
,void** ppvObject
)
761 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
763 TRACE("(%p,%p,%p)\n",This
,riid
,ppvObject
);
765 /* validate arguments */
766 if (ppvObject
== NULL
)
771 if (IsEqualIID(&IID_IUnknown
, riid
))
772 *ppvObject
= (IEnumMoniker
*)This
;
774 if (IsEqualIID(&IID_IEnumMoniker
, riid
))
775 *ppvObject
= (IEnumMoniker
*)This
;
777 if ((*ppvObject
)==NULL
)
778 return E_NOINTERFACE
;
780 IEnumMoniker_AddRef(iface
);
785 /***********************************************************************
788 static ULONG WINAPI
EnumMonikerImpl_AddRef(IEnumMoniker
* iface
)
790 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
792 TRACE("(%p)\n",This
);
794 return InterlockedIncrement(&This
->ref
);
797 /***********************************************************************
798 * EnumMoniker_release
800 static ULONG WINAPI
EnumMonikerImpl_Release(IEnumMoniker
* iface
)
802 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
805 TRACE("(%p)\n",This
);
807 ref
= InterlockedDecrement(&This
->ref
);
809 /* unitialize rot structure if there's no more reference to it*/
814 TRACE("(%p) Deleting\n",This
);
816 for (i
= 0; i
< This
->moniker_count
; i
++)
817 HeapFree(GetProcessHeap(), 0, This
->monikers
[i
]);
818 HeapFree(GetProcessHeap(), 0, This
->monikers
);
819 HeapFree(GetProcessHeap(), 0, This
);
824 /***********************************************************************
827 static HRESULT WINAPI
EnumMonikerImpl_Next(IEnumMoniker
* iface
, ULONG celt
, IMoniker
** rgelt
, ULONG
* pceltFetched
)
830 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
833 TRACE("(%p) TabCurrentPos %ld Tablastindx %ld\n", This
, This
->pos
, This
->moniker_count
);
835 /* retrieve the requested number of moniker from the current position */
836 for(i
= 0; (This
->pos
< This
->moniker_count
) && (i
< celt
); i
++)
839 hr
= create_stream_on_mip_ro(This
->monikers
[This
->pos
++], &stream
);
840 if (hr
!= S_OK
) break;
841 hr
= CoUnmarshalInterface(stream
, &IID_IMoniker
, (void **)&rgelt
[i
]);
842 IStream_Release(stream
);
843 if (hr
!= S_OK
) break;
846 if (pceltFetched
!= NULL
)
859 /***********************************************************************
862 static HRESULT WINAPI
EnumMonikerImpl_Skip(IEnumMoniker
* iface
, ULONG celt
)
864 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
866 TRACE("(%p)\n",This
);
868 if (This
->pos
+ celt
>= This
->moniker_count
)
876 /***********************************************************************
879 static HRESULT WINAPI
EnumMonikerImpl_Reset(IEnumMoniker
* iface
)
881 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
883 This
->pos
= 0; /* set back to start of list */
885 TRACE("(%p)\n",This
);
890 /***********************************************************************
893 static HRESULT WINAPI
EnumMonikerImpl_Clone(IEnumMoniker
* iface
, IEnumMoniker
** ppenum
)
895 EnumMonikerImpl
*This
= (EnumMonikerImpl
*)iface
;
896 MInterfacePointer
**monikers
= HeapAlloc(GetProcessHeap(), 0, sizeof(*monikers
)*This
->moniker_count
);
899 TRACE("(%p)\n",This
);
901 for (i
= 0; i
< This
->moniker_count
; i
++)
903 SIZE_T size
= FIELD_OFFSET(MInterfacePointer
, abData
[This
->monikers
[i
]->ulCntData
]);
904 monikers
[i
] = HeapAlloc(GetProcessHeap(), 0, size
);
905 memcpy(monikers
[i
], This
->monikers
[i
], size
);
908 /* copy the enum structure */
909 return EnumMonikerImpl_CreateEnumROTMoniker(monikers
, This
->moniker_count
,
913 /* Virtual function table for the IEnumMoniker class. */
914 static const IEnumMonikerVtbl VT_EnumMonikerImpl
=
916 EnumMonikerImpl_QueryInterface
,
917 EnumMonikerImpl_AddRef
,
918 EnumMonikerImpl_Release
,
919 EnumMonikerImpl_Next
,
920 EnumMonikerImpl_Skip
,
921 EnumMonikerImpl_Reset
,
922 EnumMonikerImpl_Clone
925 /***********************************************************************
926 * EnumMonikerImpl_CreateEnumROTMoniker
927 * Used by EnumRunning to create the structure and EnumClone
928 * to copy the structure
930 static HRESULT WINAPI
EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer
**monikers
,
933 IEnumMoniker
**ppenumMoniker
)
935 EnumMonikerImpl
* This
= NULL
;
940 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl
));
941 if (!This
) return E_OUTOFMEMORY
;
943 TRACE("(%p)\n", This
);
945 /* initialize the virtual table function */
946 This
->lpVtbl
= &VT_EnumMonikerImpl
;
948 /* the initial reference is set to "1" */
949 This
->ref
= 1; /* set the ref count to one */
950 This
->pos
= current_pos
; /* Set the list start posn */
951 This
->moniker_count
= moniker_count
; /* Need the same size table as ROT */
952 This
->monikers
= monikers
;
954 *ppenumMoniker
= (IEnumMoniker
*)This
;
960 /* Shared implementation of moniker marshaler based on saving and loading of
963 typedef struct MonikerMarshal
965 const IUnknownVtbl
*lpVtbl
;
966 const IMarshalVtbl
*lpVtblMarshal
;
972 static inline MonikerMarshal
*impl_from_IMarshal( IMarshal
*iface
)
974 return (MonikerMarshal
*)((char*)iface
- FIELD_OFFSET(MonikerMarshal
, lpVtblMarshal
));
977 static HRESULT WINAPI
MonikerMarshalInner_QueryInterface(IUnknown
*iface
, REFIID riid
, LPVOID
*ppv
)
979 MonikerMarshal
*This
= (MonikerMarshal
*)iface
;
980 TRACE("(%s, %p)\n", debugstr_guid(riid
), ppv
);
982 if (IsEqualIID(&IID_IUnknown
, riid
) || IsEqualIID(&IID_IMarshal
, riid
))
984 *ppv
= &This
->lpVtblMarshal
;
985 IUnknown_AddRef((IUnknown
*)&This
->lpVtblMarshal
);
988 FIXME("No interface for %s\n", debugstr_guid(riid
));
989 return E_NOINTERFACE
;
992 static ULONG WINAPI
MonikerMarshalInner_AddRef(IUnknown
*iface
)
994 MonikerMarshal
*This
= (MonikerMarshal
*)iface
;
995 return InterlockedIncrement(&This
->ref
);
998 static ULONG WINAPI
MonikerMarshalInner_Release(IUnknown
*iface
)
1000 MonikerMarshal
*This
= (MonikerMarshal
*)iface
;
1001 ULONG ref
= InterlockedDecrement(&This
->ref
);
1003 if (!ref
) HeapFree(GetProcessHeap(), 0, This
);
1007 static const IUnknownVtbl VT_MonikerMarshalInner
=
1009 MonikerMarshalInner_QueryInterface
,
1010 MonikerMarshalInner_AddRef
,
1011 MonikerMarshalInner_Release
1014 static HRESULT WINAPI
MonikerMarshal_QueryInterface(IMarshal
*iface
, REFIID riid
, LPVOID
*ppv
)
1016 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1017 return IMoniker_QueryInterface(This
->moniker
, riid
, ppv
);
1020 static ULONG WINAPI
MonikerMarshal_AddRef(IMarshal
*iface
)
1022 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1023 return IMoniker_AddRef(This
->moniker
);
1026 static ULONG WINAPI
MonikerMarshal_Release(IMarshal
*iface
)
1028 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1029 return IMoniker_Release(This
->moniker
);
1032 static HRESULT WINAPI
MonikerMarshal_GetUnmarshalClass(
1033 LPMARSHAL iface
, REFIID riid
, void* pv
, DWORD dwDestContext
,
1034 void* pvDestContext
, DWORD mshlflags
, CLSID
* pCid
)
1036 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1038 TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid
), pv
,
1039 dwDestContext
, pvDestContext
, mshlflags
, pCid
);
1041 return IMoniker_GetClassID(This
->moniker
, pCid
);
1044 static HRESULT WINAPI
MonikerMarshal_GetMarshalSizeMax(
1045 LPMARSHAL iface
, REFIID riid
, void* pv
, DWORD dwDestContext
,
1046 void* pvDestContext
, DWORD mshlflags
, DWORD
* pSize
)
1048 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1050 ULARGE_INTEGER size
;
1052 TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid
), pv
,
1053 dwDestContext
, pvDestContext
, mshlflags
, pSize
);
1055 hr
= IMoniker_GetSizeMax(This
->moniker
, &size
);
1057 *pSize
= (DWORD
)size
.QuadPart
;
1061 static HRESULT WINAPI
MonikerMarshal_MarshalInterface(LPMARSHAL iface
, IStream
*pStm
,
1062 REFIID riid
, void* pv
, DWORD dwDestContext
,
1063 void* pvDestContext
, DWORD mshlflags
)
1065 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1067 TRACE("(%p, %s, %p, %lx, %p, %lx)\n", pStm
, debugstr_guid(riid
), pv
,
1068 dwDestContext
, pvDestContext
, mshlflags
);
1070 return IMoniker_Save(This
->moniker
, pStm
, FALSE
);
1073 static HRESULT WINAPI
MonikerMarshal_UnmarshalInterface(LPMARSHAL iface
, IStream
*pStm
, REFIID riid
, void **ppv
)
1075 MonikerMarshal
*This
= impl_from_IMarshal(iface
);
1078 TRACE("(%p, %s, %p)\n", pStm
, debugstr_guid(riid
), ppv
);
1080 hr
= IMoniker_Load(This
->moniker
, pStm
);
1082 hr
= IMoniker_QueryInterface(This
->moniker
, riid
, ppv
);
1086 static HRESULT WINAPI
MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface
, IStream
*pStm
)
1089 /* can't release a state-based marshal as nothing on server side to
1094 static HRESULT WINAPI
MonikerMarshal_DisconnectObject(LPMARSHAL iface
, DWORD dwReserved
)
1097 /* can't disconnect a state-based marshal as nothing on server side to
1098 * disconnect from */
1102 static const IMarshalVtbl VT_MonikerMarshal
=
1104 MonikerMarshal_QueryInterface
,
1105 MonikerMarshal_AddRef
,
1106 MonikerMarshal_Release
,
1107 MonikerMarshal_GetUnmarshalClass
,
1108 MonikerMarshal_GetMarshalSizeMax
,
1109 MonikerMarshal_MarshalInterface
,
1110 MonikerMarshal_UnmarshalInterface
,
1111 MonikerMarshal_ReleaseMarshalData
,
1112 MonikerMarshal_DisconnectObject
1115 HRESULT
MonikerMarshal_Create(IMoniker
*inner
, IUnknown
**outer
)
1117 MonikerMarshal
*This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
1118 if (!This
) return E_OUTOFMEMORY
;
1120 This
->lpVtbl
= &VT_MonikerMarshalInner
;
1121 This
->lpVtblMarshal
= &VT_MonikerMarshal
;
1123 This
->moniker
= inner
;
1125 *outer
= (IUnknown
*)&This
->lpVtbl
;