rpc_assoc.c File Reference

#include <stdarg.h>
#include <assert.h>
#include "rpc.h"
#include "rpcndr.h"
#include "wine/winternl.h"
#include "wine/debug.h"
#include "rpc_binding.h"
#include "rpc_assoc.h"
#include "rpc_message.h"

Include dependency graph for rpc_assoc.c:

Go to the source code of this file.

Classes
struct	_RpcContextHandle

Macros
#define	ROUND_UP(value, alignment)   (((value) + ((alignment) - 1)) & ~((alignment)-1))

Typedefs
typedef struct _RpcContextHandle	RpcContextHandle

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (rpc)
static void	RpcContextHandle_Destroy (RpcContextHandle *context_handle)
static RPC_STATUS	RpcAssoc_Alloc (LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAssoc **assoc_out)
static BOOL	compare_networkoptions (LPCWSTR opts1, LPCWSTR opts2)
RPC_STATUS	RPCRT4_GetAssociation (LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAssoc **assoc_out)
RPC_STATUS	RpcServerAssoc_GetAssociation (LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, ULONG assoc_gid, RpcAssoc **assoc_out)
ULONG	RpcAssoc_Release (RpcAssoc *assoc)
static RPC_STATUS	RpcAssoc_BindConnection (const RpcAssoc *assoc, RpcConnection *conn, const RPC_SYNTAX_IDENTIFIER *InterfaceId, const RPC_SYNTAX_IDENTIFIER *TransferSyntax)
static RpcConnection *	RpcAssoc_GetIdleConnection (RpcAssoc *assoc, const RPC_SYNTAX_IDENTIFIER *InterfaceId, const RPC_SYNTAX_IDENTIFIER *TransferSyntax, const RpcAuthInfo *AuthInfo, const RpcQualityOfService *QOS)
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)
void	RpcAssoc_ReleaseIdleConnection (RpcAssoc *assoc, RpcConnection *Connection)
void	RpcAssoc_ConnectionReleased (RpcAssoc *assoc)
RPC_STATUS	RpcServerAssoc_AllocateContextHandle (RpcAssoc *assoc, void *CtxGuard, NDR_SCONTEXT *SContext)
BOOL	RpcContextHandle_IsGuardCorrect (NDR_SCONTEXT SContext, void *CtxGuard)
RPC_STATUS	RpcServerAssoc_FindContextHandle (RpcAssoc *assoc, const UUID *uuid, void *CtxGuard, ULONG Flags, NDR_SCONTEXT *SContext)
RPC_STATUS	RpcServerAssoc_UpdateContextHandle (RpcAssoc *assoc, NDR_SCONTEXT SContext, void *CtxGuard, NDR_RUNDOWN rundown_routine)
void	RpcContextHandle_GetUuid (NDR_SCONTEXT SContext, UUID *uuid)
unsigned int	RpcServerAssoc_ReleaseContextHandle (RpcAssoc *assoc, NDR_SCONTEXT SContext, BOOL release_lock)

Variables
static CRITICAL_SECTION	assoc_list_cs = { &assoc_list_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	assoc_list_cs_debug
static struct list	client_assoc_list = LIST_INIT(client_assoc_list)
static struct list	server_assoc_list = LIST_INIT(server_assoc_list)
static LONG	last_assoc_group_id

Macro Definition Documentation

ROUND_UP

#define ROUND_UP	(		value,
			alignment
	)		(((value) + ((alignment) - 1)) & ~((alignment)-1))

Definition at line 227 of file rpc_assoc.c.

Typedef Documentation

RpcContextHandle

typedef struct _RpcContextHandle RpcContextHandle

Function Documentation

compare_networkoptions()

static BOOL compare_networkoptions ( LPCWSTR  opts1, LPCWSTR  opts2  )

static

Definition at line 89 of file rpc_assoc.c.

{
    if ((opts1 == NULL) && (opts2 == NULL))
        return TRUE;
    if ((opts1 == NULL) || (opts2 == NULL))
        return FALSE;
    return !wcscmp(opts1, opts2);
}

Referenced by RPCRT4_GetAssociation().

RpcAssoc_Alloc()

static RPC_STATUS RpcAssoc_Alloc ( LPCSTR  Protseq, LPCSTR  NetworkAddr, LPCSTR  Endpoint, LPCWSTR  NetworkOptions, RpcAssoc **  assoc_out  )

static

Definition at line 64 of file rpc_assoc.c.

{
    RpcAssoc *assoc;
    assoc = HeapAlloc(GetProcessHeap(), 0, sizeof(*assoc));
    if (!assoc)
        return RPC_S_OUT_OF_RESOURCES;
    assoc->refs = 1;
    list_init(&assoc->free_connection_pool);
    list_init(&assoc->context_handle_list);
    InitializeCriticalSection(&assoc->cs);
    assoc->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RpcAssoc.cs");
    assoc->Protseq = RPCRT4_strdupA(Protseq);
    assoc->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
    assoc->Endpoint = RPCRT4_strdupA(Endpoint);
    assoc->NetworkOptions = NetworkOptions ? RPCRT4_strdupW(NetworkOptions) : NULL;
    assoc->assoc_group_id = 0;
    assoc->connection_cnt = 0;
    UuidCreate(&assoc->http_uuid);
    list_init(&assoc->entry);
    *assoc_out = assoc;
    return RPC_S_OK;
}

Referenced by RPCRT4_GetAssociation(), and RpcServerAssoc_GetAssociation().

RpcAssoc_BindConnection()

static RPC_STATUS RpcAssoc_BindConnection ( const RpcAssoc *  assoc, RpcConnection *  conn, const RPC_SYNTAX_IDENTIFIER *  InterfaceId, const RPC_SYNTAX_IDENTIFIER *  TransferSyntax  )

static

Definition at line 229 of file rpc_assoc.c.

{
    RpcPktHdr *hdr;
    RpcPktHdr *response_hdr;
    RPC_MESSAGE msg;
    RPC_STATUS status;
    unsigned char *auth_data = NULL;
    ULONG auth_length;
 
    TRACE("sending bind request to server\n");
 
    hdr = RPCRT4_BuildBindHeader(NDR_LOCAL_DATA_REPRESENTATION,
                                 RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE,
                                 assoc->assoc_group_id,
                                 InterfaceId, TransferSyntax);
 
    status = RPCRT4_Send(conn, hdr, NULL, 0);
    RPCRT4_FreeHeader(hdr);
    if (status != RPC_S_OK)
        return status;
 
    status = RPCRT4_ReceiveWithAuth(conn, &response_hdr, &msg, &auth_data, &auth_length);
    if (status != RPC_S_OK)
    {
        ERR("receive failed with error %d\n", status);
        return status;
    }
 
    switch (response_hdr->common.ptype)
    {
    case PKT_BIND_ACK:
    {
        RpcAddressString *server_address = msg.Buffer;
        if ((msg.BufferLength >= FIELD_OFFSET(RpcAddressString, string[0])) ||
            (msg.BufferLength >= ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4)))
        {
            unsigned short remaining = msg.BufferLength -
            ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4);
            RpcResultList *results = (RpcResultList*)((ULONG_PTR)server_address +
                ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
            if ((results->num_results == 1) &&
                (remaining >= FIELD_OFFSET(RpcResultList, results[results->num_results])))
            {
                switch (results->results[0].result)
                {
                case RESULT_ACCEPT:
                    /* respond to authorization request */
                    if (auth_length > sizeof(RpcAuthVerifier))
                        status = RPCRT4_ClientConnectionAuth(conn,
                                                             auth_data + sizeof(RpcAuthVerifier),
                                                             auth_length);
                    if (status == RPC_S_OK)
                    {
                        conn->assoc_group_id = response_hdr->bind_ack.assoc_gid;
                        conn->MaxTransmissionSize = response_hdr->bind_ack.max_tsize;
                        conn->ActiveInterface = *InterfaceId;
                    }
                    break;
                case RESULT_PROVIDER_REJECTION:
                    switch (results->results[0].reason)
                    {
                    case REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED:
                        ERR("syntax %s, %d.%d not supported\n",
                            debugstr_guid(&InterfaceId->SyntaxGUID),
                            InterfaceId->SyntaxVersion.MajorVersion,
                            InterfaceId->SyntaxVersion.MinorVersion);
                        status = RPC_S_UNKNOWN_IF;
                        break;
                    case REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED:
                        ERR("transfer syntax not supported\n");
                        status = RPC_S_SERVER_UNAVAILABLE;
                        break;
                    case REASON_NONE:
                    default:
                        status = RPC_S_CALL_FAILED_DNE;
                    }
                    break;
                case RESULT_USER_REJECTION:
                default:
                    ERR("rejection result %d\n", results->results[0].result);
                    status = RPC_S_CALL_FAILED_DNE;
                }
            }
            else
            {
                ERR("incorrect results size\n");
                status = RPC_S_CALL_FAILED_DNE;
            }
        }
        else
        {
            ERR("bind ack packet too small (%d)\n", msg.BufferLength);
            status = RPC_S_PROTOCOL_ERROR;
        }
        break;
    }
    case PKT_BIND_NACK:
        switch (response_hdr->bind_nack.reject_reason)
        {
        case REJECT_LOCAL_LIMIT_EXCEEDED:
        case REJECT_TEMPORARY_CONGESTION:
            ERR("server too busy\n");
            status = RPC_S_SERVER_TOO_BUSY;
            break;
        case REJECT_PROTOCOL_VERSION_NOT_SUPPORTED:
            ERR("protocol version not supported\n");
            status = RPC_S_PROTOCOL_ERROR;
            break;
        case REJECT_UNKNOWN_AUTHN_SERVICE:
            ERR("unknown authentication service\n");
            status = RPC_S_UNKNOWN_AUTHN_SERVICE;
            break;
        case REJECT_INVALID_CHECKSUM:
            ERR("invalid checksum\n");
            status = RPC_S_ACCESS_DENIED;
            break;
        default:
            ERR("rejected bind for reason %d\n", response_hdr->bind_nack.reject_reason);
            status = RPC_S_CALL_FAILED_DNE;
        }
        break;
    default:
        ERR("wrong packet type received %d\n", response_hdr->common.ptype);
        status = RPC_S_PROTOCOL_ERROR;
        break;
    }
 
    I_RpcFree(msg.Buffer);
    RPCRT4_FreeHeader(response_hdr);
    HeapFree(GetProcessHeap(), 0, auth_data);
    return status;
}

Referenced by RpcAssoc_GetClientConnection().

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_GetIdleConnection()

static RpcConnection * RpcAssoc_GetIdleConnection ( RpcAssoc *  assoc, const RPC_SYNTAX_IDENTIFIER *  InterfaceId, const RPC_SYNTAX_IDENTIFIER *  TransferSyntax, const RpcAuthInfo *  AuthInfo, const RpcQualityOfService *  QOS  )

static

Definition at line 364 of file rpc_assoc.c.

{
    RpcConnection *Connection;
    EnterCriticalSection(&assoc->cs);
    /* try to find a compatible connection from the connection pool */
    LIST_FOR_EACH_ENTRY(Connection, &assoc->free_connection_pool, RpcConnection, conn_pool_entry)
    {
        if (!memcmp(&Connection->ActiveInterface, InterfaceId,
                    sizeof(RPC_SYNTAX_IDENTIFIER)) &&
            RpcAuthInfo_IsEqual(Connection->AuthInfo, AuthInfo) &&
            RpcQualityOfService_IsEqual(Connection->QOS, QOS))
        {
            list_remove(&Connection->conn_pool_entry);
            LeaveCriticalSection(&assoc->cs);
            TRACE("got connection from pool %p\n", Connection);
            return Connection;
        }
    }
 
    LeaveCriticalSection(&assoc->cs);
    return NULL;
}

Referenced by RpcAssoc_GetClientConnection().

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_Destroy()

static void RpcContextHandle_Destroy ( RpcContextHandle *  context_handle )

static

Definition at line 547 of file rpc_assoc.c.

{
    TRACE("freeing %p\n", context_handle);
 
    if (context_handle->user_context && context_handle->rundown_routine)
    {
        TRACE("calling rundown routine %p with user context %p\n",
              context_handle->rundown_routine, context_handle->user_context);
        context_handle->rundown_routine(context_handle->user_context);
    }
 
    RtlDeleteResource(&context_handle->rw_lock);
 
    HeapFree(GetProcessHeap(), 0, context_handle);
}

Referenced by RpcAssoc_Release(), and RpcServerAssoc_ReleaseContextHandle().

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_out
	)

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

Referenced by NDRSContextMarshall2().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

rpc

)

Variable Documentation

assoc_list_cs

static CRITICAL_SECTION assoc_list_cs = { &assoc_list_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 37 of file rpc_assoc.c.

Referenced by RpcAssoc_Release(), RPCRT4_GetAssociation(), and RpcServerAssoc_GetAssociation().

assoc_list_cs_debug

CRITICAL_SECTION_DEBUG assoc_list_cs_debug

static

Initial value:

=
{
    0, 0, &assoc_list_cs,
    { &assoc_list_cs_debug.ProcessLocksList, &assoc_list_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": assoc_list_cs") }
}

Definition at line 38 of file rpc_assoc.c.

client_assoc_list

struct list client_assoc_list = LIST_INIT(client_assoc_list)

static

Definition at line 46 of file rpc_assoc.c.

Referenced by RPCRT4_GetAssociation().

last_assoc_group_id

LONG last_assoc_group_id

static

Definition at line 49 of file rpc_assoc.c.

Referenced by RpcServerAssoc_GetAssociation().

server_assoc_list

struct list server_assoc_list = LIST_INIT(server_assoc_list)

static

Definition at line 47 of file rpc_assoc.c.

Referenced by RpcServerAssoc_GetAssociation().