moniker.c File Reference

#include <stdarg.h>
#include <string.h>
#include "wine/list.h"
#include "wine/debug.h"
#include "compobj_private.h"
#include "moniker.h"
#include "irot.h"
#include "pathcch.h"

Include dependency graph for moniker.c:

Go to the source code of this file.

Classes
struct	rot_entry
struct	RunningObjectTableImpl
struct	EnumMonikerImpl
struct	MonikerMarshal

Macros
#define	COBJMACROS

Typedefs
typedef struct RunningObjectTableImpl	RunningObjectTableImpl
typedef struct EnumMonikerImpl	EnumMonikerImpl
typedef struct MonikerMarshal	MonikerMarshal

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
BOOL WINAPI	InternalIsProcessInitialized (void)
HRESULT WINAPI	InternalIrotRegister (const MonikerComparisonData *moniker_data, const InterfaceData *object, const InterfaceData *moniker, const FILETIME *time, DWORD flags, IrotCookie *cookie, IrotContextHandle *ctxt_handle)
HRESULT WINAPI	InternalIrotIsRunning (const MonikerComparisonData *moniker_data)
HRESULT WINAPI	InternalIrotGetObject (const MonikerComparisonData *moniker_data, PInterfaceData *obj, IrotCookie *cookie)
HRESULT WINAPI	InternalIrotNoteChangeTime (IrotCookie cookie, const FILETIME *time)
HRESULT WINAPI	InternalIrotGetTimeOfLastChange (const MonikerComparisonData *moniker_data, FILETIME *time)
HRESULT WINAPI	InternalIrotEnumRunning (PInterfaceList *list)
HRESULT WINAPI	InternalIrotRevoke (IrotCookie cookie, IrotContextHandle *ctxt_handle, PInterfaceData *object, PInterfaceData *moniker)
static RunningObjectTableImpl *	impl_from_IRunningObjectTable (IRunningObjectTable *iface)
static EnumMonikerImpl *	impl_from_IEnumMoniker (IEnumMoniker *iface)
static HRESULT	EnumMonikerImpl_CreateEnumROTMoniker (InterfaceList *moniker_list, ULONG pos, IEnumMoniker **ppenumMoniker)
static HRESULT	create_stream_on_mip_ro (const InterfaceData *mip, IStream **stream)
static void	rot_entry_delete (struct rot_entry *rot_entry)
static HRESULT	get_moniker_comparison_data (IMoniker *pMoniker, MonikerComparisonData **moniker_data)
static HRESULT	reduce_moniker (IMoniker *pmk, IBindCtx *pbc, IMoniker **pmkReduced)
static HRESULT WINAPI	RunningObjectTableImpl_QueryInterface (IRunningObjectTable *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	RunningObjectTableImpl_AddRef (IRunningObjectTable *iface)
static ULONG WINAPI	RunningObjectTableImpl_Release (IRunningObjectTable *iface)
static HRESULT WINAPI	RunningObjectTableImpl_Register (IRunningObjectTable *iface, DWORD flags, IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
static HRESULT WINAPI	RunningObjectTableImpl_Revoke (IRunningObjectTable *iface, DWORD dwRegister)
static HRESULT WINAPI	RunningObjectTableImpl_IsRunning (IRunningObjectTable *iface, IMoniker *pmkObjectName)
static HRESULT WINAPI	RunningObjectTableImpl_GetObject (IRunningObjectTable *iface, IMoniker *pmkObjectName, IUnknown **ppunkObject)
static HRESULT WINAPI	RunningObjectTableImpl_NoteChangeTime (IRunningObjectTable *iface, DWORD dwRegister, FILETIME *pfiletime)
static HRESULT WINAPI	RunningObjectTableImpl_GetTimeOfLastChange (IRunningObjectTable *iface, IMoniker *pmkObjectName, FILETIME *pfiletime)
static HRESULT WINAPI	RunningObjectTableImpl_EnumRunning (IRunningObjectTable *iface, IEnumMoniker **ppenumMoniker)
HRESULT WINAPI	GetRunningObjectTable (DWORD reserved, IRunningObjectTable **ret)
void WINAPI	DestroyRunningObjectTable (void)
static HRESULT	get_moniker_for_progid_display_name (LPBC pbc, LPCOLESTR szDisplayName, LPDWORD pchEaten, LPMONIKER *ppmk)
HRESULT WINAPI	MkParseDisplayName (LPBC pbc, LPCOLESTR szDisplayName, LPDWORD pchEaten, LPMONIKER *ppmk)
HRESULT WINAPI	GetClassFile (LPCOLESTR filePathName, CLSID *pclsid)
static HRESULT WINAPI	EnumMonikerImpl_QueryInterface (IEnumMoniker *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	EnumMonikerImpl_AddRef (IEnumMoniker *iface)
static ULONG WINAPI	EnumMonikerImpl_Release (IEnumMoniker *iface)
static HRESULT WINAPI	EnumMonikerImpl_Next (IEnumMoniker *iface, ULONG celt, IMoniker **rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	EnumMonikerImpl_Skip (IEnumMoniker *iface, ULONG celt)
static HRESULT WINAPI	EnumMonikerImpl_Reset (IEnumMoniker *iface)
static HRESULT WINAPI	EnumMonikerImpl_Clone (IEnumMoniker *iface, IEnumMoniker **ppenum)
static MonikerMarshal *	impl_from_IUnknown (IUnknown *iface)
static MonikerMarshal *	impl_from_IMarshal (IMarshal *iface)
static HRESULT WINAPI	MonikerMarshalInner_QueryInterface (IUnknown *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	MonikerMarshalInner_AddRef (IUnknown *iface)
static ULONG WINAPI	MonikerMarshalInner_Release (IUnknown *iface)
static HRESULT WINAPI	MonikerMarshal_QueryInterface (IMarshal *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	MonikerMarshal_AddRef (IMarshal *iface)
static ULONG WINAPI	MonikerMarshal_Release (IMarshal *iface)
static HRESULT WINAPI	MonikerMarshal_GetUnmarshalClass (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
static HRESULT WINAPI	MonikerMarshal_GetMarshalSizeMax (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
static HRESULT WINAPI	MonikerMarshal_MarshalInterface (LPMARSHAL iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
static HRESULT WINAPI	MonikerMarshal_UnmarshalInterface (LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
static HRESULT WINAPI	MonikerMarshal_ReleaseMarshalData (LPMARSHAL iface, IStream *pStm)
static HRESULT WINAPI	MonikerMarshal_DisconnectObject (LPMARSHAL iface, DWORD dwReserved)
HRESULT	MonikerMarshal_Create (IMoniker *inner, IUnknown **outer)
void *__RPC_USER	MIDL_user_allocate (SIZE_T size)
void __RPC_USER	MIDL_user_free (void *p)

Variables
static const IRunningObjectTableVtbl	VT_RunningObjectTableImpl
static RunningObjectTableImpl	rot
static RTL_CRITICAL_SECTION_DEBUG	critsect_debug
static const IEnumMonikerVtbl	VT_EnumMonikerImpl
static const IUnknownVtbl	VT_MonikerMarshalInner
static const IMarshalVtbl	VT_MonikerMarshal

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 27 of file moniker.c.

Typedef Documentation

EnumMonikerImpl

typedef struct EnumMonikerImpl EnumMonikerImpl

MonikerMarshal

typedef struct MonikerMarshal MonikerMarshal

RunningObjectTableImpl

typedef struct RunningObjectTableImpl RunningObjectTableImpl

Function Documentation

create_stream_on_mip_ro()

static HRESULT create_stream_on_mip_ro ( const InterfaceData *  mip, IStream **  stream  )

static

Definition at line 96 of file moniker.c.

{
    HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData);
    void *pv = GlobalLock(hglobal);
    memcpy(pv, mip->abData, mip->ulCntData);
    GlobalUnlock(hglobal);
    return CreateStreamOnHGlobal(hglobal, TRUE, stream);
}

Referenced by EnumMonikerImpl_Next(), rot_entry_delete(), and RunningObjectTableImpl_GetObject().

DestroyRunningObjectTable()

void WINAPI DestroyRunningObjectTable

(

void

)

Definition at line 748 of file moniker.c.

{
    struct rot_entry *rot_entry, *cursor2;
 
    TRACE("\n");
 
    EnterCriticalSection(&rot.lock);
    LIST_FOR_EACH_ENTRY_SAFE(rot_entry, cursor2, &rot.rot, struct rot_entry, entry)
    {
        list_remove(&rot_entry->entry);
        rot_entry_delete(rot_entry);
    }
    LeaveCriticalSection(&rot.lock);
}

Referenced by CoUninitialize().

EnumMonikerImpl_AddRef()

static ULONG WINAPI EnumMonikerImpl_AddRef ( IEnumMoniker *  iface )

static

Definition at line 1017 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    TRACE("(%p)\n",This);
 
    return InterlockedIncrement(&This->ref);
}

EnumMonikerImpl_Clone()

static HRESULT WINAPI EnumMonikerImpl_Clone ( IEnumMoniker *  iface, IEnumMoniker **  ppenum  )

static

Definition at line 1122 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
    InterfaceList *moniker_list;
    ULONG i;
 
    TRACE("(%p)\n",This);
 
    *ppenum = NULL;
 
    moniker_list = malloc(FIELD_OFFSET(InterfaceList, interfaces[This->moniker_list->size]));
    if (!moniker_list)
        return E_OUTOFMEMORY;
 
    moniker_list->size = This->moniker_list->size;
    for (i = 0; i < This->moniker_list->size; i++)
    {
        SIZE_T size = FIELD_OFFSET(InterfaceData, abData[This->moniker_list->interfaces[i]->ulCntData]);
        moniker_list->interfaces[i] = malloc(size);
        if (!moniker_list->interfaces[i])
        {
            ULONG end = i;
            for (i = 0; i < end; i++)
                free(moniker_list->interfaces[i]);
            free(moniker_list);
            return E_OUTOFMEMORY;
        }
        memcpy(moniker_list->interfaces[i], This->moniker_list->interfaces[i], size);
    }
 
    /* copy the enum structure */ 
    return EnumMonikerImpl_CreateEnumROTMoniker(moniker_list, This->pos, ppenum);
}

EnumMonikerImpl_CreateEnumROTMoniker()

static HRESULT EnumMonikerImpl_CreateEnumROTMoniker ( InterfaceList *  moniker_list, ULONG  pos, IEnumMoniker **  ppenumMoniker  )

static

Definition at line 1173 of file moniker.c.

{
    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->IEnumMoniker_iface.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_list = moniker_list;
 
    *ppenumMoniker =  &This->IEnumMoniker_iface;
 
    return S_OK;
}

Referenced by EnumMonikerImpl_Clone(), and RunningObjectTableImpl_EnumRunning().

EnumMonikerImpl_Next()

static HRESULT WINAPI EnumMonikerImpl_Next ( IEnumMoniker *  iface, ULONG  celt, IMoniker **  rgelt, ULONG *  pceltFetched  )

static

Definition at line 1056 of file moniker.c.

{
    ULONG i;
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
    HRESULT hr = S_OK;
 
    TRACE("%p, %lu, %p, %p.\n", iface, celt, rgelt, pceltFetched);
 
    /* retrieve the requested number of moniker from the current position */
    for(i = 0; (This->pos < This->moniker_list->size) && (i < celt); i++)
    {
        IStream *stream;
        hr = create_stream_on_mip_ro(This->moniker_list->interfaces[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;
 
}

EnumMonikerImpl_QueryInterface()

static HRESULT WINAPI EnumMonikerImpl_QueryInterface ( IEnumMoniker *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 993 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 
    /* validate arguments */
    if (ppvObject == NULL)
        return E_INVALIDARG;
 
    *ppvObject = NULL;
 
    if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
        *ppvObject = &This->IEnumMoniker_iface;
    else
        return E_NOINTERFACE;
 
    IEnumMoniker_AddRef(iface);
    return S_OK;
}

EnumMonikerImpl_Release()

static ULONG WINAPI EnumMonikerImpl_Release ( IEnumMoniker *  iface )

static

Definition at line 1029 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
    ULONG ref;
 
    TRACE("(%p)\n",This);
 
    ref = InterlockedDecrement(&This->ref);
 
    /* uninitialize ROT structure if there are no more references to it */
    if (ref == 0)
    {
        ULONG i;
 
        TRACE("(%p) Deleting\n",This);
 
        for (i = 0; i < This->moniker_list->size; i++)
            free(This->moniker_list->interfaces[i]);
        free(This->moniker_list);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

EnumMonikerImpl_Reset()

static HRESULT WINAPI EnumMonikerImpl_Reset ( IEnumMoniker *  iface )

static

Definition at line 1108 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    This->pos = 0;  /* set back to start of list */
 
    TRACE("(%p)\n",This);
 
    return S_OK;
}

EnumMonikerImpl_Skip()

static HRESULT WINAPI EnumMonikerImpl_Skip ( IEnumMoniker *  iface, ULONG  celt  )

static

Definition at line 1091 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    TRACE("(%p)\n",This);
 
    if  (This->pos + celt >= This->moniker_list->size)
        return S_FALSE;
 
    This->pos += celt;
 
    return S_OK;
}

get_moniker_comparison_data()

static HRESULT get_moniker_comparison_data ( IMoniker *  pMoniker, MonikerComparisonData **  moniker_data  )

static

Definition at line 144 of file moniker.c.

{
    HRESULT hr;
    IROTData *pROTData = NULL;
    hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
    if (SUCCEEDED(hr))
    {
        ULONG size = ROT_COMPARE_MAX;
        *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[size]));
        if (!*moniker_data)
        {
            IROTData_Release(pROTData);
            return E_OUTOFMEMORY;
        }
        hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size);
        IROTData_Release(pROTData);
        if (hr != S_OK)
        {
            ERR("Failed to copy comparison data into buffer, hr = %#lx\n", hr);
            HeapFree(GetProcessHeap(), 0, *moniker_data);
            *moniker_data = NULL;
            return hr;
        }
        (*moniker_data)->ulCntData = size;
    }
    else
    {
        IBindCtx *pbc;
        LPOLESTR pszDisplayName;
        CLSID clsid;
        int len;
 
        TRACE("generating comparison data from display name\n");
 
        hr = CreateBindCtx(0, &pbc);
        if (FAILED(hr))
            return hr;
        hr = IMoniker_GetDisplayName(pMoniker, pbc, NULL, &pszDisplayName);
        IBindCtx_Release(pbc);
        if (FAILED(hr))
            return hr;
        hr = IMoniker_GetClassID(pMoniker, &clsid);
        if (FAILED(hr))
        {
            CoTaskMemFree(pszDisplayName);
            return hr;
        }
 
        len = lstrlenW(pszDisplayName);
        *moniker_data = HeapAlloc(GetProcessHeap(), 0,
            FIELD_OFFSET(MonikerComparisonData, abData[sizeof(CLSID) + (len+1)*sizeof(WCHAR)]));
        if (!*moniker_data)
        {
            CoTaskMemFree(pszDisplayName);
            return E_OUTOFMEMORY;
        }
        (*moniker_data)->ulCntData = sizeof(CLSID) + (len+1)*sizeof(WCHAR);
 
        memcpy(&(*moniker_data)->abData[0], &clsid, sizeof(clsid));
        memcpy(&(*moniker_data)->abData[sizeof(clsid)], pszDisplayName, (len+1)*sizeof(WCHAR));
        CoTaskMemFree(pszDisplayName);
    }
    return S_OK;
}

Referenced by RunningObjectTableImpl_GetObject(), RunningObjectTableImpl_GetTimeOfLastChange(), RunningObjectTableImpl_IsRunning(), and RunningObjectTableImpl_Register().

get_moniker_for_progid_display_name()

static HRESULT get_moniker_for_progid_display_name ( LPBC  pbc, LPCOLESTR  szDisplayName, LPDWORD  pchEaten, LPMONIKER *  ppmk  )

static

Definition at line 763 of file moniker.c.

{
    CLSID clsid;
    HRESULT hr;
    LPWSTR progid;
    LPCWSTR start = szDisplayName;
    LPCWSTR end;
    int len;
    IMoniker *class_moniker;
 
    if (*start == '@')
        start++;
 
    /* find end delimiter */
    for (end = start; *end; end++)
        if (*end == ':')
            break;
 
    len = end - start;
 
    /* must start with '@' or have a ':' somewhere and mustn't be one character
     * long (since that looks like an absolute path) */
    if (((start == szDisplayName) && (*end == '\0')) || (len <= 1))
        return MK_E_SYNTAX;
 
    progid = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
    if (progid)
    {
        memcpy(progid, start, len * sizeof(WCHAR));
        progid[len] = '\0';
    }
    hr = CLSIDFromProgID(progid, &clsid);
    HeapFree(GetProcessHeap(), 0, progid);
    if (FAILED(hr))
        return MK_E_SYNTAX;
 
    hr = CreateClassMoniker(&clsid, &class_moniker);
    if (SUCCEEDED(hr))
    {
        IParseDisplayName *pdn;
        hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
                                   &IID_IParseDisplayName, (void **)&pdn);
        /* fallback to using IClassFactory to get IParseDisplayName -
         * adsldp.dll depends on this */
        if (FAILED(hr))
        {
            IClassFactory *pcf;
            hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
                                       &IID_IClassFactory, (void **)&pcf);
            if (SUCCEEDED(hr))
            {
                hr = IClassFactory_CreateInstance(pcf, NULL,
                                                  &IID_IParseDisplayName,
                                                  (void **)&pdn);
                IClassFactory_Release(pcf);
            }
        }
        IMoniker_Release(class_moniker);
        if (SUCCEEDED(hr))
        {
            hr = IParseDisplayName_ParseDisplayName(pdn, pbc,
                                                    (LPOLESTR)szDisplayName,
                                                    pchEaten, ppmk);
            IParseDisplayName_Release(pdn);
        }
    }
    return hr;
}

Referenced by MkParseDisplayName().

GetClassFile()

HRESULT WINAPI GetClassFile	(	LPCOLESTR	filePathName,
		CLSID *	pclsid
	)

Definition at line 921 of file moniker.c.

{
    IStorage *pstg=0;
    HRESULT res;
    LONG sizeProgId, ret;
    LPOLESTR progId=0;
    const WCHAR *extension;
 
    TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
 
    /* if the file contain a storage object the return the CLSID written by IStorage_SetClass method*/
    if((StgIsStorageFile(filePathName))==S_OK){
 
        res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
 
        if (SUCCEEDED(res)) {
            res=ReadClassStg(pstg,pclsid);
            IStorage_Release(pstg);
        }
 
        return res;
    }
    /* If the file is not a storage object then attempt to match various bits in the file against a
       pattern in the registry. This case is not frequently used, so I present only the pseudocode for
       this case.
 
     for(i=0;i<nFileTypes;i++)
 
        for(i=0;j<nPatternsForType;j++){
 
            PATTERN pat;
            HANDLE  hFile;
 
            pat=ReadPatternFromRegistry(i,j);
            hFile=CreateFileW(filePathName,,,,,,hFile);
            SetFilePosition(hFile,pat.offset);
            ReadFile(hFile,buf,pat.size,&r,NULL);
            if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
 
                *pclsid=ReadCLSIDFromRegistry(i);
                return S_OK;
            }
        }
     */
 
    /* if the above strategies fail then search for the extension key in the registry */
 
    res = PathCchFindExtension(filePathName, PATHCCH_MAX_CCH, &extension);
    if (FAILED(res) || !extension || !*extension || !wcscmp(extension, L"."))
        return MK_E_INVALIDEXTENSION;
 
    ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
    if (!ret) {
        /* get the progId associated to the extension */
        progId = CoTaskMemAlloc(sizeProgId);
        ret = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
        if (!ret)
            /* return the clsid associated to the progId */
            res = CLSIDFromProgID(progId, pclsid);
        else
            res = HRESULT_FROM_WIN32(ret);
        CoTaskMemFree(progId);
    }
    else
        res = HRESULT_FROM_WIN32(ret);
 
    return res != S_OK ? MK_E_INVALIDEXTENSION : res;
}

Referenced by CoGetInstanceFromFile(), FileMonikerImpl_BindToObject(), and UIINSERTOBJECTDLG_OnOpen().

GetRunningObjectTable()

HRESULT WINAPI GetRunningObjectTable	(	DWORD	reserved,
		IRunningObjectTable **	ret
	)

Definition at line 729 of file moniker.c.

{
    TRACE("%#lx, %p\n", reserved, ret);
 
    if (reserved!=0)
        return E_UNEXPECTED;
 
    if (!InternalIsProcessInitialized())
        return CO_E_NOTINITIALIZED;
 
    *ret = &rot.IRunningObjectTable_iface;
    IRunningObjectTable_AddRef(*ret);
 
    return S_OK;
}

Referenced by BindCtxImpl_GetRunningObjectTable(), GetActiveObject(), IHlinkBC_GetObject(), IHlinkBC_Register(), IHlinkBC_Revoke(), RegisterActiveObject(), RevokeActiveObject(), test_bind_context(), test_ROT(), and test_ROT_multiple_entries().

impl_from_IEnumMoniker()

static EnumMonikerImpl * impl_from_IEnumMoniker ( IEnumMoniker *  iface )

inlinestatic

Definition at line 87 of file moniker.c.

{
    return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
}

Referenced by EnumMonikerImpl_AddRef(), EnumMonikerImpl_Clone(), EnumMonikerImpl_Next(), EnumMonikerImpl_QueryInterface(), EnumMonikerImpl_Release(), EnumMonikerImpl_Reset(), and EnumMonikerImpl_Skip().

impl_from_IMarshal()

static MonikerMarshal * impl_from_IMarshal ( IMarshal *  iface )

inlinestatic

Definition at line 1218 of file moniker.c.

{
    return CONTAINING_RECORD(iface, MonikerMarshal, IMarshal_iface);
}

Referenced by MonikerMarshal_AddRef(), MonikerMarshal_GetMarshalSizeMax(), MonikerMarshal_GetUnmarshalClass(), MonikerMarshal_MarshalInterface(), MonikerMarshal_QueryInterface(), MonikerMarshal_Release(), and MonikerMarshal_UnmarshalInterface().

impl_from_IRunningObjectTable()

static RunningObjectTableImpl * impl_from_IRunningObjectTable ( IRunningObjectTable *  iface )

inlinestatic

Definition at line 82 of file moniker.c.

{
    return CONTAINING_RECORD(iface, RunningObjectTableImpl, IRunningObjectTable_iface);
}

Referenced by RunningObjectTableImpl_EnumRunning(), RunningObjectTableImpl_GetObject(), RunningObjectTableImpl_GetTimeOfLastChange(), RunningObjectTableImpl_IsRunning(), RunningObjectTableImpl_NoteChangeTime(), RunningObjectTableImpl_QueryInterface(), RunningObjectTableImpl_Register(), and RunningObjectTableImpl_Revoke().

impl_from_IUnknown()

static MonikerMarshal * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 1213 of file moniker.c.

{
    return CONTAINING_RECORD(iface, MonikerMarshal, IUnknown_iface);
}

Referenced by HeapUnknown_AddRef(), HeapUnknown_Release(), MonikerMarshalInner_AddRef(), MonikerMarshalInner_QueryInterface(), and MonikerMarshalInner_Release().

InternalIrotEnumRunning()

HRESULT WINAPI InternalIrotEnumRunning

(

PInterfaceList *

list

)

Definition at line 353 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotEnumRunning(get_irot_handle(), list);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_EnumRunning().

InternalIrotGetObject()

HRESULT WINAPI InternalIrotGetObject	(	const MonikerComparisonData *	moniker_data,
		PInterfaceData *	obj,
		IrotCookie *	cookie
	)

Definition at line 331 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotGetObject(get_irot_handle(), moniker_data, obj, cookie);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_GetObject().

InternalIrotGetTimeOfLastChange()

HRESULT WINAPI InternalIrotGetTimeOfLastChange	(	const MonikerComparisonData *	moniker_data,
		FILETIME *	time
	)

Definition at line 346 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotGetTimeOfLastChange(get_irot_handle(), moniker_data, time);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_GetTimeOfLastChange().

InternalIrotIsRunning()

HRESULT WINAPI InternalIrotIsRunning

(

const MonikerComparisonData *

moniker_data

)

Definition at line 324 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotIsRunning(get_irot_handle(), moniker_data);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_IsRunning().

InternalIrotNoteChangeTime()

HRESULT WINAPI InternalIrotNoteChangeTime	(	IrotCookie	cookie,
		const FILETIME *	time
	)

Definition at line 339 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotNoteChangeTime(get_irot_handle(), cookie, time);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_NoteChangeTime().

InternalIrotRegister()

HRESULT WINAPI InternalIrotRegister	(	const MonikerComparisonData *	moniker_data,
		const InterfaceData *	object,
		const InterfaceData *	moniker,
		const FILETIME *	time,
		DWORD	flags,
		IrotCookie *	cookie,
		IrotContextHandle *	ctxt_handle
	)

Definition at line 315 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotRegister(get_irot_handle(), moniker_data, object, moniker, time, flags, cookie, ctxt_handle);
    RPCSS_CALL_END
}

Referenced by RunningObjectTableImpl_Register().

InternalIrotRevoke()

HRESULT WINAPI InternalIrotRevoke	(	IrotCookie	cookie,
		IrotContextHandle *	ctxt_handle,
		PInterfaceData *	object,
		PInterfaceData *	moniker
	)

Definition at line 360 of file rpc.c.

{
    RPCSS_CALL_START
    hr = IrotRevoke(get_irot_handle(), cookie, ctxt_handle, object, moniker);
    RPCSS_CALL_END
}

Referenced by rot_entry_delete().

InternalIsProcessInitialized()

BOOL WINAPI InternalIsProcessInitialized

(

void

)

Definition at line 391 of file combase.c.

{
    struct apartment *apt;
 
    if (!(apt = apartment_get_current_or_mta()))
        return FALSE;
    apartment_release(apt);
 
    return TRUE;
}

Referenced by CoGetContextToken(), CoGetPSClsid(), CoRegisterPSClsid(), GetRunningObjectTable(), and RoGetAgileReference().

MIDL_user_allocate()

void *__RPC_USER MIDL_user_allocate

(

SIZE_T

size

)

Definition at line 1375 of file moniker.c.

{
    return malloc(size);
}

MIDL_user_free()

void __RPC_USER MIDL_user_free

(

void *

p

)

Definition at line 1380 of file moniker.c.

{
    free(p);
}

Referenced by rot_entry_delete().

MkParseDisplayName()

HRESULT WINAPI MkParseDisplayName	(	LPBC	pbc,
		LPCOLESTR	szDisplayName,
		LPDWORD	pchEaten,
		LPMONIKER *	ppmk
	)

Definition at line 838 of file moniker.c.

{
    HRESULT hr = MK_E_SYNTAX;
    IMoniker *moniker;
    DWORD chEaten;
 
    TRACE("(%p, %s, %p, %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
 
    if (!pbc || !IsValidInterface((LPUNKNOWN) pbc))
        return E_INVALIDARG;
 
    if (!szDisplayName || !*szDisplayName)
        return E_INVALIDARG;
 
    if (!pchEaten || !ppmk)
        return E_INVALIDARG;
 
    *pchEaten = 0;
    *ppmk = NULL;
 
    if (!wcsnicmp(szDisplayName, L"clsid:", 6))
    {
        hr = ClassMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
        if (FAILED(hr) && (hr != MK_E_SYNTAX))
            return hr;
    }
    else
    {
        hr = get_moniker_for_progid_display_name(pbc, szDisplayName, &chEaten, &moniker);
        if (FAILED(hr) && (hr != MK_E_SYNTAX))
            return hr;
    }
 
    if (FAILED(hr))
    {
        hr = FileMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
        if (FAILED(hr) && (hr != MK_E_SYNTAX))
            return hr;
    }
 
    if (SUCCEEDED(hr))
    {
        while (TRUE)
        {
            IMoniker *next_moniker;
            *pchEaten += chEaten;
            szDisplayName += chEaten;
            if (!*szDisplayName)
            {
                *ppmk = moniker;
                return S_OK;
            }
            chEaten = 0;
            hr = IMoniker_ParseDisplayName(moniker, pbc, NULL,
                                           (LPOLESTR)szDisplayName, &chEaten,
                                           &next_moniker);
            IMoniker_Release(moniker);
            if (FAILED(hr))
            {
                *pchEaten = 0;
                break;
            }
            moniker = next_moniker;
        }
    }
 
    return hr;
}

Referenced by CoGetObject(), Global_GetObject(), HlinkParseDisplayName(), IHlink_fnSetStringReference(), MkParseDisplayNameEx(), test_class_moniker(), and test_MkParseDisplayName().

MonikerMarshal_AddRef()

static ULONG WINAPI MonikerMarshal_AddRef ( IMarshal *  iface )

static

Definition at line 1266 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
    return IMoniker_AddRef(This->moniker);
}

MonikerMarshal_Create()

HRESULT MonikerMarshal_Create	(	IMoniker *	inner,
		IUnknown **	outer
	)

Definition at line 1361 of file moniker.c.

{
    MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IUnknown_iface.lpVtbl = &VT_MonikerMarshalInner;
    This->IMarshal_iface.lpVtbl = &VT_MonikerMarshal;
    This->ref = 1;
    This->moniker = inner;
 
    *outer = &This->IUnknown_iface;
    return S_OK;
}

Referenced by AntiMonikerImpl_QueryInterface(), ClassMoniker_QueryInterface(), FileMonikerImpl_QueryInterface(), and ItemMonikerImpl_QueryInterface().

MonikerMarshal_DisconnectObject()

static HRESULT WINAPI MonikerMarshal_DisconnectObject ( LPMARSHAL  iface, DWORD  dwReserved  )

static

Definition at line 1340 of file moniker.c.

{
    TRACE("()\n");
    /* can't disconnect a state-based marshal as nothing on server side to
     * disconnect from */
    return S_OK;
}

MonikerMarshal_GetMarshalSizeMax()

static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax ( LPMARSHAL  iface, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags, DWORD *  pSize  )

static

Definition at line 1290 of file moniker.c.

{
    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;
}

MonikerMarshal_GetUnmarshalClass()

static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass ( LPMARSHAL  iface, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags, CLSID *  pCid  )

static

Definition at line 1278 of file moniker.c.

{
    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);
}

MonikerMarshal_MarshalInterface()

static HRESULT WINAPI MonikerMarshal_MarshalInterface ( LPMARSHAL  iface, IStream *  pStm, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags  )

static

Definition at line 1307 of file moniker.c.

{
    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);
}

MonikerMarshal_QueryInterface()

static HRESULT WINAPI MonikerMarshal_QueryInterface ( IMarshal *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1260 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
    return IMoniker_QueryInterface(This->moniker, riid, ppv);
}

MonikerMarshal_Release()

static ULONG WINAPI MonikerMarshal_Release ( IMarshal *  iface )

static

Definition at line 1272 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
    return IMoniker_Release(This->moniker);
}

MonikerMarshal_ReleaseMarshalData()

static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData ( LPMARSHAL  iface, IStream *  pStm  )

static

Definition at line 1332 of file moniker.c.

{
    TRACE("()\n");
    /* can't release a state-based marshal as nothing on server side to
     * release */
    return S_OK;
}

MonikerMarshal_UnmarshalInterface()

static HRESULT WINAPI MonikerMarshal_UnmarshalInterface ( LPMARSHAL  iface, IStream *  pStm, REFIID  riid, void **  ppv  )

static

Definition at line 1319 of file moniker.c.

{
    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;
}

MonikerMarshalInner_AddRef()

static ULONG WINAPI MonikerMarshalInner_AddRef ( IUnknown *  iface )

static

Definition at line 1238 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->ref);
}

MonikerMarshalInner_QueryInterface()

static HRESULT WINAPI MonikerMarshalInner_QueryInterface ( IUnknown *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1223 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IUnknown(iface);
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
    *ppv = NULL;
    if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
    {
        *ppv = &This->IMarshal_iface;
        IMarshal_AddRef(&This->IMarshal_iface);
        return S_OK;
    }
    FIXME("No interface for %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

MonikerMarshalInner_Release()

static ULONG WINAPI MonikerMarshalInner_Release ( IUnknown *  iface )

static

Definition at line 1244 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (!ref) HeapFree(GetProcessHeap(), 0, This);
    return ref;
}

reduce_moniker()

static HRESULT reduce_moniker ( IMoniker *  pmk, IBindCtx *  pbc, IMoniker **  pmkReduced  )

static

Definition at line 209 of file moniker.c.

{
    IBindCtx *pbcNew = NULL;
    HRESULT hr;
    if (!pbc)
    {
        hr = CreateBindCtx(0, &pbcNew);
        if (FAILED(hr))
            return hr;
        pbc = pbcNew;
    }
    hr = IMoniker_Reduce(pmk, pbc, MKRREDUCE_ALL, NULL, pmkReduced);
    if (FAILED(hr))
        ERR("reducing moniker failed with error %#lx.\n", hr);
    if (pbcNew) IBindCtx_Release(pbcNew);
    return hr;
}

Referenced by RunningObjectTableImpl_GetObject(), RunningObjectTableImpl_GetTimeOfLastChange(), RunningObjectTableImpl_IsRunning(), and RunningObjectTableImpl_Register().

rot_entry_delete()

static void rot_entry_delete ( struct rot_entry *  rot_entry )

static

Definition at line 105 of file moniker.c.

{
    if (rot_entry->cookie)
    {
        InterfaceData *object = NULL;
        InterfaceData *moniker = NULL;
 
        InternalIrotRevoke(rot_entry->cookie, &rot_entry->ctxt_handle, &object, &moniker);
        MIDL_user_free(object);
        if (moniker)
        {
            IStream *stream;
            HRESULT hr;
            hr = create_stream_on_mip_ro(moniker, &stream);
            if (hr == S_OK)
            {
                CoReleaseMarshalData(stream);
                IStream_Release(stream);
            }
        }
        MIDL_user_free(moniker);
    }
    if (rot_entry->object)
    {
        IStream *stream;
        HRESULT hr;
        hr = create_stream_on_mip_ro(rot_entry->object, &stream);
        if (hr == S_OK)
        {
            CoReleaseMarshalData(stream);
            IStream_Release(stream);
        }
    }
    HeapFree(GetProcessHeap(), 0, rot_entry->object);
    HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
    HeapFree(GetProcessHeap(), 0, rot_entry);
}

Referenced by DestroyRunningObjectTable(), RunningObjectTableImpl_Register(), and RunningObjectTableImpl_Revoke().

RunningObjectTableImpl_AddRef()

static ULONG WINAPI RunningObjectTableImpl_AddRef ( IRunningObjectTable *  iface )

static

Definition at line 257 of file moniker.c.

{
    TRACE("%p\n", iface);
 
    return 2;
}

RunningObjectTableImpl_EnumRunning()

static HRESULT WINAPI RunningObjectTableImpl_EnumRunning ( IRunningObjectTable *  iface, IEnumMoniker **  ppenumMoniker  )

static

Definition at line 677 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    InterfaceList *interface_list = NULL;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, ppenumMoniker);
 
    *ppenumMoniker = NULL;
 
    hr = InternalIrotEnumRunning(&interface_list);
    if (SUCCEEDED(hr))
        hr = EnumMonikerImpl_CreateEnumROTMoniker(interface_list, 0, ppenumMoniker);
 
    return hr;
}

RunningObjectTableImpl_GetObject()

static HRESULT WINAPI RunningObjectTableImpl_GetObject ( IRunningObjectTable *  iface, IMoniker *  pmkObjectName, IUnknown **  ppunkObject  )

static

Definition at line 511 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    MonikerComparisonData *moniker_data;
    InterfaceData *object = NULL;
    IrotCookie cookie;
    HRESULT hr;
    struct rot_entry *rot_entry;
 
    TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
 
    if (ppunkObject == NULL)
        return E_POINTER;
 
    *ppunkObject = NULL;
 
    hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
    if (FAILED(hr))
        return hr;
    hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
    IMoniker_Release(pmkObjectName);
    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->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
        {
            IStream *pStream;
            hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
            LeaveCriticalSection(&This->lock);
 
            if (hr == S_OK)
            {
                hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
                IStream_Release(pStream);
            }
 
            HeapFree(GetProcessHeap(), 0, moniker_data);
 
            return hr;
        }
    }
    LeaveCriticalSection(&This->lock);
 
    TRACE("moniker unavailable locally, calling SCM\n");
 
    hr = InternalIrotGetObject(moniker_data, &object, &cookie);
    if (SUCCEEDED(hr))
    {
        IStream *pStream;
        hr = create_stream_on_mip_ro(object, &pStream);
        if (hr == S_OK)
        {
            hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
            IStream_Release(pStream);
        }
    }
    else
        WARN("Moniker unavailable, IrotGetObject returned %#lx\n", hr);
 
    HeapFree(GetProcessHeap(), 0, moniker_data);
 
    return hr;
}

RunningObjectTableImpl_GetTimeOfLastChange()

static HRESULT WINAPI RunningObjectTableImpl_GetTimeOfLastChange ( IRunningObjectTable *  iface, IMoniker *  pmkObjectName, FILETIME *  pfiletime  )

static

Definition at line 625 of file moniker.c.

{
    HRESULT hr = MK_E_UNAVAILABLE;
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    MonikerComparisonData *moniker_data;
    const struct rot_entry *rot_entry;
 
    TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
 
    if (pmkObjectName==NULL || pfiletime==NULL)
        return E_INVALIDARG;
 
    hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
    if (FAILED(hr))
        return hr;
    hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
    IMoniker_Release(pmkObjectName);
    if (hr != S_OK)
        return hr;
 
    hr = MK_E_UNAVAILABLE;
 
    EnterCriticalSection(&This->lock);
    LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
    {
        if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
            !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
        {
            *pfiletime = rot_entry->last_modified;
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&This->lock);
 
    if (hr != S_OK)
        hr = InternalIrotGetTimeOfLastChange(moniker_data, pfiletime);
 
    HeapFree(GetProcessHeap(), 0, moniker_data);
 
    TRACE("-- %#lx\n", hr);
    return hr;
}

RunningObjectTableImpl_IsRunning()

static HRESULT WINAPI RunningObjectTableImpl_IsRunning ( IRunningObjectTable *  iface, IMoniker *  pmkObjectName  )

static

Definition at line 465 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    MonikerComparisonData *moniker_data;
    HRESULT hr;
    const struct rot_entry *rot_entry;
 
    TRACE("(%p,%p)\n",This,pmkObjectName);
 
    hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
    if (FAILED(hr))
        return hr;
    hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
    IMoniker_Release(pmkObjectName);
    if (hr != S_OK)
        return hr;
 
    hr = S_FALSE;
    EnterCriticalSection(&This->lock);
    LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
    {
        if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
            !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
        {
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&This->lock);
 
    if (hr == S_FALSE)
        hr = InternalIrotIsRunning(moniker_data);
 
    HeapFree(GetProcessHeap(), 0, moniker_data);
 
    return hr;
}

RunningObjectTableImpl_NoteChangeTime()

static HRESULT WINAPI RunningObjectTableImpl_NoteChangeTime ( IRunningObjectTable *  iface, DWORD  dwRegister, FILETIME *  pfiletime  )

static

Definition at line 588 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    struct rot_entry *rot_entry;
    HRESULT hr = E_INVALIDARG;
 
    TRACE("%p, %ld, %p.\n", iface, 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);
 
            hr = InternalIrotNoteChangeTime(dwRegister, pfiletime);
 
            goto done;
        }
    }
    LeaveCriticalSection(&This->lock);
 
done:
    TRACE("-- %#lx\n", hr);
    return hr;
}

RunningObjectTableImpl_QueryInterface()

static HRESULT WINAPI RunningObjectTableImpl_QueryInterface ( IRunningObjectTable *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 231 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
 
    TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 
    /* validate arguments */
 
    if (ppvObject==0)
        return E_INVALIDARG;
 
    *ppvObject = 0;
 
    if (IsEqualIID(&IID_IUnknown, riid) ||
        IsEqualIID(&IID_IRunningObjectTable, riid))
        *ppvObject = &This->IRunningObjectTable_iface;
 
    if ((*ppvObject)==0)
        return E_NOINTERFACE;
 
    IRunningObjectTable_AddRef(iface);
 
    return S_OK;
}

RunningObjectTableImpl_Register()

static HRESULT WINAPI RunningObjectTableImpl_Register ( IRunningObjectTable *  iface, DWORD  flags, IUnknown *  punkObject, IMoniker *  pmkObjectName, DWORD *  pdwRegister  )

static

Definition at line 281 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    struct rot_entry *rot_entry;
    HRESULT hr = S_OK;
    IStream *pStream = NULL;
    DWORD mshlflags;
    IBindCtx *pbc;
    InterfaceData *moniker = NULL;
 
    TRACE("%p, %#lx, %p, %p, %p\n", iface, flags, punkObject, pmkObjectName, pdwRegister);
 
    if (flags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
    {
        ERR("Invalid flags: %#lx\n", flags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
        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;
 
    /* marshal object */
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    if (hr != S_OK)
    {
        rot_entry_delete(rot_entry);
        return hr;
    }
    mshlflags = flags & 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 = CreateBindCtx(0, &pbc);
    if (FAILED(hr))
    {
        rot_entry_delete(rot_entry);
        return hr;
    }
 
    hr = reduce_moniker(pmkObjectName, pbc, &pmkObjectName);
    if (FAILED(hr))
    {
        rot_entry_delete(rot_entry);
        IBindCtx_Release(pbc);
        return hr;
    }
 
    hr = IMoniker_GetTimeOfLastChange(pmkObjectName, pbc, NULL,
                                      &rot_entry->last_modified);
    IBindCtx_Release(pbc);
    if (FAILED(hr))
    {
        CoFileTimeNow(&rot_entry->last_modified);
        hr = S_OK;
    }
 
    hr = get_moniker_comparison_data(pmkObjectName,
                                     &rot_entry->moniker_data);
    if (hr != S_OK)
    {
        rot_entry_delete(rot_entry);
        IMoniker_Release(pmkObjectName);
        return hr;
    }
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    if (hr != S_OK)
    {
        rot_entry_delete(rot_entry);
        IMoniker_Release(pmkObjectName);
        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);
            moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[size]));
            moniker->ulCntData = size;
            memcpy(moniker->abData, pv, size);
            GlobalUnlock(hglobal);
        }
    }
    IStream_Release(pStream);
    IMoniker_Release(pmkObjectName);
    if (hr != S_OK)
    {
        HeapFree(GetProcessHeap(), 0, moniker);
        rot_entry_delete(rot_entry);
        return hr;
    }
 
    hr = InternalIrotRegister(rot_entry->moniker_data, rot_entry->object, moniker,
            &rot_entry->last_modified, flags, &rot_entry->cookie, &rot_entry->ctxt_handle);
 
    HeapFree(GetProcessHeap(), 0, moniker);
    if (FAILED(hr))
    {
        rot_entry_delete(rot_entry);
        return hr;
    }
 
    /* gives a registration identifier to the registered object*/
    *pdwRegister = rot_entry->cookie;
 
    EnterCriticalSection(&This->lock);
    list_add_tail(&This->rot, &rot_entry->entry);
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

RunningObjectTableImpl_Release()

static ULONG WINAPI RunningObjectTableImpl_Release ( IRunningObjectTable *  iface )

static

Definition at line 264 of file moniker.c.

{
    TRACE("%p\n", iface);
 
    return 1;
}

RunningObjectTableImpl_Revoke()

static HRESULT WINAPI RunningObjectTableImpl_Revoke ( IRunningObjectTable *  iface, DWORD  dwRegister  )

static

Definition at line 434 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    struct rot_entry *rot_entry;
 
    TRACE("%p, %ld.\n", iface, 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;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

critsect_debug

RTL_CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &rot.lock,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": RunningObjectTable_section") }
}

Definition at line 712 of file moniker.c.

rot

RunningObjectTableImpl rot

static

Initial value:

=
{
    .IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl,
    .lock = { &critsect_debug, -1, 0, 0, 0, 0 },
    .rot = LIST_INIT(rot.rot),
}

Definition at line 710 of file moniker.c.

Referenced by DestroyRunningObjectTable(), GetRunningObjectTable(), test_bind_context(), test_generic_composite_moniker(), and test_item_moniker().

VT_EnumMonikerImpl

const IEnumMonikerVtbl VT_EnumMonikerImpl

static

Initial value:

=
{
    EnumMonikerImpl_QueryInterface,
    EnumMonikerImpl_AddRef,
    EnumMonikerImpl_Release,
    EnumMonikerImpl_Next,
    EnumMonikerImpl_Skip,
    EnumMonikerImpl_Reset,
    EnumMonikerImpl_Clone
}

Definition at line 1157 of file moniker.c.

Referenced by EnumMonikerImpl_CreateEnumROTMoniker().

VT_MonikerMarshal

const IMarshalVtbl VT_MonikerMarshal

static

Initial value:

=
{
    MonikerMarshal_QueryInterface,
    MonikerMarshal_AddRef,
    MonikerMarshal_Release,
    MonikerMarshal_GetUnmarshalClass,
    MonikerMarshal_GetMarshalSizeMax,
    MonikerMarshal_MarshalInterface,
    MonikerMarshal_UnmarshalInterface,
    MonikerMarshal_ReleaseMarshalData,
    MonikerMarshal_DisconnectObject
}

Definition at line 1348 of file moniker.c.

Referenced by MonikerMarshal_Create().

VT_MonikerMarshalInner

const IUnknownVtbl VT_MonikerMarshalInner

static

Initial value:

=
{
    MonikerMarshalInner_QueryInterface,
    MonikerMarshalInner_AddRef,
    MonikerMarshalInner_Release
}

Definition at line 1253 of file moniker.c.

Referenced by MonikerMarshal_Create().

VT_RunningObjectTableImpl

const IRunningObjectTableVtbl VT_RunningObjectTableImpl

static

Initial value:

=
{
    RunningObjectTableImpl_QueryInterface,
    RunningObjectTableImpl_AddRef,
    RunningObjectTableImpl_Release,
    RunningObjectTableImpl_Register,
    RunningObjectTableImpl_Revoke,
    RunningObjectTableImpl_IsRunning,
    RunningObjectTableImpl_GetObject,
    RunningObjectTableImpl_NoteChangeTime,
    RunningObjectTableImpl_GetTimeOfLastChange,
    RunningObjectTableImpl_EnumRunning
}

Definition at line 696 of file moniker.c.