?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi/tests: Remove workarounds for Windows 2000.
[wine.git] / dlls / rpcrt4 / rpc_binding.c
blobe8cdb9334741bc86fa34cebc797e8093fda78e7a
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
35 #include "rpc.h"
36 #include "rpcndr.h"
37
38 #include "wine/debug.h"
39
40 #include "rpc_binding.h"
41 #include "rpc_assoc.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
44
45 LPSTR RPCRT4_strndupA(LPCSTR src, INT slen)
46 {
47 DWORD len;
48 LPSTR s;
49 if (!src) return NULL;
50 if (slen == -1) slen = strlen(src);
51 len = slen;
52 s = HeapAlloc(GetProcessHeap(), 0, len+1);
53 memcpy(s, src, len);
54 s[len] = 0;
55 return s;
56 }
57
58 LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
59 {
60 DWORD len;
61 LPSTR s;
62 if (!src) return NULL;
63 len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
64 s = HeapAlloc(GetProcessHeap(), 0, len);
65 WideCharToMultiByte(CP_ACP, 0, src, -1, s, len, NULL, NULL);
66 return s;
67 }
68
69 LPWSTR RPCRT4_strdupAtoW(LPCSTR src)
70 {
71 DWORD len;
72 LPWSTR s;
73 if (!src) return NULL;
74 len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
75 s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
76 MultiByteToWideChar(CP_ACP, 0, src, -1, s, len);
77 return s;
78 }
79
80 static LPWSTR RPCRT4_strndupAtoW(LPCSTR src, INT slen)
81 {
82 DWORD len;
83 LPWSTR s;
84 if (!src) return NULL;
85 len = MultiByteToWideChar(CP_ACP, 0, src, slen, NULL, 0);
86 s = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
87 MultiByteToWideChar(CP_ACP, 0, src, slen, s, len);
88 return s;
89 }
90
91 LPWSTR RPCRT4_strndupW(LPCWSTR src, INT slen)
92 {
93 DWORD len;
94 LPWSTR s;
95 if (!src) return NULL;
96 if (slen == -1) slen = lstrlenW(src);
97 len = slen;
98 s = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
99 memcpy(s, src, len*sizeof(WCHAR));
100 s[len] = 0;
101 return s;
102 }
103
104 void RPCRT4_strfree(LPSTR src)
105 {
106 HeapFree(GetProcessHeap(), 0, src);
107 }
108
109 static RPC_STATUS RPCRT4_AllocBinding(RpcBinding** Binding, BOOL server)
110 {
111 RpcBinding* NewBinding;
112
113 NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
114 NewBinding->refs = 1;
115 NewBinding->server = server;
116
117 *Binding = NewBinding;
118
119 return RPC_S_OK;
120 }
121
122 static RPC_STATUS RPCRT4_CreateBindingA(RpcBinding** Binding, BOOL server, LPCSTR Protseq)
123 {
124 RpcBinding* NewBinding;
125
126 RPCRT4_AllocBinding(&NewBinding, server);
127 NewBinding->Protseq = RPCRT4_strdupA(Protseq);
128
129 TRACE("binding: %p\n", NewBinding);
130 *Binding = NewBinding;
131
132 return RPC_S_OK;
133 }
134
135 static RPC_STATUS RPCRT4_CreateBindingW(RpcBinding** Binding, BOOL server, LPCWSTR Protseq)
136 {
137 RpcBinding* NewBinding;
138
139 RPCRT4_AllocBinding(&NewBinding, server);
140 NewBinding->Protseq = RPCRT4_strdupWtoA(Protseq);
141
142 TRACE("binding: %p\n", NewBinding);
143 *Binding = NewBinding;
144
145 return RPC_S_OK;
146 }
147
148 static RPC_STATUS RPCRT4_CompleteBindingA(RpcBinding* Binding, LPCSTR NetworkAddr,
149 LPCSTR Endpoint, LPCSTR NetworkOptions)
150 {
151 RPC_STATUS status;
152
153 TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
154 debugstr_a(NetworkAddr), debugstr_a(Endpoint), debugstr_a(NetworkOptions));
155
156 RPCRT4_strfree(Binding->NetworkAddr);
157 Binding->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
158 RPCRT4_strfree(Binding->Endpoint);
159 Binding->Endpoint = RPCRT4_strdupA(Endpoint);
160 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
161 Binding->NetworkOptions = RPCRT4_strdupAtoW(NetworkOptions);
162
163 /* only attempt to get an association if the binding is complete */
164 if (Endpoint && Endpoint[0] != '\0')
165 {
166 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
167 Binding->Endpoint, Binding->NetworkOptions,
168 &Binding->Assoc);
169 if (status != RPC_S_OK)
170 return status;
171 }
172
173 return RPC_S_OK;
174 }
175
176 static RPC_STATUS RPCRT4_CompleteBindingW(RpcBinding* Binding, LPCWSTR NetworkAddr,
177 LPCWSTR Endpoint, LPCWSTR NetworkOptions)
178 {
179 RPC_STATUS status;
180
181 TRACE("(RpcBinding == ^%p, NetworkAddr == %s, EndPoint == %s, NetworkOptions == %s)\n", Binding,
182 debugstr_w(NetworkAddr), debugstr_w(Endpoint), debugstr_w(NetworkOptions));
183
184 RPCRT4_strfree(Binding->NetworkAddr);
185 Binding->NetworkAddr = RPCRT4_strdupWtoA(NetworkAddr);
186 RPCRT4_strfree(Binding->Endpoint);
187 Binding->Endpoint = RPCRT4_strdupWtoA(Endpoint);
188 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
189 Binding->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
190
191 /* only attempt to get an association if the binding is complete */
192 if (Endpoint && Endpoint[0] != '\0')
193 {
194 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
195 Binding->Endpoint, Binding->NetworkOptions,
196 &Binding->Assoc);
197 if (status != RPC_S_OK)
198 return status;
199 }
200
201 return RPC_S_OK;
202 }
203
204 RPC_STATUS RPCRT4_ResolveBinding(RpcBinding* Binding, LPCSTR Endpoint)
205 {
206 RPC_STATUS status;
207
208 TRACE("(RpcBinding == ^%p, EndPoint == \"%s\"\n", Binding, Endpoint);
209
210 RPCRT4_strfree(Binding->Endpoint);
211 Binding->Endpoint = RPCRT4_strdupA(Endpoint);
212
213 if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
214 Binding->Assoc = NULL;
215 status = RPCRT4_GetAssociation(Binding->Protseq, Binding->NetworkAddr,
216 Binding->Endpoint, Binding->NetworkOptions,
217 &Binding->Assoc);
218 if (status != RPC_S_OK)
219 return status;
220
221 return RPC_S_OK;
222 }
223
224 RPC_STATUS RPCRT4_SetBindingObject(RpcBinding* Binding, const UUID* ObjectUuid)
225 {
226 TRACE("(*RpcBinding == ^%p, UUID == %s)\n", Binding, debugstr_guid(ObjectUuid));
227 if (ObjectUuid) Binding->ObjectUuid = *ObjectUuid;
228 else UuidCreateNil(&Binding->ObjectUuid);
229 return RPC_S_OK;
230 }
231
232 RPC_STATUS RPCRT4_MakeBinding(RpcBinding** Binding, RpcConnection* Connection)
233 {
234 RpcBinding* NewBinding;
235 TRACE("(RpcBinding == ^%p, Connection == ^%p)\n", Binding, Connection);
236
237 RPCRT4_AllocBinding(&NewBinding, Connection->server);
238 NewBinding->Protseq = RPCRT4_strdupA(rpcrt4_conn_get_name(Connection));
239 NewBinding->NetworkAddr = RPCRT4_strdupA(Connection->NetworkAddr);
240 NewBinding->Endpoint = RPCRT4_strdupA(Connection->Endpoint);
241 NewBinding->FromConn = Connection;
242
243 TRACE("binding: %p\n", NewBinding);
244 *Binding = NewBinding;
245
246 return RPC_S_OK;
247 }
248
249 void RPCRT4_AddRefBinding(RpcBinding* Binding)
250 {
251 InterlockedIncrement(&Binding->refs);
252 }
253
254 RPC_STATUS RPCRT4_ReleaseBinding(RpcBinding* Binding)
255 {
256 if (InterlockedDecrement(&Binding->refs))
257 return RPC_S_OK;
258
259 TRACE("binding: %p\n", Binding);
260 if (Binding->Assoc) RpcAssoc_Release(Binding->Assoc);
261 RPCRT4_strfree(Binding->Endpoint);
262 RPCRT4_strfree(Binding->NetworkAddr);
263 RPCRT4_strfree(Binding->Protseq);
264 HeapFree(GetProcessHeap(), 0, Binding->NetworkOptions);
265 HeapFree(GetProcessHeap(), 0, Binding->CookieAuth);
266 if (Binding->AuthInfo) RpcAuthInfo_Release(Binding->AuthInfo);
267 if (Binding->QOS) RpcQualityOfService_Release(Binding->QOS);
268 HeapFree(GetProcessHeap(), 0, Binding);
269 return RPC_S_OK;
270 }
271
272 RPC_STATUS RPCRT4_OpenBinding(RpcBinding* Binding, RpcConnection** Connection,
273 const RPC_SYNTAX_IDENTIFIER *TransferSyntax,
274 const RPC_SYNTAX_IDENTIFIER *InterfaceId, BOOL *from_cache)
275 {
276 TRACE("(Binding == ^%p)\n", Binding);
277
278 if (!Binding->server) {
279 return RpcAssoc_GetClientConnection(Binding->Assoc, InterfaceId,
280 TransferSyntax, Binding->AuthInfo, Binding->QOS, Binding->CookieAuth, Connection, from_cache);
281 } else {
282 /* we already have a connection with acceptable binding, so use it */
283 if (Binding->FromConn) {
284 *Connection = Binding->FromConn;
285 return RPC_S_OK;
286 } else {
287 ERR("no connection in binding\n");
288 return RPC_S_INTERNAL_ERROR;
289 }
290 }
291 }
292
293 RPC_STATUS RPCRT4_CloseBinding(RpcBinding* Binding, RpcConnection* Connection)
294 {
295 TRACE("(Binding == ^%p)\n", Binding);
296 if (!Connection) return RPC_S_OK;
297 if (Binding->server) {
298 /* don't destroy a connection that is cached in the binding */
299 if (Binding->FromConn != Connection)
300 RPCRT4_ReleaseConnection(Connection);
301 }
302 else {
303 RpcAssoc_ReleaseIdleConnection(Binding->Assoc, Connection);
304 }
305 return RPC_S_OK;
306 }
307
308 static LPSTR RPCRT4_strconcatA(LPSTR dst, LPCSTR src)
309 {
310 DWORD len = strlen(dst), slen = strlen(src);
311 LPSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(CHAR));
312 if (!ndst)
313 {
314 HeapFree(GetProcessHeap(), 0, dst);
315 return NULL;
316 }
317 ndst[len] = ',';
318 memcpy(ndst+len+1, src, slen+1);
319 return ndst;
320 }
321
322 static LPWSTR RPCRT4_strconcatW(LPWSTR dst, LPCWSTR src)
323 {
324 DWORD len = lstrlenW(dst), slen = lstrlenW(src);
325 LPWSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(WCHAR));
326 if (!ndst)
327 {
328 HeapFree(GetProcessHeap(), 0, dst);
329 return NULL;
330 }
331 ndst[len] = ',';
332 memcpy(ndst+len+1, src, (slen+1)*sizeof(WCHAR));
333 return ndst;
334 }
335
336 /* Copies the escaped version of a component into a string binding.
337 * Note: doesn't nul-terminate the string */
338 static RPC_CSTR escape_string_binding_component(RPC_CSTR string_binding,
339 const unsigned char *component)
340 {
341 for (; *component; component++) {
342 switch (*component) {
343 case '@':
344 case ':':
345 case '[':
346 case ']':
347 case '\\':
348 *string_binding++ = '\\';
349 *string_binding++ = *component;
350 break;
351 default:
352 *string_binding++ = *component;
353 break;
354 }
355 }
356 return string_binding;
357 }
358
359 static RPC_WSTR escape_string_binding_componentW(RPC_WSTR string_binding,
360 const WCHAR *component)
361 {
362 for (; *component; component++) {
363 switch (*component) {
364 case '@':
365 case ':':
366 case '[':
367 case ']':
368 case '\\':
369 *string_binding++ = '\\';
370 *string_binding++ = *component;
371 break;
372 default:
373 *string_binding++ = *component;
374 break;
375 }
376 }
377 return string_binding;
378 }
379
380 static const unsigned char *string_binding_find_delimiter(
381 const unsigned char *string_binding, unsigned char delim)
382 {
383 const unsigned char *next;
384 for (next = string_binding; *next; next++) {
385 if (*next == '\\') {
386 next++;
387 continue;
388 }
389 if (*next == delim)
390 return next;
391 }
392 return NULL;
393 }
394
395 static const WCHAR *string_binding_find_delimiterW(
396 const WCHAR *string_binding, WCHAR delim)
397 {
398 const WCHAR *next;
399 for (next = string_binding; *next; next++) {
400 if (*next == '\\') {
401 next++;
402 continue;
403 }
404 if (*next == delim)
405 return next;
406 }
407 return NULL;
408 }
409
410 static RPC_CSTR unescape_string_binding_component(
411 const unsigned char *string_binding, int len)
412 {
413 RPC_CSTR component, p;
414
415 if (len == -1) len = strlen((const char *)string_binding);
416
417 component = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(*component));
418 if (!component) return NULL;
419 for (p = component; len > 0; string_binding++, len--) {
420 if (*string_binding == '\\') {
421 string_binding++;
422 len--;
423 *p++ = *string_binding;
424 } else {
425 *p++ = *string_binding;
426 }
427 }
428 *p = '\0';
429 return component;
430 }
431
432 static RPC_WSTR unescape_string_binding_componentW(
433 const WCHAR *string_binding, int len)
434 {
435 RPC_WSTR component, p;
436
437 if (len == -1) len = lstrlenW(string_binding);
438
439 component = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(*component));
440 if (!component) return NULL;
441 for (p = component; len > 0; string_binding++, len--) {
442 if (*string_binding == '\\') {
443 string_binding++;
444 len--;
445 *p++ = *string_binding;
446 } else {
447 *p++ = *string_binding;
448 }
449 }
450 *p = '\0';
451 return component;
452 }
453
454 /***********************************************************************
455 * RpcStringBindingComposeA (RPCRT4.@)
456 */
457 RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq,
458 RPC_CSTR NetworkAddr, RPC_CSTR Endpoint,
459 RPC_CSTR Options, RPC_CSTR *StringBinding )
460 {
461 DWORD len = 1;
462 RPC_CSTR data;
463
464 TRACE( "(%s,%s,%s,%s,%s,%p)\n",
465 debugstr_a( (char*)ObjUuid ), debugstr_a( (char*)Protseq ),
466 debugstr_a( (char*)NetworkAddr ), debugstr_a( (char*)Endpoint ),
467 debugstr_a( (char*)Options ), StringBinding );
468
469 /* overestimate for each component for escaping of delimiters */
470 if (ObjUuid && *ObjUuid) len += strlen((char*)ObjUuid) * 2 + 1;
471 if (Protseq && *Protseq) len += strlen((char*)Protseq) * 2 + 1;
472 if (NetworkAddr && *NetworkAddr) len += strlen((char*)NetworkAddr) * 2;
473 if (Endpoint && *Endpoint) len += strlen((char*)Endpoint) * 2 + 2;
474 if (Options && *Options) len += strlen((char*)Options) * 2 + 2;
475
476 data = HeapAlloc(GetProcessHeap(), 0, len);
477 *StringBinding = data;
478
479 if (ObjUuid && *ObjUuid) {
480 data = escape_string_binding_component(data, ObjUuid);
481 *data++ = '@';
482 }
483 if (Protseq && *Protseq) {
484 data = escape_string_binding_component(data, Protseq);
485 *data++ = ':';
486 }
487 if (NetworkAddr && *NetworkAddr)
488 data = escape_string_binding_component(data, NetworkAddr);
489
490 if ((Endpoint && *Endpoint) ||
491 (Options && *Options)) {
492 *data++ = '[';
493 if (Endpoint && *Endpoint) {
494 data = escape_string_binding_component(data, Endpoint);
495 if (Options && *Options) *data++ = ',';
496 }
497 if (Options && *Options) {
498 data = escape_string_binding_component(data, Options);
499 }
500 *data++ = ']';
501 }
502 *data = 0;
503
504 return RPC_S_OK;
505 }
506
507 /***********************************************************************
508 * RpcStringBindingComposeW (RPCRT4.@)
509 */
510 RPC_STATUS WINAPI RpcStringBindingComposeW( RPC_WSTR ObjUuid, RPC_WSTR Protseq,
511 RPC_WSTR NetworkAddr, RPC_WSTR Endpoint,
512 RPC_WSTR Options, RPC_WSTR* StringBinding )
513 {
514 DWORD len = 1;
515 RPC_WSTR data;
516
517 TRACE("(%s,%s,%s,%s,%s,%p)\n",
518 debugstr_w( ObjUuid ), debugstr_w( Protseq ),
519 debugstr_w( NetworkAddr ), debugstr_w( Endpoint ),
520 debugstr_w( Options ), StringBinding);
521
522 /* overestimate for each component for escaping of delimiters */
523 if (ObjUuid && *ObjUuid) len += lstrlenW(ObjUuid) * 2 + 1;
524 if (Protseq && *Protseq) len += lstrlenW(Protseq) * 2 + 1;
525 if (NetworkAddr && *NetworkAddr) len += lstrlenW(NetworkAddr) * 2;
526 if (Endpoint && *Endpoint) len += lstrlenW(Endpoint) * 2 + 2;
527 if (Options && *Options) len += lstrlenW(Options) * 2 + 2;
528
529 data = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
530 *StringBinding = data;
531
532 if (ObjUuid && *ObjUuid) {
533 data = escape_string_binding_componentW(data, ObjUuid);
534 *data++ = '@';
535 }
536 if (Protseq && *Protseq) {
537 data = escape_string_binding_componentW(data, Protseq);
538 *data++ = ':';
539 }
540 if (NetworkAddr && *NetworkAddr) {
541 data = escape_string_binding_componentW(data, NetworkAddr);
542 }
543 if ((Endpoint && *Endpoint) ||
544 (Options && *Options)) {
545 *data++ = '[';
546 if (Endpoint && *Endpoint) {
547 data = escape_string_binding_componentW(data, Endpoint);
548 if (Options && *Options) *data++ = ',';
549 }
550 if (Options && *Options) {
551 data = escape_string_binding_componentW(data, Options);
552 }
553 *data++ = ']';
554 }
555 *data = 0;
556
557 return RPC_S_OK;
558 }
559
560
561 /***********************************************************************
562 * RpcStringBindingParseA (RPCRT4.@)
563 */
564 RPC_STATUS WINAPI RpcStringBindingParseA( RPC_CSTR StringBinding, RPC_CSTR *ObjUuid,
565 RPC_CSTR *Protseq, RPC_CSTR *NetworkAddr,
566 RPC_CSTR *Endpoint, RPC_CSTR *Options)
567 {
568 const unsigned char *data, *next;
569 static const char ep_opt[] = "endpoint=";
570 BOOL endpoint_already_found = FALSE;
571
572 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_a((char*)StringBinding),
573 ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
574
575 if (ObjUuid) *ObjUuid = NULL;
576 if (Protseq) *Protseq = NULL;
577 if (NetworkAddr) *NetworkAddr = NULL;
578 if (Endpoint) *Endpoint = NULL;
579 if (Options) *Options = NULL;
580
581 data = StringBinding;
582
583 next = string_binding_find_delimiter(data, '@');
584 if (next) {
585 UUID uuid;
586 RPC_STATUS status;
587 RPC_CSTR str_uuid = unescape_string_binding_component(data, next - data);
588 status = UuidFromStringA(str_uuid, &uuid);
589 if (status != RPC_S_OK) {
590 HeapFree(GetProcessHeap(), 0, str_uuid);
591 return status;
592 }
593 if (ObjUuid)
594 *ObjUuid = str_uuid;
595 else
596 HeapFree(GetProcessHeap(), 0, str_uuid);
597 data = next+1;
598 }
599
600 next = string_binding_find_delimiter(data, ':');
601 if (next) {
602 if (Protseq) *Protseq = unescape_string_binding_component(data, next - data);
603 data = next+1;
604 }
605
606 next = string_binding_find_delimiter(data, '[');
607 if (next) {
608 const unsigned char *close;
609 RPC_CSTR opt;
610
611 if (NetworkAddr) *NetworkAddr = unescape_string_binding_component(data, next - data);
612 data = next+1;
613 close = string_binding_find_delimiter(data, ']');
614 if (!close) goto fail;
615
616 /* tokenize options */
617 while (data < close) {
618 next = string_binding_find_delimiter(data, ',');
619 if (!next || next > close) next = close;
620 /* FIXME: this is kind of inefficient */
621 opt = unescape_string_binding_component(data, next - data);
622 data = next+1;
623
624 /* parse option */
625 next = string_binding_find_delimiter(opt, '=');
626 if (!next) {
627 /* not an option, must be an endpoint */
628 if (endpoint_already_found) goto fail;
629 if (Endpoint) *Endpoint = opt;
630 else HeapFree(GetProcessHeap(), 0, opt);
631 endpoint_already_found = TRUE;
632 } else {
633 if (strncmp((const char *)opt, ep_opt, strlen(ep_opt)) == 0) {
634 /* endpoint option */
635 if (endpoint_already_found) goto fail;
636 if (Endpoint) *Endpoint = unescape_string_binding_component(next+1, -1);
637 HeapFree(GetProcessHeap(), 0, opt);
638 endpoint_already_found = TRUE;
639 } else {
640 /* network option */
641 if (Options) {
642 if (*Options) {
643 /* FIXME: this is kind of inefficient */
644 *Options = (unsigned char*) RPCRT4_strconcatA( (char*)*Options, (char *)opt);
645 HeapFree(GetProcessHeap(), 0, opt);
646 } else
647 *Options = opt;
648 } else
649 HeapFree(GetProcessHeap(), 0, opt);
650 }
651 }
652 }
653
654 data = close+1;
655 if (*data) goto fail;
656 }
657 else if (NetworkAddr)
658 *NetworkAddr = unescape_string_binding_component(data, -1);
659
660 return RPC_S_OK;
661
662 fail:
663 if (ObjUuid) RpcStringFreeA(ObjUuid);
664 if (Protseq) RpcStringFreeA(Protseq);
665 if (NetworkAddr) RpcStringFreeA(NetworkAddr);
666 if (Endpoint) RpcStringFreeA(Endpoint);
667 if (Options) RpcStringFreeA(Options);
668 return RPC_S_INVALID_STRING_BINDING;
669 }
670
671 /***********************************************************************
672 * RpcStringBindingParseW (RPCRT4.@)
673 */
674 RPC_STATUS WINAPI RpcStringBindingParseW( RPC_WSTR StringBinding, RPC_WSTR *ObjUuid,
675 RPC_WSTR *Protseq, RPC_WSTR *NetworkAddr,
676 RPC_WSTR *Endpoint, RPC_WSTR *Options)
677 {
678 const WCHAR *data, *next;
679 static const WCHAR ep_opt[] = {'e','n','d','p','o','i','n','t','=',0};
680 BOOL endpoint_already_found = FALSE;
681
682 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_w(StringBinding),
683 ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
684
685 if (ObjUuid) *ObjUuid = NULL;
686 if (Protseq) *Protseq = NULL;
687 if (NetworkAddr) *NetworkAddr = NULL;
688 if (Endpoint) *Endpoint = NULL;
689 if (Options) *Options = NULL;
690
691 data = StringBinding;
692
693 next = string_binding_find_delimiterW(data, '@');
694 if (next) {
695 UUID uuid;
696 RPC_STATUS status;
697 RPC_WSTR str_uuid = unescape_string_binding_componentW(data, next - data);
698 status = UuidFromStringW(str_uuid, &uuid);
699 if (status != RPC_S_OK) {
700 HeapFree(GetProcessHeap(), 0, str_uuid);
701 return status;
702 }
703 if (ObjUuid)
704 *ObjUuid = str_uuid;
705 else
706 HeapFree(GetProcessHeap(), 0, str_uuid);
707 data = next+1;
708 }
709
710 next = string_binding_find_delimiterW(data, ':');
711 if (next) {
712 if (Protseq) *Protseq = unescape_string_binding_componentW(data, next - data);
713 data = next+1;
714 }
715
716 next = string_binding_find_delimiterW(data, '[');
717 if (next) {
718 const WCHAR *close;
719 RPC_WSTR opt;
720
721 if (NetworkAddr) *NetworkAddr = unescape_string_binding_componentW(data, next - data);
722 data = next+1;
723 close = string_binding_find_delimiterW(data, ']');
724 if (!close) goto fail;
725
726 /* tokenize options */
727 while (data < close) {
728 next = string_binding_find_delimiterW(data, ',');
729 if (!next || next > close) next = close;
730 /* FIXME: this is kind of inefficient */
731 opt = unescape_string_binding_componentW(data, next - data);
732 data = next+1;
733
734 /* parse option */
735 next = string_binding_find_delimiterW(opt, '=');
736 if (!next) {
737 /* not an option, must be an endpoint */
738 if (endpoint_already_found) goto fail;
739 if (Endpoint) *Endpoint = opt;
740 else HeapFree(GetProcessHeap(), 0, opt);
741 endpoint_already_found = TRUE;
742 } else {
743 if (wcsncmp(opt, ep_opt, lstrlenW(ep_opt)) == 0) {
744 /* endpoint option */
745 if (endpoint_already_found) goto fail;
746 if (Endpoint) *Endpoint = unescape_string_binding_componentW(next+1, -1);
747 HeapFree(GetProcessHeap(), 0, opt);
748 endpoint_already_found = TRUE;
749 } else {
750 /* network option */
751 if (Options) {
752 if (*Options) {
753 /* FIXME: this is kind of inefficient */
754 *Options = RPCRT4_strconcatW(*Options, opt);
755 HeapFree(GetProcessHeap(), 0, opt);
756 } else
757 *Options = opt;
758 } else
759 HeapFree(GetProcessHeap(), 0, opt);
760 }
761 }
762 }
763
764 data = close+1;
765 if (*data) goto fail;
766 } else if (NetworkAddr)
767 *NetworkAddr = unescape_string_binding_componentW(data, -1);
768
769 return RPC_S_OK;
770
771 fail:
772 if (ObjUuid) RpcStringFreeW(ObjUuid);
773 if (Protseq) RpcStringFreeW(Protseq);
774 if (NetworkAddr) RpcStringFreeW(NetworkAddr);
775 if (Endpoint) RpcStringFreeW(Endpoint);
776 if (Options) RpcStringFreeW(Options);
777 return RPC_S_INVALID_STRING_BINDING;
778 }
779
780 /***********************************************************************
781 * RpcBindingFree (RPCRT4.@)
782 */
783 RPC_STATUS WINAPI RpcBindingFree( RPC_BINDING_HANDLE* Binding )
784 {
785 RPC_STATUS status;
786 TRACE("(%p) = %p\n", Binding, *Binding);
787 if (*Binding)
788 status = RPCRT4_ReleaseBinding(*Binding);
789 else
790 status = RPC_S_INVALID_BINDING;
791 if (status == RPC_S_OK) *Binding = NULL;
792 return status;
793 }
794
795 /***********************************************************************
796 * RpcBindingVectorFree (RPCRT4.@)
797 */
798 RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector )
799 {
800 ULONG c;
801
802 TRACE("(%p)\n", BindingVector);
803 for (c=0; c<(*BindingVector)->Count; c++) RpcBindingFree(&(*BindingVector)->BindingH[c]);
804 HeapFree(GetProcessHeap(), 0, *BindingVector);
805 *BindingVector = NULL;
806 return RPC_S_OK;
807 }
808
809 /***********************************************************************
810 * RpcBindingInqObject (RPCRT4.@)
811 */
812 RPC_STATUS WINAPI RpcBindingInqObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
813 {
814 RpcBinding* bind = Binding;
815
816 TRACE("(%p,%p) = %s\n", Binding, ObjectUuid, debugstr_guid(&bind->ObjectUuid));
817 *ObjectUuid = bind->ObjectUuid;
818 return RPC_S_OK;
819 }
820
821 /***********************************************************************
822 * RpcBindingSetObject (RPCRT4.@)
823 */
824 RPC_STATUS WINAPI RpcBindingSetObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
825 {
826 RpcBinding* bind = Binding;
827
828 TRACE("(%p,%s)\n", Binding, debugstr_guid(ObjectUuid));
829 if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
830 return RPCRT4_SetBindingObject(Binding, ObjectUuid);
831 }
832
833 /***********************************************************************
834 * RpcBindingFromStringBindingA (RPCRT4.@)
835 */
836 RPC_STATUS WINAPI RpcBindingFromStringBindingA( RPC_CSTR StringBinding, RPC_BINDING_HANDLE* Binding )
837 {
838 RPC_STATUS ret;
839 RpcBinding* bind = NULL;
840 RPC_CSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
841 UUID Uuid;
842
843 TRACE("(%s,%p)\n", debugstr_a((char*)StringBinding), Binding);
844
845 ret = RpcStringBindingParseA(StringBinding, &ObjectUuid, &Protseq,
846 &NetworkAddr, &Endpoint, &Options);
847 if (ret != RPC_S_OK) return ret;
848
849 ret = UuidFromStringA(ObjectUuid, &Uuid);
850
851 if (ret == RPC_S_OK)
852 ret = RPCRT4_CreateBindingA(&bind, FALSE, (char*)Protseq);
853 if (ret == RPC_S_OK) {
854 ret = RPCRT4_SetBindingObject(bind, &Uuid);
855 if (ret == RPC_S_OK)
856 ret = RPCRT4_CompleteBindingA(bind, (char*)NetworkAddr, (char*)Endpoint, (char*)Options);
857
858 if (ret == RPC_S_OK)
859 *Binding = (RPC_BINDING_HANDLE)bind;
860 else
861 RPCRT4_ReleaseBinding(bind);
862 }
863
864 RpcStringFreeA(&Options);
865 RpcStringFreeA(&Endpoint);
866 RpcStringFreeA(&NetworkAddr);
867 RpcStringFreeA(&Protseq);
868 RpcStringFreeA(&ObjectUuid);
869
870 return ret;
871 }
872
873 /***********************************************************************
874 * RpcBindingFromStringBindingW (RPCRT4.@)
875 */
876 RPC_STATUS WINAPI RpcBindingFromStringBindingW( RPC_WSTR StringBinding, RPC_BINDING_HANDLE* Binding )
877 {
878 RPC_STATUS ret;
879 RpcBinding* bind = NULL;
880 RPC_WSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
881 UUID Uuid;
882
883 TRACE("(%s,%p)\n", debugstr_w(StringBinding), Binding);
884
885 ret = RpcStringBindingParseW(StringBinding, &ObjectUuid, &Protseq,
886 &NetworkAddr, &Endpoint, &Options);
887 if (ret != RPC_S_OK) return ret;
888
889 ret = UuidFromStringW(ObjectUuid, &Uuid);
890
891 if (ret == RPC_S_OK)
892 ret = RPCRT4_CreateBindingW(&bind, FALSE, Protseq);
893 if (ret == RPC_S_OK) {
894 ret = RPCRT4_SetBindingObject(bind, &Uuid);
895 if (ret == RPC_S_OK)
896 ret = RPCRT4_CompleteBindingW(bind, NetworkAddr, Endpoint, Options);
897
898 if (ret == RPC_S_OK)
899 *Binding = (RPC_BINDING_HANDLE)bind;
900 else
901 RPCRT4_ReleaseBinding(bind);
902 }
903
904 RpcStringFreeW(&Options);
905 RpcStringFreeW(&Endpoint);
906 RpcStringFreeW(&NetworkAddr);
907 RpcStringFreeW(&Protseq);
908 RpcStringFreeW(&ObjectUuid);
909
910 return ret;
911 }
912
913 /***********************************************************************
914 * RpcBindingToStringBindingA (RPCRT4.@)
915 */
916 RPC_STATUS WINAPI RpcBindingToStringBindingA( RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding )
917 {
918 RPC_STATUS ret;
919 RpcBinding* bind = Binding;
920 RPC_CSTR ObjectUuid;
921
922 TRACE("(%p,%p)\n", Binding, StringBinding);
923
924 if (UuidIsNil(&bind->ObjectUuid, &ret))
925 ObjectUuid = NULL;
926 else
927 {
928 ret = UuidToStringA(&bind->ObjectUuid, &ObjectUuid);
929 if (ret != RPC_S_OK) return ret;
930 }
931
932 ret = RpcStringBindingComposeA(ObjectUuid, (unsigned char*)bind->Protseq, (unsigned char*) bind->NetworkAddr,
933 (unsigned char*) bind->Endpoint, NULL, StringBinding);
934
935 RpcStringFreeA(&ObjectUuid);
936
937 return ret;
938 }
939
940 /***********************************************************************
941 * RpcBindingToStringBindingW (RPCRT4.@)
942 */
943 RPC_STATUS WINAPI RpcBindingToStringBindingW( RPC_BINDING_HANDLE Binding, RPC_WSTR *StringBinding )
944 {
945 RPC_STATUS ret;
946 unsigned char *str = NULL;
947 TRACE("(%p,%p)\n", Binding, StringBinding);
948 ret = RpcBindingToStringBindingA(Binding, &str);
949 *StringBinding = RPCRT4_strdupAtoW((char*)str);
950 RpcStringFreeA(&str);
951 return ret;
952 }
953
954 /***********************************************************************
955 * I_RpcBindingInqTransportType (RPCRT4.@)
956 */
957 RPC_STATUS WINAPI I_RpcBindingInqTransportType( RPC_BINDING_HANDLE Binding, unsigned int * Type )
958 {
959
960 FIXME( "(%p,%p): stub\n", Binding, Type);
961 *Type = TRANSPORT_TYPE_LPC;
962 return RPC_S_OK;
963 }
964
965 /***********************************************************************
966 * I_RpcBindingSetAsync (RPCRT4.@)
967 * NOTES
968 * Exists in win9x and winNT, but with different number of arguments
969 * (9x version has 3 arguments, NT has 2).
970 */
971 RPC_STATUS WINAPI I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn)
972 {
973 RpcBinding* bind = Binding;
974
975 TRACE( "(%p,%p): stub\n", Binding, BlockingFn );
976
977 bind->BlockingFn = BlockingFn;
978
979 return RPC_S_OK;
980 }
981
982 /***********************************************************************
983 * RpcBindingCopy (RPCRT4.@)
984 */
985 RPC_STATUS RPC_ENTRY RpcBindingCopy(
986 RPC_BINDING_HANDLE SourceBinding,
987 RPC_BINDING_HANDLE* DestinationBinding)
988 {
989 RpcBinding *DestBinding;
990 RpcBinding *SrcBinding = SourceBinding;
991 RPC_STATUS status;
992
993 TRACE("(%p, %p)\n", SourceBinding, DestinationBinding);
994
995 status = RPCRT4_AllocBinding(&DestBinding, SrcBinding->server);
996 if (status != RPC_S_OK) return status;
997
998 DestBinding->ObjectUuid = SrcBinding->ObjectUuid;
999 DestBinding->BlockingFn = SrcBinding->BlockingFn;
1000 DestBinding->Protseq = RPCRT4_strndupA(SrcBinding->Protseq, -1);
1001 DestBinding->NetworkAddr = RPCRT4_strndupA(SrcBinding->NetworkAddr, -1);
1002 DestBinding->Endpoint = RPCRT4_strndupA(SrcBinding->Endpoint, -1);
1003 DestBinding->NetworkOptions = RPCRT4_strdupW(SrcBinding->NetworkOptions);
1004 DestBinding->CookieAuth = RPCRT4_strdupW(SrcBinding->CookieAuth);
1005 if (SrcBinding->Assoc) SrcBinding->Assoc->refs++;
1006 DestBinding->Assoc = SrcBinding->Assoc;
1007
1008 if (SrcBinding->AuthInfo) RpcAuthInfo_AddRef(SrcBinding->AuthInfo);
1009 DestBinding->AuthInfo = SrcBinding->AuthInfo;
1010 if (SrcBinding->QOS) RpcQualityOfService_AddRef(SrcBinding->QOS);
1011 DestBinding->QOS = SrcBinding->QOS;
1012
1013 *DestinationBinding = DestBinding;
1014 return RPC_S_OK;
1015 }
1016
1017 /***********************************************************************
1018 * RpcBindingReset (RPCRT4.@)
1019 */
1020 RPC_STATUS RPC_ENTRY RpcBindingReset(RPC_BINDING_HANDLE Binding)
1021 {
1022 RpcBinding *bind = Binding;
1023
1024 TRACE("(%p)\n", Binding);
1025
1026 RPCRT4_strfree(bind->Endpoint);
1027 bind->Endpoint = NULL;
1028 if (bind->Assoc) RpcAssoc_Release(bind->Assoc);
1029 bind->Assoc = NULL;
1030
1031 return RPC_S_OK;
1032 }
1033
1034 /***********************************************************************
1035 * RpcImpersonateClient (RPCRT4.@)
1036 *
1037 * Impersonates the client connected via a binding handle so that security
1038 * checks are done in the context of the client.
1039 *
1040 * PARAMS
1041 * BindingHandle [I] Handle to the binding to the client.
1042 *
1043 * RETURNS
1044 * Success: RPS_S_OK.
1045 * Failure: RPC_STATUS value.
1046 *
1047 * NOTES
1048 *
1049 * If BindingHandle is NULL then the function impersonates the client
1050 * connected to the binding handle of the current thread.
1051 */
1052 RPC_STATUS WINAPI RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
1053 {
1054 RpcBinding *bind;
1055
1056 TRACE("(%p)\n", BindingHandle);
1057
1058 if (!BindingHandle) BindingHandle = I_RpcGetCurrentCallHandle();
1059 if (!BindingHandle) return RPC_S_INVALID_BINDING;
1060
1061 bind = BindingHandle;
1062 if (bind->FromConn)
1063 return rpcrt4_conn_impersonate_client(bind->FromConn);
1064 return RPC_S_WRONG_KIND_OF_BINDING;
1065 }
1066
1067 /***********************************************************************
1068 * RpcRevertToSelfEx (RPCRT4.@)
1069 *
1070 * Stops impersonating the client connected to the binding handle so that security
1071 * checks are no longer done in the context of the client.
1072 *
1073 * PARAMS
1074 * BindingHandle [I] Handle to the binding to the client.
1075 *
1076 * RETURNS
1077 * Success: RPS_S_OK.
1078 * Failure: RPC_STATUS value.
1079 *
1080 * NOTES
1081 *
1082 * If BindingHandle is NULL then the function stops impersonating the client
1083 * connected to the binding handle of the current thread.
1084 */
1085 RPC_STATUS WINAPI RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)
1086 {
1087 RpcBinding *bind;
1088
1089 TRACE("(%p)\n", BindingHandle);
1090
1091 if (!BindingHandle) BindingHandle = I_RpcGetCurrentCallHandle();
1092 if (!BindingHandle) return RPC_S_INVALID_BINDING;
1093
1094 bind = BindingHandle;
1095 if (bind->FromConn)
1096 return rpcrt4_conn_revert_to_self(bind->FromConn);
1097 return RPC_S_WRONG_KIND_OF_BINDING;
1098 }
1099
1100 static inline BOOL has_nt_auth_identity(ULONG AuthnLevel)
1101 {
1102 switch (AuthnLevel)
1103 {
1104 case RPC_C_AUTHN_GSS_NEGOTIATE:
1105 case RPC_C_AUTHN_WINNT:
1106 case RPC_C_AUTHN_GSS_KERBEROS:
1107 return TRUE;
1108 default:
1109 return FALSE;
1110 }
1111 }
1112
1113 RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc,
1114 CredHandle cred, TimeStamp exp,
1115 ULONG cbMaxToken,
1116 RPC_AUTH_IDENTITY_HANDLE identity,
1117 RpcAuthInfo **ret)
1118 {
1119 RpcAuthInfo *AuthInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo));
1120 if (!AuthInfo)
1121 return RPC_S_OUT_OF_MEMORY;
1122
1123 AuthInfo->refs = 1;
1124 AuthInfo->AuthnLevel = AuthnLevel;
1125 AuthInfo->AuthnSvc = AuthnSvc;
1126 AuthInfo->cred = cred;
1127 AuthInfo->exp = exp;
1128 AuthInfo->cbMaxToken = cbMaxToken;
1129 AuthInfo->identity = identity;
1130 AuthInfo->server_principal_name = NULL;
1131
1132 /* duplicate the SEC_WINNT_AUTH_IDENTITY structure, if applicable, to
1133 * enable better matching in RpcAuthInfo_IsEqual */
1134 if (identity && has_nt_auth_identity(AuthnSvc))
1135 {
1136 const SEC_WINNT_AUTH_IDENTITY_W *nt_identity = identity;
1137 AuthInfo->nt_identity = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo->nt_identity));
1138 if (!AuthInfo->nt_identity)
1139 {
1140 HeapFree(GetProcessHeap(), 0, AuthInfo);
1141 return RPC_S_OUT_OF_MEMORY;
1142 }
1143
1144 AuthInfo->nt_identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1145 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1146 AuthInfo->nt_identity->User = RPCRT4_strndupW(nt_identity->User, nt_identity->UserLength);
1147 else
1148 AuthInfo->nt_identity->User = RPCRT4_strndupAtoW((const char *)nt_identity->User, nt_identity->UserLength);
1149 AuthInfo->nt_identity->UserLength = nt_identity->UserLength;
1150 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1151 AuthInfo->nt_identity->Domain = RPCRT4_strndupW(nt_identity->Domain, nt_identity->DomainLength);
1152 else
1153 AuthInfo->nt_identity->Domain = RPCRT4_strndupAtoW((const char *)nt_identity->Domain, nt_identity->DomainLength);
1154 AuthInfo->nt_identity->DomainLength = nt_identity->DomainLength;
1155 if (nt_identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)
1156 AuthInfo->nt_identity->Password = RPCRT4_strndupW(nt_identity->Password, nt_identity->PasswordLength);
1157 else
1158 AuthInfo->nt_identity->Password = RPCRT4_strndupAtoW((const char *)nt_identity->Password, nt_identity->PasswordLength);
1159 AuthInfo->nt_identity->PasswordLength = nt_identity->PasswordLength;
1160
1161 if ((nt_identity->User && !AuthInfo->nt_identity->User) ||
1162 (nt_identity->Domain && !AuthInfo->nt_identity->Domain) ||
1163 (nt_identity->Password && !AuthInfo->nt_identity->Password))
1164 {
1165 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
1166 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
1167 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
1168 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
1169 HeapFree(GetProcessHeap(), 0, AuthInfo);
1170 return RPC_S_OUT_OF_MEMORY;
1171 }
1172 }
1173 else
1174 AuthInfo->nt_identity = NULL;
1175 *ret = AuthInfo;
1176 return RPC_S_OK;
1177 }
1178
1179 ULONG RpcAuthInfo_AddRef(RpcAuthInfo *AuthInfo)
1180 {
1181 return InterlockedIncrement(&AuthInfo->refs);
1182 }
1183
1184 ULONG RpcAuthInfo_Release(RpcAuthInfo *AuthInfo)
1185 {
1186 ULONG refs = InterlockedDecrement(&AuthInfo->refs);
1187
1188 if (!refs)
1189 {
1190 FreeCredentialsHandle(&AuthInfo->cred);
1191 if (AuthInfo->nt_identity)
1192 {
1193 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->User);
1194 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Domain);
1195 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity->Password);
1196 HeapFree(GetProcessHeap(), 0, AuthInfo->nt_identity);
1197 }
1198 HeapFree(GetProcessHeap(), 0, AuthInfo->server_principal_name);
1199 HeapFree(GetProcessHeap(), 0, AuthInfo);
1200 }
1201
1202 return refs;
1203 }
1204
1205 BOOL RpcAuthInfo_IsEqual(const RpcAuthInfo *AuthInfo1, const RpcAuthInfo *AuthInfo2)
1206 {
1207 if (AuthInfo1 == AuthInfo2)
1208 return TRUE;
1209
1210 if (!AuthInfo1 || !AuthInfo2)
1211 return FALSE;
1212
1213 if ((AuthInfo1->AuthnLevel != AuthInfo2->AuthnLevel) ||
1214 (AuthInfo1->AuthnSvc != AuthInfo2->AuthnSvc))
1215 return FALSE;
1216
1217 if (AuthInfo1->identity == AuthInfo2->identity)
1218 return TRUE;
1219
1220 if (!AuthInfo1->identity || !AuthInfo2->identity)
1221 return FALSE;
1222
1223 if (has_nt_auth_identity(AuthInfo1->AuthnSvc))
1224 {
1225 const SEC_WINNT_AUTH_IDENTITY_W *identity1 = AuthInfo1->nt_identity;
1226 const SEC_WINNT_AUTH_IDENTITY_W *identity2 = AuthInfo2->nt_identity;
1227 /* compare user names */
1228 if (identity1->UserLength != identity2->UserLength ||
1229 memcmp(identity1->User, identity2->User, identity1->UserLength))
1230 return FALSE;
1231 /* compare domain names */
1232 if (identity1->DomainLength != identity2->DomainLength ||
1233 memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1234 return FALSE;
1235 /* compare passwords */
1236 if (identity1->PasswordLength != identity2->PasswordLength ||
1237 memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1238 return FALSE;
1239 }
1240 else
1241 return FALSE;
1242
1243 return TRUE;
1244 }
1245
1246 static RPC_STATUS RpcQualityOfService_Create(const RPC_SECURITY_QOS *qos_src, BOOL unicode, RpcQualityOfService **qos_dst)
1247 {
1248 RpcQualityOfService *qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos));
1249
1250 if (!qos)
1251 return RPC_S_OUT_OF_RESOURCES;
1252
1253 qos->refs = 1;
1254 qos->qos = HeapAlloc(GetProcessHeap(), 0, sizeof(*qos->qos));
1255 if (!qos->qos) goto error;
1256 qos->qos->Version = qos_src->Version;
1257 qos->qos->Capabilities = qos_src->Capabilities;
1258 qos->qos->IdentityTracking = qos_src->IdentityTracking;
1259 qos->qos->ImpersonationType = qos_src->ImpersonationType;
1260 qos->qos->AdditionalSecurityInfoType = 0;
1261
1262 if (qos_src->Version >= 2)
1263 {
1264 const RPC_SECURITY_QOS_V2_W *qos_src2 = (const RPC_SECURITY_QOS_V2_W *)qos_src;
1265 qos->qos->AdditionalSecurityInfoType = qos_src2->AdditionalSecurityInfoType;
1266 if (qos_src2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1267 {
1268 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_src = qos_src2->u.HttpCredentials;
1269 RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials_dst;
1270
1271 http_credentials_dst = HeapAlloc(GetProcessHeap(), 0, sizeof(*http_credentials_dst));
1272 qos->qos->u.HttpCredentials = http_credentials_dst;
1273 if (!http_credentials_dst) goto error;
1274 http_credentials_dst->TransportCredentials = NULL;
1275 http_credentials_dst->Flags = http_credentials_src->Flags;
1276 http_credentials_dst->AuthenticationTarget = http_credentials_src->AuthenticationTarget;
1277 http_credentials_dst->NumberOfAuthnSchemes = http_credentials_src->NumberOfAuthnSchemes;
1278 http_credentials_dst->AuthnSchemes = NULL;
1279 http_credentials_dst->ServerCertificateSubject = NULL;
1280 if (http_credentials_src->TransportCredentials)
1281 {
1282 SEC_WINNT_AUTH_IDENTITY_W *cred_dst;
1283 cred_dst = http_credentials_dst->TransportCredentials = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cred_dst));
1284 if (!cred_dst) goto error;
1285 cred_dst->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1286 if (unicode)
1287 {
1288 const SEC_WINNT_AUTH_IDENTITY_W *cred_src = http_credentials_src->TransportCredentials;
1289 cred_dst->UserLength = cred_src->UserLength;
1290 cred_dst->PasswordLength = cred_src->PasswordLength;
1291 cred_dst->DomainLength = cred_src->DomainLength;
1292 cred_dst->User = RPCRT4_strndupW(cred_src->User, cred_src->UserLength);
1293 cred_dst->Password = RPCRT4_strndupW(cred_src->Password, cred_src->PasswordLength);
1294 cred_dst->Domain = RPCRT4_strndupW(cred_src->Domain, cred_src->DomainLength);
1295 }
1296 else
1297 {
1298 const SEC_WINNT_AUTH_IDENTITY_A *cred_src = (const SEC_WINNT_AUTH_IDENTITY_A *)http_credentials_src->TransportCredentials;
1299 cred_dst->UserLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, NULL, 0);
1300 cred_dst->DomainLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, NULL, 0);
1301 cred_dst->PasswordLength = MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, NULL, 0);
1302 cred_dst->User = HeapAlloc(GetProcessHeap(), 0, cred_dst->UserLength * sizeof(WCHAR));
1303 cred_dst->Password = HeapAlloc(GetProcessHeap(), 0, cred_dst->PasswordLength * sizeof(WCHAR));
1304 cred_dst->Domain = HeapAlloc(GetProcessHeap(), 0, cred_dst->DomainLength * sizeof(WCHAR));
1305 if (!cred_dst->Password || !cred_dst->Domain) goto error;
1306 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, cred_dst->User, cred_dst->UserLength);
1307 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, cred_dst->Domain, cred_dst->DomainLength);
1308 MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, cred_dst->Password, cred_dst->PasswordLength);
1309 }
1310 }
1311 if (http_credentials_src->NumberOfAuthnSchemes)
1312 {
1313 http_credentials_dst->AuthnSchemes = HeapAlloc(GetProcessHeap(), 0, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1314 if (!http_credentials_dst->AuthnSchemes) goto error;
1315 memcpy(http_credentials_dst->AuthnSchemes, http_credentials_src->AuthnSchemes, http_credentials_src->NumberOfAuthnSchemes * sizeof(*http_credentials_dst->AuthnSchemes));
1316 }
1317 if (http_credentials_src->ServerCertificateSubject)
1318 {
1319 if (unicode)
1320 http_credentials_dst->ServerCertificateSubject =
1321 RPCRT4_strndupW(http_credentials_src->ServerCertificateSubject,
1322 lstrlenW(http_credentials_src->ServerCertificateSubject));
1323 else
1324 http_credentials_dst->ServerCertificateSubject =
1325 RPCRT4_strdupAtoW((char *)http_credentials_src->ServerCertificateSubject);
1326 if (!http_credentials_dst->ServerCertificateSubject) goto error;
1327 }
1328 }
1329 }
1330 *qos_dst = qos;
1331 return RPC_S_OK;
1332
1333 error:
1334 if (qos->qos)
1335 {
1336 if (qos->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP &&
1337 qos->qos->u.HttpCredentials)
1338 {
1339 if (qos->qos->u.HttpCredentials->TransportCredentials)
1340 {
1341 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->User);
1342 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Domain);
1343 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Password);
1344 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials);
1345 }
1346 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->AuthnSchemes);
1347 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->ServerCertificateSubject);
1348 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials);
1349 }
1350 HeapFree(GetProcessHeap(), 0, qos->qos);
1351 }
1352 HeapFree(GetProcessHeap(), 0, qos);
1353 return RPC_S_OUT_OF_RESOURCES;
1354 }
1355
1356 ULONG RpcQualityOfService_AddRef(RpcQualityOfService *qos)
1357 {
1358 return InterlockedIncrement(&qos->refs);
1359 }
1360
1361 ULONG RpcQualityOfService_Release(RpcQualityOfService *qos)
1362 {
1363 ULONG refs = InterlockedDecrement(&qos->refs);
1364
1365 if (!refs)
1366 {
1367 if (qos->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1368 {
1369 if (qos->qos->u.HttpCredentials->TransportCredentials)
1370 {
1371 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->User);
1372 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Domain);
1373 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials->Password);
1374 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->TransportCredentials);
1375 }
1376 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->AuthnSchemes);
1377 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials->ServerCertificateSubject);
1378 HeapFree(GetProcessHeap(), 0, qos->qos->u.HttpCredentials);
1379 }
1380 HeapFree(GetProcessHeap(), 0, qos->qos);
1381 HeapFree(GetProcessHeap(), 0, qos);
1382 }
1383 return refs;
1384 }
1385
1386 BOOL RpcQualityOfService_IsEqual(const RpcQualityOfService *qos1, const RpcQualityOfService *qos2)
1387 {
1388 if (qos1 == qos2)
1389 return TRUE;
1390
1391 if (!qos1 || !qos2)
1392 return FALSE;
1393
1394 TRACE("qos1 = { %d %d %d %d }, qos2 = { %d %d %d %d }\n",
1395 qos1->qos->Capabilities, qos1->qos->IdentityTracking,
1396 qos1->qos->ImpersonationType, qos1->qos->AdditionalSecurityInfoType,
1397 qos2->qos->Capabilities, qos2->qos->IdentityTracking,
1398 qos2->qos->ImpersonationType, qos2->qos->AdditionalSecurityInfoType);
1399
1400 if ((qos1->qos->Capabilities != qos2->qos->Capabilities) ||
1401 (qos1->qos->IdentityTracking != qos2->qos->IdentityTracking) ||
1402 (qos1->qos->ImpersonationType != qos2->qos->ImpersonationType) ||
1403 (qos1->qos->AdditionalSecurityInfoType != qos2->qos->AdditionalSecurityInfoType))
1404 return FALSE;
1405
1406 if (qos1->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1407 {
1408 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials1 = qos1->qos->u.HttpCredentials;
1409 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_credentials2 = qos2->qos->u.HttpCredentials;
1410
1411 if (http_credentials1->Flags != http_credentials2->Flags)
1412 return FALSE;
1413
1414 if (http_credentials1->AuthenticationTarget != http_credentials2->AuthenticationTarget)
1415 return FALSE;
1416
1417 if (http_credentials1->NumberOfAuthnSchemes != http_credentials2->NumberOfAuthnSchemes)
1418 return FALSE;
1419
1420 if ((!http_credentials1->AuthnSchemes && http_credentials2->AuthnSchemes) ||
1421 (http_credentials1->AuthnSchemes && !http_credentials2->AuthnSchemes))
1422 return FALSE;
1423
1424 if (memcmp(http_credentials1->AuthnSchemes, http_credentials2->AuthnSchemes,
1425 http_credentials1->NumberOfAuthnSchemes * sizeof(http_credentials1->AuthnSchemes[0])))
1426 return FALSE;
1427
1428 /* server certificate subject not currently used */
1429
1430 if (http_credentials1->TransportCredentials != http_credentials2->TransportCredentials)
1431 {
1432 const SEC_WINNT_AUTH_IDENTITY_W *identity1 = http_credentials1->TransportCredentials;
1433 const SEC_WINNT_AUTH_IDENTITY_W *identity2 = http_credentials2->TransportCredentials;
1434
1435 if (!identity1 || !identity2)
1436 return FALSE;
1437
1438 /* compare user names */
1439 if (identity1->UserLength != identity2->UserLength ||
1440 memcmp(identity1->User, identity2->User, identity1->UserLength))
1441 return FALSE;
1442 /* compare domain names */
1443 if (identity1->DomainLength != identity2->DomainLength ||
1444 memcmp(identity1->Domain, identity2->Domain, identity1->DomainLength))
1445 return FALSE;
1446 /* compare passwords */
1447 if (identity1->PasswordLength != identity2->PasswordLength ||
1448 memcmp(identity1->Password, identity2->Password, identity1->PasswordLength))
1449 return FALSE;
1450 }
1451 }
1452
1453 return TRUE;
1454 }
1455
1456 /***********************************************************************
1457 * RpcRevertToSelf (RPCRT4.@)
1458 */
1459 RPC_STATUS WINAPI RpcRevertToSelf(void)
1460 {
1461 TRACE("\n");
1462 return RpcRevertToSelfEx(NULL);
1463 }
1464
1465 /***********************************************************************
1466 * RpcMgmtSetComTimeout (RPCRT4.@)
1467 */
1468 RPC_STATUS WINAPI RpcMgmtSetComTimeout(RPC_BINDING_HANDLE BindingHandle, unsigned int Timeout)
1469 {
1470 FIXME("(%p, %d): stub\n", BindingHandle, Timeout);
1471 return RPC_S_OK;
1472 }
1473
1474 /***********************************************************************
1475 * RpcBindingInqAuthInfoExA (RPCRT4.@)
1476 */
1477 RPCRTAPI RPC_STATUS RPC_ENTRY
1478 RpcBindingInqAuthInfoExA( RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel,
1479 ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
1480 ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
1481 {
1482 RPC_STATUS status;
1483 RPC_WSTR principal;
1484
1485 TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1486 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1487
1488 status = RpcBindingInqAuthInfoExW(Binding, ServerPrincName ? &principal : NULL, AuthnLevel,
1489 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1490 if (status == RPC_S_OK && ServerPrincName)
1491 {
1492 *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
1493 RpcStringFreeW(&principal);
1494 if (!*ServerPrincName) return RPC_S_OUT_OF_MEMORY;
1495 }
1496
1497 return status;
1498 }
1499
1500 /***********************************************************************
1501 * RpcBindingInqAuthInfoExW (RPCRT4.@)
1502 */
1503 RPCRTAPI RPC_STATUS RPC_ENTRY
1504 RpcBindingInqAuthInfoExW( RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel,
1505 ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
1506 ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
1507 {
1508 RpcBinding *bind = Binding;
1509
1510 TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
1511 AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
1512
1513 if (!bind->AuthInfo) return RPC_S_BINDING_HAS_NO_AUTH;
1514
1515 if (SecurityQOS)
1516 {
1517 FIXME("QOS not implemented\n");
1518 return RPC_S_INVALID_BINDING;
1519 }
1520
1521 if (ServerPrincName)
1522 {
1523 if (bind->AuthInfo->server_principal_name)
1524 {
1525 *ServerPrincName = RPCRT4_strdupW(bind->AuthInfo->server_principal_name);
1526 if (!*ServerPrincName) return RPC_S_OUT_OF_MEMORY;
1527 }
1528 else *ServerPrincName = NULL;
1529 }
1530 if (AuthnLevel) *AuthnLevel = bind->AuthInfo->AuthnLevel;
1531 if (AuthnSvc) *AuthnSvc = bind->AuthInfo->AuthnSvc;
1532 if (AuthIdentity) *AuthIdentity = bind->AuthInfo->identity;
1533 if (AuthzSvc)
1534 {
1535 FIXME("authorization service not implemented\n");
1536 *AuthzSvc = RPC_C_AUTHZ_NONE;
1537 }
1538
1539 return RPC_S_OK;
1540 }
1541
1542 /***********************************************************************
1543 * RpcBindingInqAuthInfoA (RPCRT4.@)
1544 */
1545 RPCRTAPI RPC_STATUS RPC_ENTRY
1546 RpcBindingInqAuthInfoA( RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel,
1547 ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
1548 {
1549 return RpcBindingInqAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
1550 AuthzSvc, 0, NULL);
1551 }
1552
1553 /***********************************************************************
1554 * RpcBindingInqAuthInfoW (RPCRT4.@)
1555 */
1556 RPCRTAPI RPC_STATUS RPC_ENTRY
1557 RpcBindingInqAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel,
1558 ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
1559 {
1560 return RpcBindingInqAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
1561 AuthzSvc, 0, NULL);
1562 }
1563
1564 /***********************************************************************
1565 * RpcBindingInqAuthClientA (RPCRT4.@)
1566 */
1567 RPCRTAPI RPC_STATUS RPC_ENTRY
1568 RpcBindingInqAuthClientA( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
1569 RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
1570 ULONG *AuthzSvc )
1571 {
1572 return RpcBindingInqAuthClientExA(ClientBinding, Privs, ServerPrincName, AuthnLevel,
1573 AuthnSvc, AuthzSvc, 0);
1574 }
1575
1576 /***********************************************************************
1577 * RpcBindingInqAuthClientW (RPCRT4.@)
1578 */
1579 RPCRTAPI RPC_STATUS RPC_ENTRY
1580 RpcBindingInqAuthClientW( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
1581 RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
1582 ULONG *AuthzSvc )
1583 {
1584 return RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName, AuthnLevel,
1585 AuthnSvc, AuthzSvc, 0);
1586 }
1587
1588 /***********************************************************************
1589 * RpcBindingInqAuthClientExA (RPCRT4.@)
1590 */
1591 RPCRTAPI RPC_STATUS RPC_ENTRY
1592 RpcBindingInqAuthClientExA( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
1593 RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
1594 ULONG *AuthzSvc, ULONG Flags )
1595 {
1596 RPC_STATUS status;
1597 RPC_WSTR principal;
1598
1599 TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
1600 AuthnSvc, AuthzSvc, Flags);
1601
1602 status = RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName ? &principal : NULL,
1603 AuthnLevel, AuthnSvc, AuthzSvc, Flags);
1604 if (status == RPC_S_OK && ServerPrincName)
1605 {
1606 *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
1607 if (!*ServerPrincName && principal) status = RPC_S_OUT_OF_MEMORY;
1608 RpcStringFreeW(&principal);
1609 }
1610
1611 return status;
1612 }
1613
1614 /***********************************************************************
1615 * RpcBindingInqAuthClientExW (RPCRT4.@)
1616 */
1617 RPCRTAPI RPC_STATUS RPC_ENTRY
1618 RpcBindingInqAuthClientExW( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
1619 RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
1620 ULONG *AuthzSvc, ULONG Flags )
1621 {
1622 RpcBinding *bind;
1623
1624 TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
1625 AuthnSvc, AuthzSvc, Flags);
1626
1627 if (!ClientBinding) ClientBinding = I_RpcGetCurrentCallHandle();
1628 if (!ClientBinding) return RPC_S_INVALID_BINDING;
1629
1630 bind = ClientBinding;
1631 if (!bind->FromConn) return RPC_S_INVALID_BINDING;
1632
1633 return rpcrt4_conn_inquire_auth_client(bind->FromConn, Privs,
1634 ServerPrincName, AuthnLevel,
1635 AuthnSvc, AuthzSvc, Flags);
1636 }
1637
1638 /***********************************************************************
1639 * RpcBindingServerFromClient (RPCRT4.@)
1640 */
1641 RPCRTAPI RPC_STATUS RPC_ENTRY
1642 RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE* ServerBinding)
1643 {
1644 RpcBinding* bind = ClientBinding;
1645 RpcBinding* NewBinding;
1646
1647 if (!bind)
1648 bind = I_RpcGetCurrentCallHandle();
1649
1650 if (!bind->server)
1651 return RPC_S_INVALID_BINDING;
1652
1653 RPCRT4_AllocBinding(&NewBinding, TRUE);
1654 NewBinding->Protseq = RPCRT4_strdupA(bind->Protseq);
1655 NewBinding->NetworkAddr = RPCRT4_strdupA(bind->NetworkAddr);
1656
1657 *ServerBinding = NewBinding;
1658
1659 return RPC_S_OK;
1660 }
1661
1662 /***********************************************************************
1663 * RpcBindingSetAuthInfoExA (RPCRT4.@)
1664 */
1665 RPCRTAPI RPC_STATUS RPC_ENTRY
1666 RpcBindingSetAuthInfoExA( RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName,
1667 ULONG AuthnLevel, ULONG AuthnSvc,
1668 RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
1669 RPC_SECURITY_QOS *SecurityQos )
1670 {
1671 RpcBinding* bind = Binding;
1672 SECURITY_STATUS r;
1673 CredHandle cred;
1674 TimeStamp exp;
1675 ULONG package_count;
1676 ULONG i;
1677 PSecPkgInfoA packages;
1678 ULONG cbMaxToken;
1679
1680 TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_a((const char*)ServerPrincName),
1681 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1682
1683 if (SecurityQos)
1684 {
1685 RPC_STATUS status;
1686
1687 TRACE("SecurityQos { Version=%d, Capabilities=0x%x, IdentityTracking=%d, ImpersonationLevel=%d",
1688 SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1689 if (SecurityQos->Version >= 2)
1690 {
1691 const RPC_SECURITY_QOS_V2_A *SecurityQos2 = (const RPC_SECURITY_QOS_V2_A *)SecurityQos;
1692 TRACE(", AdditionalSecurityInfoType=%d", SecurityQos2->AdditionalSecurityInfoType);
1693 if (SecurityQos2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1694 TRACE(", { %p, 0x%x, %d, %d, %p(%u), %s }",
1695 SecurityQos2->u.HttpCredentials->TransportCredentials,
1696 SecurityQos2->u.HttpCredentials->Flags,
1697 SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1698 SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1699 SecurityQos2->u.HttpCredentials->AuthnSchemes,
1700 SecurityQos2->u.HttpCredentials->AuthnSchemes ? *SecurityQos2->u.HttpCredentials->AuthnSchemes : 0,
1701 SecurityQos2->u.HttpCredentials->ServerCertificateSubject);
1702 }
1703 TRACE("}\n");
1704 status = RpcQualityOfService_Create(SecurityQos, FALSE, &bind->QOS);
1705 if (status != RPC_S_OK)
1706 return status;
1707 }
1708 else
1709 {
1710 if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1711 bind->QOS = NULL;
1712 }
1713
1714 if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1715 AuthnSvc = RPC_C_AUTHN_WINNT;
1716
1717 /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1718 if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1719 AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1720
1721 if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1722 {
1723 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1724 bind->AuthInfo = NULL;
1725 return RPC_S_OK;
1726 }
1727
1728 if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1729 {
1730 FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1731 return RPC_S_UNKNOWN_AUTHN_LEVEL;
1732 }
1733
1734 /* RPC_C_AUTHN_WINNT ignores the AuthzSvr parameter */
1735 if (AuthzSvr && AuthnSvc != RPC_C_AUTHN_WINNT)
1736 {
1737 FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1738 return RPC_S_UNKNOWN_AUTHZ_SERVICE;
1739 }
1740
1741 r = EnumerateSecurityPackagesA(&package_count, &packages);
1742 if (r != SEC_E_OK)
1743 {
1744 ERR("EnumerateSecurityPackagesA failed with error 0x%08x\n", r);
1745 return RPC_S_SEC_PKG_ERROR;
1746 }
1747
1748 for (i = 0; i < package_count; i++)
1749 if (packages[i].wRPCID == AuthnSvc)
1750 break;
1751
1752 if (i == package_count)
1753 {
1754 FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1755 FreeContextBuffer(packages);
1756 return RPC_S_UNKNOWN_AUTHN_SERVICE;
1757 }
1758
1759 TRACE("found package %s for service %u\n", packages[i].Name, AuthnSvc);
1760 r = AcquireCredentialsHandleA(NULL, packages[i].Name, SECPKG_CRED_OUTBOUND, NULL,
1761 AuthIdentity, NULL, NULL, &cred, &exp);
1762 cbMaxToken = packages[i].cbMaxToken;
1763 FreeContextBuffer(packages);
1764 if (r == ERROR_SUCCESS)
1765 {
1766 RpcAuthInfo *new_auth_info;
1767 r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1768 AuthIdentity, &new_auth_info);
1769 if (r == RPC_S_OK)
1770 {
1771 new_auth_info->server_principal_name = RPCRT4_strdupAtoW((char *)ServerPrincName);
1772 if (!ServerPrincName || new_auth_info->server_principal_name)
1773 {
1774 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1775 bind->AuthInfo = new_auth_info;
1776 }
1777 else
1778 {
1779 RpcAuthInfo_Release(new_auth_info);
1780 r = RPC_S_OUT_OF_MEMORY;
1781 }
1782 }
1783 else
1784 FreeCredentialsHandle(&cred);
1785 return r;
1786 }
1787 else
1788 {
1789 ERR("AcquireCredentialsHandleA failed with error 0x%08x\n", r);
1790 return RPC_S_SEC_PKG_ERROR;
1791 }
1792 }
1793
1794 /***********************************************************************
1795 * RpcBindingSetAuthInfoExW (RPCRT4.@)
1796 */
1797 RPCRTAPI RPC_STATUS RPC_ENTRY
1798 RpcBindingSetAuthInfoExW( RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel,
1799 ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
1800 RPC_SECURITY_QOS *SecurityQos )
1801 {
1802 RpcBinding* bind = Binding;
1803 SECURITY_STATUS r;
1804 CredHandle cred;
1805 TimeStamp exp;
1806 ULONG package_count;
1807 ULONG i;
1808 PSecPkgInfoW packages;
1809 ULONG cbMaxToken;
1810
1811 TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_w(ServerPrincName),
1812 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
1813
1814 if (SecurityQos)
1815 {
1816 RPC_STATUS status;
1817
1818 TRACE("SecurityQos { Version=%d, Capabilities=0x%x, IdentityTracking=%d, ImpersonationLevel=%d",
1819 SecurityQos->Version, SecurityQos->Capabilities, SecurityQos->IdentityTracking, SecurityQos->ImpersonationType);
1820 if (SecurityQos->Version >= 2)
1821 {
1822 const RPC_SECURITY_QOS_V2_W *SecurityQos2 = (const RPC_SECURITY_QOS_V2_W *)SecurityQos;
1823 TRACE(", AdditionalSecurityInfoType=%d", SecurityQos2->AdditionalSecurityInfoType);
1824 if (SecurityQos2->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP)
1825 TRACE(", { %p, 0x%x, %d, %d, %p(%u), %s }",
1826 SecurityQos2->u.HttpCredentials->TransportCredentials,
1827 SecurityQos2->u.HttpCredentials->Flags,
1828 SecurityQos2->u.HttpCredentials->AuthenticationTarget,
1829 SecurityQos2->u.HttpCredentials->NumberOfAuthnSchemes,
1830 SecurityQos2->u.HttpCredentials->AuthnSchemes,
1831 SecurityQos2->u.HttpCredentials->AuthnSchemes ? *SecurityQos2->u.HttpCredentials->AuthnSchemes : 0,
1832 debugstr_w(SecurityQos2->u.HttpCredentials->ServerCertificateSubject));
1833 }
1834 TRACE("}\n");
1835 status = RpcQualityOfService_Create(SecurityQos, TRUE, &bind->QOS);
1836 if (status != RPC_S_OK)
1837 return status;
1838 }
1839 else
1840 {
1841 if (bind->QOS) RpcQualityOfService_Release(bind->QOS);
1842 bind->QOS = NULL;
1843 }
1844
1845 if (AuthnSvc == RPC_C_AUTHN_DEFAULT)
1846 AuthnSvc = RPC_C_AUTHN_WINNT;
1847
1848 /* FIXME: the mapping should probably be retrieved using SSPI somehow */
1849 if (AuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
1850 AuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
1851
1852 if ((AuthnLevel == RPC_C_AUTHN_LEVEL_NONE) || (AuthnSvc == RPC_C_AUTHN_NONE))
1853 {
1854 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1855 bind->AuthInfo = NULL;
1856 return RPC_S_OK;
1857 }
1858
1859 if (AuthnLevel > RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
1860 {
1861 FIXME("unknown AuthnLevel %u\n", AuthnLevel);
1862 return RPC_S_UNKNOWN_AUTHN_LEVEL;
1863 }
1864
1865 /* RPC_C_AUTHN_WINNT ignores the AuthzSvr parameter */
1866 if (AuthzSvr && AuthnSvc != RPC_C_AUTHN_WINNT)
1867 {
1868 FIXME("unsupported AuthzSvr %u\n", AuthzSvr);
1869 return RPC_S_UNKNOWN_AUTHZ_SERVICE;
1870 }
1871
1872 r = EnumerateSecurityPackagesW(&package_count, &packages);
1873 if (r != SEC_E_OK)
1874 {
1875 ERR("EnumerateSecurityPackagesW failed with error 0x%08x\n", r);
1876 return RPC_S_SEC_PKG_ERROR;
1877 }
1878
1879 for (i = 0; i < package_count; i++)
1880 if (packages[i].wRPCID == AuthnSvc)
1881 break;
1882
1883 if (i == package_count)
1884 {
1885 FIXME("unsupported AuthnSvc %u\n", AuthnSvc);
1886 FreeContextBuffer(packages);
1887 return RPC_S_UNKNOWN_AUTHN_SERVICE;
1888 }
1889
1890 TRACE("found package %s for service %u\n", debugstr_w(packages[i].Name), AuthnSvc);
1891 r = AcquireCredentialsHandleW(NULL, packages[i].Name, SECPKG_CRED_OUTBOUND, NULL,
1892 AuthIdentity, NULL, NULL, &cred, &exp);
1893 cbMaxToken = packages[i].cbMaxToken;
1894 FreeContextBuffer(packages);
1895 if (r == ERROR_SUCCESS)
1896 {
1897 RpcAuthInfo *new_auth_info;
1898 r = RpcAuthInfo_Create(AuthnLevel, AuthnSvc, cred, exp, cbMaxToken,
1899 AuthIdentity, &new_auth_info);
1900 if (r == RPC_S_OK)
1901 {
1902 new_auth_info->server_principal_name = RPCRT4_strdupW(ServerPrincName);
1903 if (!ServerPrincName || new_auth_info->server_principal_name)
1904 {
1905 if (bind->AuthInfo) RpcAuthInfo_Release(bind->AuthInfo);
1906 bind->AuthInfo = new_auth_info;
1907 }
1908 else
1909 {
1910 RpcAuthInfo_Release(new_auth_info);
1911 r = RPC_S_OUT_OF_MEMORY;
1912 }
1913 }
1914 else
1915 FreeCredentialsHandle(&cred);
1916 return r;
1917 }
1918 else
1919 {
1920 ERR("AcquireCredentialsHandleW failed with error 0x%08x\n", r);
1921 return RPC_S_SEC_PKG_ERROR;
1922 }
1923 }
1924
1925 /***********************************************************************
1926 * RpcBindingSetAuthInfoA (RPCRT4.@)
1927 */
1928 RPCRTAPI RPC_STATUS RPC_ENTRY
1929 RpcBindingSetAuthInfoA( RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel,
1930 ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr )
1931 {
1932 TRACE("%p %s %u %u %p %u\n", Binding, debugstr_a((const char*)ServerPrincName),
1933 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1934 return RpcBindingSetAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1935 }
1936
1937 /***********************************************************************
1938 * RpcBindingSetAuthInfoW (RPCRT4.@)
1939 */
1940 RPCRTAPI RPC_STATUS RPC_ENTRY
1941 RpcBindingSetAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel,
1942 ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr )
1943 {
1944 TRACE("%p %s %u %u %p %u\n", Binding, debugstr_w(ServerPrincName),
1945 AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
1946 return RpcBindingSetAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
1947 }
1948
1949 /***********************************************************************
1950 * RpcBindingSetOption (RPCRT4.@)
1951 */
1952 RPC_STATUS WINAPI RpcBindingSetOption(RPC_BINDING_HANDLE BindingHandle, ULONG Option, ULONG_PTR OptionValue)
1953 {
1954 TRACE("(%p, %d, %ld)\n", BindingHandle, Option, OptionValue);
1955
1956 switch (Option)
1957 {
1958 case RPC_C_OPT_COOKIE_AUTH:
1959 {
1960 RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR *cookie = (RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR *)OptionValue;
1961 RpcBinding *binding = BindingHandle;
1962 int len = MultiByteToWideChar(CP_ACP, 0, cookie->Buffer, cookie->BufferSize, NULL, 0);
1963 WCHAR *str;
1964
1965 if (!(str = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)))) return RPC_S_OUT_OF_MEMORY;
1966 MultiByteToWideChar(CP_ACP, 0, cookie->Buffer, cookie->BufferSize, str, len);
1967 str[len] = 0;
1968 HeapFree(GetProcessHeap(), 0, binding->CookieAuth);
1969 binding->CookieAuth = str;
1970 break;
1971 }
1972 default:
1973 FIXME("option %u not supported\n", Option);
1974 break;
1975 }
1976 return RPC_S_OK;
1977 }
1978
1979 /***********************************************************************
1980 * I_RpcBindingInqLocalClientPID (RPCRT4.@)
1981 */
1982
1983 RPC_STATUS WINAPI I_RpcBindingInqLocalClientPID(RPC_BINDING_HANDLE ClientBinding, ULONG *ClientPID)
1984 {
1985 FIXME("%p %p: stub\n", ClientBinding, ClientPID);
1986 return RPC_S_INVALID_BINDING;
1987 }
Windows API implementation