ReactOS 0.4.15-dev-5666-gc548b97
rpc_binding.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winerror.h"
#include "wine/winternl.h"
#include "rpc.h"
#include "rpcndr.h"
#include "wine/debug.h"
#include "rpc_binding.h"
#include "rpc_assoc.h"
Include dependency graph for rpc_binding.c:

Go to the source code of this file.

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (rpc)
 
LPSTR RPCRT4_strndupA (LPCSTR src, INT slen)
 
LPSTR RPCRT4_strdupWtoA (LPCWSTR src)
 
LPWSTR RPCRT4_strdupAtoW (LPCSTR src)
 
static LPWSTR RPCRT4_strndupAtoW (LPCSTR src, INT slen)
 
LPWSTR RPCRT4_strndupW (LPCWSTR src, INT slen)
 
void RPCRT4_strfree (LPSTR src)
 
static RPC_STATUS RPCRT4_AllocBinding (RpcBinding **Binding, BOOL server)
 
static RPC_STATUS RPCRT4_CreateBindingA (RpcBinding **Binding, BOOL server, LPCSTR Protseq)
 
static RPC_STATUS RPCRT4_CreateBindingW (RpcBinding **Binding, BOOL server, LPCWSTR Protseq)
 
static RPC_STATUS RPCRT4_CompleteBindingA (RpcBinding *Binding, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCSTR NetworkOptions)
 
static RPC_STATUS RPCRT4_CompleteBindingW (RpcBinding *Binding, LPCWSTR NetworkAddr, LPCWSTR Endpoint, LPCWSTR NetworkOptions)
 
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)
 
static LPSTR RPCRT4_strconcatA (LPSTR dst, LPCSTR src)
 
static LPWSTR RPCRT4_strconcatW (LPWSTR dst, LPCWSTR src)
 
static RPC_CSTR escape_string_binding_component (RPC_CSTR string_binding, const unsigned char *component)
 
static RPC_WSTR escape_string_binding_componentW (RPC_WSTR string_binding, const WCHAR *component)
 
static const unsigned charstring_binding_find_delimiter (const unsigned char *string_binding, unsigned char delim)
 
static const WCHARstring_binding_find_delimiterW (const WCHAR *string_binding, WCHAR delim)
 
static RPC_CSTR unescape_string_binding_component (const unsigned char *string_binding, int len)
 
static RPC_WSTR unescape_string_binding_componentW (const WCHAR *string_binding, int len)
 
RPC_STATUS WINAPI RpcStringBindingComposeA (RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
 
RPC_STATUS WINAPI RpcStringBindingComposeW (RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr, RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR *StringBinding)
 
RPC_STATUS WINAPI RpcStringBindingParseA (RPC_CSTR StringBinding, RPC_CSTR *ObjUuid, RPC_CSTR *Protseq, RPC_CSTR *NetworkAddr, RPC_CSTR *Endpoint, RPC_CSTR *Options)
 
RPC_STATUS WINAPI RpcStringBindingParseW (RPC_WSTR StringBinding, RPC_WSTR *ObjUuid, RPC_WSTR *Protseq, RPC_WSTR *NetworkAddr, RPC_WSTR *Endpoint, RPC_WSTR *Options)
 
RPC_STATUS WINAPI RpcBindingFree (RPC_BINDING_HANDLE *Binding)
 
RPC_STATUS WINAPI RpcBindingVectorFree (RPC_BINDING_VECTOR **BindingVector)
 
RPC_STATUS WINAPI RpcBindingInqObject (RPC_BINDING_HANDLE Binding, UUID *ObjectUuid)
 
RPC_STATUS WINAPI RpcBindingSetObject (RPC_BINDING_HANDLE Binding, UUID *ObjectUuid)
 
RPC_STATUS WINAPI RpcBindingFromStringBindingA (RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
 
RPC_STATUS WINAPI RpcBindingFromStringBindingW (RPC_WSTR StringBinding, RPC_BINDING_HANDLE *Binding)
 
RPC_STATUS WINAPI RpcBindingToStringBindingA (RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding)
 
RPC_STATUS WINAPI RpcBindingToStringBindingW (RPC_BINDING_HANDLE Binding, RPC_WSTR *StringBinding)
 
RPC_STATUS WINAPI I_RpcBindingInqTransportType (RPC_BINDING_HANDLE Binding, unsigned int *Type)
 
RPC_STATUS WINAPI I_RpcBindingSetAsync (RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn)
 
RPC_STATUS RPC_ENTRY RpcBindingCopy (RPC_BINDING_HANDLE SourceBinding, RPC_BINDING_HANDLE *DestinationBinding)
 
RPC_STATUS RPC_ENTRY RpcBindingReset (RPC_BINDING_HANDLE Binding)
 
RPC_STATUS WINAPI RpcImpersonateClient (RPC_BINDING_HANDLE BindingHandle)
 
RPC_STATUS WINAPI RpcRevertToSelfEx (RPC_BINDING_HANDLE BindingHandle)
 
static BOOL has_nt_auth_identity (ULONG AuthnLevel)
 
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)
 
static RPC_STATUS RpcQualityOfService_Create (const RPC_SECURITY_QOS *qos_src, BOOL unicode, RpcQualityOfService **qos_dst)
 
ULONG RpcQualityOfService_AddRef (RpcQualityOfService *qos)
 
ULONG RpcQualityOfService_Release (RpcQualityOfService *qos)
 
BOOL RpcQualityOfService_IsEqual (const RpcQualityOfService *qos1, const RpcQualityOfService *qos2)
 
RPC_STATUS WINAPI RpcRevertToSelf (void)
 
RPC_STATUS WINAPI RpcMgmtSetComTimeout (RPC_BINDING_HANDLE BindingHandle, unsigned int Timeout)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExA (RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc, ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExW (RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc, ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoA (RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoW (RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientA (RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientW (RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExA (RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc, ULONG Flags)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExW (RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc, ULONG Flags)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingServerFromClient (RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE *ServerBinding)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExA (RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr, RPC_SECURITY_QOS *SecurityQos)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExW (RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr, RPC_SECURITY_QOS *SecurityQos)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoA (RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr)
 
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoW (RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr)
 
RPC_STATUS WINAPI RpcBindingSetOption (RPC_BINDING_HANDLE BindingHandle, ULONG Option, ULONG_PTR OptionValue)
 
RPC_STATUS WINAPI I_RpcBindingInqLocalClientPID (RPC_BINDING_HANDLE ClientBinding, ULONG *ClientPID)
 

Function Documentation

◆ escape_string_binding_component()

static RPC_CSTR escape_string_binding_component ( RPC_CSTR  string_binding,
const unsigned char component 
)
static

Definition at line 338 of file rpc_binding.c.

340{
341 for (; *component; component++) {
342 switch (*component) {
343 case '@':
344 case ':':
345 case '[':
346 case ']':
347 case '\\':
348 *string_binding++ = '\\';
349 *string_binding++ = *component;
350 break;
351 default:
352 *string_binding++ = *component;
353 break;
354 }
355 }
356 return string_binding;
357}

Referenced by RpcStringBindingComposeA().

◆ escape_string_binding_componentW()

static RPC_WSTR escape_string_binding_componentW ( RPC_WSTR  string_binding,
const WCHAR component 
)
static

Definition at line 359 of file rpc_binding.c.

361{
362 for (; *component; component++) {
363 switch (*component) {
364 case '@':
365 case ':':
366 case '[':
367 case ']':
368 case '\\':
369 *string_binding++ = '\\';
370 *string_binding++ = *component;
371 break;
372 default:
373 *string_binding++ = *component;
374 break;
375 }
376 }
377 return string_binding;
378}

Referenced by RpcStringBindingComposeW().

◆ has_nt_auth_identity()

static BOOL has_nt_auth_identity ( ULONG  AuthnLevel)
inlinestatic

Definition at line 1104 of file rpc_binding.c.

1105{
1106 switch (AuthnLevel)
1107 {
1109 case RPC_C_AUTHN_WINNT:
1111 return TRUE;
1112 default:
1113 return FALSE;
1114 }
1115}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define RPC_C_AUTHN_WINNT
Definition: rpcdce.h:158
#define RPC_C_AUTHN_GSS_NEGOTIATE
Definition: rpcdce.h:157
#define RPC_C_AUTHN_GSS_KERBEROS
Definition: rpcdce.h:160

Referenced by RpcAuthInfo_Create(), and RpcAuthInfo_IsEqual().

◆ I_RpcBindingInqLocalClientPID()

RPC_STATUS WINAPI I_RpcBindingInqLocalClientPID ( RPC_BINDING_HANDLE  ClientBinding,
ULONG ClientPID 
)

Definition at line 1987 of file rpc_binding.c.

1988{
1989 FIXME("%p %p: stub\n", ClientBinding, ClientPID);
1990 return RPC_S_INVALID_BINDING;
1991}
#define FIXME(fmt,...)
Definition: debug.h:111
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013

◆ I_RpcBindingInqTransportType()

RPC_STATUS WINAPI I_RpcBindingInqTransportType ( RPC_BINDING_HANDLE  Binding,
unsigned int Type 
)

Definition at line 961 of file rpc_binding.c.

962{
963
964 FIXME( "(%p,%p): stub\n", Binding, Type);
966 return RPC_S_OK;
967}
Type
Definition: Type.h:7
#define TRANSPORT_TYPE_LPC
Definition: rpcdcep.h:137
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ I_RpcBindingSetAsync()

RPC_STATUS WINAPI I_RpcBindingSetAsync ( RPC_BINDING_HANDLE  Binding,
RPC_BLOCKING_FN  BlockingFn 
)

Definition at line 975 of file rpc_binding.c.

976{
978
979 TRACE( "(%p,%p): stub\n", Binding, BlockingFn );
980
981 bind->BlockingFn = BlockingFn;
982
983 return RPC_S_OK;
984}
INT WSAAPI bind(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
Definition: socklife.c:36
#define TRACE(s)
Definition: solgame.cpp:4

◆ RpcAuthInfo_AddRef()

ULONG RpcAuthInfo_AddRef ( RpcAuthInfo AuthInfo)

Definition at line 1183 of file rpc_binding.c.

1184{
1185 return InterlockedIncrement(&AuthInfo->refs);
1186}
#define InterlockedIncrement
Definition: armddk.h:53

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 1117 of file rpc_binding.c.

1122{
1123 RpcAuthInfo *AuthInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo));
1124 if (!AuthInfo)
1125 return RPC_S_OUT_OF_MEMORY;
1126
1127 AuthInfo->refs = 1;
1128 AuthInfo->AuthnLevel = AuthnLevel;
1129 AuthInfo->AuthnSvc = AuthnSvc;
1130 AuthInfo->cred = cred;
1131 AuthInfo->exp = exp;
1132 AuthInfo->cbMaxToken = cbMaxToken;
1133 AuthInfo->identity = identity;
1134 AuthInfo->server_principal_name = NULL;
1135
1136 /* duplicate the SEC_WINNT_AUTH_IDENTITY structure, if applicable, to
1137 * enable better matching in RpcAuthInfo_IsEqual */
1138 if (identity && has_nt_auth_identity(AuthnSvc))
1139 {
1140 const SEC_WINNT_AUTH_IDENTITY_W *nt_identity = identity;
1141 AuthInfo->nt_identity = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo->nt_identity));
1142 if (!AuthInfo->nt_identity)
1143 {
1144 HeapFree(GetProcessHeap(), 0, AuthInfo);
1145 return RPC_S_OUT_OF_MEMORY;
1146 }
1147
1149 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1150 AuthInfo->nt_identity->User = RPCRT4_strndupW(nt_identity->User, nt_identity->UserLength);
1151 else
1152 AuthInfo->nt_identity->User = RPCRT4_strndupAtoW((const char *)nt_identity->User, nt_identity->UserLength);
1153 AuthInfo->nt_identity->UserLength = nt_identity->UserLength;
1154 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1155 AuthInfo->nt_identity->Domain = RPCRT4_strndupW(nt_identity->Domain, nt_identity->DomainLength);
1156 else
1157 AuthInfo->nt_identity->Domain = RPCRT4_strndupAtoW((const char *)nt_identity->Domain, nt_identity->DomainLength);
1158 AuthInfo->nt_identity->DomainLength = nt_identity->DomainLength;
1159 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1160 AuthInfo->nt_identity->Password = RPCRT4_strndupW(nt_identity->Password, nt_identity->PasswordLength);
1161 else
1162 AuthInfo->nt_identity->Password = RPCRT4_strndupAtoW((const char *)nt_identity->Password, nt_identity->PasswordLength);
1163 AuthInfo->nt_identity->PasswordLength = nt_identity->PasswordLength;
1164
1165 if ((nt_identity->User && !AuthInfo->nt_identity->User) ||
1166 (nt_identity->Domain && !AuthInfo->nt_identity->Domain) ||
1167 (nt_identity->Password && !AuthInfo->nt_identity->Password))
1168 {
1169 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
1170 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
1171 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
1172 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
1173 HeapFree(GetProcessHeap(), 0, AuthInfo);
1174 return RPC_S_OUT_OF_MEMORY;
1175 }
1176 }
1177 else
1178 AuthInfo->nt_identity = NULL;
1179 *ret = AuthInfo;
1180 return RPC_S_OK;
1181}
#define NULL
Definition: types.h:112
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
DWORD exp
Definition: msg.c:16058
static BOOL has_nt_auth_identity(ULONG AuthnLevel)
Definition: rpc_binding.c:1104
LPWSTR RPCRT4_strndupW(LPCWSTR src, INT slen)
Definition: rpc_binding.c:91
static LPWSTR RPCRT4_strndupAtoW(LPCSTR src, INT slen)
Definition: rpc_binding.c:80
#define SEC_WINNT_AUTH_IDENTITY_UNICODE
Definition: rpcdce.h:310
#define RPC_S_OUT_OF_MEMORY
Definition: rpcnterr.h:24
RPC_AUTH_IDENTITY_HANDLE * identity
Definition: rpc_binding.h:46
ULONG AuthnLevel
Definition: rpc_binding.h:40
ULONG AuthnSvc
Definition: rpc_binding.h:41
TimeStamp exp
Definition: rpc_binding.h:43
CredHandle cred
Definition: rpc_binding.h:42
SEC_WINNT_AUTH_IDENTITY_W * nt_identity
Definition: rpc_binding.h:49
ULONG cbMaxToken
Definition: rpc_binding.h:44
LPWSTR server_principal_name
Definition: rpc_binding.h:50
unsigned short * Domain
Definition: rpcdce.h:225
unsigned short * User
Definition: rpcdce.h:223
unsigned short * Password
Definition: rpcdce.h:227
int ret

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

◆ RpcAuthInfo_IsEqual()

BOOL RpcAuthInfo_IsEqual ( const RpcAuthInfo AuthInfo1,
const RpcAuthInfo AuthInfo2 
)

Definition at line 1209 of file rpc_binding.c.

1210{
1211 if (AuthInfo1 == AuthInfo2)
1212 return TRUE;
1213
1214 if (!AuthInfo1 || !AuthInfo2)
1215 return FALSE;
1216
1217 if ((AuthInfo1->AuthnLevel != AuthInfo2->AuthnLevel) ||
1218 (AuthInfo1->AuthnSvc != AuthInfo2->AuthnSvc))
1219 return FALSE;
1220
1221 if (AuthInfo1->identity == AuthInfo2->identity)
1222 return TRUE;
1223
1224 if (!AuthInfo1->identity || !AuthInfo2->identity)
1225 return FALSE;
1226
1227 if (has_nt_auth_identity(AuthInfo1->AuthnSvc))
1228 {
1229 const SEC_WINNT_AUTH_IDENTITY_W *identity1 = AuthInfo1->nt_identity;
1230 const SEC_WINNT_AUTH_IDENTITY_W *identity2 = AuthInfo2->nt_identity;
1231 /* compare user names */
1232 if (identity1->UserLength != identity2->UserLength ||
1233 memcmp(identity1->User, identity2->User, identity1->UserLength))
1234 return FALSE;
1235 /* compare domain names */
1236 if (identity1->DomainLength != identity2->DomainLength ||
1237 memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1238 return FALSE;
1239 /* compare passwords */
1240 if (identity1->PasswordLength != identity2->PasswordLength ||
1241 memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1242 return FALSE;
1243 }
1244 else
1245 return FALSE;
1246
1247 return TRUE;
1248}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112

Referenced by RpcAssoc_GetIdleConnection().

◆ RpcAuthInfo_Release()

ULONG RpcAuthInfo_Release ( RpcAuthInfo AuthInfo)

Definition at line 1188 of file rpc_binding.c.

1189{
1190 ULONG refs = InterlockedDecrement(&AuthInfo->refs);
1191
1192 if (!refs)
1193 {
1194 FreeCredentialsHandle(&AuthInfo->cred);
1195 if (AuthInfo->nt_identity)
1196 {
1197 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
1198 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
1199 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
1200 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
1201 }
1203 HeapFree(GetProcessHeap(), 0, AuthInfo);
1204 }
1205
1206 return refs;
1207}
#define InterlockedDecrement
Definition: armddk.h:52
unsigned int ULONG
Definition: retypes.h:1
SECURITY_STATUS WINAPI FreeCredentialsHandle(PCredHandle phCredential)
Definition: wrapper.c:151

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

◆ RpcBindingCopy()

RPC_STATUS RPC_ENTRY RpcBindingCopy ( RPC_BINDING_HANDLE  SourceBinding,
RPC_BINDING_HANDLE DestinationBinding 
)

Definition at line 989 of file rpc_binding.c.

992{
993 RpcBinding *DestBinding;
994 RpcBinding *SrcBinding = SourceBinding;
996
997 TRACE("(%p, %p)\n", SourceBinding, DestinationBinding);
998
999 status = RPCRT4_AllocBinding(&DestBinding, SrcBinding->server);
1000 if (status != RPC_S_OK) return status;
1001
1002 DestBinding->ObjectUuid = SrcBinding->ObjectUuid;
1003 DestBinding->BlockingFn = SrcBinding->BlockingFn;
1004 DestBinding->Protseq = RPCRT4_strndupA(SrcBinding->Protseq, -1);
1005 DestBinding->NetworkAddr = RPCRT4_strndupA(SrcBinding->NetworkAddr, -1);
1006 DestBinding->Endpoint = RPCRT4_strndupA(SrcBinding->Endpoint, -1);
1007 DestBinding->NetworkOptions = RPCRT4_strdupW(SrcBinding->NetworkOptions);
1008 DestBinding->CookieAuth = RPCRT4_strdupW(SrcBinding->CookieAuth);
1009 if (SrcBinding->Assoc) SrcBinding->Assoc->refs++;
1010 DestBinding->Assoc = SrcBinding->Assoc;
1011
1012 if (SrcBinding->AuthInfo) RpcAuthInfo_AddRef(SrcBinding->AuthInfo);
1013 DestBinding->AuthInfo = SrcBinding->AuthInfo;
1014 if (SrcBinding->QOS) RpcQualityOfService_AddRef(SrcBinding->QOS);
1015 DestBinding->QOS = SrcBinding->QOS;
1016
1017 *DestinationBinding = DestBinding;
1018 return RPC_S_OK;
1019}
static RPC_STATUS RPCRT4_AllocBinding(RpcBinding **Binding, BOOL server)
Definition: rpc_binding.c:109
LPSTR RPCRT4_strndupA(LPCSTR src, INT slen)
Definition: rpc_binding.c:45
ULONG RpcAuthInfo_AddRef(RpcAuthInfo *AuthInfo)
Definition: rpc_binding.c:1183
ULONG RpcQualityOfService_AddRef(RpcQualityOfService *qos)
Definition: rpc_binding.c:1360
#define RPCRT4_strdupW(x)
Definition: rpc_binding.h:152
long RPC_STATUS
Definition: rpc.h:52
RPC_BLOCKING_FN BlockingFn
Definition: rpc_binding.h:134
LPSTR NetworkAddr
Definition: rpc_binding.h:131
LPWSTR NetworkOptions
Definition: rpc_binding.h:133
LPWSTR CookieAuth
Definition: rpc_binding.h:142
RpcAuthInfo * AuthInfo
Definition: rpc_binding.h:140
LPSTR Endpoint
Definition: rpc_binding.h:132
LPSTR Protseq
Definition: rpc_binding.h:130
struct _RpcAssoc * Assoc
Definition: rpc_binding.h:137
UUID ObjectUuid
Definition: rpc_binding.h:129
RpcQualityOfService * QOS
Definition: rpc_binding.h:141
Definition: ps.c:97

Referenced by get_epm_handle_client(), and ndr_update_context_handle().

◆ RpcBindingFree()

RPC_STATUS WINAPI RpcBindingFree ( RPC_BINDING_HANDLE Binding)

◆ RpcBindingFromStringBindingA()

RPC_STATUS WINAPI RpcBindingFromStringBindingA ( RPC_CSTR  StringBinding,
RPC_BINDING_HANDLE Binding 
)

Definition at line 840 of file rpc_binding.c.

841{
844 RPC_CSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
845 UUID Uuid;
846
847 TRACE("(%s,%p)\n", debugstr_a((char*)StringBinding), Binding);
848
849 ret = RpcStringBindingParseA(StringBinding, &ObjectUuid, &Protseq,
850 &NetworkAddr, &Endpoint, &Options);
851 if (ret != RPC_S_OK) return ret;
852
853 ret = UuidFromStringA(ObjectUuid, &Uuid);
854
855 if (ret == RPC_S_OK)
856 ret = RPCRT4_CreateBindingA(&bind, FALSE, (char*)Protseq);
857 if (ret == RPC_S_OK) {
859 if (ret == RPC_S_OK)
860 ret = RPCRT4_CompleteBindingA(bind, (char*)NetworkAddr, (char*)Endpoint, (char*)Options);
861
862 if (ret == RPC_S_OK)
864 else
866 }
867
869 RpcStringFreeA(&Endpoint);
870 RpcStringFreeA(&NetworkAddr);
871 RpcStringFreeA(&Protseq);
872 RpcStringFreeA(&ObjectUuid);
873
874 return ret;
875}
#define debugstr_a
Definition: kernel32.h:31
RPC_STATUS WINAPI RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR *ObjUuid, RPC_CSTR *Protseq, RPC_CSTR *NetworkAddr, RPC_CSTR *Endpoint, RPC_CSTR *Options)
Definition: rpc_binding.c:564
static RPC_STATUS RPCRT4_CreateBindingA(RpcBinding **Binding, BOOL server, LPCSTR Protseq)
Definition: rpc_binding.c:122
RPC_STATUS RPCRT4_SetBindingObject(RpcBinding *Binding, const UUID *ObjectUuid)
Definition: rpc_binding.c:224
static RPC_STATUS RPCRT4_CompleteBindingA(RpcBinding *Binding, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCSTR NetworkOptions)
Definition: rpc_binding.c:148
I_RPC_HANDLE RPC_BINDING_HANDLE
Definition: rpcdce.h:50
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:158
RPC_STATUS WINAPI UuidFromStringA(RPC_CSTR s, UUID *uuid)
Definition: rpcrt4_main.c:574
_In_ PWDFDEVICE_INIT _In_ PWDF_REMOVE_LOCK_OPTIONS Options
Definition: wdfdevice.h:3534

Referenced by client(), EVENTLOG_HANDLE_A_bind(), get_epm_handle_server(), listen_test_client_thread(), SVCCTL_HANDLEA_bind(), test_endpoint_mapper(), test_ndr_buffer(), test_reconnect(), test_rpc_ncacn_ip_tcp(), and test_RpcStringBindingFromBinding().

◆ RpcBindingFromStringBindingW()

RPC_STATUS WINAPI RpcBindingFromStringBindingW ( RPC_WSTR  StringBinding,
RPC_BINDING_HANDLE Binding 
)

Definition at line 880 of file rpc_binding.c.

881{
884 RPC_WSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
885 UUID Uuid;
886
887 TRACE("(%s,%p)\n", debugstr_w(StringBinding), Binding);
888
889 ret = RpcStringBindingParseW(StringBinding, &ObjectUuid, &Protseq,
890 &NetworkAddr, &Endpoint, &Options);
891 if (ret != RPC_S_OK) return ret;
892
893 ret = UuidFromStringW(ObjectUuid, &Uuid);
894
895 if (ret == RPC_S_OK)
896 ret = RPCRT4_CreateBindingW(&bind, FALSE, Protseq);
897 if (ret == RPC_S_OK) {
899 if (ret == RPC_S_OK)
900 ret = RPCRT4_CompleteBindingW(bind, NetworkAddr, Endpoint, Options);
901
902 if (ret == RPC_S_OK)
904 else
906 }
907
909 RpcStringFreeW(&Endpoint);
910 RpcStringFreeW(&NetworkAddr);
911 RpcStringFreeW(&Protseq);
912 RpcStringFreeW(&ObjectUuid);
913
914 return ret;
915}
#define debugstr_w
Definition: kernel32.h:32
static RPC_STATUS RPCRT4_CreateBindingW(RpcBinding **Binding, BOOL server, LPCWSTR Protseq)
Definition: rpc_binding.c:135
RPC_STATUS WINAPI RpcStringBindingParseW(RPC_WSTR StringBinding, RPC_WSTR *ObjUuid, RPC_WSTR *Protseq, RPC_WSTR *NetworkAddr, RPC_WSTR *Endpoint, RPC_WSTR *Options)
Definition: rpc_binding.c:676
static RPC_STATUS RPCRT4_CompleteBindingW(RpcBinding *Binding, LPCWSTR NetworkAddr, LPCWSTR Endpoint, LPCWSTR NetworkOptions)
Definition: rpc_binding.c:176
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:614

Referenced by __wine_msi_call_dll_function(), ATSVC_HANDLE_bind(), BROWSER_IDENTIFY_HANDLE_bind(), CreateProcessWithLogonW(), DNSRSLVR_HANDLE_bind(), DsSetupBind(), EVENTLOG_HANDLE_W_bind(), get_irot_handle(), LOGONSRV_HANDLE_bind(), NetpBind(), PLSAPR_SERVER_NAME_bind(), PnpBindRpc(), PREGISTRY_SERVER_NAME_bind(), PSAMPR_SERVER_NAME_bind(), RPC_CreateClientChannel(), ScCreateStatusBinding(), SRVSVC_HANDLE_bind(), SVCCTL_HANDLEW_bind(), WINSPOOL_HANDLE_bind(), WKSSVC_IDENTIFY_HANDLE_bind(), WKSSVC_IMPERSONATE_HANDLE_bind(), and WLANSVC_HANDLE_bind().

◆ RpcBindingInqAuthClientA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientA ( RPC_BINDING_HANDLE  ClientBinding,
RPC_AUTHZ_HANDLE Privs,
RPC_CSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
ULONG AuthzSvc 
)

Definition at line 1572 of file rpc_binding.c.

1575{
1576 return RpcBindingInqAuthClientExA(ClientBinding, Privs, ServerPrincName, AuthnLevel,
1577 AuthnSvc, AuthzSvc, 0);
1578}
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc, ULONG Flags)
Definition: rpc_binding.c:1596

Referenced by s_authinfo_test().

◆ RpcBindingInqAuthClientExA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExA ( RPC_BINDING_HANDLE  ClientBinding,
RPC_AUTHZ_HANDLE Privs,
RPC_CSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
ULONG AuthzSvc,
ULONG  Flags 
)

Definition at line 1596 of file rpc_binding.c.

1599{
1601 RPC_WSTR principal;
1602
1603 TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
1604 AuthnSvc, AuthzSvc, Flags);
1605
1606 status = RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName ? &principal : NULL,
1607 AuthnLevel, AuthnSvc, AuthzSvc, Flags);
1608 if (status == RPC_S_OK && ServerPrincName)
1609 {
1610 *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
1611 if (!*ServerPrincName && principal) status = RPC_S_OUT_OF_MEMORY;
1612 RpcStringFreeW(&principal);
1613 }
1614
1615 return status;
1616}
LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
Definition: rpc_binding.c:58
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc, ULONG Flags)
Definition: rpc_binding.c:1622
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by RpcBindingInqAuthClientA(), and s_authinfo_test().

◆ RpcBindingInqAuthClientExW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExW ( RPC_BINDING_HANDLE  ClientBinding,
RPC_AUTHZ_HANDLE Privs,
RPC_WSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
ULONG AuthzSvc,
ULONG  Flags 
)

Definition at line 1622 of file rpc_binding.c.

1625{
1627
1628 TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
1629 AuthnSvc, AuthzSvc, Flags);
1630
1631 if (!ClientBinding) ClientBinding = I_RpcGetCurrentCallHandle();
1632 if (!ClientBinding) return RPC_S_INVALID_BINDING;
1633
1634 bind = ClientBinding;
1635 if (!bind->FromConn) return RPC_S_INVALID_BINDING;
1636
1637 return rpcrt4_conn_inquire_auth_client(bind->FromConn, Privs,
1638 ServerPrincName, AuthnLevel,
1639 AuthnSvc, AuthzSvc, Flags);
1640}
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)
Definition: rpc_binding.h:253
RPC_BINDING_HANDLE WINAPI I_RpcGetCurrentCallHandle(void)
Definition: rpc_server.c:1743

Referenced by RpcBindingInqAuthClientExA(), and RpcBindingInqAuthClientW().

◆ RpcBindingInqAuthClientW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientW ( RPC_BINDING_HANDLE  ClientBinding,
RPC_AUTHZ_HANDLE Privs,
RPC_WSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
ULONG AuthzSvc 
)

Definition at line 1584 of file rpc_binding.c.

1587{
1588 return RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName, AuthnLevel,
1589 AuthnSvc, AuthzSvc, 0);
1590}

◆ RpcBindingInqAuthInfoA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoA ( RPC_BINDING_HANDLE  Binding,
RPC_CSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
ULONG AuthzSvc 
)

Definition at line 1550 of file rpc_binding.c.

1552{
1553 return RpcBindingInqAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
1554 AuthzSvc, 0, NULL);
1555}
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc, ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS)
Definition: rpc_binding.c:1482

Referenced by test_rpc_ncacn_ip_tcp().

◆ RpcBindingInqAuthInfoExA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExA ( RPC_BINDING_HANDLE  Binding,
RPC_CSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
ULONG AuthzSvc,
ULONG  RpcQosVersion,
RPC_SECURITY_QOS SecurityQOS 
)

Definition at line 1482 of file rpc_binding.c.

1485{
1487 RPC_WSTR principal;
1488
1489 TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1490 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1491
1492 status = RpcBindingInqAuthInfoExW(Binding, ServerPrincName ? &principal : NULL, AuthnLevel,
1493 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1494 if (status == RPC_S_OK && ServerPrincName)
1495 {
1496 *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
1497 RpcStringFreeW(&principal);
1498 if (!*ServerPrincName) return RPC_S_OUT_OF_MEMORY;
1499 }
1500
1501 return status;
1502}
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc, ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS)
Definition: rpc_binding.c:1508

Referenced by RpcBindingInqAuthInfoA().

◆ RpcBindingInqAuthInfoExW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoExW ( RPC_BINDING_HANDLE  Binding,
RPC_WSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
ULONG AuthzSvc,
ULONG  RpcQosVersion,
RPC_SECURITY_QOS SecurityQOS 
)

Definition at line 1508 of file rpc_binding.c.

1511{
1513
1514 TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1515 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1516
1517 if (!bind->AuthInfo) return RPC_S_BINDING_HAS_NO_AUTH;
1518
1519 if (SecurityQOS)
1520 {
1521 FIXME("QOS not implemented\n");
1522 return RPC_S_INVALID_BINDING;
1523 }
1524
1525 if (ServerPrincName)
1526 {
1527 if (bind->AuthInfo->server_principal_name)
1528 {
1529 *ServerPrincName = RPCRT4_strdupW(bind->AuthInfo->server_principal_name);
1530 if (!*ServerPrincName) return RPC_S_OUT_OF_MEMORY;
1531 }
1532 else *ServerPrincName = NULL;
1533 }
1534 if (AuthnLevel) *AuthnLevel = bind->AuthInfo->AuthnLevel;
1535 if (AuthnSvc) *AuthnSvc = bind->AuthInfo->AuthnSvc;
1536 if (AuthIdentity) *AuthIdentity = bind->AuthInfo->identity;
1537 if (AuthzSvc)
1538 {
1539 FIXME("authorization service not implemented\n");
1540 *AuthzSvc = RPC_C_AUTHZ_NONE;
1541 }
1542
1543 return RPC_S_OK;
1544}
#define RPC_C_AUTHZ_NONE
Definition: rpcdce.h:167
#define RPC_S_BINDING_HAS_NO_AUTH
Definition: winerror.h:1054

Referenced by RpcBindingInqAuthInfoExA(), and RpcBindingInqAuthInfoW().

◆ RpcBindingInqAuthInfoW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoW ( RPC_BINDING_HANDLE  Binding,
RPC_WSTR ServerPrincName,
ULONG AuthnLevel,
ULONG AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
ULONG AuthzSvc 
)

Definition at line 1561 of file rpc_binding.c.

1563{
1564 return RpcBindingInqAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
1565 AuthzSvc, 0, NULL);
1566}

◆ RpcBindingInqObject()

RPC_STATUS WINAPI RpcBindingInqObject ( RPC_BINDING_HANDLE  Binding,
UUID ObjectUuid 
)

Definition at line 816 of file rpc_binding.c.

817{
819
820 TRACE("(%p,%p) = %s\n", Binding, ObjectUuid, debugstr_guid(&bind->ObjectUuid));
821 *ObjectUuid = bind->ObjectUuid;
822 return RPC_S_OK;
823}
#define debugstr_guid
Definition: kernel32.h:35

Referenced by ClientRpcChannelBuffer_GetBuffer(), and dispatch_rpc().

◆ RpcBindingReset()

RPC_STATUS RPC_ENTRY RpcBindingReset ( RPC_BINDING_HANDLE  Binding)

Definition at line 1024 of file rpc_binding.c.

1025{
1027
1028 TRACE("(%p)\n", Binding);
1029
1030 RPCRT4_strfree(bind->Endpoint);
1031 bind->Endpoint = NULL;
1032 if (bind->Assoc) RpcAssoc_Release(bind->Assoc);
1033 bind->Assoc = NULL;
1034
1035 return RPC_S_OK;
1036}
ULONG RpcAssoc_Release(RpcAssoc *assoc)
Definition: rpc_assoc.c:187
void RPCRT4_strfree(LPSTR src)
Definition: rpc_binding.c:104

Referenced by test_endpoint_mapper().

◆ RpcBindingServerFromClient()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingServerFromClient ( RPC_BINDING_HANDLE  ClientBinding,
RPC_BINDING_HANDLE ServerBinding 
)

Definition at line 1646 of file rpc_binding.c.

1647{
1648 RpcBinding* bind = ClientBinding;
1649 RpcBinding* NewBinding;
1650
1651 if (!bind)
1653
1654 if (!bind->server)
1655 return RPC_S_INVALID_BINDING;
1656
1657 RPCRT4_AllocBinding(&NewBinding, TRUE);
1658 NewBinding->Protseq = RPCRT4_strdupA(bind->Protseq);
1659 NewBinding->NetworkAddr = RPCRT4_strdupA(bind->NetworkAddr);
1660
1661 *ServerBinding = NewBinding;
1662
1663 return RPC_S_OK;
1664}
#define RPCRT4_strdupA(x)
Definition: rpc_binding.h:151

Referenced by CreateJob(), and s_context_handle_test().

◆ RpcBindingSetAuthInfoA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoA ( RPC_BINDING_HANDLE  Binding,
RPC_CSTR  ServerPrincName,
ULONG  AuthnLevel,
ULONG  AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE  AuthIdentity,
ULONG  AuthzSvr 
)

Definition at line 1933 of file rpc_binding.c.

1935{
1936 TRACE("%p %s %u %u %p %u\n", Binding, debugstr_a((const char*)ServerPrincName),
1937 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1938 return RpcBindingSetAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1939}
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr, RPC_SECURITY_QOS *SecurityQos)
Definition: rpc_binding.c:1670

Referenced by test_rpc_ncacn_ip_tcp().

◆ RpcBindingSetAuthInfoExA()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExA ( RPC_BINDING_HANDLE  Binding,
RPC_CSTR  ServerPrincName,
ULONG  AuthnLevel,
ULONG  AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE  AuthIdentity,
ULONG  AuthzSvr,
RPC_SECURITY_QOS SecurityQos 
)

Definition at line 1670 of file rpc_binding.c.

1674{
1677 CredHandle cred;
1678 TimeStamp exp;
1679 ULONG package_count;
1680 ULONG i;
1681 PSecPkgInfoA packages;
1682 ULONG cbMaxToken;
1683
1684 TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_a((const char*)ServerPrincName),
1685 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1686
1687 if (SecurityQos)
1688 {
1690
1691 TRACE("SecurityQos { Version=%d, Capabilities=0x%x, IdentityTracking=%d, ImpersonationLevel=%d",
1692 SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1693 if (SecurityQos->Version >= 2)
1694 {
1695 const RPC_SECURITY_QOS_V2_A *SecurityQos2 = (const RPC_SECURITY_QOS_V2_A *)SecurityQos;
1696 TRACE(", AdditionalSecurityInfoType=%d", SecurityQos2->AdditionalSecurityInfoType);
1698 TRACE(", { %p, 0x%x, %d, %d, %p(%u), %s }",
1699 SecurityQos2->u.HttpCredentials->TransportCredentials,
1700 SecurityQos2->u.HttpCredentials->Flags,
1701 SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1702 SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1703 SecurityQos2->u.HttpCredentials->AuthnSchemes,
1704 SecurityQos2->u.HttpCredentials->AuthnSchemes ? *SecurityQos2->u.HttpCredentials->AuthnSchemes : 0,
1706 }
1707 TRACE("}\n");
1708 status = RpcQualityOfService_Create(SecurityQos, FALSE, &bind->QOS);
1709 if (status != RPC_S_OK)
1710 return status;
1711 }
1712 else
1713 {
1714 if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1715 bind->QOS = NULL;
1716 }
1717
1718 if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1719 AuthnSvc = RPC_C_AUTHN_WINNT;
1720
1721 /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1722 if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1723 AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1724
1725 if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1726 {
1727 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1728 bind->AuthInfo = NULL;
1729 return RPC_S_OK;
1730 }
1731
1732 if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1733 {
1734 FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1736 }
1737
1738 /* RPC_C_AUTHN_WINNT ignores the AuthzSvr parameter */
1739 if (AuthzSvr && AuthnSvc != RPC_C_AUTHN_WINNT)
1740 {
1741 FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1743 }
1744
1745 r = EnumerateSecurityPackagesA(&package_count, &packages);
1746 if (r != SEC_E_OK)
1747 {
1748 ERR("EnumerateSecurityPackagesA failed with error 0x%08x\n", r);
1749 return RPC_S_SEC_PKG_ERROR;
1750 }
1751
1752 for (i = 0; i < package_count; i++)
1753 if (packages[i].wRPCID == AuthnSvc)
1754 break;
1755
1756 if (i == package_count)
1757 {
1758 FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1759 FreeContextBuffer(packages);
1761 }
1762
1763 TRACE("found package %s for service %u\n", packages[i].Name, AuthnSvc);
1765 AuthIdentity, NULL, NULL, &cred, &exp);
1766 cbMaxToken = packages[i].cbMaxToken;
1767 FreeContextBuffer(packages);
1768 if (r == ERROR_SUCCESS)
1769 {
1770 RpcAuthInfo *new_auth_info;
1771 r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1772 AuthIdentity, &new_auth_info);
1773 if (r == RPC_S_OK)
1774 {
1775 new_auth_info->server_principal_name = RPCRT4_strdupAtoW((char *)ServerPrincName);
1776 if (!ServerPrincName || new_auth_info->server_principal_name)
1777 {
1778 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1779 bind->AuthInfo = new_auth_info;
1780 }
1781 else
1782 {
1783 RpcAuthInfo_Release(new_auth_info);
1785 }
1786 }
1787 else
1788 FreeCredentialsHandle(&cred);
1789 return r;
1790 }
1791 else
1792 {
1793 ERR("AcquireCredentialsHandleA failed with error 0x%08x\n", r);
1794 return RPC_S_SEC_PKG_ERROR;
1795 }
1796}
#define ERR(fmt,...)
Definition: debug.h:110
#define ERROR_SUCCESS
Definition: deptool.c:10
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG SECURITY_STATUS
Definition: sspi.h:34
#define SECPKG_CRED_OUTBOUND
Definition: sspi.h:291
RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc, CredHandle cred, TimeStamp exp, ULONG cbMaxToken, RPC_AUTH_IDENTITY_HANDLE identity, RpcAuthInfo **ret)
Definition: rpc_binding.c:1117
ULONG RpcAuthInfo_Release(RpcAuthInfo *AuthInfo)
Definition: rpc_binding.c:1188
static RPC_STATUS RpcQualityOfService_Create(const RPC_SECURITY_QOS *qos_src, BOOL unicode, RpcQualityOfService **qos_dst)
Definition: rpc_binding.c:1250
LPWSTR RPCRT4_strdupAtoW(LPCSTR src)
Definition: rpc_binding.c:69
ULONG RpcQualityOfService_Release(RpcQualityOfService *qos)
Definition: rpc_binding.c:1365
#define RPC_C_AUTHN_DEFAULT
Definition: rpcdce.h:165
#define RPC_C_AUTHN_LEVEL_PKT_PRIVACY
Definition: rpcdce.h:151
#define RPC_C_AUTHN_LEVEL_NONE
Definition: rpcdce.h:146
#define RPC_C_AUTHN_LEVEL_DEFAULT
Definition: rpcdce.h:145
#define RPC_C_AUTHN_INFO_TYPE_HTTP
Definition: rpcdce.h:195
#define RPC_C_AUTHN_NONE
Definition: rpcdce.h:153
SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
Definition: sspi.c:699
SECURITY_STATUS WINAPI EnumerateSecurityPackagesA(PULONG pcPackages, PSecPkgInfoA *ppPackageInfo)
Definition: sspi.c:855
SEC_WINNT_AUTH_IDENTITY_A * TransportCredentials
Definition: rpcdce.h:255
unsigned char * ServerCertificateSubject
Definition: rpcdce.h:260
ULONG AdditionalSecurityInfoType
Definition: rpcdce.h:289
union _RPC_SECURITY_QOS_V2_A::@3193 u
RPC_HTTP_TRANSPORT_CREDENTIALS_A * HttpCredentials
Definition: rpcdce.h:292
ULONG ImpersonationType
Definition: rpcdce.h:267
ULONG Capabilities
Definition: rpcdce.h:265
ULONG IdentityTracking
Definition: rpcdce.h:266
ULONG cbMaxToken
Definition: sspi.h:107
#define SEC_E_OK
Definition: winerror.h:2356
#define RPC_S_UNKNOWN_AUTHN_LEVEL
Definition: winerror.h:1056
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
#define RPC_S_SEC_PKG_ERROR
Definition: winerror.h:1132
#define RPC_S_UNKNOWN_AUTHZ_SERVICE
Definition: winerror.h:1058
SECURITY_STATUS WINAPI AcquireCredentialsHandleA(SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialsUse, PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
Definition: wrapper.c:59

Referenced by RpcBindingSetAuthInfoA().

◆ RpcBindingSetAuthInfoExW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExW ( RPC_BINDING_HANDLE  Binding,
RPC_WSTR  ServerPrincName,
ULONG  AuthnLevel,
ULONG  AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE  AuthIdentity,
ULONG  AuthzSvr,
RPC_SECURITY_QOS SecurityQos 
)

Definition at line 1802 of file rpc_binding.c.

1805{
1808 CredHandle cred;
1809 TimeStamp exp;
1810 ULONG package_count;
1811 ULONG i;
1812 PSecPkgInfoW packages;
1813 ULONG cbMaxToken;
1814
1815 TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_w(ServerPrincName),
1816 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1817
1818 if (SecurityQos)
1819 {
1821
1822 TRACE("SecurityQos { Version=%d, Capabilities=0x%x, IdentityTracking=%d, ImpersonationLevel=%d",
1823 SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1824 if (SecurityQos->Version >= 2)
1825 {
1826 const RPC_SECURITY_QOS_V2_W *SecurityQos2 = (const RPC_SECURITY_QOS_V2_W *)SecurityQos;
1827 TRACE(", AdditionalSecurityInfoType=%d", SecurityQos2->AdditionalSecurityInfoType);
1829 TRACE(", { %p, 0x%x, %d, %d, %p(%u), %s }",
1830 SecurityQos2->u.HttpCredentials->TransportCredentials,
1831 SecurityQos2->u.HttpCredentials->Flags,
1832 SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1833 SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1834 SecurityQos2->u.HttpCredentials->AuthnSchemes,
1835 SecurityQos2->u.HttpCredentials->AuthnSchemes ? *SecurityQos2->u.HttpCredentials->AuthnSchemes : 0,
1837 }
1838 TRACE("}\n");
1839 status = RpcQualityOfService_Create(SecurityQos, TRUE, &bind->QOS);
1840 if (status != RPC_S_OK)
1841 return status;
1842 }
1843 else
1844 {
1845 if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1846 bind->QOS = NULL;
1847 }
1848
1849 if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1850 AuthnSvc = RPC_C_AUTHN_WINNT;
1851
1852 /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1853 if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1854 AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1855
1856 if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1857 {
1858 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1859 bind->AuthInfo = NULL;
1860 return RPC_S_OK;
1861 }
1862
1863 if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1864 {
1865 FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1867 }
1868
1869 /* RPC_C_AUTHN_WINNT ignores the AuthzSvr parameter */
1870 if (AuthzSvr && AuthnSvc != RPC_C_AUTHN_WINNT)
1871 {
1872 FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1874 }
1875
1876 r = EnumerateSecurityPackagesW(&package_count, &packages);
1877 if (r != SEC_E_OK)
1878 {
1879 ERR("EnumerateSecurityPackagesW failed with error 0x%08x\n", r);
1880 return RPC_S_SEC_PKG_ERROR;
1881 }
1882
1883 for (i = 0; i < package_count; i++)
1884 if (packages[i].wRPCID == AuthnSvc)
1885 break;
1886
1887 if (i == package_count)
1888 {
1889 FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1890 FreeContextBuffer(packages);
1892 }
1893
1894 TRACE("found package %s for service %u\n", debugstr_w(packages[i].Name), AuthnSvc);
1896 AuthIdentity, NULL, NULL, &cred, &exp);
1897 cbMaxToken = packages[i].cbMaxToken;
1898 FreeContextBuffer(packages);
1899 if (r == ERROR_SUCCESS)
1900 {
1901 RpcAuthInfo *new_auth_info;
1902 r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1903 AuthIdentity, &new_auth_info);
1904 if (r == RPC_S_OK)
1905 {
1906 new_auth_info->server_principal_name = RPCRT4_strdupW(ServerPrincName);
1907 if (!ServerPrincName || new_auth_info->server_principal_name)
1908 {
1909 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1910 bind->AuthInfo = new_auth_info;
1911 }
1912 else
1913 {
1914 RpcAuthInfo_Release(new_auth_info);
1916 }
1917 }
1918 else
1919 FreeCredentialsHandle(&cred);
1920 return r;
1921 }
1922 else
1923 {
1924 ERR("AcquireCredentialsHandleW failed with error 0x%08x\n", r);
1925 return RPC_S_SEC_PKG_ERROR;
1926 }
1927}
SECURITY_STATUS WINAPI EnumerateSecurityPackagesW(PULONG pcPackages, PSecPkgInfoW *ppPackageInfo)
Definition: sspi.c:709
SEC_WINNT_AUTH_IDENTITY_W * TransportCredentials
Definition: rpcdce.h:245
unsigned short * ServerCertificateSubject
Definition: rpcdce.h:250
union _RPC_SECURITY_QOS_V2_W::@3192 u
RPC_HTTP_TRANSPORT_CREDENTIALS_W * HttpCredentials
Definition: rpcdce.h:279
ULONG AdditionalSecurityInfoType
Definition: rpcdce.h:276
ULONG cbMaxToken
Definition: sspi.h:117
SECURITY_STATUS WINAPI AcquireCredentialsHandleW(SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse, PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
Definition: wrapper.c:105

Referenced by RpcBindingSetAuthInfoW().

◆ RpcBindingSetAuthInfoW()

RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoW ( RPC_BINDING_HANDLE  Binding,
RPC_WSTR  ServerPrincName,
ULONG  AuthnLevel,
ULONG  AuthnSvc,
RPC_AUTH_IDENTITY_HANDLE  AuthIdentity,
ULONG  AuthzSvr 
)

Definition at line 1945 of file rpc_binding.c.

1947{
1948 TRACE("%p %s %u %u %p %u\n", Binding, debugstr_w(ServerPrincName),
1949 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1950 return RpcBindingSetAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1951}
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr, RPC_SECURITY_QOS *SecurityQos)
Definition: rpc_binding.c:1802

◆ RpcBindingSetObject()

RPC_STATUS WINAPI RpcBindingSetObject ( RPC_BINDING_HANDLE  Binding,
UUID ObjectUuid 
)

Definition at line 828 of file rpc_binding.c.

829{
831
832 TRACE("(%p,%s)\n", Binding, debugstr_guid(ObjectUuid));
833 if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
834 return RPCRT4_SetBindingObject(Binding, ObjectUuid);
835}
#define RPC_S_WRONG_KIND_OF_BINDING
Definition: winerror.h:1012

Referenced by RPC_CreateClientChannel().

◆ RpcBindingSetOption()

RPC_STATUS WINAPI RpcBindingSetOption ( RPC_BINDING_HANDLE  BindingHandle,
ULONG  Option,
ULONG_PTR  OptionValue 
)

Definition at line 1956 of file rpc_binding.c.

1957{
1958 TRACE("(%p, %d, %ld)\n", BindingHandle, Option, OptionValue);
1959
1960 switch (Option)
1961 {
1963 {
1965 RpcBinding *binding = BindingHandle;
1966 int len = MultiByteToWideChar(CP_ACP, 0, cookie->Buffer, cookie->BufferSize, NULL, 0);
1967 WCHAR *str;
1968
1969 if (!(str = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)))) return RPC_S_OUT_OF_MEMORY;
1970 MultiByteToWideChar(CP_ACP, 0, cookie->Buffer, cookie->BufferSize, str, len);
1971 str[len] = 0;
1972 HeapFree(GetProcessHeap(), 0, binding->CookieAuth);
1973 binding->CookieAuth = str;
1974 break;
1975 }
1976 default:
1977 FIXME("option %u not supported\n", Option);
1978 break;
1979 }
1980 return RPC_S_OK;
1981}
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * str
#define RPC_C_OPT_COOKIE_AUTH
Definition: rpcdcep.h:127
Definition: cookie.c:34
_In_ ULONG _Out_ HANDLE * BindingHandle
Definition: tdikrnl.h:1147
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ RpcBindingToStringBindingA()

RPC_STATUS WINAPI RpcBindingToStringBindingA ( RPC_BINDING_HANDLE  Binding,
RPC_CSTR StringBinding 
)

Definition at line 920 of file rpc_binding.c.

921{
924 RPC_CSTR ObjectUuid;
925
926 TRACE("(%p,%p)\n", Binding, StringBinding);
927
928 if (UuidIsNil(&bind->ObjectUuid, &ret))
929 ObjectUuid = NULL;
930 else
931 {
932 ret = UuidToStringA(&bind->ObjectUuid, &ObjectUuid);
933 if (ret != RPC_S_OK) return ret;
934 }
935
936 ret = RpcStringBindingComposeA(ObjectUuid, (unsigned char*)bind->Protseq, (unsigned char*) bind->NetworkAddr,
937 (unsigned char*) bind->Endpoint, NULL, StringBinding);
938
939 RpcStringFreeA(&ObjectUuid);
940
941 return ret;
942}
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:457
RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, RPC_CSTR *StringUuid)
Definition: rpcrt4_main.c:514
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:268

Referenced by RpcBindingToStringBindingW(), s_context_handle_test(), test_RpcServerUseProtseq(), and test_RpcStringBindingFromBinding().

◆ RpcBindingToStringBindingW()

RPC_STATUS WINAPI RpcBindingToStringBindingW ( RPC_BINDING_HANDLE  Binding,
RPC_WSTR StringBinding 
)

Definition at line 947 of file rpc_binding.c.

948{
950 unsigned char *str = NULL;
951 TRACE("(%p,%p)\n", Binding, StringBinding);
953 *StringBinding = RPCRT4_strdupAtoW((char*)str);
955 return ret;
956}
RPC_STATUS WINAPI RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:920

Referenced by CreateJob().

◆ RpcBindingVectorFree()

RPC_STATUS WINAPI RpcBindingVectorFree ( RPC_BINDING_VECTOR **  BindingVector)

Definition at line 802 of file rpc_binding.c.

803{
804 ULONG c;
805
806 TRACE("(%p)\n", BindingVector);
807 for (c=0; c<(*BindingVector)->Count; c++) RpcBindingFree(&(*BindingVector)->BindingH[c]);
808 HeapFree(GetProcessHeap(), 0, *BindingVector);
809 *BindingVector = NULL;
810 return RPC_S_OK;
811}
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:787

Referenced by test_endpoint_mapper(), and test_RpcServerUseProtseq().

◆ RpcImpersonateClient()

RPC_STATUS WINAPI RpcImpersonateClient ( RPC_BINDING_HANDLE  BindingHandle)

Definition at line 1056 of file rpc_binding.c.

1057{
1059
1060 TRACE("(%p)\n", BindingHandle);
1061
1064
1066 if (bind->FromConn)
1067 return rpcrt4_conn_impersonate_client(bind->FromConn);
1069}
static RPC_STATUS rpcrt4_conn_impersonate_client(RpcConnection *conn)
Definition: rpc_binding.h:241

Referenced by _RpcAbortPrinter(), _RpcAddForm(), _RpcAddJob(), _RpcAddMonitor(), _RpcAddPort(), _RpcAddPortEx(), _RpcAddPrinterDriver(), _RpcAddPrinterDriverEx(), _RpcAddPrintProcessor(), _RpcAddPrintProvidor(), _RpcClosePrinter(), _RpcCloseSpoolFileHandle(), _RpcCommitSpoolData(), _RpcCommitSpoolData2(), _RpcConfigurePort(), _RpcDeleteForm(), _RpcDeleteMonitor(), _RpcDeletePort(), _RpcDeletePrinter(), _RpcDeletePrinterDriver(), _RpcDeletePrinterDriverEx(), _RpcDeletePrintProcessor(), _RpcDeletePrintProvidor(), _RpcEndDocPrinter(), _RpcEndPagePrinter(), _RpcEnumForms(), _RpcEnumJobs(), _RpcEnumMonitors(), _RpcEnumPorts(), _RpcEnumPrinterDrivers(), _RpcEnumPrinters(), _RpcEnumPrintProcessorDatatypes(), _RpcEnumPrintProcessors(), _RpcGetForm(), _RpcGetJob(), _RpcGetPrinter(), _RpcGetPrinterDataEx(), _RpcGetPrinterDriver(), _RpcGetPrinterDriver2(), _RpcGetPrinterDriverDirectory(), _RpcGetPrintProcessorDirectory(), _RpcGetSpoolFileInfo(), _RpcGetSpoolFileInfo2(), _RpcOpenPrinter(), _RpcPrinterMessageBox(), _RpcReadPrinter(), _RpcResetPrinterEx(), _RpcScheduleJob(), _RpcSeekPrinter(), _RpcSetForm(), _RpcSetJob(), _RpcSetPort(), _RpcSetPrinterDataEx(), _RpcSpoolerInit(), _RpcStartDocPrinter(), _RpcStartPagePrinter(), _RpcWritePrinter(), _RpcXcvData(), LsarSetSecurityObject(), RSetServiceObjectSecurity(), s_authinfo_test(), and YGetPrinterDriver2().

◆ RpcMgmtSetComTimeout()

RPC_STATUS WINAPI RpcMgmtSetComTimeout ( RPC_BINDING_HANDLE  BindingHandle,
unsigned int  Timeout 
)

Definition at line 1472 of file rpc_binding.c.

1473{
1474 FIXME("(%p, %d): stub\n", BindingHandle, Timeout);
1475 return RPC_S_OK;
1476}
static ULONG Timeout
Definition: ping.c:61

◆ RpcQualityOfService_AddRef()

ULONG RpcQualityOfService_AddRef ( RpcQualityOfService qos)

Definition at line 1360 of file rpc_binding.c.

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

Referenced by RpcBindingCopy(), and RPCRT4_CreateConnection().

◆ RpcQualityOfService_Create()

static RPC_STATUS RpcQualityOfService_Create ( const RPC_SECURITY_QOS qos_src,
BOOL  unicode,
RpcQualityOfService **  qos_dst 
)
static

Definition at line 1250 of file rpc_binding.c.

1251{
1252 RpcQualityOfService *qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos));
1253
1254 if (!qos)
1256
1257 qos->refs = 1;
1258 qos->qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos->qos));
1259 if (!qos->qos) goto error;
1260 qos->qos->Version = qos_src->Version;
1261 qos->qos->Capabilities = qos_src->Capabilities;
1262 qos->qos->IdentityTracking = qos_src->IdentityTracking;
1263 qos->qos->ImpersonationType = qos_src->ImpersonationType;
1265
1266 if (qos_src->Version >= 2)
1267 {
1268 const RPC_SECURITY_QOS_V2_W *qos_src2 = (const RPC_SECURITY_QOS_V2_W *)qos_src;
1271 {
1272 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_src = qos_src2->u.HttpCredentials;
1273 RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_dst;
1274
1275 http_credentials_dst = HeapAlloc(GetProcessHeap(), 0, sizeof(*http_credentials_dst));
1276 qos->qos->u.HttpCredentials = http_credentials_dst;
1277 if (!http_credentials_dst) goto error;
1278 http_credentials_dst->TransportCredentials = NULL;
1279 http_credentials_dst->Flags = http_credentials_src->Flags;
1280 http_credentials_dst->AuthenticationTarget = http_credentials_src->AuthenticationTarget;
1281 http_credentials_dst->NumberOfAuthnSchemes = http_credentials_src->NumberOfAuthnSchemes;
1282 http_credentials_dst->AuthnSchemes = NULL;
1283 http_credentials_dst->ServerCertificateSubject = NULL;
1284 if (http_credentials_src->TransportCredentials)
1285 {
1286 SEC_WINNT_AUTH_IDENTITY_W *cred_dst;
1287 cred_dst = http_credentials_dst->TransportCredentials = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cred_dst));
1288 if (!cred_dst) goto error;
1290 if (unicode)
1291 {
1292 const SEC_WINNT_AUTH_IDENTITY_W *cred_src = http_credentials_src->TransportCredentials;
1293 cred_dst->UserLength = cred_src->UserLength;
1294 cred_dst->PasswordLength = cred_src->PasswordLength;
1295 cred_dst->DomainLength = cred_src->DomainLength;
1296 cred_dst->User = RPCRT4_strndupW(cred_src->User, cred_src->UserLength);
1297 cred_dst->Password = RPCRT4_strndupW(cred_src->Password, cred_src->PasswordLength);
1298 cred_dst->Domain = RPCRT4_strndupW(cred_src->Domain, cred_src->DomainLength);
1299 }
1300 else
1301 {
1302 const SEC_WINNT_AUTH_IDENTITY_A *cred_src = (const SEC_WINNT_AUTH_IDENTITY_A *)http_credentials_src->TransportCredentials;
1303 cred_dst->UserLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, NULL, 0);
1304 cred_dst->DomainLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, NULL, 0);
1305 cred_dst->PasswordLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, NULL, 0);
1306 cred_dst->User = HeapAlloc(GetProcessHeap(), 0, cred_dst->UserLength * sizeof(WCHAR));
1307 cred_dst->Password = HeapAlloc(GetProcessHeap(), 0, cred_dst->PasswordLength * sizeof(WCHAR));
1308 cred_dst->Domain = HeapAlloc(GetProcessHeap(), 0, cred_dst->DomainLength * sizeof(WCHAR));
1309 if (!cred_dst->Password || !cred_dst->Domain) goto error;
1310 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, cred_dst->User, cred_dst->UserLength);
1311 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, cred_dst->Domain, cred_dst->DomainLength);
1312 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, cred_dst->Password, cred_dst->PasswordLength);
1313 }
1314 }
1315 if (http_credentials_src->NumberOfAuthnSchemes)
1316 {
1317 http_credentials_dst->AuthnSchemes = HeapAlloc(GetProcessHeap(), 0, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1318 if (!http_credentials_dst->AuthnSchemes) goto error;
1319 memcpy(http_credentials_dst->AuthnSchemes, http_credentials_src->AuthnSchemes, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1320 }
1321 if (http_credentials_src->ServerCertificateSubject)
1322 {
1323 if (unicode)
1324 http_credentials_dst->ServerCertificateSubject =
1325 RPCRT4_strndupW(http_credentials_src->ServerCertificateSubject,
1326 lstrlenW(http_credentials_src->ServerCertificateSubject));
1327 else
1328 http_credentials_dst->ServerCertificateSubject =
1329 RPCRT4_strdupAtoW((char *)http_credentials_src->ServerCertificateSubject);
1330 if (!http_credentials_dst->ServerCertificateSubject) goto error;
1331 }
1332 }
1333 }
1334 *qos_dst = qos;
1335 return RPC_S_OK;
1336
1337error:
1338 if (qos->qos)
1339 {
1341 qos->qos->u.HttpCredentials)
1342 {
1344 {
1349 }
1353 }
1354 HeapFree(GetProcessHeap(), 0, qos->qos);
1355 }
1356 HeapFree(GetProcessHeap(), 0, qos);
1358}
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
RPC_SECURITY_QOS_V2_W * qos
Definition: rpc_binding.h:57
unsigned char * Domain
Definition: rpcdce.h:236
unsigned char * User
Definition: rpcdce.h:234
unsigned char * Password
Definition: rpcdce.h:238
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032

Referenced by RpcBindingSetAuthInfoExA(), and RpcBindingSetAuthInfoExW().

◆ RpcQualityOfService_IsEqual()

BOOL RpcQualityOfService_IsEqual ( const RpcQualityOfService qos1,
const RpcQualityOfService qos2 
)

Definition at line 1390 of file rpc_binding.c.

1391{
1392 if (qos1 == qos2)
1393 return TRUE;
1394
1395 if (!qos1 || !qos2)
1396 return FALSE;
1397
1398 TRACE("qos1 = { %d %d %d %d }, qos2 = { %d %d %d %d }\n",
1399 qos1->qos->Capabilities, qos1->qos->IdentityTracking,
1401 qos2->qos->Capabilities, qos2->qos->IdentityTracking,
1403
1404 if ((qos1->qos->Capabilities != qos2->qos->Capabilities) ||
1405 (qos1->qos->IdentityTracking != qos2->qos->IdentityTracking) ||
1406 (qos1->qos->ImpersonationType != qos2->qos->ImpersonationType) ||
1408 return FALSE;
1409
1411 {
1412 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials1 = qos1->qos->u.HttpCredentials;
1413 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials2 = qos2->qos->u.HttpCredentials;
1414
1415 if (http_credentials1->Flags != http_credentials2->Flags)
1416 return FALSE;
1417
1418 if (http_credentials1->AuthenticationTarget != http_credentials2->AuthenticationTarget)
1419 return FALSE;
1420
1421 if (http_credentials1->NumberOfAuthnSchemes != http_credentials2->NumberOfAuthnSchemes)
1422 return FALSE;
1423
1424 if ((!http_credentials1->AuthnSchemes && http_credentials2->AuthnSchemes) ||
1425 (http_credentials1->AuthnSchemes && !http_credentials2->AuthnSchemes))
1426 return FALSE;
1427
1428 if (memcmp(http_credentials1->AuthnSchemes, http_credentials2->AuthnSchemes,
1429 http_credentials1->NumberOfAuthnSchemes * sizeof(http_credentials1->AuthnSchemes[0])))
1430 return FALSE;
1431
1432 /* server certificate subject not currently used */
1433
1434 if (http_credentials1->TransportCredentials != http_credentials2->TransportCredentials)
1435 {
1436 const SEC_WINNT_AUTH_IDENTITY_W *identity1 = http_credentials1->TransportCredentials;
1437 const SEC_WINNT_AUTH_IDENTITY_W *identity2 = http_credentials2->TransportCredentials;
1438
1439 if (!identity1 || !identity2)
1440 return FALSE;
1441
1442 /* compare user names */
1443 if (identity1->UserLength != identity2->UserLength ||
1444 memcmp(identity1->User, identity2->User, identity1->UserLength))
1445 return FALSE;
1446 /* compare domain names */
1447 if (identity1->DomainLength != identity2->DomainLength ||
1448 memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1449 return FALSE;
1450 /* compare passwords */
1451 if (identity1->PasswordLength != identity2->PasswordLength ||
1452 memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1453 return FALSE;
1454 }
1455 }
1456
1457 return TRUE;
1458}

Referenced by RpcAssoc_GetIdleConnection().

◆ RpcQualityOfService_Release()

◆ RpcRevertToSelf()

RPC_STATUS WINAPI RpcRevertToSelf ( void  )

Definition at line 1463 of file rpc_binding.c.

1464{
1465 TRACE("\n");
1466 return RpcRevertToSelfEx(NULL);
1467}
RPC_STATUS WINAPI RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)
Definition: rpc_binding.c:1089

Referenced by _RpcAbortPrinter(), _RpcAddForm(), _RpcAddJob(), _RpcAddMonitor(), _RpcAddPort(), _RpcAddPortEx(), _RpcAddPrinterDriver(), _RpcAddPrinterDriverEx(), _RpcAddPrintProcessor(), _RpcAddPrintProvidor(), _RpcClosePrinter(), _RpcCloseSpoolFileHandle(), _RpcCommitSpoolData(), _RpcCommitSpoolData2(), _RpcConfigurePort(), _RpcDeleteForm(), _RpcDeleteMonitor(), _RpcDeletePort(), _RpcDeletePrinter(), _RpcDeletePrinterDriver(), _RpcDeletePrinterDriverEx(), _RpcDeletePrintProcessor(), _RpcDeletePrintProvidor(), _RpcEndDocPrinter(), _RpcEndPagePrinter(), _RpcEnumForms(), _RpcEnumJobs(), _RpcEnumMonitors(), _RpcEnumPorts(), _RpcEnumPrinterDrivers(), _RpcEnumPrinters(), _RpcEnumPrintProcessorDatatypes(), _RpcEnumPrintProcessors(), _RpcGetForm(), _RpcGetJob(), _RpcGetPrinter(), _RpcGetPrinterDataEx(), _RpcGetPrinterDriver(), _RpcGetPrinterDriver2(), _RpcGetPrinterDriverDirectory(), _RpcGetPrintProcessorDirectory(), _RpcGetSpoolFileInfo(), _RpcGetSpoolFileInfo2(), _RpcOpenPrinter(), _RpcPrinterMessageBox(), _RpcReadPrinter(), _RpcResetPrinterEx(), _RpcScheduleJob(), _RpcSeekPrinter(), _RpcSetForm(), _RpcSetJob(), _RpcSetPort(), _RpcSetPrinterDataEx(), _RpcSpoolerInit(), _RpcStartDocPrinter(), _RpcStartPagePrinter(), _RpcWritePrinter(), _RpcXcvData(), LsarSetSecurityObject(), RSetServiceObjectSecurity(), s_authinfo_test(), and YGetPrinterDriver2().

◆ RpcRevertToSelfEx()

RPC_STATUS WINAPI RpcRevertToSelfEx ( RPC_BINDING_HANDLE  BindingHandle)

Definition at line 1089 of file rpc_binding.c.

1090{
1092
1093 TRACE("(%p)\n", BindingHandle);
1094
1097
1099 if (bind->FromConn)
1100 return rpcrt4_conn_revert_to_self(bind->FromConn);
1102}
static RPC_STATUS rpcrt4_conn_revert_to_self(RpcConnection *conn)
Definition: rpc_binding.h:247

Referenced by RpcRevertToSelf().

◆ RPCRT4_AddRefBinding()

void RPCRT4_AddRefBinding ( RpcBinding Binding)

Definition at line 249 of file rpc_binding.c.

250{
252}

Referenced by I_RpcNegotiateTransferSyntax().

◆ RPCRT4_AllocBinding()

static RPC_STATUS RPCRT4_AllocBinding ( RpcBinding **  Binding,
BOOL  server 
)
static

Definition at line 109 of file rpc_binding.c.

110{
111 RpcBinding* NewBinding;
112
113 NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
114 NewBinding->refs = 1;
115 NewBinding->server = server;
116
117 *Binding = NewBinding;
118
119 return RPC_S_OK;
120}
static rfbScreenInfoPtr server
Definition: vnc.c:74

Referenced by RpcBindingCopy(), RpcBindingServerFromClient(), RPCRT4_CreateBindingA(), RPCRT4_CreateBindingW(), and RPCRT4_MakeBinding().

◆ RPCRT4_CloseBinding()

RPC_STATUS RPCRT4_CloseBinding ( RpcBinding Binding,
RpcConnection Connection 
)

Definition at line 293 of file rpc_binding.c.

294{
295 TRACE("(Binding == ^%p)\n", Binding);
296 if (!Connection) return RPC_S_OK;
297 if (Binding->server) {
298 /* don't destroy a connection that is cached in the binding */
299 if (Binding->FromConn != Connection)
300 RPCRT4_ReleaseConnection(Connection);
301 }
302 else {
303 RpcAssoc_ReleaseIdleConnection(Binding->Assoc, Connection);
304 }
305 return RPC_S_OK;
306}
void RpcAssoc_ReleaseIdleConnection(RpcAssoc *assoc, RpcConnection *Connection)
Definition: rpc_assoc.c:437
void RPCRT4_ReleaseConnection(RpcConnection *Connection) DECLSPEC_HIDDEN

Referenced by I_RpcFreeBuffer().

◆ RPCRT4_CompleteBindingA()

static RPC_STATUS RPCRT4_CompleteBindingA ( RpcBinding Binding,
LPCSTR  NetworkAddr,
LPCSTR  Endpoint,
LPCSTR  NetworkOptions 
)
static

Definition at line 148 of file rpc_binding.c.

150{
152
153 TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
154 debugstr_a(NetworkAddr), debugstr_a(Endpoint), debugstr_a(NetworkOptions));
155
156 RPCRT4_strfree(Binding->NetworkAddr);
157 Binding->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
158 RPCRT4_strfree(Binding->Endpoint);
159 Binding->Endpoint = RPCRT4_strdupA(Endpoint);
160 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
161 Binding->NetworkOptions = RPCRT4_strdupAtoW(NetworkOptions);
162
163 /* only attempt to get an association if the binding is complete */
164 if (Endpoint && Endpoint[0] != '\0')
165 {
166 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
167 Binding->Endpoint, Binding->NetworkOptions,
168 &Binding->Assoc);
169 if (status != RPC_S_OK)
170 return status;
171 }
172
173 return RPC_S_OK;
174}
RPC_STATUS RPCRT4_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAssoc **assoc_out)
Definition: rpc_assoc.c:98

Referenced by RpcBindingFromStringBindingA().

◆ RPCRT4_CompleteBindingW()

static RPC_STATUS RPCRT4_CompleteBindingW ( RpcBinding Binding,
LPCWSTR  NetworkAddr,
LPCWSTR  Endpoint,
LPCWSTR  NetworkOptions 
)
static

Definition at line 176 of file rpc_binding.c.

178{
180
181 TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
182 debugstr_w(NetworkAddr), debugstr_w(Endpoint), debugstr_w(NetworkOptions));
183
184 RPCRT4_strfree(Binding->NetworkAddr);
185 Binding->NetworkAddr = RPCRT4_strdupWtoA(NetworkAddr);
186 RPCRT4_strfree(Binding->Endpoint);
187 Binding->Endpoint = RPCRT4_strdupWtoA(Endpoint);
188 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
189 Binding->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
190
191 /* only attempt to get an association if the binding is complete */
192 if (Endpoint && Endpoint[0] != '\0')
193 {
194 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
195 Binding->Endpoint, Binding->NetworkOptions,
196 &Binding->Assoc);
197 if (status != RPC_S_OK)
198 return status;
199 }
200
201 return RPC_S_OK;
202}

Referenced by RpcBindingFromStringBindingW().

◆ RPCRT4_CreateBindingA()

static RPC_STATUS RPCRT4_CreateBindingA ( RpcBinding **  Binding,
BOOL  server,
LPCSTR  Protseq 
)
static

Definition at line 122 of file rpc_binding.c.

123{
124 RpcBinding* NewBinding;
125
126 RPCRT4_AllocBinding(&NewBinding, server);
127 NewBinding->Protseq = RPCRT4_strdupA(Protseq);
128
129 TRACE("binding: %p\n", NewBinding);
130 *Binding = NewBinding;
131
132 return RPC_S_OK;
133}

Referenced by RpcBindingFromStringBindingA().

◆ RPCRT4_CreateBindingW()

static RPC_STATUS RPCRT4_CreateBindingW ( RpcBinding **  Binding,
BOOL  server,
LPCWSTR  Protseq 
)
static

Definition at line 135 of file rpc_binding.c.

136{
137 RpcBinding* NewBinding;
138
139 RPCRT4_AllocBinding(&NewBinding, server);
140 NewBinding->Protseq = RPCRT4_strdupWtoA(Protseq);
141
142 TRACE("binding: %p\n", NewBinding);
143 *Binding = NewBinding;
144
145 return RPC_S_OK;
146}

Referenced by RpcBindingFromStringBindingW().

◆ RPCRT4_MakeBinding()

RPC_STATUS RPCRT4_MakeBinding ( RpcBinding **  Binding,
RpcConnection Connection 
)

Definition at line 232 of file rpc_binding.c.

233{
234 RpcBinding* NewBinding;
235 TRACE("(RpcBinding == ^%p, Connection == ^%p)\n", Binding, Connection);
236
237 RPCRT4_AllocBinding(&NewBinding, Connection->server);
238 NewBinding->Protseq = RPCRT4_strdupA(rpcrt4_conn_get_name(Connection));
239 NewBinding->NetworkAddr = RPCRT4_strdupA(Connection->NetworkAddr);
240 NewBinding->Endpoint = RPCRT4_strdupA(Connection->Endpoint);
241 NewBinding->FromConn = Connection;
242
243 TRACE("binding: %p\n", NewBinding);
244 *Binding = NewBinding;
245
246 return RPC_S_OK;
247}
static const char * rpcrt4_conn_get_name(const RpcConnection *Connection)
Definition: rpc_binding.h:183
RpcConnection * FromConn
Definition: rpc_binding.h:136
LPSTR NetworkAddr
Definition: rpc_binding.h:67

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 272 of file rpc_binding.c.

275{
276 TRACE("(Binding == ^%p)\n", Binding);
277
278 if (!Binding->server) {
279 return RpcAssoc_GetClientConnection(Binding->Assoc, InterfaceId,
280 TransferSyntax, Binding->AuthInfo, Binding->QOS, Binding->CookieAuth, Connection, from_cache);
281 } else {
282 /* we already have a connection with acceptable binding, so use it */
283 if (Binding->FromConn) {
284 *Connection = Binding->FromConn;
285 return RPC_S_OK;
286 } else {
287 ERR("no connection in binding\n");
289 }
290 }
291}
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: rpc_assoc.c:390
#define RPC_S_INTERNAL_ERROR
Definition: winerror.h:1074

Referenced by I_RpcNegotiateTransferSyntax(), and I_RpcSend().

◆ RPCRT4_ReleaseBinding()

RPC_STATUS RPCRT4_ReleaseBinding ( RpcBinding Binding)

Definition at line 254 of file rpc_binding.c.

255{
256 if (InterlockedDecrement(&Binding->refs))
257 return RPC_S_OK;
258
259 TRACE("binding: %p\n", Binding);
260 if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
261 RPCRT4_strfree(Binding->Endpoint);
262 RPCRT4_strfree(Binding->NetworkAddr);
263 RPCRT4_strfree(Binding->Protseq);
264 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
265 HeapFree(GetProcessHeap(), 0, Binding->CookieAuth);
266 if (Binding->AuthInfo) RpcAuthInfo_Release(Binding->AuthInfo);
269 return RPC_S_OK;
270}

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

◆ RPCRT4_ResolveBinding()

RPC_STATUS RPCRT4_ResolveBinding ( RpcBinding Binding,
LPCSTR  Endpoint 
)

Definition at line 204 of file rpc_binding.c.

205{
207
208 TRACE("(RpcBinding == ^%p, EndPoint == \"%s\"\n", Binding, Endpoint);
209
210 RPCRT4_strfree(Binding->Endpoint);
211 Binding->Endpoint = RPCRT4_strdupA(Endpoint);
212
213 if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
214 Binding->Assoc = NULL;
215 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
216 Binding->Endpoint, Binding->NetworkOptions,
217 &Binding->Assoc);
218 if (status != RPC_S_OK)
219 return status;
220
221 return RPC_S_OK;
222}

Referenced by get_epm_handle_client(), and RpcEpResolveBinding().

◆ RPCRT4_SetBindingObject()

RPC_STATUS RPCRT4_SetBindingObject ( RpcBinding Binding,
const UUID ObjectUuid 
)

Definition at line 224 of file rpc_binding.c.

225{
226 TRACE("(*RpcBinding == ^%p, UUID == %s)\n", Binding, debugstr_guid(ObjectUuid));
227 if (ObjectUuid) Binding->ObjectUuid = *ObjectUuid;
228 else UuidCreateNil(&Binding->ObjectUuid);
229 return RPC_S_OK;
230}
RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
Definition: rpcrt4_main.c:284

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

◆ RPCRT4_strconcatA()

static LPSTR RPCRT4_strconcatA ( LPSTR  dst,
LPCSTR  src 
)
static

Definition at line 308 of file rpc_binding.c.

309{
310 DWORD len = strlen(dst), slen = strlen(src);
311 LPSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(CHAR));
312 if (!ndst)
313 {
315 return NULL;
316 }
317 ndst[len] = ',';
318 memcpy(ndst+len+1, src, slen+1);
319 return ndst;
320}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define HeapReAlloc
Definition: compat.h:734
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
char * LPSTR
Definition: xmlstorage.h:182
char CHAR
Definition: xmlstorage.h:175

Referenced by RpcStringBindingParseA().

◆ RPCRT4_strconcatW()

static LPWSTR RPCRT4_strconcatW ( LPWSTR  dst,
LPCWSTR  src 
)
static

Definition at line 322 of file rpc_binding.c.

323{
324 DWORD len = lstrlenW(dst), slen = lstrlenW(src);
325 LPWSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(WCHAR));
326 if (!ndst)
327 {
329 return NULL;
330 }
331 ndst[len] = ',';
332 memcpy(ndst+len+1, src, (slen+1)*sizeof(WCHAR));
333 return ndst;
334}
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by RpcStringBindingParseW().

◆ RPCRT4_strdupAtoW()

LPWSTR RPCRT4_strdupAtoW ( LPCSTR  src)

Definition at line 69 of file rpc_binding.c.

70{
71 DWORD len;
72 LPWSTR s;
73 if (!src) return NULL;
74 len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
75 s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
77 return s;
78}
GLdouble s
Definition: gl.h:2039

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

◆ RPCRT4_strdupWtoA()

◆ RPCRT4_strfree()

◆ RPCRT4_strndupA()

LPSTR RPCRT4_strndupA ( LPCSTR  src,
INT  slen 
)

Definition at line 45 of file rpc_binding.c.

46{
47 DWORD len;
48 LPSTR s;
49 if (!src) return NULL;
50 if (slen == -1) slen = strlen(src);
51 len = slen;
52 s = HeapAlloc(GetProcessHeap(), 0, len+1);
53 memcpy(s, src, len);
54 s[len] = 0;
55 return s;
56}

Referenced by RpcBindingCopy().

◆ RPCRT4_strndupAtoW()

static LPWSTR RPCRT4_strndupAtoW ( LPCSTR  src,
INT  slen 
)
static

Definition at line 80 of file rpc_binding.c.

81{
82 DWORD len;
83 LPWSTR s;
84 if (!src) return NULL;
85 len = MultiByteToWideChar(CP_ACP, 0, src, slen, NULL, 0);
86 s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
87 MultiByteToWideChar(CP_ACP, 0, src, slen, s, len);
88 return s;
89}

Referenced by RpcAuthInfo_Create().

◆ RPCRT4_strndupW()

LPWSTR RPCRT4_strndupW ( LPCWSTR  src,
INT  slen 
)

Definition at line 91 of file rpc_binding.c.

92{
93 DWORD len;
94 LPWSTR s;
95 if (!src) return NULL;
96 if (slen == -1) slen = lstrlenW(src);
97 len = slen;
98 s = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
99 memcpy(s, src, len*sizeof(WCHAR));
100 s[len] = 0;
101 return s;
102}

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

◆ RpcStringBindingComposeA()

RPC_STATUS WINAPI RpcStringBindingComposeA ( RPC_CSTR  ObjUuid,
RPC_CSTR  Protseq,
RPC_CSTR  NetworkAddr,
RPC_CSTR  Endpoint,
RPC_CSTR  Options,
RPC_CSTR StringBinding 
)

Definition at line 457 of file rpc_binding.c.

460{
461 DWORD len = 1;
463
464 TRACE( "(%s,%s,%s,%s,%s,%p)\n",
465 debugstr_a( (char*)ObjUuid ), debugstr_a( (char*)Protseq ),
466 debugstr_a( (char*)NetworkAddr ), debugstr_a( (char*)Endpoint ),
467 debugstr_a( (char*)Options ), StringBinding );
468
469 /* overestimate for each component for escaping of delimiters */
470 if (ObjUuid && *ObjUuid) len += strlen((char*)ObjUuid) * 2 + 1;
471 if (Protseq && *Protseq) len += strlen((char*)Protseq) * 2 + 1;
472 if (NetworkAddr && *NetworkAddr) len += strlen((char*)NetworkAddr) * 2;
473 if (Endpoint && *Endpoint) len += strlen((char*)Endpoint) * 2 + 2;
474 if (Options && *Options) len += strlen((char*)Options) * 2 + 2;
475
477 *StringBinding = data;
478
479 if (ObjUuid && *ObjUuid) {
481 *data++ = '@';
482 }
483 if (Protseq && *Protseq) {
485 *data++ = ':';
486 }
487 if (NetworkAddr && *NetworkAddr)
489
490 if ((Endpoint && *Endpoint) ||
491 (Options && *Options)) {
492 *data++ = '[';
493 if (Endpoint && *Endpoint) {
495 if (Options && *Options) *data++ = ',';
496 }
497 if (Options && *Options) {
499 }
500 *data++ = ']';
501 }
502 *data = 0;
503
504 return RPC_S_OK;
505}
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static RPC_CSTR escape_string_binding_component(RPC_CSTR string_binding, const unsigned char *component)
Definition: rpc_binding.c:338

Referenced by client(), EVENTLOG_HANDLE_A_bind(), RpcBindingToStringBindingA(), SVCCTL_HANDLEA_bind(), test_endpoint_mapper(), test_ndr_buffer(), test_reconnect(), test_rpc_ncacn_ip_tcp(), test_RpcStringBindingFromBinding(), and test_server_listening().

◆ RpcStringBindingComposeW()

RPC_STATUS WINAPI RpcStringBindingComposeW ( RPC_WSTR  ObjUuid,
RPC_WSTR  Protseq,
RPC_WSTR  NetworkAddr,
RPC_WSTR  Endpoint,
RPC_WSTR  Options,
RPC_WSTR StringBinding 
)

Definition at line 510 of file rpc_binding.c.

513{
514 DWORD len = 1;
516
517 TRACE("(%s,%s,%s,%s,%s,%p)\n",
518 debugstr_w( ObjUuid ), debugstr_w( Protseq ),
519 debugstr_w( NetworkAddr ), debugstr_w( Endpoint ),
520 debugstr_w( Options ), StringBinding);
521
522 /* overestimate for each component for escaping of delimiters */
523 if (ObjUuid && *ObjUuid) len += lstrlenW(ObjUuid) * 2 + 1;
524 if (Protseq && *Protseq) len += lstrlenW(Protseq) * 2 + 1;
525 if (NetworkAddr && *NetworkAddr) len += lstrlenW(NetworkAddr) * 2;
526 if (Endpoint && *Endpoint) len += lstrlenW(Endpoint) * 2 + 2;
527 if (Options && *Options) len += lstrlenW(Options) * 2 + 2;
528
529 data = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
530 *StringBinding = data;
531
532 if (ObjUuid && *ObjUuid) {
534 *data++ = '@';
535 }
536 if (Protseq && *Protseq) {
538 *data++ = ':';
539 }
540 if (NetworkAddr && *NetworkAddr) {
542 }
543 if ((Endpoint && *Endpoint) ||
544 (Options && *Options)) {
545 *data++ = '[';
546 if (Endpoint && *Endpoint) {
548 if (Options && *Options) *data++ = ',';
549 }
550 if (Options && *Options) {
552 }
553 *data++ = ']';
554 }
555 *data = 0;
556
557 return RPC_S_OK;
558}
static RPC_WSTR escape_string_binding_componentW(RPC_WSTR string_binding, const WCHAR *component)
Definition: rpc_binding.c:359

Referenced by __wine_msi_call_dll_function(), ATSVC_HANDLE_bind(), BROWSER_IDENTIFY_HANDLE_bind(), CreateProcessWithLogonW(), DNSRSLVR_HANDLE_bind(), DsSetupBind(), EVENTLOG_HANDLE_W_bind(), get_irot_handle(), LOGONSRV_HANDLE_bind(), NetpBind(), PLSAPR_SERVER_NAME_bind(), PnpBindRpc(), PREGISTRY_SERVER_NAME_bind(), PSAMPR_SERVER_NAME_bind(), RPC_CreateClientChannel(), ScCreateStatusBinding(), SRVSVC_HANDLE_bind(), SVCCTL_HANDLEW_bind(), WINSPOOL_HANDLE_bind(), WKSSVC_IDENTIFY_HANDLE_bind(), WKSSVC_IMPERSONATE_HANDLE_bind(), and WLANSVC_HANDLE_bind().

◆ RpcStringBindingParseA()

RPC_STATUS WINAPI RpcStringBindingParseA ( RPC_CSTR  StringBinding,
RPC_CSTR ObjUuid,
RPC_CSTR Protseq,
RPC_CSTR NetworkAddr,
RPC_CSTR Endpoint,
RPC_CSTR Options 
)

Definition at line 564 of file rpc_binding.c.

567{
568 const unsigned char *data, *next;
569 static const char ep_opt[] = "endpoint=";
570 BOOL endpoint_already_found = FALSE;
571
572 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_a((char*)StringBinding),
573 ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
574
575 if (ObjUuid) *ObjUuid = NULL;
576 if (Protseq) *Protseq = NULL;
577 if (NetworkAddr) *NetworkAddr = NULL;
578 if (Endpoint) *Endpoint = NULL;
579 if (Options) *Options = NULL;
580
581 data = StringBinding;
582
584 if (next) {
585 UUID uuid;
588 status = UuidFromStringA(str_uuid, &uuid);
589 if (status != RPC_S_OK) {
590 HeapFree(GetProcessHeap(), 0, str_uuid);
591 return status;
592 }
593 if (ObjUuid)
594 *ObjUuid = str_uuid;
595 else
596 HeapFree(GetProcessHeap(), 0, str_uuid);
597 data = next+1;
598 }
599
601 if (next) {
602 if (Protseq) *Protseq = unescape_string_binding_component(data, next - data);
603 data = next+1;
604 } else {
605 goto fail;
606 }
607
609 if (next) {
610 const unsigned char *close;
611 RPC_CSTR opt;
612
613 if (NetworkAddr) *NetworkAddr = unescape_string_binding_component(data, next - data);
614 data = next+1;
616 if (!close) goto fail;
617
618 /* tokenize options */
619 while (data < close) {
621 if (!next || next > close) next = close;
622 /* FIXME: this is kind of inefficient */
624 data = next+1;
625
626 /* parse option */
628 if (!next) {
629 /* not an option, must be an endpoint */
630 if (endpoint_already_found) goto fail;
631 if (Endpoint) *Endpoint = opt;
632 else HeapFree(GetProcessHeap(), 0, opt);
633 endpoint_already_found = TRUE;
634 } else {
635 if (strncmp((const char *)opt, ep_opt, strlen(ep_opt)) == 0) {
636 /* endpoint option */
637 if (endpoint_already_found) goto fail;
638 if (Endpoint) *Endpoint = unescape_string_binding_component(next+1, -1);
639 HeapFree(GetProcessHeap(), 0, opt);
640 endpoint_already_found = TRUE;
641 } else {
642 /* network option */
643 if (Options) {
644 if (*Options) {
645 /* FIXME: this is kind of inefficient */
646 *Options = (unsigned char*) RPCRT4_strconcatA( (char*)*Options, (char *)opt);
647 HeapFree(GetProcessHeap(), 0, opt);
648 } else
649 *Options = opt;
650 } else
651 HeapFree(GetProcessHeap(), 0, opt);
652 }
653 }
654 }
655
656 data = close+1;
657 if (*data) goto fail;
658 }
659 else if (NetworkAddr)
660 *NetworkAddr = unescape_string_binding_component(data, -1);
661
662 return RPC_S_OK;
663
664fail:
665 if (ObjUuid) RpcStringFreeA(ObjUuid);
666 if (Protseq) RpcStringFreeA(Protseq);
667 if (NetworkAddr) RpcStringFreeA(NetworkAddr);
668 if (Endpoint) RpcStringFreeA(Endpoint);
671}
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
#define close
Definition: acwin.h:98
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: msctf.idl:511
static unsigned __int64 next
Definition: rand_nt.c:6
static LPSTR RPCRT4_strconcatA(LPSTR dst, LPCSTR src)
Definition: rpc_binding.c:308
static const unsigned char * string_binding_find_delimiter(const unsigned char *string_binding, unsigned char delim)
Definition: rpc_binding.c:380
static RPC_CSTR unescape_string_binding_component(const unsigned char *string_binding, int len)
Definition: rpc_binding.c:410
#define RPC_S_INVALID_STRING_BINDING
Definition: winerror.h:1011

Referenced by RpcBindingFromStringBindingA(), s_context_handle_test(), and test_RpcStringBindingParseA().

◆ RpcStringBindingParseW()

RPC_STATUS WINAPI RpcStringBindingParseW ( RPC_WSTR  StringBinding,
RPC_WSTR ObjUuid,
RPC_WSTR Protseq,
RPC_WSTR NetworkAddr,
RPC_WSTR Endpoint,
RPC_WSTR Options 
)

Definition at line 676 of file rpc_binding.c.

679{
680 const WCHAR *data, *next;
681 static const WCHAR ep_opt[] = {'e','n','d','p','o','i','n','t','=',0};
682 BOOL endpoint_already_found = FALSE;
683
684 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_w(StringBinding),
685 ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
686
687 if (ObjUuid) *ObjUuid = NULL;
688 if (Protseq) *Protseq = NULL;
689 if (NetworkAddr) *NetworkAddr = NULL;
690 if (Endpoint) *Endpoint = NULL;
691 if (Options) *Options = NULL;
692
693 data = StringBinding;
694
696 if (next) {
697 UUID uuid;
700 status = UuidFromStringW(str_uuid, &uuid);
701 if (status != RPC_S_OK) {
702 HeapFree(GetProcessHeap(), 0, str_uuid);
703 return status;
704 }
705 if (ObjUuid)
706 *ObjUuid = str_uuid;
707 else
708 HeapFree(GetProcessHeap(), 0, str_uuid);
709 data = next+1;
710 }
711
713 if (next) {
714 if (Protseq) *Protseq = unescape_string_binding_componentW(data, next - data);
715 data = next+1;
716 } else {
717 goto fail;
718 }
719
721 if (next) {
722 const WCHAR *close;
723 RPC_WSTR opt;
724
725 if (NetworkAddr) *NetworkAddr = unescape_string_binding_componentW(data, next - data);
726 data = next+1;
728 if (!close) goto fail;
729
730 /* tokenize options */
731 while (data < close) {
733 if (!next || next > close) next = close;
734 /* FIXME: this is kind of inefficient */
736 data = next+1;
737
738 /* parse option */
740 if (!next) {
741 /* not an option, must be an endpoint */
742 if (endpoint_already_found) goto fail;
743 if (Endpoint) *Endpoint = opt;
744 else HeapFree(GetProcessHeap(), 0, opt);
745 endpoint_already_found = TRUE;
746 } else {
747 if (wcsncmp(opt, ep_opt, lstrlenW(ep_opt)) == 0) {
748 /* endpoint option */
749 if (endpoint_already_found) goto fail;
750 if (Endpoint) *Endpoint = unescape_string_binding_componentW(next+1, -1);
751 HeapFree(GetProcessHeap(), 0, opt);
752 endpoint_already_found = TRUE;
753 } else {
754 /* network option */
755 if (Options) {
756 if (*Options) {
757 /* FIXME: this is kind of inefficient */
759 HeapFree(GetProcessHeap(), 0, opt);
760 } else
761 *Options = opt;
762 } else
763 HeapFree(GetProcessHeap(), 0, opt);
764 }
765 }
766 }
767
768 data = close+1;
769 if (*data) goto fail;
770 } else if (NetworkAddr)
771 *NetworkAddr = unescape_string_binding_componentW(data, -1);
772
773 return RPC_S_OK;
774
775fail:
776 if (ObjUuid) RpcStringFreeW(ObjUuid);
777 if (Protseq) RpcStringFreeW(Protseq);
778 if (NetworkAddr) RpcStringFreeW(NetworkAddr);
779 if (Endpoint) RpcStringFreeW(Endpoint);
782}
static const WCHAR * string_binding_find_delimiterW(const WCHAR *string_binding, WCHAR delim)
Definition: rpc_binding.c:395
static RPC_WSTR unescape_string_binding_componentW(const WCHAR *string_binding, int len)
Definition: rpc_binding.c:432
static LPWSTR RPCRT4_strconcatW(LPWSTR dst, LPCWSTR src)
Definition: rpc_binding.c:322
_Check_return_ _CRTIMP int __cdecl wcsncmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)

Referenced by CreateJob(), and RpcBindingFromStringBindingW().

◆ string_binding_find_delimiter()

static const unsigned char * string_binding_find_delimiter ( const unsigned char string_binding,
unsigned char  delim 
)
static

Definition at line 380 of file rpc_binding.c.

382{
383 const unsigned char *next;
384 for (next = string_binding; *next; next++) {
385 if (*next == '\\') {
386 next++;
387 continue;
388 }
389 if (*next == delim)
390 return next;
391 }
392 return NULL;
393}

Referenced by RpcStringBindingParseA().

◆ string_binding_find_delimiterW()

static const WCHAR * string_binding_find_delimiterW ( const WCHAR string_binding,
WCHAR  delim 
)
static

Definition at line 395 of file rpc_binding.c.

397{
398 const WCHAR *next;
399 for (next = string_binding; *next; next++) {
400 if (*next == '\\') {
401 next++;
402 continue;
403 }
404 if (*next == delim)
405 return next;
406 }
407 return NULL;
408}

Referenced by RpcStringBindingParseW().

◆ unescape_string_binding_component()

static RPC_CSTR unescape_string_binding_component ( const unsigned char string_binding,
int  len 
)
static

Definition at line 410 of file rpc_binding.c.

412{
413 RPC_CSTR component, p;
414
415 if (len == -1) len = strlen((const char *)string_binding);
416
417 component = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(*component));
418 if (!component) return NULL;
419 for (p = component; len > 0; string_binding++, len--) {
420 if (*string_binding == '\\') {
421 string_binding++;
422 len--;
423 *p++ = *string_binding;
424 } else {
425 *p++ = *string_binding;
426 }
427 }
428 *p = '\0';
429 return component;
430}
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by RpcStringBindingParseA().

◆ unescape_string_binding_componentW()

static RPC_WSTR unescape_string_binding_componentW ( const WCHAR string_binding,
int  len 
)
static

Definition at line 432 of file rpc_binding.c.

434{
435 RPC_WSTR component, p;
436
437 if (len == -1) len = lstrlenW(string_binding);
438
439 component = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(*component));
440 if (!component) return NULL;
441 for (p = component; len > 0; string_binding++, len--) {
442 if (*string_binding == '\\') {
443 string_binding++;
444 len--;
445 *p++ = *string_binding;
446 } else {
447 *p++ = *string_binding;
448 }
449 }
450 *p = '\0';
451 return component;
452}

Referenced by RpcStringBindingParseW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( rpc  )