/* * Monikers * * Copyright 1998 Marcus Meissner * Copyright 1999 Noomen Hamza * Copyright 2005 Robert Shearman (for CodeWeavers) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * TODO: * - IRunningObjectTable should work interprocess, but currently doesn't. * Native (on Win2k at least) uses an undocumented RPC interface, IROT, to * communicate with RPCSS which contains the table of marshalled data. */ #include #include #include #define COBJMACROS #include "winerror.h" #include "windef.h" #include "winbase.h" #include "winuser.h" #include "wtypes.h" #include "ole2.h" #include "wine/list.h" #include "wine/debug.h" #include "compobj_private.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); /* define the structure of the running object table elements */ struct rot_entry { struct list entry; MInterfacePointer* object; /* marshaled running object*/ MInterfacePointer* moniker; /* marshaled moniker that identifies this object */ MInterfacePointer* moniker_data; /* moniker comparison data that identifies this object */ DWORD cookie; /* cookie identifying this object */ FILETIME last_modified; }; /* define the RunningObjectTableImpl structure */ typedef struct RunningObjectTableImpl { const IRunningObjectTableVtbl *lpVtbl; LONG ref; struct list rot; /* list of ROT entries */ CRITICAL_SECTION lock; } RunningObjectTableImpl; static RunningObjectTableImpl* runningObjectTableInstance = NULL; static inline HRESULT WINAPI IrotRegister(DWORD *cookie) { static LONG last_cookie = 1; *cookie = InterlockedIncrement(&last_cookie); return S_OK; } /* define the EnumMonikerImpl structure */ typedef struct EnumMonikerImpl { const IEnumMonikerVtbl *lpVtbl; LONG ref; MInterfacePointer **monikers; ULONG moniker_count; ULONG pos; } EnumMonikerImpl; /* IEnumMoniker Local functions*/ static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers, ULONG moniker_count, ULONG pos, IEnumMoniker **ppenumMoniker); static HRESULT create_stream_on_mip_ro(const MInterfacePointer *mip, IStream **stream) { HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData); void *pv = GlobalLock(hglobal); memcpy(pv, mip->abData, mip->ulCntData); GlobalUnlock(hglobal); return CreateStreamOnHGlobal(hglobal, TRUE, stream); } static inline void rot_entry_delete(struct rot_entry *rot_entry) { /* FIXME: revoke entry from rpcss's copy of the ROT */ if (rot_entry->object) { IStream *stream; HRESULT hr; hr = create_stream_on_mip_ro(rot_entry->object, &stream); if (hr == S_OK) { CoReleaseMarshalData(stream); IUnknown_Release(stream); } } if (rot_entry->moniker) { IStream *stream; HRESULT hr; hr = create_stream_on_mip_ro(rot_entry->moniker, &stream); if (hr == S_OK) { CoReleaseMarshalData(stream); IUnknown_Release(stream); } } HeapFree(GetProcessHeap(), 0, rot_entry->object); HeapFree(GetProcessHeap(), 0, rot_entry->moniker); HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data); HeapFree(GetProcessHeap(), 0, rot_entry); } /* moniker_data must be freed with HeapFree when no longer in use */ static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MInterfacePointer **moniker_data) { HRESULT hr; IROTData *pROTData = NULL; ULONG size = 0; hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData); if (hr != S_OK) { ERR("Failed to query moniker for IROTData interface, hr = 0x%08lx\n", hr); return hr; } IROTData_GetComparisonData(pROTData, NULL, 0, &size); *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size])); (*moniker_data)->ulCntData = size; hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size); if (hr != S_OK) { ERR("Failed to copy comparison data into buffer, hr = 0x%08lx\n", hr); HeapFree(GetProcessHeap(), 0, *moniker_data); return hr; } return S_OK; } /*********************************************************************** * RunningObjectTable_QueryInterface */ static HRESULT WINAPI RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface, REFIID riid,void** ppvObject) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; TRACE("(%p,%p,%p)\n",This,riid,ppvObject); /* validate arguments */ if (ppvObject==0) return E_INVALIDARG; *ppvObject = 0; if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IRunningObjectTable, riid)) *ppvObject = (IRunningObjectTable*)This; if ((*ppvObject)==0) return E_NOINTERFACE; IRunningObjectTable_AddRef(iface); return S_OK; } /*********************************************************************** * RunningObjectTable_AddRef */ static ULONG WINAPI RunningObjectTableImpl_AddRef(IRunningObjectTable* iface) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; TRACE("(%p)\n",This); return InterlockedIncrement(&This->ref); } /*********************************************************************** * RunningObjectTable_Initialize */ static HRESULT WINAPI RunningObjectTableImpl_Destroy(void) { struct list *cursor, *cursor2; TRACE("()\n"); if (runningObjectTableInstance==NULL) return E_INVALIDARG; /* free the ROT table memory */ LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot) { struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry); list_remove(&rot_entry->entry); rot_entry_delete(rot_entry); } /* free the ROT structure memory */ HeapFree(GetProcessHeap(),0,runningObjectTableInstance); runningObjectTableInstance = NULL; return S_OK; } /*********************************************************************** * RunningObjectTable_Release */ static ULONG WINAPI RunningObjectTableImpl_Release(IRunningObjectTable* iface) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; ULONG ref; TRACE("(%p)\n",This); ref = InterlockedDecrement(&This->ref); /* uninitialize ROT structure if there's no more references to it */ if (ref == 0) { struct list *cursor, *cursor2; LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot) { struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry); list_remove(&rot_entry->entry); rot_entry_delete(rot_entry); } /* RunningObjectTable data structure will be not destroyed here ! the destruction will be done only * when RunningObjectTableImpl_UnInitialize function is called */ } return ref; } /*********************************************************************** * RunningObjectTable_Register * * PARAMS * grfFlags [in] Registration options * punkObject [in] the object being registered * pmkObjectName [in] the moniker of the object being registered * pdwRegister [in] the value identifying the registration */ static HRESULT WINAPI RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD grfFlags, IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; struct rot_entry *rot_entry; HRESULT hr = S_OK; IStream *pStream = NULL; DWORD mshlflags; TRACE("(%p,%ld,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister); /* * there's only two types of register : strong and or weak registration * (only one must be passed on parameter) */ if ( ( (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) || !(grfFlags & ROTFLAGS_ALLOWANYCLIENT)) && (!(grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) || (grfFlags & ROTFLAGS_ALLOWANYCLIENT)) && (grfFlags) ) { ERR("Invalid combination of ROTFLAGS: %lx\n", grfFlags); return E_INVALIDARG; } if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL) return E_INVALIDARG; rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry)); if (!rot_entry) return E_OUTOFMEMORY; CoFileTimeNow(&rot_entry->last_modified); /* marshal object */ hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } mshlflags = (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) ? MSHLFLAGS_TABLESTRONG : MSHLFLAGS_TABLEWEAK; hr = CoMarshalInterface(pStream, &IID_IUnknown, punkObject, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, mshlflags); /* FIXME: a cleaner way would be to create an IStream class that writes * directly to an MInterfacePointer */ if (hr == S_OK) { HGLOBAL hglobal; hr = GetHGlobalFromStream(pStream, &hglobal); if (hr == S_OK) { SIZE_T size = GlobalSize(hglobal); const void *pv = GlobalLock(hglobal); rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size])); rot_entry->object->ulCntData = size; memcpy(&rot_entry->object->abData, pv, size); GlobalUnlock(hglobal); } } IStream_Release(pStream); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } hr = get_moniker_comparison_data(pmkObjectName, &rot_entry->moniker_data); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } /* marshal moniker */ hr = CoMarshalInterface(pStream, &IID_IMoniker, (IUnknown *)pmkObjectName, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG); /* FIXME: a cleaner way would be to create an IStream class that writes * directly to an MInterfacePointer */ if (hr == S_OK) { HGLOBAL hglobal; hr = GetHGlobalFromStream(pStream, &hglobal); if (hr == S_OK) { SIZE_T size = GlobalSize(hglobal); const void *pv = GlobalLock(hglobal); rot_entry->moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size])); rot_entry->moniker->ulCntData = size; memcpy(&rot_entry->moniker->abData, pv, size); GlobalUnlock(hglobal); } } IStream_Release(pStream); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } /* FIXME: not the right signature of IrotRegister function */ hr = IrotRegister(&rot_entry->cookie); if (hr != S_OK) { rot_entry_delete(rot_entry); return hr; } /* gives a registration identifier to the registered object*/ *pdwRegister = rot_entry->cookie; EnterCriticalSection(&This->lock); /* FIXME: see if object was registered before and return MK_S_MONIKERALREADYREGISTERED */ list_add_tail(&This->rot, &rot_entry->entry); LeaveCriticalSection(&This->lock); return hr; } /*********************************************************************** * RunningObjectTable_Revoke * * PARAMS * dwRegister [in] Value identifying registration to be revoked */ static HRESULT WINAPI RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; struct rot_entry *rot_entry; TRACE("(%p,%ld)\n",This,dwRegister); EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry) { if (rot_entry->cookie == dwRegister) { list_remove(&rot_entry->entry); LeaveCriticalSection(&This->lock); rot_entry_delete(rot_entry); return S_OK; } } LeaveCriticalSection(&This->lock); return E_INVALIDARG; } /*********************************************************************** * RunningObjectTable_IsRunning * * PARAMS * pmkObjectName [in] moniker of the object whose status is desired */ static HRESULT WINAPI RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; MInterfacePointer *moniker_data; HRESULT hr; struct rot_entry *rot_entry; TRACE("(%p,%p)\n",This,pmkObjectName); hr = get_moniker_comparison_data(pmkObjectName, &moniker_data); if (hr != S_OK) return hr; hr = S_FALSE; EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry) { if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) && !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData)) { hr = S_OK; break; } } LeaveCriticalSection(&This->lock); /* FIXME: call IrotIsRunning */ HeapFree(GetProcessHeap(), 0, moniker_data); return hr; } /*********************************************************************** * RunningObjectTable_GetObject * * PARAMS * pmkObjectName [in] Pointer to the moniker on the object * ppunkObject [out] variable that receives the IUnknown interface pointer */ static HRESULT WINAPI RunningObjectTableImpl_GetObject( IRunningObjectTable* iface, IMoniker *pmkObjectName, IUnknown **ppunkObject) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; MInterfacePointer *moniker_data; HRESULT hr; struct rot_entry *rot_entry; TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject); if (ppunkObject == NULL) return E_POINTER; *ppunkObject = NULL; hr = get_moniker_comparison_data(pmkObjectName, &moniker_data); if (hr != S_OK) return hr; EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry) { if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) && !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData)) { IStream *pStream; hr = create_stream_on_mip_ro(rot_entry->object, &pStream); if (hr == S_OK) { hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject); IStream_Release(pStream); } LeaveCriticalSection(&This->lock); HeapFree(GetProcessHeap(), 0, moniker_data); return hr; } } LeaveCriticalSection(&This->lock); /* FIXME: call IrotGetObject */ WARN("Moniker unavailable - app may require interprocess running object table\n"); hr = MK_E_UNAVAILABLE; HeapFree(GetProcessHeap(), 0, moniker_data); return hr; } /*********************************************************************** * RunningObjectTable_NoteChangeTime * * PARAMS * dwRegister [in] Value identifying registration being updated * pfiletime [in] Pointer to structure containing object's last change time */ static HRESULT WINAPI RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface, DWORD dwRegister, FILETIME *pfiletime) { RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; struct rot_entry *rot_entry; TRACE("(%p,%ld,%p)\n",This,dwRegister,pfiletime); EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry) { if (rot_entry->cookie == dwRegister) { rot_entry->last_modified = *pfiletime; LeaveCriticalSection(&This->lock); return S_OK; } } LeaveCriticalSection(&This->lock); /* FIXME: call IrotNoteChangeTime */ return E_INVALIDARG; } /*********************************************************************** * RunningObjectTable_GetTimeOfLastChange * * PARAMS * pmkObjectName [in] moniker of the object whose status is desired * pfiletime [out] structure that receives object's last change time */ static HRESULT WINAPI RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface, IMoniker *pmkObjectName, FILETIME *pfiletime) { HRESULT hr = MK_E_UNAVAILABLE; RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; MInterfacePointer *moniker_data; struct rot_entry *rot_entry; TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime); if (pmkObjectName==NULL || pfiletime==NULL) return E_INVALIDARG; hr = get_moniker_comparison_data(pmkObjectName, &moniker_data); if (hr != S_OK) return hr; hr = MK_E_UNAVAILABLE; EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry) { if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) && !memcmp(moniker_data, rot_entry->moniker_data, moniker_data->ulCntData)) { *pfiletime = rot_entry->last_modified; hr = S_OK; break; } } LeaveCriticalSection(&This->lock); /* FIXME: if (hr != S_OK) call IrotGetTimeOfLastChange */ HeapFree(GetProcessHeap(), 0, moniker_data); return hr; } /*********************************************************************** * RunningObjectTable_EnumRunning * * PARAMS * ppenumMoniker [out] receives the IEnumMoniker interface pointer */ static HRESULT WINAPI RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface, IEnumMoniker **ppenumMoniker) { HRESULT hr; RunningObjectTableImpl *This = (RunningObjectTableImpl *)iface; MInterfacePointer **monikers; ULONG moniker_count = 0; const struct rot_entry *rot_entry; ULONG i = 0; EnterCriticalSection(&This->lock); LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry ) moniker_count++; monikers = HeapAlloc(GetProcessHeap(), 0, moniker_count * sizeof(*monikers)); LIST_FOR_EACH_ENTRY( rot_entry, &This->rot, const struct rot_entry, entry ) { SIZE_T size = FIELD_OFFSET(MInterfacePointer, abData[rot_entry->moniker->ulCntData]); monikers[i] = HeapAlloc(GetProcessHeap(), 0, size); memcpy(monikers[i], rot_entry->moniker, size); i++; } LeaveCriticalSection(&This->lock); /* FIXME: call IrotEnumRunning and append data */ hr = EnumMonikerImpl_CreateEnumROTMoniker(monikers, moniker_count, 0, ppenumMoniker); return hr; } /*********************************************************************** * GetRunningObjectTable (OLE32.@) */ HRESULT WINAPI GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot) { IID riid=IID_IRunningObjectTable; HRESULT res; TRACE("()\n"); if (reserved!=0) return E_UNEXPECTED; if(runningObjectTableInstance==NULL) return CO_E_NOTINITIALIZED; res = IRunningObjectTable_QueryInterface((IRunningObjectTable*)runningObjectTableInstance,&riid,(void**)pprot); return res; } /****************************************************************************** * OleRun [OLE32.@] */ HRESULT WINAPI OleRun(LPUNKNOWN pUnknown) { IRunnableObject *runable; IRunnableObject *This = (IRunnableObject *)pUnknown; LRESULT ret; ret = IRunnableObject_QueryInterface(This,&IID_IRunnableObject,(LPVOID*)&runable); if (ret) return 0; /* Appears to return no error. */ ret = IRunnableObject_Run(runable,NULL); IRunnableObject_Release(runable); return ret; } /****************************************************************************** * MkParseDisplayName [OLE32.@] */ HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName, LPDWORD pchEaten, LPMONIKER *ppmk) { FIXME("(%p, %s, %p, %p): stub.\n", pbc, debugstr_w(szUserName), pchEaten, *ppmk); if (!(IsValidInterface((LPUNKNOWN) pbc))) return E_INVALIDARG; return MK_E_SYNTAX; } /* Virtual function table for the IRunningObjectTable class. */ static const IRunningObjectTableVtbl VT_RunningObjectTableImpl = { RunningObjectTableImpl_QueryInterface, RunningObjectTableImpl_AddRef, RunningObjectTableImpl_Release, RunningObjectTableImpl_Register, RunningObjectTableImpl_Revoke, RunningObjectTableImpl_IsRunning, RunningObjectTableImpl_GetObject, RunningObjectTableImpl_NoteChangeTime, RunningObjectTableImpl_GetTimeOfLastChange, RunningObjectTableImpl_EnumRunning }; /*********************************************************************** * RunningObjectTable_Initialize */ HRESULT WINAPI RunningObjectTableImpl_Initialize(void) { TRACE("\n"); /* create the unique instance of the RunningObjectTableImpl structure */ runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl)); if (!runningObjectTableInstance) return E_OUTOFMEMORY; /* initialize the virtual table function */ runningObjectTableInstance->lpVtbl = &VT_RunningObjectTableImpl; /* the initial reference is set to "1" ! because if set to "0" it will be not practis when */ /* the ROT referred many times not in the same time (all the objects in the ROT will */ /* be removed every time the ROT is removed ) */ runningObjectTableInstance->ref = 1; list_init(&runningObjectTableInstance->rot); InitializeCriticalSection(&runningObjectTableInstance->lock); return S_OK; } /*********************************************************************** * RunningObjectTable_UnInitialize */ HRESULT WINAPI RunningObjectTableImpl_UnInitialize() { TRACE("\n"); if (runningObjectTableInstance==NULL) return E_POINTER; RunningObjectTableImpl_Release((IRunningObjectTable*)runningObjectTableInstance); RunningObjectTableImpl_Destroy(); return S_OK; } /*********************************************************************** * EnumMoniker_QueryInterface */ static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; TRACE("(%p,%p,%p)\n",This,riid,ppvObject); /* validate arguments */ if (ppvObject == NULL) return E_INVALIDARG; *ppvObject = NULL; if (IsEqualIID(&IID_IUnknown, riid)) *ppvObject = (IEnumMoniker*)This; else if (IsEqualIID(&IID_IEnumMoniker, riid)) *ppvObject = (IEnumMoniker*)This; if ((*ppvObject)==NULL) return E_NOINTERFACE; IEnumMoniker_AddRef(iface); return S_OK; } /*********************************************************************** * EnumMoniker_AddRef */ static ULONG WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; TRACE("(%p)\n",This); return InterlockedIncrement(&This->ref); } /*********************************************************************** * EnumMoniker_release */ static ULONG WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; ULONG ref; TRACE("(%p)\n",This); ref = InterlockedDecrement(&This->ref); /* unitialize rot structure if there's no more reference to it*/ if (ref == 0) { ULONG i; TRACE("(%p) Deleting\n",This); for (i = 0; i < This->moniker_count; i++) HeapFree(GetProcessHeap(), 0, This->monikers[i]); HeapFree(GetProcessHeap(), 0, This->monikers); HeapFree(GetProcessHeap(), 0, This); } return ref; } /*********************************************************************** * EnmumMoniker_Next */ static HRESULT WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched) { ULONG i; EnumMonikerImpl *This = (EnumMonikerImpl *)iface; HRESULT hr = S_OK; TRACE("(%p) TabCurrentPos %ld Tablastindx %ld\n", This, This->pos, This->moniker_count); /* retrieve the requested number of moniker from the current position */ for(i = 0; (This->pos < This->moniker_count) && (i < celt); i++) { IStream *stream; hr = create_stream_on_mip_ro(This->monikers[This->pos++], &stream); if (hr != S_OK) break; hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]); IStream_Release(stream); if (hr != S_OK) break; } if (pceltFetched != NULL) *pceltFetched= i; if (hr != S_OK) return hr; if (i == celt) return S_OK; else return S_FALSE; } /*********************************************************************** * EnmumMoniker_Skip */ static HRESULT WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; TRACE("(%p)\n",This); if (This->pos + celt >= This->moniker_count) return S_FALSE; This->pos += celt; return S_OK; } /*********************************************************************** * EnmumMoniker_Reset */ static HRESULT WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; This->pos = 0; /* set back to start of list */ TRACE("(%p)\n",This); return S_OK; } /*********************************************************************** * EnmumMoniker_Clone */ static HRESULT WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum) { EnumMonikerImpl *This = (EnumMonikerImpl *)iface; MInterfacePointer **monikers = HeapAlloc(GetProcessHeap(), 0, sizeof(*monikers)*This->moniker_count); ULONG i; TRACE("(%p)\n",This); for (i = 0; i < This->moniker_count; i++) { SIZE_T size = FIELD_OFFSET(MInterfacePointer, abData[This->monikers[i]->ulCntData]); monikers[i] = HeapAlloc(GetProcessHeap(), 0, size); memcpy(monikers[i], This->monikers[i], size); } /* copy the enum structure */ return EnumMonikerImpl_CreateEnumROTMoniker(monikers, This->moniker_count, This->pos, ppenum); } /* Virtual function table for the IEnumMoniker class. */ static const IEnumMonikerVtbl VT_EnumMonikerImpl = { EnumMonikerImpl_QueryInterface, EnumMonikerImpl_AddRef, EnumMonikerImpl_Release, EnumMonikerImpl_Next, EnumMonikerImpl_Skip, EnumMonikerImpl_Reset, EnumMonikerImpl_Clone }; /*********************************************************************** * EnumMonikerImpl_CreateEnumROTMoniker * Used by EnumRunning to create the structure and EnumClone * to copy the structure */ static HRESULT WINAPI EnumMonikerImpl_CreateEnumROTMoniker(MInterfacePointer **monikers, ULONG moniker_count, ULONG current_pos, IEnumMoniker **ppenumMoniker) { EnumMonikerImpl* This = NULL; if (!ppenumMoniker) return E_INVALIDARG; This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl)); if (!This) return E_OUTOFMEMORY; TRACE("(%p)\n", This); /* initialize the virtual table function */ This->lpVtbl = &VT_EnumMonikerImpl; /* the initial reference is set to "1" */ This->ref = 1; /* set the ref count to one */ This->pos = current_pos; /* Set the list start posn */ This->moniker_count = moniker_count; /* Need the same size table as ROT */ This->monikers = monikers; *ppenumMoniker = (IEnumMoniker*)This; return S_OK; } /* Shared implementation of moniker marshaler based on saving and loading of * monikers */ typedef struct MonikerMarshal { const IUnknownVtbl *lpVtbl; const IMarshalVtbl *lpVtblMarshal; LONG ref; IMoniker *moniker; } MonikerMarshal; static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface ) { return (MonikerMarshal *)((char*)iface - FIELD_OFFSET(MonikerMarshal, lpVtblMarshal)); } static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv) { MonikerMarshal *This = (MonikerMarshal *)iface; TRACE("(%s, %p)\n", debugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid)) { *ppv = &This->lpVtblMarshal; IUnknown_AddRef((IUnknown *)&This->lpVtblMarshal); return S_OK; } FIXME("No interface for %s\n", debugstr_guid(riid)); return E_NOINTERFACE; } static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface) { MonikerMarshal *This = (MonikerMarshal *)iface; return InterlockedIncrement(&This->ref); } static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface) { MonikerMarshal *This = (MonikerMarshal *)iface; ULONG ref = InterlockedDecrement(&This->ref); if (!ref) HeapFree(GetProcessHeap(), 0, This); return ref; } static const IUnknownVtbl VT_MonikerMarshalInner = { MonikerMarshalInner_QueryInterface, MonikerMarshalInner_AddRef, MonikerMarshalInner_Release }; static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv) { MonikerMarshal *This = impl_from_IMarshal(iface); return IMoniker_QueryInterface(This->moniker, riid, ppv); } static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface) { MonikerMarshal *This = impl_from_IMarshal(iface); return IMoniker_AddRef(This->moniker); } static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface) { MonikerMarshal *This = impl_from_IMarshal(iface); return IMoniker_Release(This->moniker); } static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass( LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, CLSID* pCid) { MonikerMarshal *This = impl_from_IMarshal(iface); TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags, pCid); return IMoniker_GetClassID(This->moniker, pCid); } static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax( LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, DWORD* pSize) { MonikerMarshal *This = impl_from_IMarshal(iface); HRESULT hr; ULARGE_INTEGER size; TRACE("(%s, %p, %lx, %p, %lx, %p)\n", debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags, pSize); hr = IMoniker_GetSizeMax(This->moniker, &size); if (hr == S_OK) *pSize = (DWORD)size.QuadPart; return hr; } static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags) { MonikerMarshal *This = impl_from_IMarshal(iface); TRACE("(%p, %s, %p, %lx, %p, %lx)\n", pStm, debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags); return IMoniker_Save(This->moniker, pStm, FALSE); } static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv) { MonikerMarshal *This = impl_from_IMarshal(iface); HRESULT hr; TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv); hr = IMoniker_Load(This->moniker, pStm); if (hr == S_OK) hr = IMoniker_QueryInterface(This->moniker, riid, ppv); return hr; } static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm) { TRACE("()\n"); /* can't release a state-based marshal as nothing on server side to * release */ return S_OK; } static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved) { TRACE("()\n"); /* can't disconnect a state-based marshal as nothing on server side to * disconnect from */ return S_OK; } static const IMarshalVtbl VT_MonikerMarshal = { MonikerMarshal_QueryInterface, MonikerMarshal_AddRef, MonikerMarshal_Release, MonikerMarshal_GetUnmarshalClass, MonikerMarshal_GetMarshalSizeMax, MonikerMarshal_MarshalInterface, MonikerMarshal_UnmarshalInterface, MonikerMarshal_ReleaseMarshalData, MonikerMarshal_DisconnectObject }; HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer) { MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); if (!This) return E_OUTOFMEMORY; This->lpVtbl = &VT_MonikerMarshalInner; This->lpVtblMarshal = &VT_MonikerMarshal; This->ref = 1; This->moniker = inner; *outer = (IUnknown *)&This->lpVtbl; return S_OK; }