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