?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli:security: allow spaces after BAD:
[Samba.git] / librpc / rpc / binding.c
blobeaf3430c9d32207c08df757eb578e73ab5511c76
1 /*
2 Unix SMB/CIFS implementation.
3
4 dcerpc utility functions
5
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
9 Copyright (C) Rafal Szczesniak 2006
10 Copyright (C) Stefan Metzmacher 2014
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "../../lib/util/util_net.h"
28 #include "librpc/gen_ndr/ndr_epmapper.h"
29 #include "librpc/gen_ndr/ndr_misc.h"
30 #include "librpc/rpc/dcerpc.h"
31 #include "rpc_common.h"
32
33 #undef strcasecmp
34 #undef strncasecmp
35
36 #define MAX_PROTSEQ 10
37
38 struct dcerpc_binding {
39 enum dcerpc_transport_t transport;
40 struct GUID object;
41 const char *object_string;
42 const char *host;
43 const char *target_hostname;
44 const char *target_principal;
45 const char *endpoint;
46 const char **options;
47 uint32_t flags;
48 uint32_t assoc_group_id;
49 char assoc_group_string[11]; /* 0x3456789a + '\0' */
50 };
51
52 static const struct {
53 const char *name;
54 enum dcerpc_transport_t transport;
55 int num_protocols;
56 enum epm_protocol protseq[MAX_PROTSEQ];
57 } transports[] = {
58 { "ncacn_np", NCACN_NP, 3,
59 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB, EPM_PROTOCOL_NETBIOS }},
60 { "ncacn_ip_tcp", NCACN_IP_TCP, 3,
61 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP, EPM_PROTOCOL_IP } },
62 { "ncacn_http", NCACN_HTTP, 3,
63 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_HTTP, EPM_PROTOCOL_IP } },
64 { "ncadg_ip_udp", NCACN_IP_UDP, 3,
65 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UDP, EPM_PROTOCOL_IP } },
66 { "ncalrpc", NCALRPC, 2,
67 { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_NAMED_PIPE } },
68 { "ncacn_unix_stream", NCACN_UNIX_STREAM, 2,
69 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_UNIX_DS } },
70 { "ncadg_unix_dgram", NCADG_UNIX_DGRAM, 2,
71 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UNIX_DS } },
72 { "ncacn_at_dsp", NCACN_AT_DSP, 3,
73 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DSP } },
74 { "ncadg_at_ddp", NCADG_AT_DDP, 3,
75 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DDP } },
76 { "ncacn_vns_ssp", NCACN_VNS_SPP, 3,
77 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_SPP } },
78 { "ncacn_vns_ipc", NCACN_VNS_IPC, 3,
79 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_IPC }, },
80 { "ncadg_ipx", NCADG_IPX, 2,
81 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_IPX },
82 },
83 { "ncacn_spx", NCACN_SPX, 3,
84 /* I guess some MS programmer confused the identifier for
85 * EPM_PROTOCOL_UUID (0x0D or 13) with the one for
86 * EPM_PROTOCOL_SPX (0x13) here. -- jelmer*/
87 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_UUID },
88 },
89 };
90
91 static const struct ncacn_option {
92 const char *name;
93 uint32_t flag;
94 } ncacn_options[] = {
95 {"sign", DCERPC_SIGN},
96 {"seal", DCERPC_SEAL},
97 {"connect", DCERPC_CONNECT},
98 {"spnego", DCERPC_AUTH_SPNEGO},
99 {"ntlm", DCERPC_AUTH_NTLM},
100 {"krb5", DCERPC_AUTH_KRB5},
101 {"schannel", DCERPC_SCHANNEL | DCERPC_SCHANNEL_AUTO},
102 {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
103 {"print", DCERPC_DEBUG_PRINT_BOTH},
104 {"padcheck", DCERPC_DEBUG_PAD_CHECK},
105 {"bigendian", DCERPC_PUSH_BIGENDIAN},
106 {"smb1", DCERPC_SMB1},
107 {"smb2", DCERPC_SMB2},
108 {"ndr64", DCERPC_NDR64},
109 {"packet", DCERPC_PACKET},
110 };
111
112 static const struct ncacn_option *ncacn_option_by_name(const char *name)
113 {
114 size_t i;
115
116 for (i=0; i<ARRAY_SIZE(ncacn_options); i++) {
117 int ret;
118
119 ret = strcasecmp(ncacn_options[i].name, name);
120 if (ret != 0) {
121 continue;
122 }
123
124 return &ncacn_options[i];
125 }
126
127 return NULL;
128 }
129
130 const char *epm_floor_string(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
131 {
132 struct ndr_syntax_id syntax;
133 NTSTATUS status;
134
135 switch(epm_floor->lhs.protocol) {
136 case EPM_PROTOCOL_UUID:
137 status = dcerpc_floor_get_uuid_full(epm_floor, &syntax);
138 if (NT_STATUS_IS_OK(status)) {
139 /* lhs is used: UUID */
140 struct GUID_txt_buf buf;
141
142 if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax_ndr.uuid)) {
143 return "NDR";
144 }
145
146 if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax_ndr64.uuid)) {
147 return "NDR64";
148 }
149
150 return talloc_asprintf(
151 mem_ctx,
152 " uuid %s/0x%02x",
153 GUID_buf_string(&syntax.uuid, &buf),
154 syntax.if_version);
155 } else { /* IPX */
156 return talloc_asprintf(mem_ctx, "IPX:%s",
157 data_blob_hex_string_upper(mem_ctx, &epm_floor->rhs.uuid.unknown));
158 }
159
160 case EPM_PROTOCOL_NCACN:
161 return "RPC-C";
162
163 case EPM_PROTOCOL_NCADG:
164 return "RPC";
165
166 case EPM_PROTOCOL_NCALRPC:
167 return "NCALRPC";
168
169 case EPM_PROTOCOL_DNET_NSP:
170 return "DNET/NSP";
171
172 case EPM_PROTOCOL_IP:
173 return talloc_asprintf(mem_ctx, "IP:%s", epm_floor->rhs.ip.ipaddr);
174
175 case EPM_PROTOCOL_NAMED_PIPE:
176 return talloc_asprintf(mem_ctx, "NAMED-PIPE:%s", epm_floor->rhs.named_pipe.path);
177
178 case EPM_PROTOCOL_SMB:
179 return talloc_asprintf(mem_ctx, "SMB:%s", epm_floor->rhs.smb.unc);
180
181 case EPM_PROTOCOL_UNIX_DS:
182 return talloc_asprintf(mem_ctx, "Unix:%s", epm_floor->rhs.unix_ds.path);
183
184 case EPM_PROTOCOL_NETBIOS:
185 return talloc_asprintf(mem_ctx, "NetBIOS:%s", epm_floor->rhs.netbios.name);
186
187 case EPM_PROTOCOL_NETBEUI:
188 return "NETBeui";
189
190 case EPM_PROTOCOL_SPX:
191 return "SPX";
192
193 case EPM_PROTOCOL_NB_IPX:
194 return "NB_IPX";
195
196 case EPM_PROTOCOL_HTTP:
197 return talloc_asprintf(mem_ctx, "HTTP:%"PRIu16, epm_floor->rhs.http.port);
198
199 case EPM_PROTOCOL_TCP:
200 return talloc_asprintf(mem_ctx, "TCP:%"PRIu16, epm_floor->rhs.tcp.port);
201
202 case EPM_PROTOCOL_UDP:
203 return talloc_asprintf(mem_ctx, "UDP:%"PRIu16, epm_floor->rhs.udp.port);
204
205 default:
206 return talloc_asprintf(mem_ctx, "UNK(%02x):", epm_floor->lhs.protocol);
207 }
208 }
209
210
211 /*
212 form a binding string from a binding structure
213 */
214 _PUBLIC_ char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
215 {
216 char *s = NULL;
217 size_t i;
218 const char *t_name = NULL;
219 bool option_section = false;
220 const char *target_hostname = NULL;
221
222 if (b->transport != NCA_UNKNOWN) {
223 t_name = derpc_transport_string_by_transport(b->transport);
224 if (!t_name) {
225 return NULL;
226 }
227 }
228
229 s = talloc_strdup(mem_ctx, "");
230
231 if (!GUID_all_zero(&b->object)) {
232 struct GUID_txt_buf buf;
233 talloc_asprintf_addbuf(
234 &s, "%s@", GUID_buf_string(&b->object, &buf));
235 }
236
237 if (t_name != NULL) {
238 talloc_asprintf_addbuf(&s, "%s:", t_name);
239 }
240
241 if (b->host) {
242 talloc_asprintf_addbuf(&s, "%s", b->host);
243 }
244
245 target_hostname = b->target_hostname;
246 if (target_hostname != NULL && b->host != NULL) {
247 if (strcmp(target_hostname, b->host) == 0) {
248 target_hostname = NULL;
249 }
250 }
251
252 option_section =
253 (b->endpoint != NULL) ||
254 (target_hostname != NULL) ||
255 (b->target_principal != NULL) ||
256 (b->assoc_group_id != 0) ||
257 (b->options != NULL) ||
258 (b->flags != 0);
259
260 if (!option_section) {
261 return s;
262 }
263
264 talloc_asprintf_addbuf(&s, "[");
265
266 if (b->endpoint) {
267 talloc_asprintf_addbuf(&s, "%s", b->endpoint);
268 }
269
270 for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
271 if (!(b->flags & ncacn_options[i].flag)) {
272 continue;
273 }
274
275 talloc_asprintf_addbuf(&s, ",%s", ncacn_options[i].name);
276 }
277
278 if (target_hostname) {
279 talloc_asprintf_addbuf(
280 &s, ",target_hostname=%s", b->target_hostname);
281 }
282
283 if (b->target_principal) {
284 talloc_asprintf_addbuf(
285 &s, ",target_principal=%s", b->target_principal);
286 }
287
288 if (b->assoc_group_id != 0) {
289 talloc_asprintf_addbuf(
290 &s, ",assoc_group_id=0x%08x", b->assoc_group_id);
291 }
292
293 for (i=0;b->options && b->options[i];i++) {
294 talloc_asprintf_addbuf(&s, ",%s", b->options[i]);
295 }
296
297 talloc_asprintf_addbuf(&s, "]");
298
299 return s;
300 }
301
302 /*
303 parse a binding string into a dcerpc_binding structure
304 */
305 _PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *_s, struct dcerpc_binding **b_out)
306 {
307 char *_t;
308 struct dcerpc_binding *b;
309 char *s;
310 char *options = NULL;
311 char *p;
312 size_t i;
313 NTSTATUS status;
314
315 b = talloc_zero(mem_ctx, struct dcerpc_binding);
316 if (!b) {
317 return NT_STATUS_NO_MEMORY;
318 }
319
320 _t = talloc_strdup(b, _s);
321 if (_t == NULL) {
322 talloc_free(b);
323 return NT_STATUS_NO_MEMORY;
324 }
325
326 s = _t;
327
328 p = strchr(s, '[');
329 if (p) {
330 char *q = p + strlen(p) - 1;
331 if (*q != ']') {
332 talloc_free(b);
333 return NT_STATUS_INVALID_PARAMETER_MIX;
334 }
335 *p = '\0';
336 *q = '\0';
337 options = p + 1;
338 }
339
340 p = strchr(s, '@');
341
342 if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
343 *p = '\0';
344
345 status = dcerpc_binding_set_string_option(b, "object", s);
346 if (!NT_STATUS_IS_OK(status)) {
347 talloc_free(b);
348 return status;
349 }
350
351 s = p + 1;
352 }
353
354 p = strchr(s, ':');
355
356 if (p == NULL) {
357 b->transport = NCA_UNKNOWN;
358 } else if (is_ipaddress_v6(s)) {
359 b->transport = NCA_UNKNOWN;
360 } else {
361 *p = '\0';
362
363 status = dcerpc_binding_set_string_option(b, "transport", s);
364 if (!NT_STATUS_IS_OK(status)) {
365 talloc_free(b);
366 return status;
367 }
368
369 s = p + 1;
370 }
371
372 if (strlen(s) > 0) {
373 status = dcerpc_binding_set_string_option(b, "host", s);
374 if (!NT_STATUS_IS_OK(status)) {
375 talloc_free(b);
376 return status;
377 }
378
379 b->target_hostname = talloc_strdup(b, b->host);
380 if (b->target_hostname == NULL) {
381 talloc_free(b);
382 return NT_STATUS_NO_MEMORY;
383 }
384 }
385
386 for (i=0; options != NULL; i++) {
387 const char *name = options;
388 const char *value = NULL;
389
390 p = strchr(options, ',');
391 if (p != NULL) {
392 *p = '\0';
393 options = p+1;
394 } else {
395 options = NULL;
396 }
397
398 p = strchr(name, '=');
399 if (p != NULL) {
400 *p = '\0';
401 value = p + 1;
402 }
403
404 if (value == NULL) {
405 /*
406 * If it's not a key=value pair
407 * it might be a ncacn_option
408 * or if it's the first option
409 * it's the endpoint.
410 */
411 const struct ncacn_option *no = NULL;
412
413 value = name;
414
415 no = ncacn_option_by_name(name);
416 if (no == NULL) {
417 if (i > 0) {
418 /*
419 * we don't allow unknown options
420 */
421 return NT_STATUS_INVALID_PARAMETER_MIX;
422 }
423
424 /*
425 * This is the endpoint
426 */
427 name = "endpoint";
428 if (strlen(value) == 0) {
429 value = NULL;
430 }
431 }
432 }
433
434 status = dcerpc_binding_set_string_option(b, name, value);
435 if (!NT_STATUS_IS_OK(status)) {
436 talloc_free(b);
437 return status;
438 }
439 }
440
441 talloc_free(_t);
442 *b_out = b;
443 return NT_STATUS_OK;
444 }
445
446 _PUBLIC_ struct GUID dcerpc_binding_get_object(const struct dcerpc_binding *b)
447 {
448 return b->object;
449 }
450
451 _PUBLIC_ NTSTATUS dcerpc_binding_set_object(struct dcerpc_binding *b,
452 struct GUID object)
453 {
454 char *tmp = discard_const_p(char, b->object_string);
455
456 if (GUID_all_zero(&object)) {
457 talloc_free(tmp);
458 b->object_string = NULL;
459 ZERO_STRUCT(b->object);
460 return NT_STATUS_OK;
461 }
462
463 b->object_string = GUID_string(b, &object);
464 if (b->object_string == NULL) {
465 b->object_string = tmp;
466 return NT_STATUS_NO_MEMORY;
467 }
468 talloc_free(tmp);
469
470 b->object = object;
471 return NT_STATUS_OK;
472 }
473
474 _PUBLIC_ enum dcerpc_transport_t dcerpc_binding_get_transport(const struct dcerpc_binding *b)
475 {
476 return b->transport;
477 }
478
479 _PUBLIC_ NTSTATUS dcerpc_binding_set_transport(struct dcerpc_binding *b,
480 enum dcerpc_transport_t transport)
481 {
482 NTSTATUS status;
483
484 /*
485 * TODO: we may want to check the transport value is
486 * wellknown.
487 */
488 if (b->transport == transport) {
489 return NT_STATUS_OK;
490 }
491
492 /*
493 * This implicitly resets the endpoint
494 * as the endpoint is transport specific.
495 *
496 * It also resets the assoc group as it's
497 * also endpoint specific.
498 *
499 * TODO: in future we may reset more options
500 * here.
501 */
502 status = dcerpc_binding_set_string_option(b, "endpoint", NULL);
503 if (!NT_STATUS_IS_OK(status)) {
504 return status;
505 }
506
507 b->assoc_group_id = 0;
508
509 b->transport = transport;
510 return NT_STATUS_OK;
511 }
512
513 _PUBLIC_ void dcerpc_binding_get_auth_info(const struct dcerpc_binding *b,
514 enum dcerpc_AuthType *_auth_type,
515 enum dcerpc_AuthLevel *_auth_level)
516 {
517 enum dcerpc_AuthType auth_type;
518 enum dcerpc_AuthLevel auth_level;
519
520 if (b->flags & DCERPC_AUTH_SPNEGO) {
521 auth_type = DCERPC_AUTH_TYPE_SPNEGO;
522 } else if (b->flags & DCERPC_AUTH_KRB5) {
523 auth_type = DCERPC_AUTH_TYPE_KRB5;
524 } else if (b->flags & DCERPC_SCHANNEL) {
525 auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
526 } else if (b->flags & DCERPC_AUTH_NTLM) {
527 auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
528 } else {
529 auth_type = DCERPC_AUTH_TYPE_NONE;
530 }
531
532 if (b->flags & DCERPC_SEAL) {
533 auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
534 } else if (b->flags & DCERPC_SIGN) {
535 auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
536 } else if (b->flags & DCERPC_CONNECT) {
537 auth_level = DCERPC_AUTH_LEVEL_CONNECT;
538 } else if (b->flags & DCERPC_PACKET) {
539 auth_level = DCERPC_AUTH_LEVEL_PACKET;
540 } else if (auth_type != DCERPC_AUTH_TYPE_NONE) {
541 auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
542 } else {
543 auth_level = DCERPC_AUTH_LEVEL_NONE;
544 }
545
546 if (_auth_type != NULL) {
547 *_auth_type = auth_type;
548 }
549
550 if (_auth_level != NULL) {
551 *_auth_level = auth_level;
552 }
553 }
554
555 _PUBLIC_ uint32_t dcerpc_binding_get_assoc_group_id(const struct dcerpc_binding *b)
556 {
557 return b->assoc_group_id;
558 }
559
560 _PUBLIC_ NTSTATUS dcerpc_binding_set_assoc_group_id(struct dcerpc_binding *b,
561 uint32_t assoc_group_id)
562 {
563 b->assoc_group_id = assoc_group_id;
564 return NT_STATUS_OK;
565 }
566
567 _PUBLIC_ struct ndr_syntax_id dcerpc_binding_get_abstract_syntax(const struct dcerpc_binding *b)
568 {
569 const char *s = dcerpc_binding_get_string_option(b, "abstract_syntax");
570 bool ok;
571 struct ndr_syntax_id id;
572
573 if (s == NULL) {
574 return ndr_syntax_id_null;
575 }
576
577 ok = ndr_syntax_id_from_string(s, &id);
578 if (!ok) {
579 return ndr_syntax_id_null;
580 }
581
582 return id;
583 }
584
585 _PUBLIC_ NTSTATUS dcerpc_binding_set_abstract_syntax(struct dcerpc_binding *b,
586 const struct ndr_syntax_id *syntax)
587 {
588 NTSTATUS status;
589 struct ndr_syntax_id_buf buf;
590
591 if (syntax == NULL) {
592 status = dcerpc_binding_set_string_option(b, "abstract_syntax", NULL);
593 return status;
594 }
595
596 if (ndr_syntax_id_equal(&ndr_syntax_id_null, syntax)) {
597 status = dcerpc_binding_set_string_option(b, "abstract_syntax", NULL);
598 return status;
599 }
600
601 status = dcerpc_binding_set_string_option(
602 b, "abstract_syntax", ndr_syntax_id_buf_string(syntax, &buf));
603 return status;
604 }
605
606 _PUBLIC_ const char *dcerpc_binding_get_string_option(const struct dcerpc_binding *b,
607 const char *name)
608 {
609 struct {
610 const char *name;
611 const char *value;
612 #define _SPECIAL(x) { .name = #x, .value = b->x, }
613 } specials[] = {
614 { .name = "object", .value = b->object_string, },
615 _SPECIAL(host),
616 _SPECIAL(endpoint),
617 _SPECIAL(target_hostname),
618 _SPECIAL(target_principal),
619 #undef _SPECIAL
620 };
621 const struct ncacn_option *no = NULL;
622 size_t name_len = strlen(name);
623 size_t i;
624 int ret;
625
626 ret = strcmp(name, "transport");
627 if (ret == 0) {
628 return derpc_transport_string_by_transport(b->transport);
629 }
630
631 ret = strcmp(name, "assoc_group_id");
632 if (ret == 0) {
633 char *tmp = discard_const_p(char, b->assoc_group_string);
634
635 if (b->assoc_group_id == 0) {
636 return NULL;
637 }
638
639 snprintf(tmp, sizeof(b->assoc_group_string),
640 "0x%08x", b->assoc_group_id);
641 return (const char *)b->assoc_group_string;
642 }
643
644 for (i=0; i < ARRAY_SIZE(specials); i++) {
645 ret = strcmp(specials[i].name, name);
646 if (ret != 0) {
647 continue;
648 }
649
650 return specials[i].value;
651 }
652
653 no = ncacn_option_by_name(name);
654 if (no != NULL) {
655 if (b->flags & no->flag) {
656 return no->name;
657 }
658
659 return NULL;
660 }
661
662 if (b->options == NULL) {
663 return NULL;
664 }
665
666 for (i=0; b->options[i]; i++) {
667 const char *o = b->options[i];
668 const char *vs = NULL;
669
670 ret = strncmp(name, o, name_len);
671 if (ret != 0) {
672 continue;
673 }
674
675 if (o[name_len] != '=') {
676 continue;
677 }
678
679 vs = &o[name_len + 1];
680
681 return vs;
682 }
683
684 return NULL;
685 }
686
687 _PUBLIC_ char *dcerpc_binding_copy_string_option(TALLOC_CTX *mem_ctx,
688 const struct dcerpc_binding *b,
689 const char *name)
690 {
691 const char *c = dcerpc_binding_get_string_option(b, name);
692 char *v;
693
694 if (c == NULL) {
695 errno = ENOENT;
696 return NULL;
697 }
698
699 v = talloc_strdup(mem_ctx, c);
700 if (v == NULL) {
701 errno = ENOMEM;
702 return NULL;
703 }
704
705 return v;
706 }
707
708 _PUBLIC_ NTSTATUS dcerpc_binding_set_string_option(struct dcerpc_binding *b,
709 const char *name,
710 const char *value)
711 {
712 struct {
713 const char *name;
714 const char **ptr;
715 #define _SPECIAL(x) { .name = #x, .ptr = &b->x, }
716 } specials[] = {
717 _SPECIAL(host),
718 _SPECIAL(endpoint),
719 _SPECIAL(target_hostname),
720 _SPECIAL(target_principal),
721 #undef _SPECIAL
722 };
723 const struct ncacn_option *no = NULL;
724 size_t name_len = strlen(name);
725 const char *opt = NULL;
726 char *tmp;
727 size_t i;
728 int ret;
729
730 /*
731 * Note: value == NULL, means delete it.
732 * value != NULL means add or reset.
733 */
734
735 ret = strcmp(name, "transport");
736 if (ret == 0) {
737 enum dcerpc_transport_t t = dcerpc_transport_by_name(value);
738
739 if (t == NCA_UNKNOWN && value != NULL) {
740 return NT_STATUS_INVALID_PARAMETER_MIX;
741 }
742
743 return dcerpc_binding_set_transport(b, t);
744 }
745
746 ret = strcmp(name, "object");
747 if (ret == 0) {
748 NTSTATUS status;
749 struct GUID uuid = GUID_zero();
750
751 if (value != NULL) {
752 DATA_BLOB blob;
753 blob = data_blob_string_const(value);
754 if (blob.length != 36) {
755 return NT_STATUS_INVALID_PARAMETER_MIX;
756 }
757
758 status = GUID_from_data_blob(&blob, &uuid);
759 if (!NT_STATUS_IS_OK(status)) {
760 return status;
761 }
762 }
763
764 return dcerpc_binding_set_object(b, uuid);
765 }
766
767 ret = strcmp(name, "assoc_group_id");
768 if (ret == 0) {
769 uint32_t assoc_group_id = 0;
770
771 if (value != NULL) {
772 char c;
773
774 ret = sscanf(value, "0x%08x%c", &assoc_group_id, &c);
775 if (ret != 1) {
776 return NT_STATUS_INVALID_PARAMETER_MIX;
777 }
778 }
779
780 return dcerpc_binding_set_assoc_group_id(b, assoc_group_id);
781 }
782
783 for (i=0; i < ARRAY_SIZE(specials); i++) {
784 ret = strcmp(specials[i].name, name);
785 if (ret != 0) {
786 continue;
787 }
788
789 tmp = discard_const_p(char, *specials[i].ptr);
790
791 if (value == NULL) {
792 talloc_free(tmp);
793 *specials[i].ptr = NULL;
794 return NT_STATUS_OK;
795 }
796
797 if (value[0] == '\0') {
798 return NT_STATUS_INVALID_PARAMETER_MIX;
799 }
800
801 *specials[i].ptr = talloc_strdup(b, value);
802 if (*specials[i].ptr == NULL) {
803 *specials[i].ptr = tmp;
804 return NT_STATUS_NO_MEMORY;
805 }
806 talloc_free(tmp);
807
808 return NT_STATUS_OK;
809 }
810
811 no = ncacn_option_by_name(name);
812 if (no != NULL) {
813 if (value == NULL) {
814 b->flags &= ~no->flag;
815 return NT_STATUS_OK;
816 }
817
818 ret = strcasecmp(no->name, value);
819 if (ret != 0) {
820 return NT_STATUS_INVALID_PARAMETER_MIX;
821 }
822
823 b->flags |= no->flag;
824 return NT_STATUS_OK;
825 }
826
827 for (i=0; b->options && b->options[i]; i++) {
828 const char *o = b->options[i];
829
830 ret = strncmp(name, o, name_len);
831 if (ret != 0) {
832 continue;
833 }
834
835 if (o[name_len] != '=') {
836 continue;
837 }
838
839 opt = o;
840 break;
841 }
842
843 if (opt == NULL) {
844 const char **n;
845
846 if (value == NULL) {
847 return NT_STATUS_OK;
848 }
849
850 n = talloc_realloc(b, b->options, const char *, i + 2);
851 if (n == NULL) {
852 return NT_STATUS_NO_MEMORY;
853 }
854 n[i] = NULL;
855 n[i + 1] = NULL;
856 b->options = n;
857 }
858
859 tmp = discard_const_p(char, opt);
860
861 if (value == NULL) {
862 for (;b->options[i];i++) {
863 b->options[i] = b->options[i+1];
864 }
865 talloc_free(tmp);
866 return NT_STATUS_OK;
867 }
868
869 b->options[i] = talloc_asprintf(b->options, "%s=%s",
870 name, value);
871 if (b->options[i] == NULL) {
872 b->options[i] = tmp;
873 return NT_STATUS_NO_MEMORY;
874 }
875
876 return NT_STATUS_OK;
877 }
878
879 _PUBLIC_ uint32_t dcerpc_binding_get_flags(const struct dcerpc_binding *b)
880 {
881 return b->flags;
882 }
883
884 _PUBLIC_ NTSTATUS dcerpc_binding_set_flags(struct dcerpc_binding *b,
885 uint32_t additional,
886 uint32_t clear)
887 {
888 /*
889 * TODO: in future we may want to reject invalid combinations
890 */
891 b->flags &= ~clear;
892 b->flags |= additional;
893
894 return NT_STATUS_OK;
895 }
896
897 _PUBLIC_ NTSTATUS dcerpc_floor_get_uuid_full(const struct epm_floor *epm_floor,
898 struct ndr_syntax_id *syntax)
899 {
900 TALLOC_CTX *mem_ctx = talloc_init("floor_get_lhs_data");
901 struct ndr_pull *ndr;
902 enum ndr_err_code ndr_err;
903 uint16_t if_version=0;
904
905 *syntax = (struct ndr_syntax_id) { .if_version = 0, };
906
907 if (epm_floor->lhs.protocol != EPM_PROTOCOL_UUID) {
908 talloc_free(mem_ctx);
909 return NT_STATUS_INVALID_PARAMETER;
910 }
911
912 ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx);
913 if (ndr == NULL) {
914 talloc_free(mem_ctx);
915 return NT_STATUS_NO_MEMORY;
916 }
917 ndr->flags |= LIBNDR_FLAG_NOALIGN;
918
919 ndr_err = ndr_pull_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
920 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
921 talloc_free(mem_ctx);
922 return ndr_map_error2ntstatus(ndr_err);
923 }
924
925 ndr_err = ndr_pull_uint16(ndr, NDR_SCALARS, &if_version);
926 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
927 talloc_free(mem_ctx);
928 return ndr_map_error2ntstatus(ndr_err);
929 }
930
931 syntax->if_version = if_version;
932
933 TALLOC_FREE(ndr);
934
935 ndr = ndr_pull_init_blob(&epm_floor->rhs.uuid.unknown, mem_ctx);
936 if (ndr == NULL) {
937 talloc_free(mem_ctx);
938 return NT_STATUS_NO_MEMORY;
939 }
940 ndr->flags |= LIBNDR_FLAG_NOALIGN;
941
942 ndr_err = ndr_pull_uint16(ndr, NDR_SCALARS, &if_version);
943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
944 talloc_free(mem_ctx);
945 return ndr_map_error2ntstatus(ndr_err);
946 }
947
948 syntax->if_version |= (((uint32_t)if_version) << 16) & 0xffff0000;
949
950 talloc_free(mem_ctx);
951
952 return NT_STATUS_OK;
953 }
954
955 static DATA_BLOB dcerpc_floor_pack_lhs_data(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax)
956 {
957 DATA_BLOB blob;
958 enum ndr_err_code ndr_err;
959 struct ndr_push *ndr;
960
961 ndr = ndr_push_init_ctx(mem_ctx);
962 if (ndr == NULL) {
963 return data_blob_null;
964 }
965
966 ndr->flags |= LIBNDR_FLAG_NOALIGN;
967
968 ndr_err = ndr_push_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
969 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
970 return data_blob_null;
971 }
972 ndr_err = ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version);
973 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
974 return data_blob_null;
975 }
976
977 blob = ndr_push_blob(ndr);
978 talloc_steal(mem_ctx, blob.data);
979 talloc_free(ndr);
980 return blob;
981 }
982
983 static bool dcerpc_floor_pack_rhs_if_version_data(
984 TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax,
985 DATA_BLOB *pblob)
986 {
987 DATA_BLOB blob;
988 struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
989 enum ndr_err_code ndr_err;
990
991 if (ndr == NULL) {
992 return false;
993 }
994
995 ndr->flags |= LIBNDR_FLAG_NOALIGN;
996
997 ndr_err = ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version >> 16);
998 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
999 return false;
1000 }
1001
1002 blob = ndr_push_blob(ndr);
1003 talloc_steal(mem_ctx, blob.data);
1004 talloc_free(ndr);
1005 *pblob = blob;
1006 return true;
1007 }
1008
1009 static NTSTATUS dcerpc_floor_pack_uuid_full(TALLOC_CTX *mem_ctx,
1010 struct epm_floor *floor,
1011 const struct ndr_syntax_id *syntax)
1012 {
1013 bool ok;
1014
1015 floor->lhs.protocol = EPM_PROTOCOL_UUID;
1016
1017 floor->lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, syntax);
1018 if (floor->lhs.lhs_data.data == NULL) {
1019 return NT_STATUS_NO_MEMORY;
1020 }
1021
1022 ok = dcerpc_floor_pack_rhs_if_version_data(mem_ctx, syntax,
1023 &floor->rhs.uuid.unknown);
1024 if (!ok) {
1025 data_blob_free(&floor->lhs.lhs_data);
1026 return NT_STATUS_NO_MEMORY;
1027 }
1028
1029 return NT_STATUS_OK;
1030 }
1031
1032 char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
1033 {
1034 switch (epm_floor->lhs.protocol) {
1035 case EPM_PROTOCOL_TCP:
1036 if (epm_floor->rhs.tcp.port == 0) return NULL;
1037 return talloc_asprintf(mem_ctx, "%"PRIu16, epm_floor->rhs.tcp.port);
1038
1039 case EPM_PROTOCOL_UDP:
1040 if (epm_floor->rhs.udp.port == 0) return NULL;
1041 return talloc_asprintf(mem_ctx, "%"PRIu16, epm_floor->rhs.udp.port);
1042
1043 case EPM_PROTOCOL_HTTP:
1044 if (epm_floor->rhs.http.port == 0) return NULL;
1045 return talloc_asprintf(mem_ctx, "%"PRIu16, epm_floor->rhs.http.port);
1046
1047 case EPM_PROTOCOL_IP:
1048 return talloc_strdup(mem_ctx, epm_floor->rhs.ip.ipaddr);
1049
1050 case EPM_PROTOCOL_NCACN:
1051 return NULL;
1052
1053 case EPM_PROTOCOL_NCADG:
1054 return NULL;
1055
1056 case EPM_PROTOCOL_SMB:
1057 if (strlen(epm_floor->rhs.smb.unc) == 0) return NULL;
1058 return talloc_strdup(mem_ctx, epm_floor->rhs.smb.unc);
1059
1060 case EPM_PROTOCOL_NAMED_PIPE:
1061 if (strlen(epm_floor->rhs.named_pipe.path) == 0) return NULL;
1062 return talloc_strdup(mem_ctx, epm_floor->rhs.named_pipe.path);
1063
1064 case EPM_PROTOCOL_NETBIOS:
1065 if (strlen(epm_floor->rhs.netbios.name) == 0) return NULL;
1066 return talloc_strdup(mem_ctx, epm_floor->rhs.netbios.name);
1067
1068 case EPM_PROTOCOL_NCALRPC:
1069 return NULL;
1070
1071 case EPM_PROTOCOL_VINES_SPP:
1072 return talloc_asprintf(mem_ctx, "%"PRIu16, epm_floor->rhs.vines_spp.port);
1073
1074 case EPM_PROTOCOL_VINES_IPC:
1075 return talloc_asprintf(mem_ctx, "%"PRIu16, epm_floor->rhs.vines_ipc.port);
1076
1077 case EPM_PROTOCOL_STREETTALK:
1078 return talloc_strdup(mem_ctx, epm_floor->rhs.streettalk.streettalk);
1079
1080 case EPM_PROTOCOL_UNIX_DS:
1081 if (strlen(epm_floor->rhs.unix_ds.path) == 0) return NULL;
1082 return talloc_strdup(mem_ctx, epm_floor->rhs.unix_ds.path);
1083
1084 case EPM_PROTOCOL_NULL:
1085 return NULL;
1086
1087 default:
1088 DEBUG(0,("Unsupported lhs protocol %d\n", epm_floor->lhs.protocol));
1089 break;
1090 }
1091
1092 return NULL;
1093 }
1094
1095 static NTSTATUS dcerpc_floor_set_rhs_data(TALLOC_CTX *mem_ctx,
1096 struct epm_floor *epm_floor,
1097 const char *data)
1098 {
1099 if (data == NULL) {
1100 data = "";
1101 }
1102
1103 switch (epm_floor->lhs.protocol) {
1104 case EPM_PROTOCOL_TCP:
1105 epm_floor->rhs.tcp.port = atoi(data);
1106 return NT_STATUS_OK;
1107
1108 case EPM_PROTOCOL_UDP:
1109 epm_floor->rhs.udp.port = atoi(data);
1110 return NT_STATUS_OK;
1111
1112 case EPM_PROTOCOL_HTTP:
1113 epm_floor->rhs.http.port = atoi(data);
1114 return NT_STATUS_OK;
1115
1116 case EPM_PROTOCOL_IP:
1117 if (!is_ipaddress_v4(data)) {
1118 data = "0.0.0.0";
1119 }
1120 epm_floor->rhs.ip.ipaddr = talloc_strdup(mem_ctx, data);
1121 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.ip.ipaddr);
1122 return NT_STATUS_OK;
1123
1124 case EPM_PROTOCOL_NCACN:
1125 epm_floor->rhs.ncacn.minor_version = 0;
1126 return NT_STATUS_OK;
1127
1128 case EPM_PROTOCOL_NCADG:
1129 epm_floor->rhs.ncadg.minor_version = 0;
1130 return NT_STATUS_OK;
1131
1132 case EPM_PROTOCOL_SMB:
1133 epm_floor->rhs.smb.unc = talloc_strdup(mem_ctx, data);
1134 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.smb.unc);
1135 return NT_STATUS_OK;
1136
1137 case EPM_PROTOCOL_NAMED_PIPE:
1138 epm_floor->rhs.named_pipe.path = talloc_strdup(mem_ctx, data);
1139 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.named_pipe.path);
1140 return NT_STATUS_OK;
1141
1142 case EPM_PROTOCOL_NETBIOS:
1143 epm_floor->rhs.netbios.name = talloc_strdup(mem_ctx, data);
1144 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.netbios.name);
1145 return NT_STATUS_OK;
1146
1147 case EPM_PROTOCOL_NCALRPC:
1148 return NT_STATUS_OK;
1149
1150 case EPM_PROTOCOL_VINES_SPP:
1151 epm_floor->rhs.vines_spp.port = atoi(data);
1152 return NT_STATUS_OK;
1153
1154 case EPM_PROTOCOL_VINES_IPC:
1155 epm_floor->rhs.vines_ipc.port = atoi(data);
1156 return NT_STATUS_OK;
1157
1158 case EPM_PROTOCOL_STREETTALK:
1159 epm_floor->rhs.streettalk.streettalk = talloc_strdup(mem_ctx, data);
1160 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.streettalk.streettalk);
1161 return NT_STATUS_OK;
1162
1163 case EPM_PROTOCOL_UNIX_DS:
1164 epm_floor->rhs.unix_ds.path = talloc_strdup(mem_ctx, data);
1165 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.unix_ds.path);
1166 return NT_STATUS_OK;
1167
1168 case EPM_PROTOCOL_NULL:
1169 return NT_STATUS_OK;
1170
1171 default:
1172 DEBUG(0,("Unsupported lhs protocol %d\n", epm_floor->lhs.protocol));
1173 break;
1174 }
1175
1176 return NT_STATUS_NOT_SUPPORTED;
1177 }
1178
1179 enum dcerpc_transport_t dcerpc_transport_by_endpoint_protocol(int prot)
1180 {
1181 size_t i;
1182
1183 /* Find a transport that has 'prot' as 4th protocol */
1184 for (i=0;i<ARRAY_SIZE(transports);i++) {
1185 if (transports[i].num_protocols >= 2 &&
1186 transports[i].protseq[1] == prot) {
1187 return transports[i].transport;
1188 }
1189 }
1190
1191 /* Unknown transport */
1192 return (unsigned int)-1;
1193 }
1194
1195 _PUBLIC_ enum dcerpc_transport_t dcerpc_transport_by_tower(const struct epm_tower *tower)
1196 {
1197 size_t i;
1198
1199 /* Find a transport that matches this tower */
1200 for (i=0;i<ARRAY_SIZE(transports);i++) {
1201 int j;
1202 if (transports[i].num_protocols != tower->num_floors - 2) {
1203 continue;
1204 }
1205
1206 for (j = 0; j < transports[i].num_protocols && j < MAX_PROTSEQ; j++) {
1207 if (transports[i].protseq[j] != tower->floors[j+2].lhs.protocol) {
1208 break;
1209 }
1210 }
1211
1212 if (j == transports[i].num_protocols) {
1213 return transports[i].transport;
1214 }
1215 }
1216
1217 /* Unknown transport */
1218 return (unsigned int)-1;
1219 }
1220
1221 _PUBLIC_ const char *derpc_transport_string_by_transport(enum dcerpc_transport_t t)
1222 {
1223 size_t i;
1224
1225 for (i=0; i<ARRAY_SIZE(transports); i++) {
1226 if (t == transports[i].transport) {
1227 return transports[i].name;
1228 }
1229 }
1230 return NULL;
1231 }
1232
1233 _PUBLIC_ enum dcerpc_transport_t dcerpc_transport_by_name(const char *name)
1234 {
1235 size_t i;
1236
1237 if (name == NULL) {
1238 return NCA_UNKNOWN;
1239 }
1240
1241 for (i=0; i<ARRAY_SIZE(transports);i++) {
1242 if (strcasecmp(name, transports[i].name) == 0) {
1243 return transports[i].transport;
1244 }
1245 }
1246
1247 return NCA_UNKNOWN;
1248 }
1249
1250 _PUBLIC_ NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx,
1251 struct epm_tower *tower,
1252 struct dcerpc_binding **b_out)
1253 {
1254 NTSTATUS status;
1255 struct dcerpc_binding *b;
1256 enum dcerpc_transport_t transport;
1257 struct ndr_syntax_id abstract_syntax;
1258 char *endpoint = NULL;
1259 char *host = NULL;
1260
1261 /*
1262 * A tower needs to have at least 4 floors to carry useful
1263 * information. Floor 3 is the transport identifier which defines
1264 * how many floors are required at least.
1265 */
1266 if (tower->num_floors < 4) {
1267 return NT_STATUS_INVALID_PARAMETER;
1268 }
1269
1270 status = dcerpc_parse_binding(mem_ctx, "", &b);
1271 if (!NT_STATUS_IS_OK(status)) {
1272 return status;
1273 }
1274
1275 transport = dcerpc_transport_by_tower(tower);
1276 if (transport == NCA_UNKNOWN) {
1277 talloc_free(b);
1278 return NT_STATUS_NOT_SUPPORTED;
1279 }
1280
1281 status = dcerpc_binding_set_transport(b, transport);
1282 if (!NT_STATUS_IS_OK(status)) {
1283 talloc_free(b);
1284 return status;
1285 }
1286
1287 /* Set abstract syntax */
1288 status = dcerpc_floor_get_uuid_full(&tower->floors[0], &abstract_syntax);
1289 if (!NT_STATUS_IS_OK(status)) {
1290 talloc_free(b);
1291 return status;
1292 }
1293
1294 status = dcerpc_binding_set_abstract_syntax(b, &abstract_syntax);
1295 if (!NT_STATUS_IS_OK(status)) {
1296 talloc_free(b);
1297 return status;
1298 }
1299
1300 /* Ignore floor 1, it contains the NDR version info */
1301
1302 /* Set endpoint */
1303 errno = 0;
1304 if (tower->num_floors >= 4) {
1305 endpoint = dcerpc_floor_get_rhs_data(b, &tower->floors[3]);
1306 }
1307 if (errno != 0) {
1308 int saved_errno = errno;
1309 talloc_free(b);
1310 return map_nt_error_from_unix_common(saved_errno);
1311 }
1312
1313 status = dcerpc_binding_set_string_option(b, "endpoint", endpoint);
1314 if (!NT_STATUS_IS_OK(status)) {
1315 talloc_free(b);
1316 return status;
1317 }
1318 TALLOC_FREE(endpoint);
1319
1320 /* Set network address */
1321 errno = 0;
1322 if (tower->num_floors >= 5) {
1323 host = dcerpc_floor_get_rhs_data(b, &tower->floors[4]);
1324 }
1325 if (errno != 0) {
1326 int saved_errno = errno;
1327 talloc_free(b);
1328 return map_nt_error_from_unix_common(saved_errno);
1329 }
1330
1331 status = dcerpc_binding_set_string_option(b, "host", host);
1332 if (!NT_STATUS_IS_OK(status)) {
1333 talloc_free(b);
1334 return status;
1335 }
1336 status = dcerpc_binding_set_string_option(b, "target_hostname", host);
1337 if (!NT_STATUS_IS_OK(status)) {
1338 talloc_free(b);
1339 return status;
1340 }
1341 TALLOC_FREE(host);
1342
1343 *b_out = b;
1344 return NT_STATUS_OK;
1345 }
1346
1347 _PUBLIC_ struct dcerpc_binding *dcerpc_binding_dup(TALLOC_CTX *mem_ctx,
1348 const struct dcerpc_binding *b)
1349 {
1350 struct dcerpc_binding *n;
1351 uint32_t count;
1352
1353 n = talloc_zero(mem_ctx, struct dcerpc_binding);
1354 if (n == NULL) {
1355 return NULL;
1356 }
1357
1358 n->transport = b->transport;
1359 n->object = b->object;
1360 n->flags = b->flags;
1361 n->assoc_group_id = b->assoc_group_id;
1362
1363 if (b->object_string != NULL) {
1364 n->object_string = talloc_strdup(n, b->object_string);
1365 if (n->object_string == NULL) {
1366 goto nomem;
1367 }
1368 }
1369 if (b->host != NULL) {
1370 n->host = talloc_strdup(n, b->host);
1371 if (n->host == NULL) {
1372 goto nomem;
1373 }
1374 }
1375
1376 if (b->target_hostname != NULL) {
1377 n->target_hostname = talloc_strdup(n, b->target_hostname);
1378 if (n->target_hostname == NULL) {
1379 goto nomem;
1380 }
1381 }
1382
1383 if (b->target_principal != NULL) {
1384 n->target_principal = talloc_strdup(n, b->target_principal);
1385 if (n->target_principal == NULL) {
1386 goto nomem;
1387 }
1388 }
1389
1390 if (b->endpoint != NULL) {
1391 n->endpoint = talloc_strdup(n, b->endpoint);
1392 if (n->endpoint == NULL) {
1393 goto nomem;
1394 }
1395 }
1396
1397 for (count = 0; b->options && b->options[count]; count++);
1398
1399 if (count > 0) {
1400 uint32_t i;
1401
1402 n->options = talloc_array(n, const char *, count + 1);
1403 if (n->options == NULL) {
1404 goto nomem;
1405 }
1406
1407 for (i = 0; i < count; i++) {
1408 n->options[i] = talloc_strdup(n->options, b->options[i]);
1409 if (n->options[i] == NULL) {
1410 goto nomem;
1411 }
1412 }
1413 n->options[count] = NULL;
1414 }
1415
1416 return n;
1417 nomem:
1418 TALLOC_FREE(n);
1419 return NULL;
1420 }
1421
1422 _PUBLIC_ NTSTATUS dcerpc_binding_build_tower(TALLOC_CTX *mem_ctx,
1423 const struct dcerpc_binding *binding,
1424 struct epm_tower *tower)
1425 {
1426 const enum epm_protocol *protseq = NULL;
1427 size_t i, num_protocols = 0;
1428 struct ndr_syntax_id abstract_syntax;
1429 NTSTATUS status;
1430
1431 /* Find transport */
1432 for (i=0;i<ARRAY_SIZE(transports);i++) {
1433 if (transports[i].transport == binding->transport) {
1434 protseq = transports[i].protseq;
1435 num_protocols = transports[i].num_protocols;
1436 break;
1437 }
1438 }
1439
1440 if (i == ARRAY_SIZE(transports)) {
1441 DEBUG(0, ("Unable to find transport with id '%d'\n", binding->transport));
1442 return NT_STATUS_UNSUCCESSFUL;
1443 }
1444
1445 tower->num_floors = 2 + num_protocols;
1446 tower->floors = talloc_array(mem_ctx, struct epm_floor, tower->num_floors);
1447 if (tower->floors == NULL) {
1448 return NT_STATUS_NO_MEMORY;
1449 }
1450
1451 /* Floor 0 */
1452 abstract_syntax = dcerpc_binding_get_abstract_syntax(binding);
1453 status = dcerpc_floor_pack_uuid_full(tower->floors,
1454 &tower->floors[0],
1455 &abstract_syntax);
1456 if (!NT_STATUS_IS_OK(status)) {
1457 return status;
1458 }
1459
1460 /* Floor 1 */
1461 status = dcerpc_floor_pack_uuid_full(tower->floors,
1462 &tower->floors[1],
1463 &ndr_transfer_syntax_ndr);
1464 if (!NT_STATUS_IS_OK(status)) {
1465 return status;
1466 }
1467
1468 /* Floor 2 to num_protocols */
1469 for (i = 0; i < num_protocols; i++) {
1470 tower->floors[2 + i].lhs.protocol = protseq[i];
1471 tower->floors[2 + i].lhs.lhs_data = data_blob_null;
1472 ZERO_STRUCT(tower->floors[2 + i].rhs);
1473 status = dcerpc_floor_set_rhs_data(tower->floors,
1474 &tower->floors[2 + i],
1475 NULL);
1476 if (!NT_STATUS_IS_OK(status)) {
1477 return status;
1478 }
1479 }
1480
1481 /* The 4th floor contains the endpoint */
1482 if (num_protocols >= 2 && binding->endpoint) {
1483 status = dcerpc_floor_set_rhs_data(tower->floors,
1484 &tower->floors[3],
1485 binding->endpoint);
1486 if (!NT_STATUS_IS_OK(status)) {
1487 return status;
1488 }
1489 }
1490
1491 /* The 5th contains the network address */
1492 if (num_protocols >= 3 && binding->host) {
1493 status = dcerpc_floor_set_rhs_data(tower->floors,
1494 &tower->floors[4],
1495 binding->host);
1496 if (!NT_STATUS_IS_OK(status)) {
1497 return status;
1498 }
1499 }
1500
1501 return NT_STATUS_OK;
1502 }
Samba GIT mirror