moniker.c File Reference

#include <stdarg.h>
#include <string.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winsvc.h"
#include "wtypes.h"
#include "ole2.h"
#include "wine/list.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "compobj_private.h"
#include "moniker.h"
#include "irot.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
#define	MAX_COMPARISON_DATA   2048

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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static LONG WINAPI	rpc_filter (EXCEPTION_POINTERS *eptr)
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 IrotHandle	get_irot_handle (void)
static BOOL	start_rpcss (void)
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 HRESULT	RunningObjectTableImpl_Destroy (void)
static ULONG WINAPI	RunningObjectTableImpl_Release (IRunningObjectTable *iface)
static HRESULT WINAPI	RunningObjectTableImpl_Register (IRunningObjectTable *iface, DWORD grfFlags, 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	RunningObjectTableImpl_Initialize (void)
HRESULT WINAPI	RunningObjectTableImpl_UnInitialize (void)
HRESULT WINAPI	GetRunningObjectTable (DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
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 RunningObjectTableImpl *	runningObjectTableInstance = NULL
static IrotHandle	irot_handle
static const IRunningObjectTableVtbl	VT_RunningObjectTableImpl
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.

MAX_COMPARISON_DATA

#define MAX_COMPARISON_DATA   2048

Definition at line 50 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 179 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().

EnumMonikerImpl_AddRef()

static ULONG WINAPI EnumMonikerImpl_AddRef ( IEnumMoniker *  iface )

static

Definition at line 1333 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 1438 of file moniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
    InterfaceList *moniker_list;
    ULONG i;
 
    TRACE("(%p)\n",This);
 
    *ppenum = NULL;
 
    moniker_list = HeapAlloc(GetProcessHeap(), 0, 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] = HeapAlloc(GetProcessHeap(), 0, size);
        if (!moniker_list->interfaces[i])
        {
            ULONG end = i;
            for (i = 0; i < end; i++)
                HeapFree(GetProcessHeap(), 0, moniker_list->interfaces[i]);
            HeapFree(GetProcessHeap(), 0, 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 1489 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 1372 of file moniker.c.

{
    ULONG i;
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
    HRESULT hr = S_OK;
 
    TRACE("(%p) TabCurrentPos %d Tablastindx %d\n", This, This->pos, This->moniker_list->size);
 
    /* 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 1309 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 1345 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++)
            HeapFree(GetProcessHeap(), 0, This->moniker_list->interfaces[i]);
        HeapFree(GetProcessHeap(), 0, This->moniker_list);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

EnumMonikerImpl_Reset()

static HRESULT WINAPI EnumMonikerImpl_Reset ( IEnumMoniker *  iface )

static

Definition at line 1424 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 1407 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_irot_handle()

static IrotHandle get_irot_handle ( void  )

static

Definition at line 105 of file moniker.c.

{
    if (!irot_handle)
    {
        RPC_STATUS status;
        RPC_WSTR binding;
        IrotHandle new_handle;
        unsigned short ncacn_np[] = IROT_PROTSEQ;
        unsigned short endpoint[] = IROT_ENDPOINT;
        status = RpcStringBindingComposeW(NULL, ncacn_np, NULL, endpoint, NULL, &binding);
        if (status == RPC_S_OK)
        {
            status = RpcBindingFromStringBindingW(binding, &new_handle);
            RpcStringFreeW(&binding);
        }
        if (status != RPC_S_OK)
            return NULL;
        if (InterlockedCompareExchangePointer(&irot_handle, new_handle, NULL))
            /* another thread beat us to it */
            RpcBindingFree(&new_handle);
    }
    return irot_handle;
}

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

get_moniker_comparison_data()

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

static

Definition at line 234 of file moniker.c.

{
    HRESULT hr;
    IROTData *pROTData = NULL;
    hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
    if (SUCCEEDED(hr))
    {
        ULONG size = MAX_COMPARISON_DATA;
        *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 = 0x%08x\n", hr);
            HeapFree(GetProcessHeap(), 0, *moniker_data);
            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 1054 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 1213 of file moniker.c.

{
    IStorage *pstg=0;
    HRESULT res;
    int nbElm, length, i;
    LONG sizeProgId, ret;
    LPOLESTR *pathDec=0,absFile=0,progId=0;
    LPWSTR extension;
    static const WCHAR bkslashW[] = {'\\',0};
    static const WCHAR dotW[] = {'.',0};
 
    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 */
 
    /* get the last element (absolute file) in the path name */
    nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
    absFile=pathDec[nbElm-1];
 
    /* failed if the path represents a directory and not an absolute file name*/
    if (!wcscmp(absFile, bkslashW)) {
        CoTaskMemFree(pathDec);
        return MK_E_INVALIDEXTENSION;
    }
 
    /* get the extension of the file */
    extension = NULL;
    length=lstrlenW(absFile);
    for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
        /* nothing */;
 
    if (!extension || !wcscmp(extension, dotW)) {
        CoTaskMemFree(pathDec);
        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);
 
    for(i=0; pathDec[i]!=NULL;i++)
        CoTaskMemFree(pathDec[i]);
    CoTaskMemFree(pathDec);
 
    return res != S_OK ? MK_E_INVALIDEXTENSION : res;
}

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

GetRunningObjectTable()

HRESULT WINAPI GetRunningObjectTable	(	DWORD	reserved,
		LPRUNNINGOBJECTTABLE *	pprot
	)

Definition at line 1035 of file moniker.c.

{
    IID riid=IID_IRunningObjectTable;
    HRESULT res;
 
    TRACE("()\n");
 
    if (reserved!=0)
        return E_UNEXPECTED;
 
    if(runningObjectTableInstance==NULL)
        return CO_E_NOTINITIALIZED;
 
    res = IRunningObjectTable_QueryInterface(&runningObjectTableInstance->IRunningObjectTable_iface,
                                             &riid,(void**)pprot);
 
    return res;
}

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

impl_from_IEnumMoniker()

static EnumMonikerImpl * impl_from_IEnumMoniker ( IEnumMoniker *  iface )

inlinestatic

Definition at line 96 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 1534 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 91 of file moniker.c.

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

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

impl_from_IUnknown()

static MonikerMarshal * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 1529 of file moniker.c.

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

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

MIDL_user_allocate()

void *__RPC_USER MIDL_user_allocate

(

SIZE_T

size

)

Definition at line 1691 of file moniker.c.

{
    return HeapAlloc(GetProcessHeap(), 0, size);
}

MIDL_user_free()

void __RPC_USER MIDL_user_free

(

void *

p

)

Definition at line 1696 of file moniker.c.

{
    HeapFree(GetProcessHeap(), 0, p);
}

Referenced by rot_entry_delete().

MkParseDisplayName()

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

Definition at line 1129 of file moniker.c.

{
    HRESULT hr = MK_E_SYNTAX;
    static const WCHAR wszClsidColon[] = {'c','l','s','i','d',':'};
    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, wszClsidColon, ARRAY_SIZE(wszClsidColon)))
    {
        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(), and test_MkParseDisplayName().

MonikerMarshal_AddRef()

static ULONG WINAPI MonikerMarshal_AddRef ( IMarshal *  iface )

static

Definition at line 1582 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 1677 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 1656 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 1606 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
    HRESULT hr;
    ULARGE_INTEGER size;
 
    TRACE("(%s, %p, %x, %p, %x, %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 1594 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
 
    TRACE("(%s, %p, %x, %p, %x, %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 1623 of file moniker.c.

{
    MonikerMarshal *This = impl_from_IMarshal(iface);
 
    TRACE("(%p, %s, %p, %x, %p, %x)\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 1576 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 1588 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 1648 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 1635 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 1554 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 1539 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 1560 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 298 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 0x%08x\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 188 of file moniker.c.

{
    if (rot_entry->cookie)
    {
        InterfaceData *object = NULL;
        InterfaceData *moniker = NULL;
        __TRY
        {
            IrotRevoke(get_irot_handle(), rot_entry->cookie,
                       &rot_entry->ctxt_handle, &object, &moniker);
        }
        __EXCEPT(rpc_filter)
        {
        }
        __ENDTRY
        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 RunningObjectTableImpl_Destroy(), RunningObjectTableImpl_Register(), RunningObjectTableImpl_Release(), and RunningObjectTableImpl_Revoke().

rpc_filter()

static LONG WINAPI rpc_filter ( EXCEPTION_POINTERS *  eptr )

static

Definition at line 52 of file moniker.c.

{
    return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode);
}

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

RunningObjectTableImpl_AddRef()

static ULONG WINAPI RunningObjectTableImpl_AddRef ( IRunningObjectTable *  iface )

static

Definition at line 350 of file moniker.c.

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

RunningObjectTableImpl_Destroy()

static HRESULT RunningObjectTableImpl_Destroy ( void  )

static

Definition at line 363 of file moniker.c.

{
    struct list *cursor, *cursor2;
    IrotHandle old_handle;
 
    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);
    }
 
    DEBUG_CLEAR_CRITSEC_NAME(&runningObjectTableInstance->lock);
    DeleteCriticalSection(&runningObjectTableInstance->lock);
 
    /* free the ROT structure memory */
    HeapFree(GetProcessHeap(),0,runningObjectTableInstance);
    runningObjectTableInstance = NULL;
 
    old_handle = irot_handle;
    irot_handle = NULL;
    if (old_handle)
        RpcBindingFree(&old_handle);
 
    return S_OK;
}

Referenced by RunningObjectTableImpl_UnInitialize().

RunningObjectTableImpl_EnumRunning()

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

static

Definition at line 924 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    InterfaceList *interface_list = NULL;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, ppenumMoniker);
 
    *ppenumMoniker = NULL;
 
    while (TRUE)
    {
        __TRY
        {
            hr = IrotEnumRunning(get_irot_handle(), &interface_list);
        }
        __EXCEPT(rpc_filter)
        {
            hr = HRESULT_FROM_WIN32(GetExceptionCode());
        }
        __ENDTRY
        if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
        {
            if (start_rpcss())
                continue;
        }
        break;
    }
 
    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 705 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);
            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);
 
    TRACE("moniker unavailable locally, calling SCM\n");
 
    while (TRUE)
    {
        __TRY
        {
            hr = IrotGetObject(get_irot_handle(), moniker_data, &object, &cookie);
        }
        __EXCEPT(rpc_filter)
        {
            hr = HRESULT_FROM_WIN32(GetExceptionCode());
        }
        __ENDTRY
        if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
        {
            if (start_rpcss())
                continue;
        }
        break;
    }
 
    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 0x%08x\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 853 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)
    {
        while (TRUE)
        {
            __TRY
            {
                hr = IrotGetTimeOfLastChange(get_irot_handle(), moniker_data, pfiletime);
            }
            __EXCEPT(rpc_filter)
            {
                hr = HRESULT_FROM_WIN32(GetExceptionCode());
            }
            __ENDTRY
            if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
            {
                if (start_rpcss())
                    continue;
            }
            break;
        }
    }
 
    HeapFree(GetProcessHeap(), 0, moniker_data);
 
    TRACE("-- 0x%08x\n", hr);
    return hr;
}

RunningObjectTableImpl_Initialize()

HRESULT WINAPI RunningObjectTableImpl_Initialize

(

void

)

Definition at line 979 of file moniker.c.

{
    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->IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl;
 
    /* the initial reference is set to "1" so that it isn't destroyed after its
     * first use until the process is destroyed, as the running object table is
     * a process-wide cache of a global table */
    runningObjectTableInstance->ref = 1;
 
    list_init(&runningObjectTableInstance->rot);
    InitializeCriticalSection(&runningObjectTableInstance->lock);
    DEBUG_SET_CRITSEC_NAME(&runningObjectTableInstance->lock, "RunningObjectTableImpl.lock");
 
    return S_OK;
}

Referenced by CoInitializeEx().

RunningObjectTableImpl_IsRunning()

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

static

Definition at line 640 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)
    {
        while (TRUE)
        {
            __TRY
            {
                hr = IrotIsRunning(get_irot_handle(), moniker_data);
            }
            __EXCEPT(rpc_filter)
            {
                hr = HRESULT_FROM_WIN32(GetExceptionCode());
            }
            __ENDTRY
            if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
            {
                if (start_rpcss())
                    continue;
            }
            break;
        }
    }
 
    HeapFree(GetProcessHeap(), 0, moniker_data);
 
    return hr;
}

RunningObjectTableImpl_NoteChangeTime()

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

static

Definition at line 799 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
    struct rot_entry *rot_entry;
    HRESULT hr = E_INVALIDARG;
 
    TRACE("(%p,%d,%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);
 
            while (TRUE)
            {
                __TRY
                {
                    hr = IrotNoteChangeTime(get_irot_handle(), dwRegister, pfiletime);
                }
                __EXCEPT(rpc_filter)
                {
                    hr = HRESULT_FROM_WIN32(GetExceptionCode());
                }
                __ENDTRY
                if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
                {
                    if (start_rpcss())
                        continue;
                }
                break;
            }
 
            goto done;
        }
    }
    LeaveCriticalSection(&This->lock);
 
done:
    TRACE("-- 0x08%x\n", hr);
    return hr;
}

RunningObjectTableImpl_QueryInterface()

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

static

Definition at line 320 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  grfFlags, IUnknown *  punkObject, IMoniker *  pmkObjectName, DWORD *  pdwRegister  )

static

Definition at line 437 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,%d,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister);
 
    if (grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
    {
        ERR("Invalid grfFlags: 0x%08x\n", grfFlags & ~(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 = (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 = 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;
    }
 
 
    while (TRUE)
    {
        __TRY
        {
            hr = IrotRegister(get_irot_handle(), rot_entry->moniker_data,
                              rot_entry->object, moniker,
                              &rot_entry->last_modified, grfFlags,
                              &rot_entry->cookie, &rot_entry->ctxt_handle);
        }
        __EXCEPT(rpc_filter)
        {
            hr = HRESULT_FROM_WIN32(GetExceptionCode());
        }
        __ENDTRY
        if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
        {
            if (start_rpcss())
                continue;
        }
        break;
    }
    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 400 of file moniker.c.

{
    RunningObjectTableImpl *This = impl_from_IRunningObjectTable(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)
    {
        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;
}

Referenced by RunningObjectTableImpl_UnInitialize().

RunningObjectTableImpl_Revoke()

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

static

Definition at line 609 of file moniker.c.

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

RunningObjectTableImpl_UnInitialize()

HRESULT WINAPI RunningObjectTableImpl_UnInitialize

(

void

)

Definition at line 1007 of file moniker.c.

{
    TRACE("\n");
 
    if (runningObjectTableInstance==NULL)
        return E_POINTER;
 
    RunningObjectTableImpl_Release(&runningObjectTableInstance->IRunningObjectTable_iface);
 
    RunningObjectTableImpl_Destroy();
 
    return S_OK;
}

Referenced by CoUninitialize().

start_rpcss()

static BOOL start_rpcss ( void  )

static

Definition at line 129 of file moniker.c.

{
    static const WCHAR rpcssW[] = {'R','p','c','S','s',0};
    SC_HANDLE scm, service;
    SERVICE_STATUS_PROCESS status;
    BOOL ret = FALSE;
 
    TRACE("\n");
 
    if (!(scm = OpenSCManagerW( NULL, NULL, 0 )))
    {
        ERR( "failed to open service manager\n" );
        return FALSE;
    }
    if (!(service = OpenServiceW( scm, rpcssW, SERVICE_START | SERVICE_QUERY_STATUS )))
    {
        ERR( "failed to open RpcSs service\n" );
        CloseServiceHandle( scm );
        return FALSE;
    }
    if (StartServiceW( service, 0, NULL ) || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
    {
        ULONGLONG start_time = GetTickCount64();
        do
        {
            DWORD dummy;
 
            if (!QueryServiceStatusEx( service, SC_STATUS_PROCESS_INFO,
                                       (BYTE *)&status, sizeof(status), &dummy ))
                break;
            if (status.dwCurrentState == SERVICE_RUNNING)
            {
                ret = TRUE;
                break;
            }
            if (GetTickCount64() - start_time > 30000) break;
            Sleep( 100 );
 
        } while (status.dwCurrentState == SERVICE_START_PENDING);
 
        if (status.dwCurrentState != SERVICE_RUNNING)
            WARN( "RpcSs failed to start %u\n", status.dwCurrentState );
    }
    else ERR( "failed to start RpcSs service\n" );
 
    CloseServiceHandle( service );
    CloseServiceHandle( scm );
    return ret;
}

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

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

irot_handle

IrotHandle irot_handle

static

Definition at line 79 of file moniker.c.

Referenced by get_irot_handle(), and RunningObjectTableImpl_Destroy().

runningObjectTableInstance

RunningObjectTableImpl* runningObjectTableInstance = NULL

static

Definition at line 78 of file moniker.c.

Referenced by GetRunningObjectTable(), RunningObjectTableImpl_Destroy(), RunningObjectTableImpl_Initialize(), and RunningObjectTableImpl_UnInitialize().

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 1473 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 1664 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 1569 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 962 of file moniker.c.

Referenced by RunningObjectTableImpl_Initialize().