dlls/rpcrt4/rpc_binding.c

   1 /*
   2  * RPC binding API
   3  *
   4  * Copyright 2001 Ove Kåven, TransGaming Technologies
   5  * Copyright 2003 Mike Hearn
   6  * Copyright 2004 Filip Navara
   7  * Copyright 2006 CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winnls.h"
  32 #include "winerror.h"
  33 #include "winternl.h"
  34 #include "wine/unicode.h"
  35
  36 #include "rpc.h"
  37 #include "rpcndr.h"
  38
  39 #include "wine/debug.h"
  40
  41 #include "rpc_binding.h"
  42 #include "rpc_assoc.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  45
  46 LPSTR RPCRT4_strndupA(LPCSTR src, INT slen)
  47 {
  48   DWORD len;
  49   LPSTR s;
  50   if (!src) return NULL;
  51   if (slen == -1) slen = strlen(src);
  52   len = slen;
  53   s = HeapAlloc(GetProcessHeap(), 0, len+1);
  54   memcpy(s, src, len);
  55   s[len] = 0;
  56   return s;
  57 }
  58
  59 LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
  60 {
  61   DWORD len;
  62   LPSTR s;
  63   if (!src) return NULL;
  64   len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
  65   s = HeapAlloc(GetProcessHeap(), 0, len);
  66   WideCharToMultiByte(CP_ACP, 0, src, -1, s, len, NULL, NULL);
  67   return s;
  68 }
  69
  70 LPWSTR RPCRT4_strdupAtoW(LPCSTR src)
  71 {
  72   DWORD len;
  73   LPWSTR s;
  74   if (!src) return NULL;
  75   len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
  76   s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
  77   MultiByteToWideChar(CP_ACP, 0, src, -1, s, len);
  78   return s;
  79 }
  80
  81 static LPWSTR RPCRT4_strndupAtoW(LPCSTR src, INT slen)
  82 {
  83   DWORD len;
  84   LPWSTR s;
  85   if (!src) return NULL;
  86   len = MultiByteToWideChar(CP_ACP, 0, src, slen, NULL, 0);
  87   s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
  88   MultiByteToWideChar(CP_ACP, 0, src, slen, s, len);
  89   return s;
  90 }
  91
  92 LPWSTR RPCRT4_strndupW(LPCWSTR src, INT slen)
  93 {
  94   DWORD len;
  95   LPWSTR s;
  96   if (!src) return NULL;
  97   if (slen == -1) slen = strlenW(src);
  98   len = slen;
  99   s = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
 100   memcpy(s, src, len*sizeof(WCHAR));
 101   s[len] = 0;
 102   return s;
 103 }
 104
 105 void RPCRT4_strfree(LPSTR src)
 106 {
 107   HeapFree(GetProcessHeap(), 0, src);
 108 }
 109
 110 static RPC_STATUS RPCRT4_AllocBinding(RpcBinding** Binding, BOOL server)
 111 {
 112   RpcBinding* NewBinding;
 113
 114   NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
 115   NewBinding->refs = 1;
 116   NewBinding->server = server;
 117
 118   *Binding = NewBinding;
 119
 120   return RPC_S_OK;
 121 }
 122
 123 static RPC_STATUS RPCRT4_CreateBindingA(RpcBinding** Binding, BOOL server, LPCSTR Protseq)
 124 {
 125   RpcBinding* NewBinding;
 126
 127   RPCRT4_AllocBinding(&NewBinding, server);
 128   NewBinding->Protseq = RPCRT4_strdupA(Protseq);
 129
 130   TRACE("binding: %p\n", NewBinding);
 131   *Binding = NewBinding;
 132
 133   return RPC_S_OK;
 134 }
 135
 136 static RPC_STATUS RPCRT4_CreateBindingW(RpcBinding** Binding, BOOL server, LPCWSTR Protseq)
 137 {
 138   RpcBinding* NewBinding;
 139
 140   RPCRT4_AllocBinding(&NewBinding, server);
 141   NewBinding->Protseq = RPCRT4_strdupWtoA(Protseq);
 142
 143   TRACE("binding: %p\n", NewBinding);
 144   *Binding = NewBinding;
 145
 146   return RPC_S_OK;
 147 }
 148
 149 static RPC_STATUS RPCRT4_CompleteBindingA(RpcBinding* Binding, LPCSTR NetworkAddr,
 150                                           LPCSTR Endpoint, LPCSTR NetworkOptions)
 151 {
 152   RPC_STATUS status;
 153
 154   TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
 155    debugstr_a(NetworkAddr), debugstr_a(Endpoint), debugstr_a(NetworkOptions));
 156
 157   RPCRT4_strfree(Binding->NetworkAddr);
 158   Binding->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
 159   RPCRT4_strfree(Binding->Endpoint);
 160   if (Endpoint) {
 161     Binding->Endpoint = RPCRT4_strdupA(Endpoint);
 162   } else {
 163     Binding->Endpoint = RPCRT4_strdupA("");
 164   }
 165   HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
 166   Binding->NetworkOptions = RPCRT4_strdupAtoW(NetworkOptions);
 167   if (!Binding->Endpoint) ERR("out of memory?\n");
 168
 169   status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
 170                                  Binding->Endpoint, Binding->NetworkOptions,
 171                                  &Binding->Assoc);
 172   if (status != RPC_S_OK)
 173       return status;
 174
 175   return RPC_S_OK;
 176 }
 177
 178 static RPC_STATUS RPCRT4_CompleteBindingW(RpcBinding* Binding, LPCWSTR NetworkAddr,
 179                                           LPCWSTR Endpoint, LPCWSTR NetworkOptions)
 180 {
 181   RPC_STATUS status;
 182
 183   TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
 184    debugstr_w(NetworkAddr), debugstr_w(Endpoint), debugstr_w(NetworkOptions));
 185
 186   RPCRT4_strfree(Binding->NetworkAddr);
 187   Binding->NetworkAddr = RPCRT4_strdupWtoA(NetworkAddr);
 188   RPCRT4_strfree(Binding->Endpoint);
 189   if (Endpoint) {
 190     Binding->Endpoint = RPCRT4_strdupWtoA(Endpoint);
 191   } else {
 192     Binding->Endpoint = RPCRT4_strdupA("");
 193   }
 194   if (!Binding->Endpoint) ERR("out of memory?\n");
 195   HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
 196   Binding->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
 197
 198   status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
 199                                  Binding->Endpoint, Binding->NetworkOptions,
 200                                  &Binding->Assoc);
 201   if (status != RPC_S_OK)
 202       return status;
 203
 204   return RPC_S_OK;
 205 }
 206
 207 RPC_STATUS RPCRT4_ResolveBinding(RpcBinding* Binding, LPCSTR Endpoint)
 208 {
 209   RPC_STATUS status;
 210
 211   TRACE("(RpcBinding == ^%p, EndPoint == \"%s\"\n", Binding, Endpoint);
 212
 213   RPCRT4_strfree(Binding->Endpoint);
 214   Binding->Endpoint = RPCRT4_strdupA(Endpoint);
 215
 216   RpcAssoc_Release(Binding->Assoc);
 217   Binding->Assoc = NULL;
 218   status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
 219                                  Binding->Endpoint, Binding->NetworkOptions,
 220                                  &Binding->Assoc);
 221   if (status != RPC_S_OK)
 222       return status;
 223
 224   return RPC_S_OK;
 225 }
 226
 227 RPC_STATUS RPCRT4_SetBindingObject(RpcBinding* Binding, const UUID* ObjectUuid)
 228 {
 229   TRACE("(*RpcBinding == ^%p, UUID == %s)\n", Binding, debugstr_guid(ObjectUuid));
 230   if (ObjectUuid) Binding->ObjectUuid = *ObjectUuid;
 231   else UuidCreateNil(&Binding->ObjectUuid);
 232   return RPC_S_OK;
 233 }
 234
 235 RPC_STATUS RPCRT4_MakeBinding(RpcBinding** Binding, RpcConnection* Connection)
 236 {
 237   RpcBinding* NewBinding;
 238   TRACE("(RpcBinding == ^%p, Connection == ^%p)\n", Binding, Connection);
 239
 240   RPCRT4_AllocBinding(&NewBinding, Connection->server);
 241   NewBinding->Protseq = RPCRT4_strdupA(rpcrt4_conn_get_name(Connection));
 242   NewBinding->NetworkAddr = RPCRT4_strdupA(Connection->NetworkAddr);
 243   NewBinding->Endpoint = RPCRT4_strdupA(Connection->Endpoint);
 244   NewBinding->FromConn = Connection;
 245
 246   TRACE("binding: %p\n", NewBinding);
 247   *Binding = NewBinding;
 248
 249   return RPC_S_OK;
 250 }
 251
 252 RPC_STATUS RPCRT4_ExportBinding(RpcBinding** Binding, RpcBinding* OldBinding)
 253 {
 254   InterlockedIncrement(&OldBinding->refs);
 255   *Binding = OldBinding;
 256   return RPC_S_OK;
 257 }
 258
 259 RPC_STATUS RPCRT4_DestroyBinding(RpcBinding* Binding)
 260 {
 261   if (InterlockedDecrement(&Binding->refs))
 262     return RPC_S_OK;
 263
 264   TRACE("binding: %p\n", Binding);
 265   if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
 266   RPCRT4_strfree(Binding->Endpoint);
 267   RPCRT4_strfree(Binding->NetworkAddr);
 268   RPCRT4_strfree(Binding->Protseq);
 269   HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
 270   if (Binding->AuthInfo) RpcAuthInfo_Release(Binding->AuthInfo);
 271   if (Binding->QOS) RpcQualityOfService_Release(Binding->QOS);
 272   HeapFree(GetProcessHeap(), 0, Binding);
 273   return RPC_S_OK;
 274 }
 275
 276 RPC_STATUS RPCRT4_OpenBinding(RpcBinding* Binding, RpcConnection** Connection,
 277                               const RPC_SYNTAX_IDENTIFIER *TransferSyntax,
 278                               const RPC_SYNTAX_IDENTIFIER *InterfaceId)
 279 {
 280   TRACE("(Binding == ^%p)\n", Binding);
 281
 282   if (!Binding->server) {
 283      return RpcAssoc_GetClientConnection(Binding->Assoc, InterfaceId,
 284          TransferSyntax, Binding->AuthInfo, Binding->QOS, Connection);
 285   } else {
 286     /* we already have a connection with acceptable binding, so use it */
 287     if (Binding->FromConn) {
 288       *Connection = Binding->FromConn;
 289       return RPC_S_OK;
 290     } else {
 291        ERR("no connection in binding\n");
 292        return RPC_S_INTERNAL_ERROR;
 293     }
 294   }
 295 }
 296
 297 RPC_STATUS RPCRT4_CloseBinding(RpcBinding* Binding, RpcConnection* Connection)
 298 {
 299   TRACE("(Binding == ^%p)\n", Binding);
 300   if (!Connection) return RPC_S_OK;
 301   if (Binding->server) {
 302     /* don't destroy a connection that is cached in the binding */
 303     if (Binding->FromConn == Connection)
 304       return RPC_S_OK;
 305     return RPCRT4_DestroyConnection(Connection);
 306   }
 307   else {
 308     RpcAssoc_ReleaseIdleConnection(Binding->Assoc, Connection);
 309     return RPC_S_OK;
 310   }
 311 }
 312
 313 /* utility functions for string composing and parsing */
 314 static unsigned RPCRT4_strcopyA(LPSTR data, LPCSTR src)
 315 {
 316   unsigned len = strlen(src);
 317   memcpy(data, src, len*sizeof(CHAR));
 318   return len;
 319 }
 320
 321 static unsigned RPCRT4_strcopyW(LPWSTR data, LPCWSTR src)
 322 {
 323   unsigned len = strlenW(src);
 324   memcpy(data, src, len*sizeof(WCHAR));
 325   return len;
 326 }
 327
 328 static LPSTR RPCRT4_strconcatA(LPSTR dst, LPCSTR src)
 329 {
 330   DWORD len = strlen(dst), slen = strlen(src);
 331   LPSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(CHAR));
 332   if (!ndst)
 333   {
 334     HeapFree(GetProcessHeap(), 0, dst);
 335     return NULL;
 336   }
 337   ndst[len] = ',';
 338   memcpy(ndst+len+1, src, slen+1);
 339   return ndst;
 340 }
 341
 342 static LPWSTR RPCRT4_strconcatW(LPWSTR dst, LPCWSTR src)
 343 {
 344   DWORD len = strlenW(dst), slen = strlenW(src);
 345   LPWSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(WCHAR));
 346   if (!ndst)
 347   {
 348     HeapFree(GetProcessHeap(), 0, dst);
 349     return NULL;
 350   }
 351   ndst[len] = ',';
 352   memcpy(ndst+len+1, src, (slen+1)*sizeof(WCHAR));
 353   return ndst;
 354 }
 355
 356
 357 /***********************************************************************
 358  *             RpcStringBindingComposeA (RPCRT4.@)
 359  */
 360 RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq,
 361                                            RPC_CSTR NetworkAddr, RPC_CSTR Endpoint,
 362                                            RPC_CSTR Options, RPC_CSTR *StringBinding )
 363 {
 364   DWORD len = 1;
 365   LPSTR data;
 366
 367   TRACE( "(%s,%s,%s,%s,%s,%p)\n",
 368         debugstr_a( (char*)ObjUuid ), debugstr_a( (char*)Protseq ),
 369         debugstr_a( (char*)NetworkAddr ), debugstr_a( (char*)Endpoint ),
 370         debugstr_a( (char*)Options ), StringBinding );
 371
 372   if (ObjUuid && *ObjUuid) len += strlen((char*)ObjUuid) + 1;
 373   if (Protseq && *Protseq) len += strlen((char*)Protseq) + 1;
 374   if (NetworkAddr && *NetworkAddr) len += strlen((char*)NetworkAddr);
 375   if (Endpoint && *Endpoint) len += strlen((char*)Endpoint) + 2;
 376   if (Options && *Options) len += strlen((char*)Options) + 2;
 377
 378   data = HeapAlloc(GetProcessHeap(), 0, len);
 379   *StringBinding = (unsigned char*)data;
 380
 381   if (ObjUuid && *ObjUuid) {
 382     data += RPCRT4_strcopyA(data, (char*)ObjUuid);
 383     *data++ = '@';
 384   }
 385   if (Protseq && *Protseq) {
 386     data += RPCRT4_strcopyA(data, (char*)Protseq);
 387     *data++ = ':';
 388   }
 389   if (NetworkAddr && *NetworkAddr)
 390     data += RPCRT4_strcopyA(data, (char*)NetworkAddr);
 391
 392   if ((Endpoint && *Endpoint) ||
 393       (Options && *Options)) {
 394     *data++ = '[';
 395     if (Endpoint && *Endpoint) {
 396       data += RPCRT4_strcopyA(data, (char*)Endpoint);
 397       if (Options && *Options) *data++ = ',';
 398     }
 399     if (Options && *Options) {
 400       data += RPCRT4_strcopyA(data, (char*)Options);
 401     }
 402     *data++ = ']';
 403   }
 404   *data = 0;
 405
 406   return RPC_S_OK;
 407 }
 408
 409 /***********************************************************************
 410  *             RpcStringBindingComposeW (RPCRT4.@)
 411  */
 412 RPC_STATUS WINAPI RpcStringBindingComposeW( RPC_WSTR ObjUuid, RPC_WSTR Protseq,
 413                                             RPC_WSTR NetworkAddr, RPC_WSTR Endpoint,
 414                                             RPC_WSTR Options, RPC_WSTR* StringBinding )
 415 {
 416   DWORD len = 1;
 417   RPC_WSTR data;
 418
 419   TRACE("(%s,%s,%s,%s,%s,%p)\n",
 420        debugstr_w( ObjUuid ), debugstr_w( Protseq ),
 421        debugstr_w( NetworkAddr ), debugstr_w( Endpoint ),
 422        debugstr_w( Options ), StringBinding);
 423
 424   if (ObjUuid && *ObjUuid) len += strlenW(ObjUuid) + 1;
 425   if (Protseq && *Protseq) len += strlenW(Protseq) + 1;
 426   if (NetworkAddr && *NetworkAddr) len += strlenW(NetworkAddr);
 427   if (Endpoint && *Endpoint) len += strlenW(Endpoint) + 2;
 428   if (Options && *Options) len += strlenW(Options) + 2;
 429
 430   data = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 431   *StringBinding = data;
 432
 433   if (ObjUuid && *ObjUuid) {
 434     data += RPCRT4_strcopyW(data, ObjUuid);
 435     *data++ = '@';
 436   }
 437   if (Protseq && *Protseq) {
 438     data += RPCRT4_strcopyW(data, Protseq);
 439     *data++ = ':';
 440   }
 441   if (NetworkAddr && *NetworkAddr) {
 442     data += RPCRT4_strcopyW(data, NetworkAddr);
 443   }
 444   if ((Endpoint && *Endpoint) ||
 445       (Options && *Options)) {
 446     *data++ = '[';
 447     if (Endpoint && *Endpoint) {
 448       data += RPCRT4_strcopyW(data, Endpoint);
 449       if (Options && *Options) *data++ = ',';
 450     }
 451     if (Options && *Options) {
 452       data += RPCRT4_strcopyW(data, Options);
 453     }
 454     *data++ = ']';
 455   }
 456   *data = 0;
 457
 458   return RPC_S_OK;
 459 }
 460
 461
 462 /***********************************************************************
 463  *             RpcStringBindingParseA (RPCRT4.@)
 464  */
 465 RPC_STATUS WINAPI RpcStringBindingParseA( RPC_CSTR StringBinding, RPC_CSTR *ObjUuid,
 466                                           RPC_CSTR *Protseq, RPC_CSTR *NetworkAddr,
 467                                           RPC_CSTR *Endpoint, RPC_CSTR *Options)
 468 {
 469   CHAR *data, *next;
 470   static const char ep_opt[] = "endpoint=";
 471   BOOL endpoint_already_found = FALSE;
 472
 473   TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_a((char*)StringBinding),
 474        ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
 475
 476   if (ObjUuid) *ObjUuid = NULL;
 477   if (Protseq) *Protseq = NULL;
 478   if (NetworkAddr) *NetworkAddr = NULL;
 479   if (Endpoint) *Endpoint = NULL;
 480   if (Options) *Options = NULL;
 481
 482   data = (char*) StringBinding;
 483
 484   next = strchr(data, '@');
 485   if (next) {
 486     if (ObjUuid) *ObjUuid = (unsigned char*)RPCRT4_strndupA(data, next - data);
 487     data = next+1;
 488   }
 489
 490   next = strchr(data, ':');
 491   if (next) {
 492     if (Protseq) *Protseq = (unsigned char*)RPCRT4_strndupA(data, next - data);
 493     data = next+1;
 494   }
 495
 496   next = strchr(data, '[');
 497   if (next) {
 498     CHAR *close, *opt;
 499
 500     if (NetworkAddr) *NetworkAddr = (unsigned char*)RPCRT4_strndupA(data, next - data);
 501     data = next+1;
 502     close = strchr(data, ']');
 503     if (!close) goto fail;
 504
 505     /* tokenize options */
 506     while (data < close) {
 507       next = strchr(data, ',');
 508       if (!next || next > close) next = close;
 509       /* FIXME: this is kind of inefficient */
 510       opt = RPCRT4_strndupA(data, next - data);
 511       data = next+1;
 512
 513       /* parse option */
 514       next = strchr(opt, '=');
 515       if (!next) {
 516         /* not an option, must be an endpoint */
 517         if (endpoint_already_found) goto fail;
 518         if (Endpoint) *Endpoint = (unsigned char*) opt;
 519         else HeapFree(GetProcessHeap(), 0, opt);
 520         endpoint_already_found = TRUE;
 521       } else {
 522         if (strncmp(opt, ep_opt, strlen(ep_opt)) == 0) {
 523           /* endpoint option */
 524           if (endpoint_already_found) goto fail;
 525           if (Endpoint) *Endpoint = (unsigned char*) RPCRT4_strdupA(next+1);
 526           HeapFree(GetProcessHeap(), 0, opt);
 527           endpoint_already_found = TRUE;
 528         } else {
 529           /* network option */
 530           if (Options) {
 531             if (*Options) {
 532               /* FIXME: this is kind of inefficient */
 533               *Options = (unsigned char*) RPCRT4_strconcatA( (char*)*Options, opt);
 534               HeapFree(GetProcessHeap(), 0, opt);
 535             } else
 536               *Options = (unsigned char*) opt;
 537           } else
 538             HeapFree(GetProcessHeap(), 0, opt);
 539         }
 540       }
 541     }
 542
 543     data = close+1;
 544     if (*data) goto fail;
 545   }
 546   else if (NetworkAddr)
 547     *NetworkAddr = (unsigned char*)RPCRT4_strdupA(data);
 548
 549   return RPC_S_OK;
 550
 551 fail:
 552   if (ObjUuid) RpcStringFreeA((unsigned char**)ObjUuid);
 553   if (Protseq) RpcStringFreeA((unsigned char**)Protseq);
 554   if (NetworkAddr) RpcStringFreeA((unsigned char**)NetworkAddr);
 555   if (Endpoint) RpcStringFreeA((unsigned char**)Endpoint);
 556   if (Options) RpcStringFreeA((unsigned char**)Options);
 557   return RPC_S_INVALID_STRING_BINDING;
 558 }
 559
 560 /***********************************************************************
 561  *             RpcStringBindingParseW (RPCRT4.@)
 562  */
 563 RPC_STATUS WINAPI RpcStringBindingParseW( RPC_WSTR StringBinding, RPC_WSTR *ObjUuid,
 564                                           RPC_WSTR *Protseq, RPC_WSTR *NetworkAddr,
 565                                           RPC_WSTR *Endpoint, RPC_WSTR *Options)
 566 {
 567   WCHAR *data, *next;
 568   static const WCHAR ep_opt[] = {'e','n','d','p','o','i','n','t','=',0};
 569   BOOL endpoint_already_found = FALSE;
 570
 571   TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_w(StringBinding),
 572        ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
 573
 574   if (ObjUuid) *ObjUuid = NULL;
 575   if (Protseq) *Protseq = NULL;
 576   if (NetworkAddr) *NetworkAddr = NULL;
 577   if (Endpoint) *Endpoint = NULL;
 578   if (Options) *Options = NULL;
 579
 580   data = StringBinding;
 581
 582   next = strchrW(data, '@');
 583   if (next) {
 584     if (ObjUuid) *ObjUuid = RPCRT4_strndupW(data, next - data);
 585     data = next+1;
 586   }
 587
 588   next = strchrW(data, ':');
 589   if (next) {
 590     if (Protseq) *Protseq = RPCRT4_strndupW(data, next - data);
 591     data = next+1;
 592   }
 593
 594   next = strchrW(data, '[');
 595   if (next) {
 596     WCHAR *close, *opt;
 597
 598     if (NetworkAddr) *NetworkAddr = RPCRT4_strndupW(data, next - data);
 599     data = next+1;
 600     close = strchrW(data, ']');
 601     if (!close) goto fail;
 602
 603     /* tokenize options */
 604     while (data < close) {
 605       next = strchrW(data, ',');
 606       if (!next || next > close) next = close;
 607       /* FIXME: this is kind of inefficient */
 608       opt = RPCRT4_strndupW(data, next - data);
 609       data = next+1;
 610
 611       /* parse option */
 612       next = strchrW(opt, '=');
 613       if (!next) {
 614         /* not an option, must be an endpoint */
 615         if (endpoint_already_found) goto fail;
 616         if (Endpoint) *Endpoint = opt;
 617         else HeapFree(GetProcessHeap(), 0, opt);
 618         endpoint_already_found = TRUE;
 619       } else {
 620         if (strncmpW(opt, ep_opt, strlenW(ep_opt)) == 0) {
 621           /* endpoint option */
 622           if (endpoint_already_found) goto fail;
 623           if (Endpoint) *Endpoint = RPCRT4_strdupW(next+1);
 624           HeapFree(GetProcessHeap(), 0, opt);
 625           endpoint_already_found = TRUE;
 626         } else {
 627           /* network option */
 628           if (Options) {
 629             if (*Options) {
 630               /* FIXME: this is kind of inefficient */
 631               *Options = RPCRT4_strconcatW(*Options, opt);
 632               HeapFree(GetProcessHeap(), 0, opt);
 633             } else
 634               *Options = opt;
 635           } else
 636             HeapFree(GetProcessHeap(), 0, opt);
 637         }
 638       }
 639     }
 640
 641     data = close+1;
 642     if (*data) goto fail;
 643   } else if (NetworkAddr)
 644     *NetworkAddr = RPCRT4_strdupW(data);
 645
 646   return RPC_S_OK;
 647
 648 fail:
 649   if (ObjUuid) RpcStringFreeW(ObjUuid);
 650   if (Protseq) RpcStringFreeW(Protseq);
 651   if (NetworkAddr) RpcStringFreeW(NetworkAddr);
 652   if (Endpoint) RpcStringFreeW(Endpoint);
 653   if (Options) RpcStringFreeW(Options);
 654   return RPC_S_INVALID_STRING_BINDING;
 655 }
 656
 657 /***********************************************************************
 658  *             RpcBindingFree (RPCRT4.@)
 659  */
 660 RPC_STATUS WINAPI RpcBindingFree( RPC_BINDING_HANDLE* Binding )
 661 {
 662   RPC_STATUS status;
 663   TRACE("(%p) = %p\n", Binding, *Binding);
 664   status = RPCRT4_DestroyBinding(*Binding);
 665   if (status == RPC_S_OK) *Binding = 0;
 666   return status;
 667 }
 668
 669 /***********************************************************************
 670  *             RpcBindingVectorFree (RPCRT4.@)
 671  */
 672 RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector )
 673 {
 674   RPC_STATUS status;
 675   unsigned long c;
 676
 677   TRACE("(%p)\n", BindingVector);
 678   for (c=0; c<(*BindingVector)->Count; c++) {
 679     status = RpcBindingFree(&(*BindingVector)->BindingH[c]);
 680   }
 681   HeapFree(GetProcessHeap(), 0, *BindingVector);
 682   *BindingVector = NULL;
 683   return RPC_S_OK;
 684 }
 685
 686 /***********************************************************************
 687  *             RpcBindingInqObject (RPCRT4.@)
 688  */
 689 RPC_STATUS WINAPI RpcBindingInqObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
 690 {
 691   RpcBinding* bind = (RpcBinding*)Binding;
 692
 693   TRACE("(%p,%p) = %s\n", Binding, ObjectUuid, debugstr_guid(&bind->ObjectUuid));
 694   *ObjectUuid = bind->ObjectUuid;
 695   return RPC_S_OK;
 696 }
 697
 698 /***********************************************************************
 699  *             RpcBindingSetObject (RPCRT4.@)
 700  */
 701 RPC_STATUS WINAPI RpcBindingSetObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
 702 {
 703   RpcBinding* bind = (RpcBinding*)Binding;
 704
 705   TRACE("(%p,%s)\n", Binding, debugstr_guid(ObjectUuid));
 706   if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
 707   return RPCRT4_SetBindingObject(Binding, ObjectUuid);
 708 }
 709
 710 /***********************************************************************
 711  *             RpcBindingFromStringBindingA (RPCRT4.@)
 712  */
 713 RPC_STATUS WINAPI RpcBindingFromStringBindingA( RPC_CSTR StringBinding, RPC_BINDING_HANDLE* Binding )
 714 {
 715   RPC_STATUS ret;
 716   RpcBinding* bind = NULL;
 717   RPC_CSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
 718   UUID Uuid;
 719
 720   TRACE("(%s,%p)\n", debugstr_a((char*)StringBinding), Binding);
 721
 722   ret = RpcStringBindingParseA(StringBinding, &ObjectUuid, &Protseq,
 723                               &NetworkAddr, &Endpoint, &Options);
 724   if (ret != RPC_S_OK) return ret;
 725
 726   ret = UuidFromStringA(ObjectUuid, &Uuid);
 727
 728   if (ret == RPC_S_OK)
 729     ret = RPCRT4_CreateBindingA(&bind, FALSE, (char*)Protseq);
 730   if (ret == RPC_S_OK)
 731     ret = RPCRT4_SetBindingObject(bind, &Uuid);
 732   if (ret == RPC_S_OK)
 733     ret = RPCRT4_CompleteBindingA(bind, (char*)NetworkAddr, (char*)Endpoint, (char*)Options);
 734
 735   RpcStringFreeA((unsigned char**)&Options);
 736   RpcStringFreeA((unsigned char**)&Endpoint);
 737   RpcStringFreeA((unsigned char**)&NetworkAddr);
 738   RpcStringFreeA((unsigned char**)&Protseq);
 739   RpcStringFreeA((unsigned char**)&ObjectUuid);
 740
 741   if (ret == RPC_S_OK)
 742     *Binding = (RPC_BINDING_HANDLE)bind;
 743   else
 744     RPCRT4_DestroyBinding(bind);
 745
 746   return ret;
 747 }
 748
 749 /***********************************************************************
 750  *             RpcBindingFromStringBindingW (RPCRT4.@)
 751  */
 752 RPC_STATUS WINAPI RpcBindingFromStringBindingW( RPC_WSTR StringBinding, RPC_BINDING_HANDLE* Binding )
 753 {
 754   RPC_STATUS ret;
 755   RpcBinding* bind = NULL;
 756   RPC_WSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
 757   UUID Uuid;
 758
 759   TRACE("(%s,%p)\n", debugstr_w(StringBinding), Binding);
 760
 761   ret = RpcStringBindingParseW(StringBinding, &ObjectUuid, &Protseq,
 762                               &NetworkAddr, &Endpoint, &Options);
 763   if (ret != RPC_S_OK) return ret;
 764
 765   ret = UuidFromStringW(ObjectUuid, &Uuid);
 766
 767   if (ret == RPC_S_OK)
 768     ret = RPCRT4_CreateBindingW(&bind, FALSE, Protseq);
 769   if (ret == RPC_S_OK)
 770     ret = RPCRT4_SetBindingObject(bind, &Uuid);
 771   if (ret == RPC_S_OK)
 772     ret = RPCRT4_CompleteBindingW(bind, NetworkAddr, Endpoint, Options);
 773
 774   RpcStringFreeW(&Options);
 775   RpcStringFreeW(&Endpoint);
 776   RpcStringFreeW(&NetworkAddr);
 777   RpcStringFreeW(&Protseq);
 778   RpcStringFreeW(&ObjectUuid);
 779
 780   if (ret == RPC_S_OK)
 781     *Binding = (RPC_BINDING_HANDLE)bind;
 782   else
 783     RPCRT4_DestroyBinding(bind);
 784
 785   return ret;
 786 }
 787
 788 /***********************************************************************
 789  *             RpcBindingToStringBindingA (RPCRT4.@)
 790  */
 791 RPC_STATUS WINAPI RpcBindingToStringBindingA( RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding )
 792 {
 793   RPC_STATUS ret;
 794   RpcBinding* bind = (RpcBinding*)Binding;
 795   RPC_CSTR ObjectUuid;
 796
 797   TRACE("(%p,%p)\n", Binding, StringBinding);
 798
 799   ret = UuidToStringA(&bind->ObjectUuid, &ObjectUuid);
 800   if (ret != RPC_S_OK) return ret;
 801
 802   ret = RpcStringBindingComposeA(ObjectUuid, (unsigned char*)bind->Protseq, (unsigned char*) bind->NetworkAddr,
 803                                  (unsigned char*) bind->Endpoint, NULL, StringBinding);
 804
 805   RpcStringFreeA(&ObjectUuid);
 806
 807   return ret;
 808 }
 809
 810 /***********************************************************************
 811  *             RpcBindingToStringBindingW (RPCRT4.@)
 812  */
 813 RPC_STATUS WINAPI RpcBindingToStringBindingW( RPC_BINDING_HANDLE Binding, RPC_WSTR *StringBinding )
 814 {
 815   RPC_STATUS ret;
 816   unsigned char *str = NULL;
 817   TRACE("(%p,%p)\n", Binding, StringBinding);
 818   ret = RpcBindingToStringBindingA(Binding, &str);
 819   *StringBinding = RPCRT4_strdupAtoW((char*)str);
 820   RpcStringFreeA((unsigned char**)&str);
 821   return ret;
 822 }
 823
 824 /***********************************************************************
 825  *             I_RpcBindingSetAsync (RPCRT4.@)
 826  * NOTES
 827  *  Exists in win9x and winNT, but with different number of arguments
 828  *  (9x version has 3 arguments, NT has 2).
 829  */
 830 RPC_STATUS WINAPI I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn)
 831 {
 832   RpcBinding* bind = (RpcBinding*)Binding;
 833
 834   TRACE( "(%p,%p): stub\n", Binding, BlockingFn );
 835
 836   bind->BlockingFn = BlockingFn;
 837
 838   return RPC_S_OK;
 839 }
 840
 841 /***********************************************************************
 842  *             RpcBindingCopy (RPCRT4.@)
 843  */
 844 RPC_STATUS RPC_ENTRY RpcBindingCopy(
 845   RPC_BINDING_HANDLE SourceBinding,
 846   RPC_BINDING_HANDLE* DestinationBinding)
 847 {
 848   RpcBinding *DestBinding;
 849   RpcBinding *SrcBinding = (RpcBinding*)SourceBinding;
 850   RPC_STATUS status;
 851
 852   TRACE("(%p, %p)\n", SourceBinding, DestinationBinding);
 853
 854   status = RPCRT4_AllocBinding(&DestBinding, SrcBinding->server);
 855   if (status != RPC_S_OK) return status;
 856
 857   DestBinding->ObjectUuid = SrcBinding->ObjectUuid;
 858   DestBinding->BlockingFn = SrcBinding->BlockingFn;
 859   DestBinding->Protseq = RPCRT4_strndupA(SrcBinding->Protseq, -1);
 860   DestBinding->NetworkAddr = RPCRT4_strndupA(SrcBinding->NetworkAddr, -1);
 861   DestBinding->Endpoint = RPCRT4_strndupA(SrcBinding->Endpoint, -1);
 862   DestBinding->NetworkOptions = RPCRT4_strdupW(SrcBinding->NetworkOptions);
 863   if (SrcBinding->Assoc) SrcBinding->Assoc->refs++;
 864   DestBinding->Assoc = SrcBinding->Assoc;
 865
 866   if (SrcBinding->AuthInfo) RpcAuthInfo_AddRef(SrcBinding->AuthInfo);
 867   DestBinding->AuthInfo = SrcBinding->AuthInfo;
 868   if (SrcBinding->QOS) RpcQualityOfService_AddRef(SrcBinding->QOS);
 869   DestBinding->QOS = SrcBinding->QOS;
 870
 871   *DestinationBinding = DestBinding;
 872   return RPC_S_OK;
 873 }
 874
 875 /***********************************************************************
 876  *             RpcImpersonateClient (RPCRT4.@)
 877  *
 878  * Impersonates the client connected via a binding handle so that security
 879  * checks are done in the context of the client.
 880  *
 881  * PARAMS
 882  *  BindingHandle [I] Handle to the binding to the client.
 883  *
 884  * RETURNS
 885  *  Success: RPS_S_OK.
 886  *  Failure: RPC_STATUS value.
 887  *
 888  * NOTES
 889  *
 890  * If BindingHandle is NULL then the function impersonates the client
 891  * connected to the binding handle of the current thread.
 892  */
 893 RPC_STATUS WINAPI RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
 894 {
 895     FIXME("(%p): stub\n", BindingHandle);
 896     ImpersonateSelf(SecurityImpersonation);
 897     return RPC_S_OK;
 898 }
 899
 900 /***********************************************************************
 901  *             RpcRevertToSelfEx (RPCRT4.@)
 902  *
 903  * Stops impersonating the client connected to the binding handle so that security
 904  * checks are no longer done in the context of the client.
 905  *
 906  * PARAMS
 907  *  BindingHandle [I] Handle to the binding to the client.
 908  *
 909  * RETURNS
 910  *  Success: RPS_S_OK.
 911  *  Failure: RPC_STATUS value.
 912  *
 913  * NOTES
 914  *
 915  * If BindingHandle is NULL then the function stops impersonating the client
 916  * connected to the binding handle of the current thread.
 917  */
 918 RPC_STATUS WINAPI RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)
 919 {
 920     FIXME("(%p): stub\n", BindingHandle);
 921     return RPC_S_OK;
 922 }
 923
 924 static inline BOOL has_nt_auth_identity(ULONG AuthnLevel)
 925 {
 926     switch (AuthnLevel)
 927     {
 928     case RPC_C_AUTHN_GSS_NEGOTIATE:
 929     case RPC_C_AUTHN_WINNT:
 930     case RPC_C_AUTHN_GSS_KERBEROS:
 931         return TRUE;
 932     default:
 933         return FALSE;
 934     }
 935 }
 936
 937 static RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc,
 938                                      CredHandle cred, TimeStamp exp,
 939                                      ULONG cbMaxToken,
 940                                      RPC_AUTH_IDENTITY_HANDLE identity,
 941                                      RpcAuthInfo **ret)
 942 {
 943     RpcAuthInfo *AuthInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo));
 944     if (!AuthInfo)
 945         return ERROR_OUTOFMEMORY;
 946
 947     AuthInfo->refs = 1;
 948     AuthInfo->AuthnLevel = AuthnLevel;
 949     AuthInfo->AuthnSvc = AuthnSvc;
 950     AuthInfo->cred = cred;
 951     AuthInfo->exp = exp;
 952     AuthInfo->cbMaxToken = cbMaxToken;
 953     AuthInfo->identity = identity;
 954     AuthInfo->server_principal_name = NULL;
 955
 956     /* duplicate the SEC_WINNT_AUTH_IDENTITY structure, if applicable, to
 957      * enable better matching in RpcAuthInfo_IsEqual */
 958     if (identity && has_nt_auth_identity(AuthnSvc))
 959     {
 960         const SEC_WINNT_AUTH_IDENTITY_W *nt_identity = identity;
 961         AuthInfo->nt_identity = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo->nt_identity));
 962         if (!AuthInfo->nt_identity)
 963         {
 964             HeapFree(GetProcessHeap(), 0, AuthInfo);
 965             return ERROR_OUTOFMEMORY;
 966         }
 967
 968         AuthInfo->nt_identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
 969         if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
 970             AuthInfo->nt_identity->User = RPCRT4_strndupW(nt_identity->User, nt_identity->UserLength);
 971         else
 972             AuthInfo->nt_identity->User = RPCRT4_strndupAtoW((const char *)nt_identity->User, nt_identity->UserLength);
 973         AuthInfo->nt_identity->UserLength = nt_identity->UserLength;
 974         if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
 975             AuthInfo->nt_identity->Domain = RPCRT4_strndupW(nt_identity->Domain, nt_identity->DomainLength);
 976         else
 977             AuthInfo->nt_identity->Domain = RPCRT4_strndupAtoW((const char *)nt_identity->Domain, nt_identity->DomainLength);
 978         AuthInfo->nt_identity->DomainLength = nt_identity->DomainLength;
 979         if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
 980             AuthInfo->nt_identity->Password = RPCRT4_strndupW(nt_identity->Password, nt_identity->PasswordLength);
 981         else
 982             AuthInfo->nt_identity->Password = RPCRT4_strndupAtoW((const char *)nt_identity->Password, nt_identity->PasswordLength);
 983         AuthInfo->nt_identity->PasswordLength = nt_identity->PasswordLength;
 984
 985         if ((nt_identity->User && !AuthInfo->nt_identity->User) ||
 986             (nt_identity->Domain && !AuthInfo->nt_identity->Domain) ||
 987             (nt_identity->Password && !AuthInfo->nt_identity->Password))
 988         {
 989             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
 990             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
 991             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
 992             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
 993             HeapFree(GetProcessHeap(), 0, AuthInfo);
 994             return ERROR_OUTOFMEMORY;
 995         }
 996     }
 997     else
 998         AuthInfo->nt_identity = NULL;
 999     *ret = AuthInfo;
1000     return RPC_S_OK;
1001 }
1002
1003 ULONG RpcAuthInfo_AddRef(RpcAuthInfo *AuthInfo)
1004 {
1005     return InterlockedIncrement(&AuthInfo->refs);
1006 }
1007
1008 ULONG RpcAuthInfo_Release(RpcAuthInfo *AuthInfo)
1009 {
1010     ULONG refs = InterlockedDecrement(&AuthInfo->refs);
1011
1012     if (!refs)
1013     {
1014         FreeCredentialsHandle(&AuthInfo->cred);
1015         if (AuthInfo->nt_identity)
1016         {
1017             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
1018             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
1019             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
1020             HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
1021         }
1022         HeapFree(GetProcessHeap(), 0, AuthInfo->server_principal_name);
1023         HeapFree(GetProcessHeap(), 0, AuthInfo);
1024     }
1025
1026     return refs;
1027 }
1028
1029 BOOL RpcAuthInfo_IsEqual(const RpcAuthInfo *AuthInfo1, const RpcAuthInfo *AuthInfo2)
1030 {
1031     if (AuthInfo1 == AuthInfo2)
1032         return TRUE;
1033
1034     if (!AuthInfo1 || !AuthInfo2)
1035         return FALSE;
1036
1037     if ((AuthInfo1->AuthnLevel != AuthInfo2->AuthnLevel) ||
1038         (AuthInfo1->AuthnSvc != AuthInfo2->AuthnSvc))
1039         return FALSE;
1040
1041     if (AuthInfo1->identity == AuthInfo2->identity)
1042         return TRUE;
1043
1044     if (!AuthInfo1->identity || !AuthInfo2->identity)
1045         return FALSE;
1046
1047     if (has_nt_auth_identity(AuthInfo1->AuthnSvc))
1048     {
1049         const SEC_WINNT_AUTH_IDENTITY_W *identity1 = AuthInfo1->nt_identity;
1050         const SEC_WINNT_AUTH_IDENTITY_W *identity2 = AuthInfo2->nt_identity;
1051         /* compare user names */
1052         if (identity1->UserLength != identity2->UserLength ||
1053             memcmp(identity1->User, identity2->User, identity1->UserLength))
1054             return FALSE;
1055         /* compare domain names */
1056         if (identity1->DomainLength != identity2->DomainLength ||
1057             memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1058             return FALSE;
1059         /* compare passwords */
1060         if (identity1->PasswordLength != identity2->PasswordLength ||
1061             memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1062             return FALSE;
1063     }
1064     else
1065         return FALSE;
1066
1067     return TRUE;
1068 }
1069
1070 static RPC_STATUS RpcQualityOfService_Create(const RPC_SECURITY_QOS *qos_src, BOOL unicode, RpcQualityOfService **qos_dst)
1071 {
1072     RpcQualityOfService *qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos));
1073
1074     if (!qos)
1075         return RPC_S_OUT_OF_RESOURCES;
1076
1077     qos->refs = 1;
1078     qos->qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos->qos));
1079     if (!qos->qos) goto error;
1080     qos->qos->Version = qos_src->Version;
1081     qos->qos->Capabilities = qos_src->Capabilities;
1082     qos->qos->IdentityTracking = qos_src->IdentityTracking;
1083     qos->qos->ImpersonationType = qos_src->ImpersonationType;
1084     qos->qos->AdditionalSecurityInfoType = 0;
1085
1086     if (qos_src->Version >= 2)
1087     {
1088         const RPC_SECURITY_QOS_V2_W *qos_src2 = (const RPC_SECURITY_QOS_V2_W *)qos_src;
1089         qos->qos->AdditionalSecurityInfoType = qos_src2->AdditionalSecurityInfoType;
1090         if (qos_src2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1091         {
1092             const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_src = qos_src2->u.HttpCredentials;
1093             RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_dst;
1094
1095             http_credentials_dst = HeapAlloc(GetProcessHeap(), 0, sizeof(*http_credentials_dst));
1096             qos->qos->u.HttpCredentials = http_credentials_dst;
1097             if (!http_credentials_dst) goto error;
1098             http_credentials_dst->TransportCredentials = NULL;
1099             http_credentials_dst->Flags = http_credentials_src->Flags;
1100             http_credentials_dst->AuthenticationTarget = http_credentials_src->AuthenticationTarget;
1101             http_credentials_dst->NumberOfAuthnSchemes = http_credentials_src->NumberOfAuthnSchemes;
1102             http_credentials_dst->AuthnSchemes = NULL;
1103             http_credentials_dst->ServerCertificateSubject = NULL;
1104             if (http_credentials_src->TransportCredentials)
1105             {
1106                 SEC_WINNT_AUTH_IDENTITY_W *cred_dst;
1107                 cred_dst = http_credentials_dst->TransportCredentials = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cred_dst));
1108                 if (!cred_dst) goto error;
1109                 cred_dst->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1110                 if (unicode)
1111                 {
1112                     const SEC_WINNT_AUTH_IDENTITY_W *cred_src = http_credentials_src->TransportCredentials;
1113                     cred_dst->UserLength = cred_src->UserLength;
1114                     cred_dst->PasswordLength = cred_src->PasswordLength;
1115                     cred_dst->DomainLength = cred_src->DomainLength;
1116                     cred_dst->User = RPCRT4_strndupW(cred_src->User, cred_src->UserLength);
1117                     cred_dst->Password = RPCRT4_strndupW(cred_src->Password, cred_src->PasswordLength);
1118                     cred_dst->Domain = RPCRT4_strndupW(cred_src->Domain, cred_src->DomainLength);
1119                 }
1120                 else
1121                 {
1122                     const SEC_WINNT_AUTH_IDENTITY_A *cred_src = (const SEC_WINNT_AUTH_IDENTITY_A *)http_credentials_src->TransportCredentials;
1123                     cred_dst->UserLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, NULL, 0);
1124                     cred_dst->DomainLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, NULL, 0);
1125                     cred_dst->PasswordLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, NULL, 0);
1126                     cred_dst->User = HeapAlloc(GetProcessHeap(), 0, cred_dst->UserLength * sizeof(WCHAR));
1127                     cred_dst->Password = HeapAlloc(GetProcessHeap(), 0, cred_dst->PasswordLength * sizeof(WCHAR));
1128                     cred_dst->Domain = HeapAlloc(GetProcessHeap(), 0, cred_dst->DomainLength * sizeof(WCHAR));
1129                     if (!cred_dst || !cred_dst->Password || !cred_dst->Domain) goto error;
1130                     MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, cred_dst->User, cred_dst->UserLength);
1131                     MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, cred_dst->Domain, cred_dst->DomainLength);
1132                     MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, cred_dst->Password, cred_dst->PasswordLength);
1133                 }
1134             }
1135             if (http_credentials_src->NumberOfAuthnSchemes)
1136             {
1137                 http_credentials_dst->AuthnSchemes = HeapAlloc(GetProcessHeap(), 0, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1138                 if (!http_credentials_dst->AuthnSchemes) goto error;
1139                 memcpy(http_credentials_dst->AuthnSchemes, http_credentials_src->AuthnSchemes, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1140             }
1141             if (http_credentials_src->ServerCertificateSubject)
1142             {
1143                 if (unicode)
1144                     http_credentials_dst->ServerCertificateSubject =
1145                         RPCRT4_strndupW(http_credentials_src->ServerCertificateSubject,
1146                                         strlenW(http_credentials_src->ServerCertificateSubject));
1147                 else
1148                     http_credentials_dst->ServerCertificateSubject =
1149                         RPCRT4_strdupAtoW((char *)http_credentials_src->ServerCertificateSubject);
1150                 if (!http_credentials_dst->ServerCertificateSubject) goto error;
1151             }
1152         }
1153     }
1154     *qos_dst = qos;
1155     return RPC_S_OK;
1156
1157 error:
1158     if (qos->qos)
1159     {
1160         if (qos->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP &&
1161             qos->qos->u.HttpCredentials)
1162         {
1163             if (qos->qos->u.HttpCredentials->TransportCredentials)
1164             {
1165                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->User);
1166                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Domain);
1167                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Password);
1168                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials);
1169             }
1170             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->AuthnSchemes);
1171             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->ServerCertificateSubject);
1172             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials);
1173         }
1174         HeapFree(GetProcessHeap(), 0, qos->qos);
1175     }
1176     HeapFree(GetProcessHeap(), 0, qos);
1177     return RPC_S_OUT_OF_RESOURCES;
1178 }
1179
1180 ULONG RpcQualityOfService_AddRef(RpcQualityOfService *qos)
1181 {
1182     return InterlockedIncrement(&qos->refs);
1183 }
1184
1185 ULONG RpcQualityOfService_Release(RpcQualityOfService *qos)
1186 {
1187     ULONG refs = InterlockedDecrement(&qos->refs);
1188
1189     if (!refs)
1190     {
1191         if (qos->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1192         {
1193             if (qos->qos->u.HttpCredentials->TransportCredentials)
1194             {
1195                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->User);
1196                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Domain);
1197                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Password);
1198                 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials);
1199             }
1200             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->AuthnSchemes);
1201             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->ServerCertificateSubject);
1202             HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials);
1203         }
1204         HeapFree(GetProcessHeap(), 0, qos->qos);
1205         HeapFree(GetProcessHeap(), 0, qos);
1206     }
1207     return refs;
1208 }
1209
1210 BOOL RpcQualityOfService_IsEqual(const RpcQualityOfService *qos1, const RpcQualityOfService *qos2)
1211 {
1212     if (qos1 == qos2)
1213         return TRUE;
1214
1215     if (!qos1 || !qos2)
1216         return FALSE;
1217
1218     TRACE("qos1 = { %ld %ld %ld %ld }, qos2 = { %ld %ld %ld %ld }\n",
1219         qos1->qos->Capabilities, qos1->qos->IdentityTracking,
1220         qos1->qos->ImpersonationType, qos1->qos->AdditionalSecurityInfoType,
1221         qos2->qos->Capabilities, qos2->qos->IdentityTracking,
1222         qos2->qos->ImpersonationType, qos2->qos->AdditionalSecurityInfoType);
1223
1224     if ((qos1->qos->Capabilities != qos2->qos->Capabilities) ||
1225         (qos1->qos->IdentityTracking != qos2->qos->IdentityTracking) ||
1226         (qos1->qos->ImpersonationType != qos2->qos->ImpersonationType) ||
1227         (qos1->qos->AdditionalSecurityInfoType != qos2->qos->AdditionalSecurityInfoType))
1228         return FALSE;
1229
1230     if (qos1->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1231     {
1232         const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials1 = qos1->qos->u.HttpCredentials;
1233         const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials2 = qos2->qos->u.HttpCredentials;
1234
1235         if (http_credentials1->Flags != http_credentials2->Flags)
1236             return FALSE;
1237
1238         if (http_credentials1->AuthenticationTarget != http_credentials2->AuthenticationTarget)
1239             return FALSE;
1240
1241         /* authentication schemes and server certificate subject not currently used */
1242
1243         if (http_credentials1->TransportCredentials != http_credentials2->TransportCredentials)
1244         {
1245             const SEC_WINNT_AUTH_IDENTITY_W *identity1 = http_credentials1->TransportCredentials;
1246             const SEC_WINNT_AUTH_IDENTITY_W *identity2 = http_credentials2->TransportCredentials;
1247
1248             if (!identity1 || !identity2)
1249                 return FALSE;
1250
1251             /* compare user names */
1252             if (identity1->UserLength != identity2->UserLength ||
1253                 memcmp(identity1->User, identity2->User, identity1->UserLength))
1254                 return FALSE;
1255             /* compare domain names */
1256             if (identity1->DomainLength != identity2->DomainLength ||
1257                 memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1258                 return FALSE;
1259             /* compare passwords */
1260             if (identity1->PasswordLength != identity2->PasswordLength ||
1261                 memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1262                 return FALSE;
1263         }
1264     }
1265
1266     return TRUE;
1267 }
1268
1269 /***********************************************************************
1270  *             RpcRevertToSelf (RPCRT4.@)
1271  */
1272 RPC_STATUS WINAPI RpcRevertToSelf(void)
1273 {
1274     FIXME("stub\n");
1275     RevertToSelf();
1276     return RPC_S_OK;
1277 }
1278
1279 /***********************************************************************
1280  *             RpcMgmtSetComTimeout (RPCRT4.@)
1281  */
1282 RPC_STATUS WINAPI RpcMgmtSetComTimeout(RPC_BINDING_HANDLE BindingHandle, unsigned int Timeout)
1283 {
1284     FIXME("(%p, %d): stub\n", BindingHandle, Timeout);
1285     return RPC_S_OK;
1286 }
1287
1288 /***********************************************************************
1289  *             RpcBindingInqAuthInfoExA (RPCRT4.@)
1290  */
1291 RPCRTAPI RPC_STATUS RPC_ENTRY
1292 RpcBindingInqAuthInfoExA( RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel,
1293                           ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
1294                           ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
1295 {
1296     FIXME("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1297           AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1298     return RPC_S_INVALID_BINDING;
1299 }
1300
1301 /***********************************************************************
1302  *             RpcBindingInqAuthInfoExW (RPCRT4.@)
1303  */
1304 RPCRTAPI RPC_STATUS RPC_ENTRY
1305 RpcBindingInqAuthInfoExW( RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel,
1306                           ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
1307                           ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
1308 {
1309     FIXME("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1310           AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1311     return RPC_S_INVALID_BINDING;
1312 }
1313
1314 /***********************************************************************
1315  *             RpcBindingInqAuthInfoA (RPCRT4.@)
1316  */
1317 RPCRTAPI RPC_STATUS RPC_ENTRY
1318 RpcBindingInqAuthInfoA( RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel,
1319                         ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
1320 {
1321     FIXME("%p %p %p %p %p %p\n", Binding, ServerPrincName, AuthnLevel,
1322           AuthnSvc, AuthIdentity, AuthzSvc);
1323     return RPC_S_INVALID_BINDING;
1324 }
1325
1326 /***********************************************************************
1327  *             RpcBindingInqAuthInfoW (RPCRT4.@)
1328  */
1329 RPCRTAPI RPC_STATUS RPC_ENTRY
1330 RpcBindingInqAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel,
1331                         ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
1332 {
1333     FIXME("%p %p %p %p %p %p\n", Binding, ServerPrincName, AuthnLevel,
1334           AuthnSvc, AuthIdentity, AuthzSvc);
1335     return RPC_S_INVALID_BINDING;
1336 }
1337
1338 /***********************************************************************
1339  *             RpcBindingSetAuthInfoExA (RPCRT4.@)
1340  */
1341 RPCRTAPI RPC_STATUS RPC_ENTRY
1342 RpcBindingSetAuthInfoExA( RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName,
1343                           ULONG AuthnLevel, ULONG AuthnSvc,
1344                           RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
1345                           RPC_SECURITY_QOS *SecurityQos )
1346 {
1347   RpcBinding* bind = (RpcBinding*)Binding;
1348   SECURITY_STATUS r;
1349   CredHandle cred;
1350   TimeStamp exp;
1351   ULONG package_count;
1352   ULONG i;
1353   PSecPkgInfoA packages;
1354   ULONG cbMaxToken;
1355
1356   TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_a((const char*)ServerPrincName),
1357         AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1358
1359   if (SecurityQos)
1360   {
1361       RPC_STATUS status;
1362
1363       TRACE("SecurityQos { Version=%ld, Capabilties=0x%lx, IdentityTracking=%ld, ImpersonationLevel=%ld",
1364             SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1365       if (SecurityQos->Version >= 2)
1366       {
1367           const RPC_SECURITY_QOS_V2_A *SecurityQos2 = (const RPC_SECURITY_QOS_V2_A *)SecurityQos;
1368           TRACE(", AdditionalSecurityInfoType=%ld", SecurityQos2->AdditionalSecurityInfoType);
1369           if (SecurityQos2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1370               TRACE(", { %p, 0x%lx, %ld, %ld, %p, %s }",
1371                     SecurityQos2->u.HttpCredentials->TransportCredentials,
1372                     SecurityQos2->u.HttpCredentials->Flags,
1373                     SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1374                     SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1375                     SecurityQos2->u.HttpCredentials->AuthnSchemes,
1376                     SecurityQos2->u.HttpCredentials->ServerCertificateSubject);
1377       }
1378       TRACE("}\n");
1379       status = RpcQualityOfService_Create(SecurityQos, FALSE, &bind->QOS);
1380       if (status != RPC_S_OK)
1381           return status;
1382   }
1383   else
1384   {
1385       if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1386       bind->QOS = NULL;
1387   }
1388
1389   if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1390     AuthnSvc = RPC_C_AUTHN_WINNT;
1391
1392   /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1393   if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1394     AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1395
1396   if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1397   {
1398     if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1399     bind->AuthInfo = NULL;
1400     return RPC_S_OK;
1401   }
1402
1403   if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1404   {
1405     FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1406     return RPC_S_UNKNOWN_AUTHN_LEVEL;
1407   }
1408
1409   if (AuthzSvr)
1410   {
1411     FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1412     return RPC_S_UNKNOWN_AUTHZ_SERVICE;
1413   }
1414
1415   r = EnumerateSecurityPackagesA(&package_count, &packages);
1416   if (r != SEC_E_OK)
1417   {
1418     ERR("EnumerateSecurityPackagesA failed with error 0x%08x\n", r);
1419     return RPC_S_SEC_PKG_ERROR;
1420   }
1421
1422   for (i = 0; i < package_count; i++)
1423     if (packages[i].wRPCID == AuthnSvc)
1424         break;
1425
1426   if (i == package_count)
1427   {
1428     FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1429     FreeContextBuffer(packages);
1430     return RPC_S_UNKNOWN_AUTHN_SERVICE;
1431   }
1432
1433   TRACE("found package %s for service %u\n", packages[i].Name, AuthnSvc);
1434   r = AcquireCredentialsHandleA(NULL, packages[i].Name, SECPKG_CRED_OUTBOUND, NULL,
1435                                 AuthIdentity, NULL, NULL, &cred, &exp);
1436   cbMaxToken = packages[i].cbMaxToken;
1437   FreeContextBuffer(packages);
1438   if (r == ERROR_SUCCESS)
1439   {
1440     RpcAuthInfo *new_auth_info;
1441     r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1442                            AuthIdentity, &new_auth_info);
1443     if (r == RPC_S_OK)
1444     {
1445       new_auth_info->server_principal_name = RPCRT4_strdupAtoW((char *)ServerPrincName);
1446       if (new_auth_info->server_principal_name)
1447       {
1448         if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1449         bind->AuthInfo = new_auth_info;
1450       }
1451       else
1452       {
1453         RpcAuthInfo_Release(new_auth_info);
1454         r = ERROR_OUTOFMEMORY;
1455       }
1456     }
1457     else
1458       FreeCredentialsHandle(&cred);
1459     return r;
1460   }
1461   else
1462   {
1463     ERR("AcquireCredentialsHandleA failed with error 0x%08x\n", r);
1464     return RPC_S_SEC_PKG_ERROR;
1465   }
1466 }
1467
1468 /***********************************************************************
1469  *             RpcBindingSetAuthInfoExW (RPCRT4.@)
1470  */
1471 RPCRTAPI RPC_STATUS RPC_ENTRY
1472 RpcBindingSetAuthInfoExW( RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel,
1473                           ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
1474                           RPC_SECURITY_QOS *SecurityQos )
1475 {
1476   RpcBinding* bind = (RpcBinding*)Binding;
1477   SECURITY_STATUS r;
1478   CredHandle cred;
1479   TimeStamp exp;
1480   ULONG package_count;
1481   ULONG i;
1482   PSecPkgInfoW packages;
1483   ULONG cbMaxToken;
1484
1485   TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_w((const WCHAR*)ServerPrincName),
1486         AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1487
1488   if (SecurityQos)
1489   {
1490       RPC_STATUS status;
1491
1492       TRACE("SecurityQos { Version=%ld, Capabilties=0x%lx, IdentityTracking=%ld, ImpersonationLevel=%ld",
1493             SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1494       if (SecurityQos->Version >= 2)
1495       {
1496           const RPC_SECURITY_QOS_V2_W *SecurityQos2 = (const RPC_SECURITY_QOS_V2_W *)SecurityQos;
1497           TRACE(", AdditionalSecurityInfoType=%ld", SecurityQos2->AdditionalSecurityInfoType);
1498           if (SecurityQos2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1499               TRACE(", { %p, 0x%lx, %ld, %ld, %p, %s }",
1500                     SecurityQos2->u.HttpCredentials->TransportCredentials,
1501                     SecurityQos2->u.HttpCredentials->Flags,
1502                     SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1503                     SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1504                     SecurityQos2->u.HttpCredentials->AuthnSchemes,
1505                     debugstr_w(SecurityQos2->u.HttpCredentials->ServerCertificateSubject));
1506       }
1507       TRACE("}\n");
1508       status = RpcQualityOfService_Create(SecurityQos, TRUE, &bind->QOS);
1509       if (status != RPC_S_OK)
1510           return status;
1511   }
1512   else
1513   {
1514       if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1515       bind->QOS = NULL;
1516   }
1517
1518   if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1519     AuthnSvc = RPC_C_AUTHN_WINNT;
1520
1521   /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1522   if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1523     AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1524
1525   if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1526   {
1527     if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1528     bind->AuthInfo = NULL;
1529     return RPC_S_OK;
1530   }
1531
1532   if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1533   {
1534     FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1535     return RPC_S_UNKNOWN_AUTHN_LEVEL;
1536   }
1537
1538   if (AuthzSvr)
1539   {
1540     FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1541     return RPC_S_UNKNOWN_AUTHZ_SERVICE;
1542   }
1543
1544   r = EnumerateSecurityPackagesW(&package_count, &packages);
1545   if (r != SEC_E_OK)
1546   {
1547     ERR("EnumerateSecurityPackagesA failed with error 0x%08x\n", r);
1548     return RPC_S_SEC_PKG_ERROR;
1549   }
1550
1551   for (i = 0; i < package_count; i++)
1552     if (packages[i].wRPCID == AuthnSvc)
1553         break;
1554
1555   if (i == package_count)
1556   {
1557     FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1558     FreeContextBuffer(packages);
1559     return RPC_S_UNKNOWN_AUTHN_SERVICE;
1560   }
1561
1562   TRACE("found package %s for service %u\n", debugstr_w(packages[i].Name), AuthnSvc);
1563   r = AcquireCredentialsHandleW(NULL, packages[i].Name, SECPKG_CRED_OUTBOUND, NULL,
1564                                 AuthIdentity, NULL, NULL, &cred, &exp);
1565   cbMaxToken = packages[i].cbMaxToken;
1566   FreeContextBuffer(packages);
1567   if (r == ERROR_SUCCESS)
1568   {
1569     RpcAuthInfo *new_auth_info;
1570     r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1571                            AuthIdentity, &new_auth_info);
1572     if (r == RPC_S_OK)
1573     {
1574       new_auth_info->server_principal_name = RPCRT4_strdupW(ServerPrincName);
1575       if (!ServerPrincName || new_auth_info->server_principal_name)
1576       {
1577         if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1578         bind->AuthInfo = new_auth_info;
1579       }
1580       else
1581       {
1582         RpcAuthInfo_Release(new_auth_info);
1583         r = ERROR_OUTOFMEMORY;
1584       }
1585     }
1586     else
1587       FreeCredentialsHandle(&cred);
1588     return r;
1589   }
1590   else
1591   {
1592     ERR("AcquireCredentialsHandleA failed with error 0x%08x\n", r);
1593     return RPC_S_SEC_PKG_ERROR;
1594   }
1595 }
1596
1597 /***********************************************************************
1598  *             RpcBindingSetAuthInfoA (RPCRT4.@)
1599  */
1600 RPCRTAPI RPC_STATUS RPC_ENTRY
1601 RpcBindingSetAuthInfoA( RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel,
1602                         ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr )
1603 {
1604     TRACE("%p %s %u %u %p %u\n", Binding, debugstr_a((const char*)ServerPrincName),
1605           AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1606     return RpcBindingSetAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1607 }
1608
1609 /***********************************************************************
1610  *             RpcBindingSetAuthInfoW (RPCRT4.@)
1611  */
1612 RPCRTAPI RPC_STATUS RPC_ENTRY
1613 RpcBindingSetAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel,
1614                         ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr )
1615 {
1616     TRACE("%p %s %u %u %p %u\n", Binding, debugstr_w((const WCHAR*)ServerPrincName),
1617           AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1618     return RpcBindingSetAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1619 }
1620
1621 /***********************************************************************
1622  *             RpcBindingSetOption (RPCRT4.@)
1623  */
1624 RPC_STATUS WINAPI RpcBindingSetOption(RPC_BINDING_HANDLE BindingHandle, ULONG Option, ULONG OptionValue)
1625 {
1626     FIXME("(%p, %d, %d): stub\n", BindingHandle, Option, OptionValue);
1627     return RPC_S_OK;
1628 }