epmp.c File Reference

#include "epm_s.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for epmp.c:

Go to the source code of this file.

Classes
struct	registered_ept_entry

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static void	delete_registered_ept_entry (struct registered_ept_entry *entry)
static struct registered_ept_entry *	find_ept_entry (const RPC_SYNTAX_IDENTIFIER *iface, const RPC_SYNTAX_IDENTIFIER *syntax, const char *protseq, const char *endpoint, const char *address, const UUID *object)
void __RPC_USER	ept_lookup_handle_t_rundown (ept_lookup_handle_t entry_handle)
void __cdecl	ept_insert (handle_t h, unsigned32 num_ents, ept_entry_t entries[], boolean32 replace, error_status_t *status)
void __cdecl	ept_delete (handle_t h, unsigned32 num_ents, ept_entry_t entries[], error_status_t *status)
void __cdecl	ept_lookup (handle_t h, unsigned32 inquiry_type, uuid_p_t object, rpc_if_id_p_t interface_id, unsigned32 vers_option, ept_lookup_handle_t *entry_handle, unsigned32 max_ents, unsigned32 *num_ents, ept_entry_t entries[], error_status_t *status)
void __cdecl	ept_map (handle_t h, uuid_p_t object, twr_p_t map_tower, ept_lookup_handle_t *entry_handle, unsigned32 max_towers, unsigned32 *num_towers, twr_p_t *towers, error_status_t *status)
void __cdecl	ept_lookup_handle_free (handle_t h, ept_lookup_handle_t *entry_handle, error_status_t *status)
void __cdecl	ept_inq_object (handle_t h, GUID *ept_object, error_status_t *status)
void __cdecl	ept_mgmt_delete (handle_t h, boolean32 object_speced, uuid_p_t object, twr_p_t tower, error_status_t *status)

Variables
static struct list	registered_ept_entry_list = LIST_INIT(registered_ept_entry_list)
static CRITICAL_SECTION	csEpm = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
static const UUID	nil_object

Function Documentation

delete_registered_ept_entry()

static void delete_registered_ept_entry ( struct registered_ept_entry *  entry )

static

Definition at line 54 of file epmp.c.

{
    I_RpcFree(entry->protseq);
    I_RpcFree(entry->endpoint);
    I_RpcFree(entry->address);
    list_remove(&entry->entry);
    HeapFree(GetProcessHeap(), 0, entry);
}

Referenced by ept_delete(), and ept_insert().

ept_delete()

void __cdecl ept_delete	(	handle_t	h,
		unsigned32	num_ents,
		ept_entry_t	entries[],
		error_status_t *	status
	)

Definition at line 142 of file epmp.c.

{
    unsigned32 i;
    RPC_STATUS rpc_status;
 
    *status = RPC_S_OK;
 
    WINE_TRACE("(%p, %u, %p, %p)\n", h, num_ents, entries, status);
 
    EnterCriticalSection(&csEpm);
 
    for (i = 0; i < num_ents; i++)
    {
        struct registered_ept_entry *entry;
        RPC_SYNTAX_IDENTIFIER iface, syntax;
        char *protseq;
        char *endpoint;
        char *address;
        rpc_status = TowerExplode(entries[i].tower, &iface, &syntax, &protseq,
                                  &endpoint, &address);
        if (rpc_status != RPC_S_OK)
            break;
        entry = find_ept_entry(&iface, &syntax, protseq, endpoint, address, &entries[i].object);
 
        I_RpcFree(protseq);
        I_RpcFree(endpoint);
        I_RpcFree(address);
 
        if (entry)
            delete_registered_ept_entry(entry);
        else
        {
            *status = EPT_S_NOT_REGISTERED;
            break;
        }
    }
 
    LeaveCriticalSection(&csEpm);
}

ept_inq_object()

void __cdecl ept_inq_object	(	handle_t	h,
		GUID *	ept_object,
		error_status_t *	status
	)

Definition at line 270 of file epmp.c.

{
    WINE_FIXME("(%p, %p, %p): stub\n", h, ept_object, status);
 
    *status = EPT_S_CANT_PERFORM_OP;
}

ept_insert()

void __cdecl ept_insert	(	handle_t	h,
		unsigned32	num_ents,
		ept_entry_t	entries[],
		boolean32	replace,
		error_status_t *	status
	)

Definition at line 92 of file epmp.c.

{
    unsigned32 i;
    RPC_STATUS rpc_status;
 
    WINE_TRACE("(%p, %u, %p, %u, %p)\n", h, num_ents, entries, replace, status);
 
    *status = RPC_S_OK;
 
    EnterCriticalSection(&csEpm);
 
    for (i = 0; i < num_ents; i++)
    {
        struct registered_ept_entry *entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
        if (!entry)
        {
            /* FIXME: cleanup code to delete added entries */
            *status = EPT_S_CANT_PERFORM_OP;
            break;
        }
        memcpy(entry->annotation, entries[i].annotation, sizeof(entries[i].annotation));
        rpc_status = TowerExplode(entries[i].tower, &entry->iface, &entry->syntax,
                                  &entry->protseq, &entry->endpoint,
                                  &entry->address);
        if (rpc_status != RPC_S_OK)
        {
            WINE_WARN("TowerExplode failed %u\n", rpc_status);
            *status = rpc_status;
            HeapFree(GetProcessHeap(), 0, entry);
            break; /* FIXME: more cleanup? */
        }
 
        entry->object = entries[i].object;
 
        if (replace)
        {
            /* FIXME: correct find algorithm */
            struct registered_ept_entry *old_entry = find_ept_entry(&entry->iface, &entry->syntax, entry->protseq, entry->endpoint, entry->address, &entry->object);
            if (old_entry) delete_registered_ept_entry(old_entry);
        }
        list_add_tail(&registered_ept_entry_list, &entry->entry);
    }
 
    LeaveCriticalSection(&csEpm);
}

Referenced by epm_register(), and RpcEpUnregister().

ept_lookup()

void __cdecl ept_lookup	(	handle_t	h,
		unsigned32	inquiry_type,
		uuid_p_t	object,
		rpc_if_id_p_t	interface_id,
		unsigned32	vers_option,
		ept_lookup_handle_t *	entry_handle,
		unsigned32	max_ents,
		unsigned32 *	num_ents,
		ept_entry_t	entries[],
		error_status_t *	status
	)

Definition at line 185 of file epmp.c.

{
    WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 
    *status = EPT_S_CANT_PERFORM_OP;
}

ept_lookup_handle_free()

void __cdecl ept_lookup_handle_free	(	handle_t	h,
		ept_lookup_handle_t *	entry_handle,
		error_status_t *	status
	)

Definition at line 261 of file epmp.c.

{
    WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 
    *status = EPT_S_CANT_PERFORM_OP;
}

ept_lookup_handle_t_rundown()

void __RPC_USER ept_lookup_handle_t_rundown

(

ept_lookup_handle_t

entry_handle

)

Definition at line 87 of file epmp.c.

{
    WINE_FIXME("%p\n", entry_handle);
}

ept_map()

void __cdecl ept_map	(	handle_t	h,
		uuid_p_t	object,
		twr_p_t	map_tower,
		ept_lookup_handle_t *	entry_handle,
		unsigned32	max_towers,
		unsigned32 *	num_towers,
		twr_p_t *	towers,
		error_status_t *	status
	)

Definition at line 201 of file epmp.c.

{
    RPC_STATUS rpc_status;
    RPC_SYNTAX_IDENTIFIER iface, syntax;
    char *protseq;
    struct registered_ept_entry *entry;
 
    *status = RPC_S_OK;
    *num_towers = 0;
 
    WINE_TRACE("(%p, %p, %p, %p, %u, %p, %p, %p)\n", h, object, map_tower,
          entry_handle, max_towers, num_towers, towers, status);
 
    rpc_status = TowerExplode(map_tower, &iface, &syntax, &protseq,
                              NULL, NULL);
    if (rpc_status != RPC_S_OK)
    {
        *status = rpc_status;
        return;
    }
 
    EnterCriticalSection(&csEpm);
 
    LIST_FOR_EACH_ENTRY(entry, &registered_ept_entry_list, struct registered_ept_entry, entry)
    {
        if (IsEqualGUID(&entry->iface.SyntaxGUID, &iface.SyntaxGUID) &&
            (entry->iface.SyntaxVersion.MajorVersion == iface.SyntaxVersion.MajorVersion) &&
            (entry->iface.SyntaxVersion.MinorVersion >= iface.SyntaxVersion.MinorVersion) &&
            !memcmp(&entry->syntax, &syntax, sizeof(syntax)) &&
            !strcmp(entry->protseq, protseq) &&
            ((!object && IsEqualGUID(&entry->object, &nil_object)) || IsEqualGUID(object, &entry->object)))
        {
            if (*num_towers < max_towers)
            {
                rpc_status = TowerConstruct(&entry->iface, &entry->syntax,
                                            entry->protseq, entry->endpoint,
                                            entry->address,
                                            &towers[*num_towers]);
                if (rpc_status != RPC_S_OK)
                {
                    *status = rpc_status;
                    break; /* FIXME: more cleanup? */
                }
            }
            (*num_towers)++;
        }
    }
 
    LeaveCriticalSection(&csEpm);
 
    I_RpcFree(protseq);
}

Referenced by RpcEpResolveBinding().

ept_mgmt_delete()

void __cdecl ept_mgmt_delete	(	handle_t	h,
		boolean32	object_speced,
		uuid_p_t	object,
		twr_p_t	tower,
		error_status_t *	status
	)

Definition at line 279 of file epmp.c.

{
    WINE_FIXME("(%p, %d, %p, %p, %p): stub\n", h, object_speced, object, tower, status);
 
    *status = EPT_S_CANT_PERFORM_OP;
}

find_ept_entry()

static struct registered_ept_entry * find_ept_entry ( const RPC_SYNTAX_IDENTIFIER *  iface, const RPC_SYNTAX_IDENTIFIER *  syntax, const char *  protseq, const char *  endpoint, const char *  address, const UUID *  object  )

static

Definition at line 63 of file epmp.c.

{
    struct registered_ept_entry *entry;
    LIST_FOR_EACH_ENTRY(entry, &registered_ept_entry_list, struct registered_ept_entry, entry)
    {
        if (memcmp(&entry->iface, iface, sizeof(RPC_SYNTAX_IDENTIFIER))) continue;
        if (memcmp(&entry->syntax, syntax, sizeof(RPC_SYNTAX_IDENTIFIER))) continue;
        if (strcmp(entry->protseq, protseq)) continue;
        if (memcmp(&entry->object, object, sizeof(UUID))) continue;
    WINE_TRACE("found entry with iface %d.%d %s, syntax %d.%d %s, protseq %s, object %s\n",
                   entry->iface.SyntaxVersion.MajorVersion, entry->iface.SyntaxVersion.MinorVersion,
                   wine_dbgstr_guid(&entry->iface.SyntaxGUID),
                   entry->syntax.SyntaxVersion.MajorVersion, entry->syntax.SyntaxVersion.MinorVersion,
                   wine_dbgstr_guid(&entry->syntax.SyntaxGUID), protseq,
                   wine_dbgstr_guid(&entry->object));
        return entry;
    }
    WINE_TRACE("not found\n");
    return NULL;
}

Referenced by ept_delete(), and ept_insert().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

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

Definition at line 43 of file epmp.c.

csEpm

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

static

Definition at line 42 of file epmp.c.

Referenced by ept_delete(), ept_insert(), and ept_map().

nil_object

const UUID nil_object

static

Definition at line 51 of file epmp.c.

Referenced by ept_map().

registered_ept_entry_list

struct list registered_ept_entry_list = LIST_INIT(registered_ept_entry_list)

static

Definition at line 40 of file epmp.c.

Referenced by ept_insert(), ept_map(), and find_ept_entry().