#include "rpc_binding.h"
#include "wine/list.h"

Include dependency graph for rpc_assoc.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	_RpcAssoc

Typedefs
typedef struct _RpcAssoc	RpcAssoc

Functions
RPC_STATUS	RPCRT4_GetAssociation (LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAssoc **assoc) DECLSPEC_HIDDEN

RPC_STATUS	RpcAssoc_GetClientConnection (RpcAssoc assoc, const RPC_SYNTAX_IDENTIFIER InterfaceId, const RPC_SYNTAX_IDENTIFIER TransferSyntax, RpcAuthInfo AuthInfo, RpcQualityOfService QOS, LPCWSTR CookieAuth, RpcConnection Connection, BOOL from_cache) DECLSPEC_HIDDEN

void	RpcAssoc_ReleaseIdleConnection (RpcAssoc assoc, RpcConnection Connection) DECLSPEC_HIDDEN

ULONG	RpcAssoc_Release (RpcAssoc *assoc) DECLSPEC_HIDDEN

RPC_STATUS	RpcServerAssoc_GetAssociation (LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, ULONG assoc_gid, RpcAssoc **assoc_out) DECLSPEC_HIDDEN

RPC_STATUS	RpcServerAssoc_AllocateContextHandle (RpcAssoc assoc, void CtxGuard, NDR_SCONTEXT *SContext) DECLSPEC_HIDDEN

RPC_STATUS	RpcServerAssoc_FindContextHandle (RpcAssoc assoc, const UUID uuid, void CtxGuard, ULONG Flags, NDR_SCONTEXT SContext) DECLSPEC_HIDDEN

RPC_STATUS	RpcServerAssoc_UpdateContextHandle (RpcAssoc assoc, NDR_SCONTEXT SContext, void CtxGuard, NDR_RUNDOWN rundown_routine) DECLSPEC_HIDDEN

unsigned int	RpcServerAssoc_ReleaseContextHandle (RpcAssoc *assoc, NDR_SCONTEXT SContext, BOOL release_lock) DECLSPEC_HIDDEN

void	RpcContextHandle_GetUuid (NDR_SCONTEXT SContext, UUID *uuid) DECLSPEC_HIDDEN

BOOL	RpcContextHandle_IsGuardCorrect (NDR_SCONTEXT SContext, void *CtxGuard) DECLSPEC_HIDDEN

void	RpcAssoc_ConnectionReleased (RpcAssoc *assoc) DECLSPEC_HIDDEN

Typedef Documentation

◆ RpcAssoc

typedef struct _RpcAssoc RpcAssoc

Function Documentation

◆ RpcAssoc_ConnectionReleased()

void RpcAssoc_ConnectionReleased ( RpcAssoc * assoc )

Definition at line 447 of file rpc_assoc.c.

{
    if (InterlockedDecrement(&assoc->connection_cnt))
        return;
 
    TRACE("Last %p connection released\n", assoc);
    assoc->assoc_group_id = 0;
}

Referenced by RPCRT4_ReleaseConnection().

◆ RpcAssoc_GetClientConnection()

RPC_STATUS RpcAssoc_GetClientConnection	(	RpcAssoc *	assoc,
		const RPC_SYNTAX_IDENTIFIER *	InterfaceId,
		const RPC_SYNTAX_IDENTIFIER *	TransferSyntax,
		RpcAuthInfo *	AuthInfo,
		RpcQualityOfService *	QOS,
		LPCWSTR	CookieAuth,
		RpcConnection **	Connection,
		BOOL *	from_cache
	)

Definition at line 390 of file rpc_assoc.c.

{
    RpcConnection *NewConnection;
    RPC_STATUS status;
 
    *Connection = RpcAssoc_GetIdleConnection(assoc, InterfaceId, TransferSyntax, AuthInfo, QOS);
    if (*Connection) {
        TRACE("return idle connection %p for association %p\n", *Connection, assoc);
        if (from_cache) *from_cache = TRUE;
        return RPC_S_OK;
    }
 
    /* create a new connection */
    status = RPCRT4_CreateConnection(&NewConnection, FALSE /* is this a server connection? */,
        assoc->Protseq, assoc->NetworkAddr,
        assoc->Endpoint, assoc->NetworkOptions,
        AuthInfo, QOS, CookieAuth);
    if (status != RPC_S_OK)
        return status;
 
    NewConnection->assoc = assoc;
    status = RPCRT4_OpenClientConnection(NewConnection);
    if (status != RPC_S_OK)
    {
        RPCRT4_ReleaseConnection(NewConnection);
        return status;
    }
 
    status = RpcAssoc_BindConnection(assoc, NewConnection, InterfaceId, TransferSyntax);
    if (status != RPC_S_OK)
    {
        RPCRT4_ReleaseConnection(NewConnection);
        return status;
    }
 
    InterlockedIncrement(&assoc->connection_cnt);
 
    TRACE("return new connection %p for association %p\n", *Connection, assoc);
    *Connection = NewConnection;
    if (from_cache) *from_cache = FALSE;
    return RPC_S_OK;
}

Referenced by RPCRT4_OpenBinding().

◆ RpcAssoc_Release()

ULONG RpcAssoc_Release ( RpcAssoc * assoc )

Definition at line 187 of file rpc_assoc.c.

{
    ULONG refs;
 
    EnterCriticalSection(&assoc_list_cs);
    refs = --assoc->refs;
    if (!refs)
        list_remove(&assoc->entry);
    LeaveCriticalSection(&assoc_list_cs);
 
    if (!refs)
    {
        RpcConnection *Connection, *cursor2;
        RpcContextHandle *context_handle, *context_handle_cursor;
 
        TRACE("destroying assoc %p\n", assoc);
 
        LIST_FOR_EACH_ENTRY_SAFE(Connection, cursor2, &assoc->free_connection_pool, RpcConnection, conn_pool_entry)
        {
            list_remove(&Connection->conn_pool_entry);
            RPCRT4_ReleaseConnection(Connection);
        }
 
        LIST_FOR_EACH_ENTRY_SAFE(context_handle, context_handle_cursor, &assoc->context_handle_list, RpcContextHandle, entry)
            RpcContextHandle_Destroy(context_handle);
 
        HeapFree(GetProcessHeap(), 0, assoc->NetworkOptions);
        HeapFree(GetProcessHeap(), 0, assoc->Endpoint);
        HeapFree(GetProcessHeap(), 0, assoc->NetworkAddr);
        HeapFree(GetProcessHeap(), 0, assoc->Protseq);
 
        assoc->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&assoc->cs);
 
        HeapFree(GetProcessHeap(), 0, assoc);
    }
 
    return refs;
}

Referenced by RpcBindingReset(), RPCRT4_ReleaseBinding(), and RPCRT4_ResolveBinding().

◆ RpcAssoc_ReleaseIdleConnection()

void RpcAssoc_ReleaseIdleConnection	(	RpcAssoc *	assoc,
		RpcConnection *	Connection
	)

Definition at line 437 of file rpc_assoc.c.

{
    assert(!Connection->server);
    Connection->async_state = NULL;
    EnterCriticalSection(&assoc->cs);
    if (!assoc->assoc_group_id) assoc->assoc_group_id = Connection->assoc_group_id;
    list_add_head(&assoc->free_connection_pool, &Connection->conn_pool_entry);
    LeaveCriticalSection(&assoc->cs);
}

Referenced by RPCRT4_CloseBinding().

◆ RpcContextHandle_GetUuid()

void RpcContextHandle_GetUuid	(	NDR_SCONTEXT	SContext,
		UUID *	uuid
	)

Definition at line 541 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle = (RpcContextHandle *)SContext;
    *uuid = context_handle->uuid;
}

Referenced by NDRSContextMarshall2().

◆ RpcContextHandle_IsGuardCorrect()

BOOL RpcContextHandle_IsGuardCorrect	(	NDR_SCONTEXT	SContext,
		void *	CtxGuard
	)

Definition at line 481 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle = (RpcContextHandle *)SContext;
    return context_handle->ctx_guard == CtxGuard;
}

Referenced by NDRSContextMarshall2(), RpcServerAssoc_FindContextHandle(), and RpcServerAssoc_UpdateContextHandle().

◆ RPCRT4_GetAssociation()

RPC_STATUS RPCRT4_GetAssociation	(	LPCSTR	Protseq,
		LPCSTR	NetworkAddr,
		LPCSTR	Endpoint,
		LPCWSTR	NetworkOptions,
		RpcAssoc **	assoc
	)

Definition at line 98 of file rpc_assoc.c.

{
    RpcAssoc *assoc;
    RPC_STATUS status;
 
    EnterCriticalSection(&assoc_list_cs);
    LIST_FOR_EACH_ENTRY(assoc, &client_assoc_list, RpcAssoc, entry)
    {
        if (!strcmp(Protseq, assoc->Protseq) &&
            !strcmp(NetworkAddr, assoc->NetworkAddr) &&
            !strcmp(Endpoint, assoc->Endpoint) &&
            compare_networkoptions(NetworkOptions, assoc->NetworkOptions))
        {
            assoc->refs++;
            *assoc_out = assoc;
            LeaveCriticalSection(&assoc_list_cs);
            TRACE("using existing assoc %p\n", assoc);
            return RPC_S_OK;
        }
    }
 
    status = RpcAssoc_Alloc(Protseq, NetworkAddr, Endpoint, NetworkOptions, &assoc);
    if (status != RPC_S_OK)
    {
        LeaveCriticalSection(&assoc_list_cs);
        return status;
    }
    list_add_head(&client_assoc_list, &assoc->entry);
    *assoc_out = assoc;
 
    LeaveCriticalSection(&assoc_list_cs);
 
    TRACE("new assoc %p\n", assoc);
 
    return RPC_S_OK;
}

Referenced by RPCRT4_CompleteBindingA(), RPCRT4_CompleteBindingW(), and RPCRT4_ResolveBinding().

◆ RpcServerAssoc_AllocateContextHandle()

RPC_STATUS RpcServerAssoc_AllocateContextHandle	(	RpcAssoc *	assoc,
		void *	CtxGuard,
		NDR_SCONTEXT *	SContext
	)

Definition at line 456 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle;
 
    context_handle = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*context_handle));
    if (!context_handle)
        return RPC_S_OUT_OF_MEMORY;
 
    context_handle->ctx_guard = CtxGuard;
    RtlInitializeResource(&context_handle->rw_lock);
    context_handle->refs = 1;
 
    /* lock here to mirror unmarshall, so we don't need to special-case the
     * freeing of a non-marshalled context handle */
    RtlAcquireResourceExclusive(&context_handle->rw_lock, TRUE);
 
    EnterCriticalSection(&assoc->cs);
    list_add_tail(&assoc->context_handle_list, &context_handle->entry);
    LeaveCriticalSection(&assoc->cs);
 
    *SContext = (NDR_SCONTEXT)context_handle;
    return RPC_S_OK;
}

Referenced by NDRSContextUnmarshall2().

◆ RpcServerAssoc_FindContextHandle()

RPC_STATUS RpcServerAssoc_FindContextHandle	(	RpcAssoc *	assoc,
		const UUID *	uuid,
		void *	CtxGuard,
		ULONG	Flags,
		NDR_SCONTEXT *	SContext
	)

Definition at line 487 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle;
 
    EnterCriticalSection(&assoc->cs);
    LIST_FOR_EACH_ENTRY(context_handle, &assoc->context_handle_list, RpcContextHandle, entry)
    {
        if (RpcContextHandle_IsGuardCorrect((NDR_SCONTEXT)context_handle, CtxGuard) &&
            !memcmp(&context_handle->uuid, uuid, sizeof(*uuid)))
        {
            *SContext = (NDR_SCONTEXT)context_handle;
            if (context_handle->refs++)
            {
                LeaveCriticalSection(&assoc->cs);
                TRACE("found %p\n", context_handle);
                RtlAcquireResourceExclusive(&context_handle->rw_lock, TRUE);
                return RPC_S_OK;
            }
        }
    }
    LeaveCriticalSection(&assoc->cs);
 
    ERR("no context handle found for uuid %s, guard %p\n",
        debugstr_guid(uuid), CtxGuard);
    return ERROR_INVALID_HANDLE;
}

Referenced by NDRSContextUnmarshall2().

◆ RpcServerAssoc_GetAssociation()

RPC_STATUS RpcServerAssoc_GetAssociation	(	LPCSTR	Protseq,
		LPCSTR	NetworkAddr,
		LPCSTR	Endpoint,
		LPCWSTR	NetworkOptions,
		ULONG	assoc_gid,
		RpcAssoc **	assoc_out
	)

Definition at line 137 of file rpc_assoc.c.

{
    RpcAssoc *assoc;
    RPC_STATUS status;
 
    EnterCriticalSection(&assoc_list_cs);
    if (assoc_gid)
    {
        LIST_FOR_EACH_ENTRY(assoc, &server_assoc_list, RpcAssoc, entry)
        {
            /* FIXME: NetworkAddr shouldn't be NULL */
            if (assoc->assoc_group_id == assoc_gid &&
                !strcmp(Protseq, assoc->Protseq) &&
                (!NetworkAddr || !assoc->NetworkAddr || !strcmp(NetworkAddr, assoc->NetworkAddr)) &&
                !strcmp(Endpoint, assoc->Endpoint) &&
                ((!assoc->NetworkOptions == !NetworkOptions) &&
                 (!NetworkOptions || !wcscmp(NetworkOptions, assoc->NetworkOptions))))
            {
                assoc->refs++;
                *assoc_out = assoc;
                LeaveCriticalSection(&assoc_list_cs);
                TRACE("using existing assoc %p\n", assoc);
                return RPC_S_OK;
            }
        }
        *assoc_out = NULL;
        LeaveCriticalSection(&assoc_list_cs);
        return RPC_S_NO_CONTEXT_AVAILABLE;
    }
 
    status = RpcAssoc_Alloc(Protseq, NetworkAddr, Endpoint, NetworkOptions, &assoc);
    if (status != RPC_S_OK)
    {
        LeaveCriticalSection(&assoc_list_cs);
        return status;
    }
    assoc->assoc_group_id = InterlockedIncrement(&last_assoc_group_id);
    list_add_head(&server_assoc_list, &assoc->entry);
    *assoc_out = assoc;
 
    LeaveCriticalSection(&assoc_list_cs);
 
    TRACE("new assoc %p\n", assoc);
 
    return RPC_S_OK;
}

Referenced by process_bind_packet_no_send().

◆ RpcServerAssoc_ReleaseContextHandle()

unsigned int RpcServerAssoc_ReleaseContextHandle	(	RpcAssoc *	assoc,
		NDR_SCONTEXT	SContext,
		BOOL	release_lock
	)

Definition at line 563 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle = (RpcContextHandle *)SContext;
    unsigned int refs;
 
    if (release_lock)
        RtlReleaseResource(&context_handle->rw_lock);
 
    EnterCriticalSection(&assoc->cs);
    refs = --context_handle->refs;
    if (!refs)
        list_remove(&context_handle->entry);
    LeaveCriticalSection(&assoc->cs);
 
    if (!refs)
        RpcContextHandle_Destroy(context_handle);
 
    return refs;
}

Referenced by NDRSContextMarshall2(), and process_request_packet().

◆ RpcServerAssoc_UpdateContextHandle()

RPC_STATUS RpcServerAssoc_UpdateContextHandle	(	RpcAssoc *	assoc,
		NDR_SCONTEXT	SContext,
		void *	CtxGuard,
		NDR_RUNDOWN	rundown_routine
	)

Definition at line 515 of file rpc_assoc.c.

{
    RpcContextHandle *context_handle = (RpcContextHandle *)SContext;
    RPC_STATUS status;
 
    if (!RpcContextHandle_IsGuardCorrect((NDR_SCONTEXT)context_handle, CtxGuard))
        return ERROR_INVALID_HANDLE;
 
    EnterCriticalSection(&assoc->cs);
    if (UuidIsNil(&context_handle->uuid, &status))
    {
        /* add a ref for the data being valid */
        context_handle->refs++;
        UuidCreate(&context_handle->uuid);
        context_handle->rundown_routine = rundown_routine;
        TRACE("allocated uuid %s for context handle %p\n",
              debugstr_guid(&context_handle->uuid), context_handle);
    }
    LeaveCriticalSection(&assoc->cs);
 
    return RPC_S_OK;
}