irotp.c File Reference

#include <stdarg.h>
#include <string.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "irot_s.h"
#include "wine/list.h"
#include "wine/debug.h"

Include dependency graph for irotp.c:

Go to the source code of this file.

Classes
struct	rot_entry

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (rpcss)
static void	rot_entry_release (struct rot_entry *rot_entry)
HRESULT __cdecl	IrotRegister (IrotHandle h, const MonikerComparisonData *data, const InterfaceData *obj, const InterfaceData *mk, const FILETIME *time, DWORD grfFlags, IrotCookie *cookie, IrotContextHandle *ctxt_handle)
HRESULT __cdecl	IrotRevoke (IrotHandle h, IrotCookie cookie, IrotContextHandle *ctxt_handle, PInterfaceData *obj, PInterfaceData *mk)
HRESULT __cdecl	IrotIsRunning (IrotHandle h, const MonikerComparisonData *data)
HRESULT __cdecl	IrotGetObject (IrotHandle h, const MonikerComparisonData *moniker_data, PInterfaceData *obj, IrotCookie *cookie)
HRESULT __cdecl	IrotNoteChangeTime (IrotHandle h, IrotCookie cookie, const FILETIME *last_modified_time)
HRESULT __cdecl	IrotGetTimeOfLastChange (IrotHandle h, const MonikerComparisonData *moniker_data, FILETIME *time)
HRESULT __cdecl	IrotEnumRunning (IrotHandle h, PInterfaceList *list)
void __RPC_USER	IrotContextHandle_rundown (IrotContextHandle ctxt_handle)
void *__RPC_USER	MIDL_user_allocate (SIZE_T size)
void __RPC_USER	MIDL_user_free (void *p)

Variables
static struct list	RunningObjectTable = LIST_INIT(RunningObjectTable)
static CRITICAL_SECTION	csRunningObjectTable = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
static LONG	last_cookie = 1

Function Documentation

IrotContextHandle_rundown()

void __RPC_USER IrotContextHandle_rundown

(

IrotContextHandle

ctxt_handle

)

Definition at line 362 of file irotp.c.

{
    struct rot_entry *rot_entry = ctxt_handle;
    EnterCriticalSection(&csRunningObjectTable);
    list_remove(&rot_entry->entry);
    LeaveCriticalSection(&csRunningObjectTable);
    rot_entry_release(rot_entry);
}

IrotEnumRunning()

HRESULT __cdecl IrotEnumRunning	(	IrotHandle	h,
		PInterfaceList *	list
	)

Definition at line 317 of file irotp.c.

{
    const struct rot_entry *rot_entry;
    HRESULT hr = S_OK;
    ULONG moniker_count = 0;
    ULONG i = 0;
 
    WINE_TRACE("\n");
 
    EnterCriticalSection(&csRunningObjectTable);
 
    LIST_FOR_EACH_ENTRY( rot_entry, &RunningObjectTable, const struct rot_entry, entry )
        moniker_count++;
 
    *list = MIDL_user_allocate(FIELD_OFFSET(InterfaceList, interfaces[moniker_count]));
    if (*list)
    {
        (*list)->size = moniker_count;
        LIST_FOR_EACH_ENTRY( rot_entry, &RunningObjectTable, const struct rot_entry, entry )
        {
            (*list)->interfaces[i] = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->moniker->ulCntData]));
            if (!(*list)->interfaces[i])
            {
                ULONG end = i - 1;
                for (i = 0; i < end; i++)
                    MIDL_user_free((*list)->interfaces[i]);
                MIDL_user_free(*list);
                hr = E_OUTOFMEMORY;
                break;
            }
            (*list)->interfaces[i]->ulCntData = rot_entry->moniker->ulCntData;
            memcpy((*list)->interfaces[i]->abData, rot_entry->moniker->abData, rot_entry->moniker->ulCntData);
            i++;
        }
    }
    else
        hr = E_OUTOFMEMORY;
 
    LeaveCriticalSection(&csRunningObjectTable);
 
    return hr;
}

Referenced by RunningObjectTableImpl_EnumRunning().

IrotGetObject()

HRESULT __cdecl IrotGetObject	(	IrotHandle	h,
		const MonikerComparisonData *	moniker_data,
		PInterfaceData *	obj,
		IrotCookie *	cookie
	)

Definition at line 223 of file irotp.c.

{
    const struct rot_entry *rot_entry;
 
    WINE_TRACE("%p\n", moniker_data);
 
    *cookie = 0;
 
    EnterCriticalSection(&csRunningObjectTable);
 
    LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, const struct rot_entry, entry)
    {
        HRESULT hr = S_OK;
        if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
            !memcmp(&moniker_data->abData, &rot_entry->moniker_data->abData, moniker_data->ulCntData))
        {
            *obj = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->object->ulCntData]));
            if (*obj)
            {
                (*obj)->ulCntData = rot_entry->object->ulCntData;
                memcpy((*obj)->abData, rot_entry->object->abData, (*obj)->ulCntData);
 
                *cookie = rot_entry->cookie;
            }
            else
                hr = E_OUTOFMEMORY;
 
            LeaveCriticalSection(&csRunningObjectTable);
 
            return hr;
        }
    }
 
    LeaveCriticalSection(&csRunningObjectTable);
 
    return MK_E_UNAVAILABLE;
}

Referenced by RunningObjectTableImpl_GetObject().

IrotGetTimeOfLastChange()

HRESULT __cdecl IrotGetTimeOfLastChange	(	IrotHandle	h,
		const MonikerComparisonData *	moniker_data,
		FILETIME *	time
	)

Definition at line 289 of file irotp.c.

{
    const struct rot_entry *rot_entry;
    HRESULT hr = MK_E_UNAVAILABLE;
 
    WINE_TRACE("%p\n", moniker_data);
 
    memset(time, 0, sizeof(*time));
 
    EnterCriticalSection(&csRunningObjectTable);
    LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, 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))
        {
            *time = rot_entry->last_modified;
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&csRunningObjectTable);
 
    return hr;
}

Referenced by RunningObjectTableImpl_GetTimeOfLastChange().

IrotIsRunning()

HRESULT __cdecl IrotIsRunning	(	IrotHandle	h,
		const MonikerComparisonData *	data
	)

Definition at line 198 of file irotp.c.

{
    const struct rot_entry *rot_entry;
    HRESULT hr = S_FALSE;
 
    WINE_TRACE("\n");
 
    EnterCriticalSection(&csRunningObjectTable);
 
    LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, const struct rot_entry, entry)
    {
        if ((rot_entry->moniker_data->ulCntData == data->ulCntData) &&
            !memcmp(&data->abData, &rot_entry->moniker_data->abData, data->ulCntData))
        {
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&csRunningObjectTable);
 
    return hr;
}

Referenced by RunningObjectTableImpl_IsRunning().

IrotNoteChangeTime()

HRESULT __cdecl IrotNoteChangeTime	(	IrotHandle	h,
		IrotCookie	cookie,
		const FILETIME *	last_modified_time
	)

Definition at line 265 of file irotp.c.

{
    struct rot_entry *rot_entry;
 
    WINE_TRACE("%d %p\n", cookie, last_modified_time);
 
    EnterCriticalSection(&csRunningObjectTable);
    LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, struct rot_entry, entry)
    {
        if (rot_entry->cookie == cookie)
        {
            rot_entry->last_modified = *last_modified_time;
            LeaveCriticalSection(&csRunningObjectTable);
            return S_OK;
        }
    }
    LeaveCriticalSection(&csRunningObjectTable);
 
    return E_INVALIDARG;
}

Referenced by RunningObjectTableImpl_NoteChangeTime().

IrotRegister()

HRESULT __cdecl IrotRegister	(	IrotHandle	h,
		const MonikerComparisonData *	data,
		const InterfaceData *	obj,
		const InterfaceData *	mk,
		const FILETIME *	time,
		DWORD	grfFlags,
		IrotCookie *	cookie,
		IrotContextHandle *	ctxt_handle
	)

Definition at line 71 of file irotp.c.

{
    struct rot_entry *rot_entry;
    struct rot_entry *existing_rot_entry;
    HRESULT hr;
 
    if (grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
    {
        WINE_ERR("Invalid grfFlags: 0x%08x\n", grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
        return E_INVALIDARG;
    }
 
    rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
    if (!rot_entry)
        return E_OUTOFMEMORY;
 
    rot_entry->refs = 1;
    rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[obj->ulCntData]));
    if (!rot_entry->object)
    {
        rot_entry_release(rot_entry);
        return E_OUTOFMEMORY;
    }
    rot_entry->object->ulCntData = obj->ulCntData;
    memcpy(&rot_entry->object->abData, obj->abData, obj->ulCntData);
 
    rot_entry->last_modified = *time;
 
    rot_entry->moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[mk->ulCntData]));
    if (!rot_entry->moniker)
    {
        rot_entry_release(rot_entry);
        return E_OUTOFMEMORY;
    }
    rot_entry->moniker->ulCntData = mk->ulCntData;
    memcpy(&rot_entry->moniker->abData, mk->abData, mk->ulCntData);
 
    rot_entry->moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[data->ulCntData]));
    if (!rot_entry->moniker_data)
    {
        rot_entry_release(rot_entry);
        return E_OUTOFMEMORY;
    }
    rot_entry->moniker_data->ulCntData = data->ulCntData;
    memcpy(&rot_entry->moniker_data->abData, data->abData, data->ulCntData);
 
    EnterCriticalSection(&csRunningObjectTable);
 
    hr = S_OK;
 
    LIST_FOR_EACH_ENTRY(existing_rot_entry, &RunningObjectTable, struct rot_entry, entry)
    {
        if ((existing_rot_entry->moniker_data->ulCntData == data->ulCntData) &&
            !memcmp(&data->abData, &existing_rot_entry->moniker_data->abData, data->ulCntData))
        {
            hr = MK_S_MONIKERALREADYREGISTERED;
            WINE_TRACE("moniker already registered with cookie %d\n", existing_rot_entry->cookie);
            break;
        }
    }
 
    list_add_tail(&RunningObjectTable, &rot_entry->entry);
 
    LeaveCriticalSection(&csRunningObjectTable);
 
    /* gives a registration identifier to the registered object*/
    *cookie = rot_entry->cookie = InterlockedIncrement(&last_cookie);
    *ctxt_handle = rot_entry;
 
    return hr;
}

Referenced by RunningObjectTableImpl_Register().

IrotRevoke()

HRESULT __cdecl IrotRevoke	(	IrotHandle	h,
		IrotCookie	cookie,
		IrotContextHandle *	ctxt_handle,
		PInterfaceData *	obj,
		PInterfaceData *	mk
	)

Definition at line 151 of file irotp.c.

{
    struct rot_entry *rot_entry;
 
    WINE_TRACE("%d\n", cookie);
 
    EnterCriticalSection(&csRunningObjectTable);
    LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, struct rot_entry, entry)
    {
        if (rot_entry->cookie == cookie)
        {
            HRESULT hr = S_OK;
 
            list_remove(&rot_entry->entry);
            LeaveCriticalSection(&csRunningObjectTable);
 
            *obj = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->object->ulCntData]));
            *mk = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->moniker->ulCntData]));
            if (*obj && *mk)
            {
                (*obj)->ulCntData = rot_entry->object->ulCntData;
                memcpy((*obj)->abData, rot_entry->object->abData, (*obj)->ulCntData);
                (*mk)->ulCntData = rot_entry->moniker->ulCntData;
                memcpy((*mk)->abData, rot_entry->moniker->abData, (*mk)->ulCntData);
            }
            else
            {
                MIDL_user_free(*obj);
                MIDL_user_free(*mk);
                hr = E_OUTOFMEMORY;
            }
 
            rot_entry_release(rot_entry);
            *ctxt_handle = NULL;
            return hr;
        }
    }
    LeaveCriticalSection(&csRunningObjectTable);
 
    return E_INVALIDARG;
}

Referenced by rot_entry_delete().

MIDL_user_allocate()

void *__RPC_USER MIDL_user_allocate

(

SIZE_T

size

)

Definition at line 371 of file irotp.c.

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

Referenced by IrotEnumRunning(), IrotGetObject(), and IrotRevoke().

MIDL_user_free()

void __RPC_USER MIDL_user_free

(

void *

p

)

Definition at line 376 of file irotp.c.

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

Referenced by IrotEnumRunning(), and IrotRevoke().

rot_entry_release()

static void rot_entry_release ( struct rot_entry *  rot_entry )

inlinestatic

Definition at line 60 of file irotp.c.

{
    if (!InterlockedDecrement(&rot_entry->refs))
    {
        HeapFree(GetProcessHeap(), 0, rot_entry->object);
        HeapFree(GetProcessHeap(), 0, rot_entry->moniker);
        HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
        HeapFree(GetProcessHeap(), 0, rot_entry);
    }
}

Referenced by IrotContextHandle_rundown(), IrotRegister(), and IrotRevoke().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

rpcss

)

Variable Documentation

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &csRunningObjectTable,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": csRunningObjectTable") }
}

Definition at line 50 of file irotp.c.

csRunningObjectTable

static CRITICAL_SECTION csRunningObjectTable = { &critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 49 of file irotp.c.

Referenced by IrotContextHandle_rundown(), IrotEnumRunning(), IrotGetObject(), IrotGetTimeOfLastChange(), IrotIsRunning(), IrotNoteChangeTime(), IrotRegister(), and IrotRevoke().

last_cookie

LONG last_cookie = 1

static

Definition at line 58 of file irotp.c.

Referenced by IrotRegister().

RunningObjectTable

struct list RunningObjectTable = LIST_INIT(RunningObjectTable)

static

Definition at line 47 of file irotp.c.

Referenced by IrotEnumRunning(), IrotGetObject(), IrotGetTimeOfLastChange(), IrotIsRunning(), IrotNoteChangeTime(), IrotRegister(), and IrotRevoke().