rpc_binding.h File Reference

#include "rpcndr.h"
#include "security.h"
#include "wine/list.h"
#include "rpc_defs.h"

Include dependency graph for rpc_binding.h:

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

Go to the source code of this file.

Classes
struct	_RpcAuthInfo
struct	_RpcQualityOfService
struct	_RpcConnection
struct	connection_ops
struct	_RpcBinding

Typedefs
typedef struct _RpcAuthInfo	RpcAuthInfo
typedef struct _RpcQualityOfService	RpcQualityOfService
typedef struct _RpcConnection	RpcConnection
typedef struct _RpcBinding	RpcBinding

Enumerations
enum	secure_packet_direction { SECURE_PACKET_SEND , SECURE_PACKET_RECEIVE }

Functions
LPWSTR	RPCRT4_strndupW (LPCWSTR src, INT len)
LPSTR	RPCRT4_strdupWtoA (LPCWSTR src)
LPWSTR	RPCRT4_strdupAtoW (LPCSTR src)
RPC_STATUS	RpcAuthInfo_Create (ULONG AuthnLevel, ULONG AuthnSvc, CredHandle cred, TimeStamp exp, ULONG cbMaxToken, RPC_AUTH_IDENTITY_HANDLE identity, RpcAuthInfo **ret)
ULONG	RpcAuthInfo_AddRef (RpcAuthInfo *AuthInfo)
ULONG	RpcAuthInfo_Release (RpcAuthInfo *AuthInfo)
BOOL	RpcAuthInfo_IsEqual (const RpcAuthInfo *AuthInfo1, const RpcAuthInfo *AuthInfo2)
ULONG	RpcQualityOfService_AddRef (RpcQualityOfService *qos)
ULONG	RpcQualityOfService_Release (RpcQualityOfService *qos)
BOOL	RpcQualityOfService_IsEqual (const RpcQualityOfService *qos1, const RpcQualityOfService *qos2)
RPC_STATUS	RPCRT4_CreateConnection (RpcConnection **Connection, BOOL server, LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAuthInfo *AuthInfo, RpcQualityOfService *QOS, LPCWSTR CookieAuth)
RpcConnection *	RPCRT4_GrabConnection (RpcConnection *conn)
void	RPCRT4_ReleaseConnection (RpcConnection *Connection)
RPC_STATUS	RPCRT4_OpenClientConnection (RpcConnection *Connection)
RPC_STATUS	RPCRT4_CloseConnection (RpcConnection *Connection)
RPC_STATUS	RPCRT4_IsServerListening (const char *protseq, const char *endpoint)
RPC_STATUS	RPCRT4_ResolveBinding (RpcBinding *Binding, LPCSTR Endpoint)
RPC_STATUS	RPCRT4_SetBindingObject (RpcBinding *Binding, const UUID *ObjectUuid)
RPC_STATUS	RPCRT4_MakeBinding (RpcBinding **Binding, RpcConnection *Connection)
void	RPCRT4_AddRefBinding (RpcBinding *Binding)
RPC_STATUS	RPCRT4_ReleaseBinding (RpcBinding *Binding)
RPC_STATUS	RPCRT4_OpenBinding (RpcBinding *Binding, RpcConnection **Connection, const RPC_SYNTAX_IDENTIFIER *TransferSyntax, const RPC_SYNTAX_IDENTIFIER *InterfaceId, BOOL *from_cache)
RPC_STATUS	RPCRT4_CloseBinding (RpcBinding *Binding, RpcConnection *Connection)
void	rpcrt4_conn_release_and_wait (RpcConnection *connection)
static const char *	rpcrt4_conn_get_name (const RpcConnection *Connection)
static int	rpcrt4_conn_read (RpcConnection *Connection, void *buffer, unsigned int len)
static int	rpcrt4_conn_write (RpcConnection *Connection, const void *buffer, unsigned int len)
static int	rpcrt4_conn_close (RpcConnection *Connection)
static void	rpcrt4_conn_close_read (RpcConnection *connection)
static void	rpcrt4_conn_cancel_call (RpcConnection *Connection)
static RPC_STATUS	rpcrt4_conn_handoff (RpcConnection *old_conn, RpcConnection *new_conn)
static BOOL	rpcrt4_conn_is_authorized (RpcConnection *Connection)
static RPC_STATUS	rpcrt4_conn_authorize (RpcConnection *conn, BOOL first_time, unsigned char *in_buffer, unsigned int in_len, unsigned char *out_buffer, unsigned int *out_len)
static RPC_STATUS	rpcrt4_conn_secure_packet (RpcConnection *conn, enum secure_packet_direction dir, RpcPktHdr *hdr, unsigned int hdr_size, unsigned char *stub_data, unsigned int stub_data_size, RpcAuthVerifier *auth_hdr, unsigned char *auth_value, unsigned int auth_value_size)
static RPC_STATUS	rpcrt4_conn_impersonate_client (RpcConnection *conn)
static RPC_STATUS	rpcrt4_conn_revert_to_self (RpcConnection *conn)
static RPC_STATUS	rpcrt4_conn_inquire_auth_client (RpcConnection *conn, RPC_AUTHZ_HANDLE *privs, RPC_WSTR *server_princ_name, ULONG *authn_level, ULONG *authn_svc, ULONG *authz_svc, ULONG flags)
RPC_STATUS	RpcTransport_GetTopOfTower (unsigned char *tower_data, size_t *tower_size, const char *protseq, const char *networkaddr, const char *endpoint)
RPC_STATUS	RpcTransport_ParseTopOfTower (const unsigned char *tower_data, size_t tower_size, char **protseq, char **networkaddr, char **endpoint)
void	RPCRT4_SetThreadCurrentConnection (RpcConnection *Connection)
void	RPCRT4_SetThreadCurrentCallHandle (RpcBinding *Binding)
RpcBinding *	RPCRT4_GetThreadCurrentCallHandle (void)
void	RPCRT4_PushThreadContextHandle (NDR_SCONTEXT SContext)
void	RPCRT4_RemoveThreadContextHandle (NDR_SCONTEXT SContext)
NDR_SCONTEXT	RPCRT4_PopThreadContextHandle (void)

Typedef Documentation

RpcAuthInfo

typedef struct _RpcAuthInfo RpcAuthInfo

RpcBinding

typedef struct _RpcBinding RpcBinding

RpcConnection

typedef struct _RpcConnection RpcConnection

RpcQualityOfService

typedef struct _RpcQualityOfService RpcQualityOfService

Enumeration Type Documentation

secure_packet_direction

enum secure_packet_direction

Enumerator
SECURE_PACKET_SEND
SECURE_PACKET_RECEIVE

Definition at line 30 of file rpc_binding.h.

{
  SECURE_PACKET_SEND,
  SECURE_PACKET_RECEIVE
};

Function Documentation

RpcAuthInfo_AddRef()

ULONG RpcAuthInfo_AddRef

(

RpcAuthInfo *

AuthInfo

)

Definition at line 1165 of file rpc_binding.c.

{
    return InterlockedIncrement(&AuthInfo->refs);
}

Referenced by RpcBindingCopy(), and RPCRT4_CreateConnection().

RpcAuthInfo_Create()

RPC_STATUS RpcAuthInfo_Create	(	ULONG	AuthnLevel,
		ULONG	AuthnSvc,
		CredHandle	cred,
		TimeStamp	exp,
		ULONG	cbMaxToken,
		RPC_AUTH_IDENTITY_HANDLE	identity,
		RpcAuthInfo **	ret
	)

Definition at line 1099 of file rpc_binding.c.

{
    RpcAuthInfo *AuthInfo = malloc(sizeof(*AuthInfo));
    if (!AuthInfo)
        return RPC_S_OUT_OF_MEMORY;
 
    AuthInfo->refs = 1;
    AuthInfo->AuthnLevel = AuthnLevel;
    AuthInfo->AuthnSvc = AuthnSvc;
    AuthInfo->cred = cred;
    AuthInfo->exp = exp;
    AuthInfo->cbMaxToken = cbMaxToken;
    AuthInfo->identity = identity;
    AuthInfo->server_principal_name = NULL;
 
    /* duplicate the SEC_WINNT_AUTH_IDENTITY structure, if applicable, to
     * enable better matching in RpcAuthInfo_IsEqual */
    if (identity && has_nt_auth_identity(AuthnSvc))
    {
        const SEC_WINNT_AUTH_IDENTITY_W *nt_identity = identity;
        AuthInfo->nt_identity = malloc(sizeof(*AuthInfo->nt_identity));
        if (!AuthInfo->nt_identity)
        {
            free(AuthInfo);
            return RPC_S_OUT_OF_MEMORY;
        }
 
        AuthInfo->nt_identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
        if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
            AuthInfo->nt_identity->User = RPCRT4_strndupW(nt_identity->User, nt_identity->UserLength);
        else
            AuthInfo->nt_identity->User = RPCRT4_strndupAtoW((const char *)nt_identity->User, nt_identity->UserLength);
        AuthInfo->nt_identity->UserLength = nt_identity->UserLength;
        if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
            AuthInfo->nt_identity->Domain = RPCRT4_strndupW(nt_identity->Domain, nt_identity->DomainLength);
        else
            AuthInfo->nt_identity->Domain = RPCRT4_strndupAtoW((const char *)nt_identity->Domain, nt_identity->DomainLength);
        AuthInfo->nt_identity->DomainLength = nt_identity->DomainLength;
        if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
            AuthInfo->nt_identity->Password = RPCRT4_strndupW(nt_identity->Password, nt_identity->PasswordLength);
        else
            AuthInfo->nt_identity->Password = RPCRT4_strndupAtoW((const char *)nt_identity->Password, nt_identity->PasswordLength);
        AuthInfo->nt_identity->PasswordLength = nt_identity->PasswordLength;
 
        if ((nt_identity->User && !AuthInfo->nt_identity->User) ||
            (nt_identity->Domain && !AuthInfo->nt_identity->Domain) ||
            (nt_identity->Password && !AuthInfo->nt_identity->Password))
        {
            free(AuthInfo->nt_identity->User);
            free(AuthInfo->nt_identity->Domain);
            free(AuthInfo->nt_identity->Password);
            free(AuthInfo->nt_identity);
            free(AuthInfo);
            return RPC_S_OUT_OF_MEMORY;
        }
    }
    else
        AuthInfo->nt_identity = NULL;
    *ret = AuthInfo;
    return RPC_S_OK;
}

Referenced by RpcBindingSetAuthInfoExA(), RpcBindingSetAuthInfoExW(), and RPCRT4_ServerConnectionAuth().

RpcAuthInfo_IsEqual()

BOOL RpcAuthInfo_IsEqual	(	const RpcAuthInfo *	AuthInfo1,
		const RpcAuthInfo *	AuthInfo2
	)

Definition at line 1191 of file rpc_binding.c.

{
    if (AuthInfo1 == AuthInfo2)
        return TRUE;
 
    if (!AuthInfo1 || !AuthInfo2)
        return FALSE;
 
    if ((AuthInfo1->AuthnLevel != AuthInfo2->AuthnLevel) ||
        (AuthInfo1->AuthnSvc != AuthInfo2->AuthnSvc))
        return FALSE;
 
    if (AuthInfo1->identity == AuthInfo2->identity)
        return TRUE;
 
    if (!AuthInfo1->identity || !AuthInfo2->identity)
        return FALSE;
 
    if (has_nt_auth_identity(AuthInfo1->AuthnSvc))
    {
        const SEC_WINNT_AUTH_IDENTITY_W *identity1 = AuthInfo1->nt_identity;
        const SEC_WINNT_AUTH_IDENTITY_W *identity2 = AuthInfo2->nt_identity;
        /* compare user names */
        if (identity1->UserLength != identity2->UserLength ||
            memcmp(identity1->User, identity2->User, identity1->UserLength))
            return FALSE;
        /* compare domain names */
        if (identity1->DomainLength != identity2->DomainLength ||
            memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
            return FALSE;
        /* compare passwords */
        if (identity1->PasswordLength != identity2->PasswordLength ||
            memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
            return FALSE;
    }
    else
        return FALSE;
 
    return TRUE;
}

Referenced by RpcAssoc_GetIdleConnection().

RpcAuthInfo_Release()

ULONG RpcAuthInfo_Release

(

RpcAuthInfo *

AuthInfo

)

Definition at line 1170 of file rpc_binding.c.

{
    ULONG refs = InterlockedDecrement(&AuthInfo->refs);
 
    if (!refs)
    {
        FreeCredentialsHandle(&AuthInfo->cred);
        if (AuthInfo->nt_identity)
        {
            free(AuthInfo->nt_identity->User);
            free(AuthInfo->nt_identity->Domain);
            free(AuthInfo->nt_identity->Password);
            free(AuthInfo->nt_identity);
        }
        free(AuthInfo->server_principal_name);
        free(AuthInfo);
    }
 
    return refs;
}

Referenced by get_epm_handle_client(), RpcBindingSetAuthInfoExA(), RpcBindingSetAuthInfoExW(), RPCRT4_ReleaseBinding(), RPCRT4_ReleaseConnection(), and RPCRT4_ServerConnectionAuth().

RpcQualityOfService_AddRef()

ULONG RpcQualityOfService_AddRef

(

RpcQualityOfService *

qos

)

Definition at line 1342 of file rpc_binding.c.

{
    return InterlockedIncrement(&qos->refs);
}

Referenced by RpcBindingCopy(), and RPCRT4_CreateConnection().

RpcQualityOfService_IsEqual()

BOOL RpcQualityOfService_IsEqual	(	const RpcQualityOfService *	qos1,
		const RpcQualityOfService *	qos2
	)

Definition at line 1372 of file rpc_binding.c.

{
    if (qos1 == qos2)
        return TRUE;
 
    if (!qos1 || !qos2)
        return FALSE;
 
    TRACE("qos1 = { %ld %ld %ld %ld }, qos2 = { %ld %ld %ld %ld }\n",
        qos1->qos->Capabilities, qos1->qos->IdentityTracking,
        qos1->qos->ImpersonationType, qos1->qos->AdditionalSecurityInfoType,
        qos2->qos->Capabilities, qos2->qos->IdentityTracking,
        qos2->qos->ImpersonationType, qos2->qos->AdditionalSecurityInfoType);
 
    if ((qos1->qos->Capabilities != qos2->qos->Capabilities) ||
        (qos1->qos->IdentityTracking != qos2->qos->IdentityTracking) ||
        (qos1->qos->ImpersonationType != qos2->qos->ImpersonationType) ||
        (qos1->qos->AdditionalSecurityInfoType != qos2->qos->AdditionalSecurityInfoType))
        return FALSE;
 
    if (qos1->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
    {
        const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials1 = qos1->qos->u.HttpCredentials;
        const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials2 = qos2->qos->u.HttpCredentials;
 
        if (http_credentials1->Flags != http_credentials2->Flags)
            return FALSE;
 
        if (http_credentials1->AuthenticationTarget != http_credentials2->AuthenticationTarget)
            return FALSE;
 
        if (http_credentials1->NumberOfAuthnSchemes != http_credentials2->NumberOfAuthnSchemes)
            return FALSE;
 
        if ((!http_credentials1->AuthnSchemes && http_credentials2->AuthnSchemes) ||
            (http_credentials1->AuthnSchemes && !http_credentials2->AuthnSchemes))
            return FALSE;
 
        if (memcmp(http_credentials1->AuthnSchemes, http_credentials2->AuthnSchemes,
                   http_credentials1->NumberOfAuthnSchemes * sizeof(http_credentials1->AuthnSchemes[0])))
            return FALSE;
 
        /* server certificate subject not currently used */
 
        if (http_credentials1->TransportCredentials != http_credentials2->TransportCredentials)
        {
            const SEC_WINNT_AUTH_IDENTITY_W *identity1 = http_credentials1->TransportCredentials;
            const SEC_WINNT_AUTH_IDENTITY_W *identity2 = http_credentials2->TransportCredentials;
 
            if (!identity1 || !identity2)
                return FALSE;
 
            /* compare user names */
            if (identity1->UserLength != identity2->UserLength ||
                memcmp(identity1->User, identity2->User, identity1->UserLength))
                return FALSE;
            /* compare domain names */
            if (identity1->DomainLength != identity2->DomainLength ||
                memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
                return FALSE;
            /* compare passwords */
            if (identity1->PasswordLength != identity2->PasswordLength ||
                memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
                return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by RpcAssoc_GetIdleConnection().

RpcQualityOfService_Release()

ULONG RpcQualityOfService_Release

(

RpcQualityOfService *

qos

)

Definition at line 1347 of file rpc_binding.c.

{
    ULONG refs = InterlockedDecrement(&qos->refs);
 
    if (!refs)
    {
        if (qos->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
        {
            if (qos->qos->u.HttpCredentials->TransportCredentials)
            {
                free(qos->qos->u.HttpCredentials->TransportCredentials->User);
                free(qos->qos->u.HttpCredentials->TransportCredentials->Domain);
                free(qos->qos->u.HttpCredentials->TransportCredentials->Password);
                free(qos->qos->u.HttpCredentials->TransportCredentials);
            }
            free(qos->qos->u.HttpCredentials->AuthnSchemes);
            free(qos->qos->u.HttpCredentials->ServerCertificateSubject);
            free(qos->qos->u.HttpCredentials);
        }
        free(qos->qos);
        free(qos);
    }
    return refs;
}

Referenced by RpcBindingSetAuthInfoExA(), RpcBindingSetAuthInfoExW(), RPCRT4_ReleaseBinding(), and RPCRT4_ReleaseConnection().

RPCRT4_AddRefBinding()

void RPCRT4_AddRefBinding

(

RpcBinding *

Binding

)

Definition at line 232 of file rpc_binding.c.

{
  InterlockedIncrement(&Binding->refs);
}

Referenced by I_RpcNegotiateTransferSyntax().

RPCRT4_CloseBinding()

RPC_STATUS RPCRT4_CloseBinding	(	RpcBinding *	Binding,
		RpcConnection *	Connection
	)

Definition at line 276 of file rpc_binding.c.

{
  TRACE("(Binding == ^%p)\n", Binding);
  if (!Connection) return RPC_S_OK;
  if (Binding->server) {
    /* don't destroy a connection that is cached in the binding */
    if (Binding->FromConn != Connection)
      RPCRT4_ReleaseConnection(Connection);
  }
  else {
    RpcAssoc_ReleaseIdleConnection(Binding->Assoc, Connection);
  }
  return RPC_S_OK;
}

Referenced by I_RpcFreeBuffer().

RPCRT4_CloseConnection()

RPC_STATUS RPCRT4_CloseConnection

(

RpcConnection *

Connection

)

Definition at line 3590 of file rpc_transport.c.

{
  TRACE("(Connection == ^%p)\n", Connection);
  if (SecIsValidHandle(&Connection->ctx))
  {
    DeleteSecurityContext(&Connection->ctx);
    SecInvalidateHandle(&Connection->ctx);
  }
  rpcrt4_conn_close(Connection);
  return RPC_S_OK;
}

Referenced by RPCRT4_ReleaseConnection(), and RPCRT4_server_thread().

rpcrt4_conn_authorize()

static RPC_STATUS rpcrt4_conn_authorize ( RpcConnection *  conn, BOOL  first_time, unsigned char *  in_buffer, unsigned int  in_len, unsigned char *  out_buffer, unsigned int *  out_len  )

inlinestatic

Definition at line 221 of file rpc_binding.h.

{
    return conn->ops->authorize(conn, first_time, in_buffer, in_len, out_buffer, out_len);
}

Referenced by RPCRT4_ClientConnectionAuth(), RPCRT4_Send(), and RPCRT4_ServerConnectionAuth().

rpcrt4_conn_cancel_call()

static void rpcrt4_conn_cancel_call ( RpcConnection *  Connection )

inlinestatic

Definition at line 206 of file rpc_binding.h.

{
  Connection->ops->cancel_call(Connection);
}

Referenced by rpc_cancel_thread().

rpcrt4_conn_close()

static int rpcrt4_conn_close ( RpcConnection *  Connection )

inlinestatic

Definition at line 196 of file rpc_binding.h.

{
  return Connection->ops->close(Connection);
}

Referenced by RPCRT4_CloseConnection().

rpcrt4_conn_close_read()

static void rpcrt4_conn_close_read ( RpcConnection *  connection )

inlinestatic

Definition at line 201 of file rpc_binding.h.

{
  connection->ops->close_read(connection);
}

Referenced by RPCRT4_server_thread().

rpcrt4_conn_get_name()

static const char * rpcrt4_conn_get_name ( const RpcConnection *  Connection )

inlinestatic

Definition at line 179 of file rpc_binding.h.

{
  return Connection->ops->name;
}

Referenced by process_bind_packet_no_send(), RPCRT4_MakeBinding(), and rpcrt4_spawn_connection().

rpcrt4_conn_handoff()

static RPC_STATUS rpcrt4_conn_handoff ( RpcConnection *  old_conn, RpcConnection *  new_conn  )

inlinestatic

Definition at line 211 of file rpc_binding.h.

{
  return old_conn->ops->handoff(old_conn, new_conn);
}

Referenced by rpcrt4_spawn_connection().

rpcrt4_conn_impersonate_client()

static RPC_STATUS rpcrt4_conn_impersonate_client ( RpcConnection *  conn )

inlinestatic

Definition at line 237 of file rpc_binding.h.

{
    return conn->ops->impersonate_client(conn);
}

Referenced by RpcImpersonateClient().

rpcrt4_conn_inquire_auth_client()

static RPC_STATUS rpcrt4_conn_inquire_auth_client ( RpcConnection *  conn, RPC_AUTHZ_HANDLE *  privs, RPC_WSTR *  server_princ_name, ULONG *  authn_level, ULONG *  authn_svc, ULONG *  authz_svc, ULONG  flags  )

inlinestatic

Definition at line 249 of file rpc_binding.h.

{
    return conn->ops->inquire_auth_client(conn, privs, server_princ_name, authn_level, authn_svc, authz_svc, flags);
}

Referenced by RpcBindingInqAuthClientExW().

rpcrt4_conn_is_authorized()

static BOOL rpcrt4_conn_is_authorized ( RpcConnection *  Connection )

inlinestatic

Definition at line 216 of file rpc_binding.h.

{
    return Connection->ops->is_authorized(Connection);
}

Referenced by RPCRT4_ReceiveWithAuth(), and RPCRT4_Send().

rpcrt4_conn_read()

static int rpcrt4_conn_read ( RpcConnection *  Connection, void *  buffer, unsigned int  len  )

inlinestatic

Definition at line 184 of file rpc_binding.h.

{
  return Connection->ops->read(Connection, buffer, len);
}

Referenced by RPCRT4_default_receive_fragment().

rpcrt4_conn_release_and_wait()

void rpcrt4_conn_release_and_wait

(

RpcConnection *

connection

)

Definition at line 3666 of file rpc_transport.c.

{
    HANDLE event = NULL;
 
    if (connection->ref > 1)
        event = connection->wait_release = CreateEventW(NULL, TRUE, FALSE, NULL);
 
    RPCRT4_ReleaseConnection(connection);
 
    if(event)
    {
        WaitForSingleObject(event, INFINITE);
        CloseHandle(event);
    }
}

Referenced by RPCRT4_server_thread().

rpcrt4_conn_revert_to_self()

static RPC_STATUS rpcrt4_conn_revert_to_self ( RpcConnection *  conn )

inlinestatic

Definition at line 243 of file rpc_binding.h.

{
    return conn->ops->revert_to_self(conn);
}

Referenced by RpcRevertToSelfEx().

rpcrt4_conn_secure_packet()

static RPC_STATUS rpcrt4_conn_secure_packet ( RpcConnection *  conn, enum secure_packet_direction  dir, RpcPktHdr *  hdr, unsigned int  hdr_size, unsigned char *  stub_data, unsigned int  stub_data_size, RpcAuthVerifier *  auth_hdr, unsigned char *  auth_value, unsigned int  auth_value_size  )

inlinestatic

Definition at line 228 of file rpc_binding.h.

{
    return conn->ops->secure_packet(conn, dir, hdr, hdr_size, stub_data, stub_data_size, auth_hdr, auth_value, auth_value_size);
}

Referenced by RPCRT4_ReceiveWithAuth(), and RPCRT4_SendWithAuth().

rpcrt4_conn_write()

static int rpcrt4_conn_write ( RpcConnection *  Connection, const void *  buffer, unsigned int  len  )

inlinestatic

Definition at line 190 of file rpc_binding.h.

{
  return Connection->ops->write(Connection, buffer, len);
}

Referenced by RPCRT4_SendWithAuth().

RPCRT4_CreateConnection()

RPC_STATUS RPCRT4_CreateConnection	(	RpcConnection **	Connection,
		BOOL	server,
		LPCSTR	Protseq,
		LPCSTR	NetworkAddr,
		LPCSTR	Endpoint,
		LPCWSTR	NetworkOptions,
		RpcAuthInfo *	AuthInfo,
		RpcQualityOfService *	QOS,
		LPCWSTR	CookieAuth
	)

Definition at line 3602 of file rpc_transport.c.

{
  static LONG next_id;
  const struct connection_ops *ops;
  RpcConnection* NewConnection;
 
  ops = rpcrt4_get_conn_protseq_ops(Protseq);
  if (!ops)
  {
    FIXME("not supported for protseq %s\n", Protseq);
    return RPC_S_PROTSEQ_NOT_SUPPORTED;
  }
 
  NewConnection = ops->alloc();
  NewConnection->ref = 1;
  NewConnection->server = server;
  NewConnection->ops = ops;
  NewConnection->NetworkAddr = strdup(NetworkAddr);
  NewConnection->Endpoint = strdup(Endpoint);
  NewConnection->NetworkOptions = wcsdup(NetworkOptions);
  NewConnection->CookieAuth = wcsdup(CookieAuth);
  NewConnection->MaxTransmissionSize = RPC_MAX_PACKET_SIZE;
  NewConnection->NextCallId = 1;
 
  SecInvalidateHandle(&NewConnection->ctx);
  if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
  NewConnection->AuthInfo = AuthInfo;
  NewConnection->auth_context_id = InterlockedIncrement( &next_id );
  if (QOS) RpcQualityOfService_AddRef(QOS);
  NewConnection->QOS = QOS;
 
  list_init(&NewConnection->conn_pool_entry);
  list_init(&NewConnection->protseq_entry);
 
  TRACE("connection: %p\n", NewConnection);
  *Connection = NewConnection;
 
  return RPC_S_OK;
}

Referenced by RpcAssoc_GetClientConnection(), rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(), rpcrt4_protseq_ncacn_np_open_endpoint(), rpcrt4_protseq_ncalrpc_open_endpoint(), and rpcrt4_spawn_connection().

RPCRT4_GetThreadCurrentCallHandle()

RpcBinding * RPCRT4_GetThreadCurrentCallHandle

(

void

)

Definition at line 1003 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    if (!tdata) return NULL;
 
    return tdata->server_binding;
}

Referenced by I_RpcBindingInqLocalClientPID(), and I_RpcGetCurrentCallHandle().

RPCRT4_GrabConnection()

RpcConnection * RPCRT4_GrabConnection

(

RpcConnection *

conn

)

Definition at line 3682 of file rpc_transport.c.

{
    LONG ref = InterlockedIncrement(&connection->ref);
    TRACE("%p ref=%lu\n", connection, ref);
    return connection;
}

Referenced by RPCRT4_io_thread(), and RPCRT4_server_thread().

RPCRT4_IsServerListening()

RPC_STATUS RPCRT4_IsServerListening	(	const char *	protseq,
		const char *	endpoint
	)

Definition at line 3732 of file rpc_transport.c.

{
  const struct connection_ops *ops;
 
  ops = rpcrt4_get_conn_protseq_ops(protseq);
  if (!ops)
  {
    FIXME("not supported for protseq %s\n", protseq);
    return RPC_S_INVALID_BINDING;
  }
 
  return ops->is_server_listening(endpoint);
}

Referenced by RpcMgmtIsServerListening().

RPCRT4_MakeBinding()

RPC_STATUS RPCRT4_MakeBinding	(	RpcBinding **	Binding,
		RpcConnection *	Connection
	)

Definition at line 215 of file rpc_binding.c.

{
  RpcBinding* NewBinding;
  TRACE("(RpcBinding == ^%p, Connection == ^%p)\n", Binding, Connection);
 
  RPCRT4_AllocBinding(&NewBinding, Connection->server);
  NewBinding->Protseq = strdup(rpcrt4_conn_get_name(Connection));
  NewBinding->NetworkAddr = strdup(Connection->NetworkAddr);
  NewBinding->Endpoint = strdup(Connection->Endpoint);
  NewBinding->FromConn = Connection;
 
  TRACE("binding: %p\n", NewBinding);
  *Binding = NewBinding;
 
  return RPC_S_OK;
}

Referenced by process_bind_packet_no_send(), and RpcServerInqBindings().

RPCRT4_OpenBinding()

RPC_STATUS RPCRT4_OpenBinding	(	RpcBinding *	Binding,
		RpcConnection **	Connection,
		const RPC_SYNTAX_IDENTIFIER *	TransferSyntax,
		const RPC_SYNTAX_IDENTIFIER *	InterfaceId,
		BOOL *	from_cache
	)

Definition at line 255 of file rpc_binding.c.

{
  TRACE("(Binding == ^%p)\n", Binding);
 
  if (!Binding->server) {
     return RpcAssoc_GetClientConnection(Binding->Assoc, InterfaceId,
         TransferSyntax, Binding->AuthInfo, Binding->QOS, Binding->CookieAuth, Connection, from_cache);
  } else {
    /* we already have a connection with acceptable binding, so use it */
    if (Binding->FromConn) {
      *Connection = Binding->FromConn;
      return RPC_S_OK;
    } else {
       ERR("no connection in binding\n");
       return RPC_S_INTERNAL_ERROR;
    }
  }
}

Referenced by I_RpcNegotiateTransferSyntax(), and I_RpcSend().

RPCRT4_OpenClientConnection()

RPC_STATUS RPCRT4_OpenClientConnection

(

RpcConnection *

Connection

)

Definition at line 3582 of file rpc_transport.c.

{
  TRACE("(Connection == ^%p)\n", Connection);
 
  assert(!Connection->server);
  return Connection->ops->open_connection_client(Connection);
}

Referenced by RpcAssoc_GetClientConnection().

RPCRT4_PopThreadContextHandle()

NDR_SCONTEXT RPCRT4_PopThreadContextHandle

(

void

)

Definition at line 1047 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    struct context_handle_list *context_handle_list;
    NDR_SCONTEXT context_handle;
 
    if (!tdata) return NULL;
 
    context_handle_list = tdata->context_handle_list;
    if (!context_handle_list) return NULL;
    tdata->context_handle_list = context_handle_list->next;
 
    context_handle = context_handle_list->context_handle;
    free(context_handle_list);
    return context_handle;
}

Referenced by process_request_packet().

RPCRT4_PushThreadContextHandle()

void RPCRT4_PushThreadContextHandle

(

NDR_SCONTEXT

SContext

)

Definition at line 1011 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    struct context_handle_list *context_handle_list;
 
    if (!tdata) return;
 
    context_handle_list = malloc(sizeof(*context_handle_list));
    if (!context_handle_list) return;
 
    context_handle_list->context_handle = SContext;
    context_handle_list->next = tdata->context_handle_list;
    tdata->context_handle_list = context_handle_list;
}

Referenced by NDRSContextUnmarshall2().

RPCRT4_ReleaseBinding()

RPC_STATUS RPCRT4_ReleaseBinding

(

RpcBinding *

Binding

)

Definition at line 237 of file rpc_binding.c.

{
  if (InterlockedDecrement(&Binding->refs))
    return RPC_S_OK;
 
  TRACE("binding: %p\n", Binding);
  if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
  free(Binding->Endpoint);
  free(Binding->NetworkAddr);
  free(Binding->Protseq);
  free(Binding->NetworkOptions);
  free(Binding->CookieAuth);
  if (Binding->AuthInfo) RpcAuthInfo_Release(Binding->AuthInfo);
  if (Binding->QOS) RpcQualityOfService_Release(Binding->QOS);
  free(Binding);
  return RPC_S_OK;
}

Referenced by I_RpcFreeBuffer(), RpcBindingFree(), RpcBindingFromStringBindingA(), RpcBindingFromStringBindingW(), and RPCRT4_ReleaseConnection().

RPCRT4_ReleaseConnection()

void RPCRT4_ReleaseConnection

(

RpcConnection *

Connection

)

Definition at line 3689 of file rpc_transport.c.

{
    LONG ref;
 
    /* protseq stores a list of active connections, but does not own references to them.
     * It may need to grab a connection from the list, which could lead to a race if
     * connection is being released, but not yet removed from the list. We handle that
     * by synchronizing on CS here. */
    if (connection->protseq)
    {
        EnterCriticalSection(&connection->protseq->cs);
        ref = InterlockedDecrement(&connection->ref);
        if (!ref)
            list_remove(&connection->protseq_entry);
        LeaveCriticalSection(&connection->protseq->cs);
    }
    else
    {
        ref = InterlockedDecrement(&connection->ref);
    }
 
    TRACE("%p ref=%lu\n", connection, ref);
 
    if (!ref)
    {
        RPCRT4_CloseConnection(connection);
        free(connection->Endpoint);
        free(connection->NetworkAddr);
        free(connection->NetworkOptions);
        free(connection->CookieAuth);
        if (connection->AuthInfo) RpcAuthInfo_Release(connection->AuthInfo);
        if (connection->QOS) RpcQualityOfService_Release(connection->QOS);
 
        /* server-only */
        if (connection->server_binding) RPCRT4_ReleaseBinding(connection->server_binding);
        else if (connection->assoc) RpcAssoc_ConnectionReleased(connection->assoc);
 
        if (connection->wait_release) SetEvent(connection->wait_release);
 
        free(connection);
    }
}

Referenced by I_RpcReceive(), I_RpcSend(), RpcAssoc_GetClientConnection(), RpcAssoc_Release(), RPCRT4_CloseBinding(), rpcrt4_conn_release_and_wait(), RPCRT4_io_thread(), RPCRT4_new_client(), rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(), and RPCRT4_worker_thread().

RPCRT4_RemoveThreadContextHandle()

void RPCRT4_RemoveThreadContextHandle

(

NDR_SCONTEXT

SContext

)

Definition at line 1026 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    struct context_handle_list *current, *prev;
 
    if (!tdata) return;
 
    for (current = tdata->context_handle_list, prev = NULL; current; prev = current, current = current->next)
    {
        if (current->context_handle == SContext)
        {
            if (prev)
                prev->next = current->next;
            else
                tdata->context_handle_list = current->next;
            free(current);
            return;
        }
    }
}

Referenced by NDRSContextMarshall2().

RPCRT4_ResolveBinding()

RPC_STATUS RPCRT4_ResolveBinding	(	RpcBinding *	Binding,
		LPCSTR	Endpoint
	)

Definition at line 187 of file rpc_binding.c.

{
  RPC_STATUS status;
 
  TRACE("(RpcBinding == ^%p, EndPoint == \"%s\"\n", Binding, Endpoint);
 
  free(Binding->Endpoint);
  Binding->Endpoint = strdup(Endpoint);
 
  if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
  Binding->Assoc = NULL;
  status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
                                 Binding->Endpoint, Binding->NetworkOptions,
                                 &Binding->Assoc);
  if (status != RPC_S_OK)
      return status;
 
  return RPC_S_OK;
}

Referenced by get_epm_handle_client(), and RpcEpResolveBinding().

RPCRT4_SetBindingObject()

RPC_STATUS RPCRT4_SetBindingObject	(	RpcBinding *	Binding,
		const UUID *	ObjectUuid
	)

Definition at line 207 of file rpc_binding.c.

{
  TRACE("(*RpcBinding == ^%p, UUID == %s)\n", Binding, debugstr_guid(ObjectUuid)); 
  if (ObjectUuid) Binding->ObjectUuid = *ObjectUuid;
  else UuidCreateNil(&Binding->ObjectUuid);
  return RPC_S_OK;
}

Referenced by process_request_packet(), RpcBindingFromStringBindingA(), RpcBindingFromStringBindingW(), and RpcBindingSetObject().

RPCRT4_SetThreadCurrentCallHandle()

void RPCRT4_SetThreadCurrentCallHandle

(

RpcBinding *

Binding

)

Definition at line 995 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    if (!tdata) return;
 
    tdata->server_binding = Binding;
}

Referenced by process_request_packet().

RPCRT4_SetThreadCurrentConnection()

void RPCRT4_SetThreadCurrentConnection

(

RpcConnection *

Connection

)

Definition at line 985 of file rpcrt4_main.c.

{
    struct threaddata *tdata = get_or_create_threaddata();
    if (!tdata) return;
 
    EnterCriticalSection(&tdata->cs);
    tdata->connection = Connection;
    LeaveCriticalSection(&tdata->cs);
}

Referenced by RPCRT4_ReceiveWithAuth(), and RPCRT4_SendWithAuth().

RPCRT4_strdupAtoW()

LPWSTR RPCRT4_strdupAtoW

(

LPCSTR

src

)

Definition at line 57 of file rpc_binding.c.

{
  DWORD len;
  LPWSTR s;
  if (!src) return NULL;
  len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
  s = malloc(len * sizeof(WCHAR));
  MultiByteToWideChar(CP_ACP, 0, src, -1, s, len);
  return s;
}

Referenced by RpcBindingSetAuthInfoExA(), RpcBindingToStringBindingW(), RpcQualityOfService_Create(), RPCRT4_CompleteBindingA(), RpcServerRegisterAuthInfoA(), and UuidToStringW().

RPCRT4_strdupWtoA()

LPSTR RPCRT4_strdupWtoA

(

LPCWSTR

src

)

Definition at line 46 of file rpc_binding.c.

{
  DWORD len;
  LPSTR s;
  if (!src) return NULL;
  len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
  s = malloc(len);
  WideCharToMultiByte(CP_ACP, 0, src, -1, s, len, NULL, NULL);
  return s;
}

Referenced by RpcBindingInqAuthClientExA(), RpcBindingInqAuthInfoExA(), RpcEpRegisterNoReplaceW(), RpcEpRegisterW(), RPCRT4_CompleteBindingW(), RPCRT4_CreateBindingW(), RpcServerInqDefaultPrincNameA(), RpcServerUseProtseqEpExW(), and RpcServerUseProtseqW().

RPCRT4_strndupW()

LPWSTR RPCRT4_strndupW	(	LPCWSTR	src,
		INT	len
	)

Definition at line 79 of file rpc_binding.c.

{
  DWORD len;
  LPWSTR s;
  if (!src) return NULL;
  if (slen == -1) slen = lstrlenW(src);
  len = slen;
  s = malloc((len + 1) * sizeof(WCHAR));
  memcpy(s, src, len*sizeof(WCHAR));
  s[len] = 0;
  return s;
}

Referenced by RpcAuthInfo_Create(), RpcQualityOfService_Create(), and rpcrt4_http_internet_connect().

RpcTransport_GetTopOfTower()

RPC_STATUS RpcTransport_GetTopOfTower	(	unsigned char *	tower_data,
		size_t *	tower_size,
		const char *	protseq,
		const char *	networkaddr,
		const char *	endpoint
	)

Definition at line 3746 of file rpc_transport.c.

{
    twr_empty_floor_t *protocol_floor;
    const struct connection_ops *protseq_ops = rpcrt4_get_conn_protseq_ops(protseq);
 
    *tower_size = 0;
 
    if (!protseq_ops)
        return RPC_S_INVALID_RPC_PROTSEQ;
 
    if (!tower_data)
    {
        *tower_size = sizeof(*protocol_floor);
        *tower_size += protseq_ops->get_top_of_tower(NULL, networkaddr, endpoint);
        return RPC_S_OK;
    }
 
    protocol_floor = (twr_empty_floor_t *)tower_data;
    protocol_floor->count_lhs = sizeof(protocol_floor->protid);
    protocol_floor->protid = protseq_ops->epm_protocols[0];
    protocol_floor->count_rhs = 0;
 
    tower_data += sizeof(*protocol_floor);
 
    *tower_size = protseq_ops->get_top_of_tower(tower_data, networkaddr, endpoint);
    if (!*tower_size)
        return EPT_S_NOT_REGISTERED;
 
    *tower_size += sizeof(*protocol_floor);
 
    return RPC_S_OK;
}

Referenced by TowerConstruct().

RpcTransport_ParseTopOfTower()

RPC_STATUS RpcTransport_ParseTopOfTower	(	const unsigned char *	tower_data,
		size_t	tower_size,
		char **	protseq,
		char **	networkaddr,
		char **	endpoint
	)

Definition at line 3783 of file rpc_transport.c.

{
    const twr_empty_floor_t *protocol_floor;
    const twr_empty_floor_t *floor4;
    const struct connection_ops *protseq_ops = NULL;
    RPC_STATUS status;
    unsigned int i;
 
    if (tower_size < sizeof(*protocol_floor))
        return EPT_S_NOT_REGISTERED;
 
    protocol_floor = (const twr_empty_floor_t *)tower_data;
    tower_data += sizeof(*protocol_floor);
    tower_size -= sizeof(*protocol_floor);
    if ((protocol_floor->count_lhs != sizeof(protocol_floor->protid)) ||
        (protocol_floor->count_rhs > tower_size))
        return EPT_S_NOT_REGISTERED;
    tower_data += protocol_floor->count_rhs;
    tower_size -= protocol_floor->count_rhs;
 
    floor4 = (const twr_empty_floor_t *)tower_data;
    if ((tower_size < sizeof(*floor4)) ||
        (floor4->count_lhs != sizeof(floor4->protid)))
        return EPT_S_NOT_REGISTERED;
 
    for(i = 0; i < ARRAY_SIZE(conn_protseq_list); i++)
        if ((protocol_floor->protid == conn_protseq_list[i].epm_protocols[0]) &&
            (floor4->protid == conn_protseq_list[i].epm_protocols[1]))
        {
            protseq_ops = &conn_protseq_list[i];
            break;
        }
 
    if (!protseq_ops)
        return EPT_S_NOT_REGISTERED;
 
    status = protseq_ops->parse_top_of_tower(tower_data, tower_size, networkaddr, endpoint);
 
    if ((status == RPC_S_OK) && protseq)
    {
        *protseq = I_RpcAllocate(strlen(protseq_ops->name) + 1);
        strcpy(*protseq, protseq_ops->name);
    }
 
    return status;
}

Referenced by TowerExplode().