dsdb/samdb: add resolve_oids module
[gd/samba/.git] / librpc / rpc / binding.c
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
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "librpc/gen_ndr/ndr_epmapper.h"
27 #include "librpc/gen_ndr/ndr_misc.h"
28 #include "librpc/rpc/dcerpc.h"
29 #undef strcasecmp
30
31 #define MAX_PROTSEQ             10
32
33 static const struct {
34         const char *name;
35         enum dcerpc_transport_t transport;
36         int num_protocols;
37         enum epm_protocol protseq[MAX_PROTSEQ];
38 } transports[] = {
39         { "ncacn_np",     NCACN_NP, 3, 
40                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB, EPM_PROTOCOL_NETBIOS }},
41         { "ncacn_ip_tcp", NCACN_IP_TCP, 3, 
42                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP, EPM_PROTOCOL_IP } }, 
43         { "ncacn_http", NCACN_HTTP, 3, 
44                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_HTTP, EPM_PROTOCOL_IP } }, 
45         { "ncadg_ip_udp", NCACN_IP_UDP, 3, 
46                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UDP, EPM_PROTOCOL_IP } },
47         { "ncalrpc", NCALRPC, 2, 
48                 { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_NAMED_PIPE } },
49         { "ncacn_unix_stream", NCACN_UNIX_STREAM, 2, 
50                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_UNIX_DS } },
51         { "ncadg_unix_dgram", NCADG_UNIX_DGRAM, 2, 
52                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UNIX_DS } },
53         { "ncacn_at_dsp", NCACN_AT_DSP, 3, 
54                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DSP } },
55         { "ncadg_at_ddp", NCADG_AT_DDP, 3, 
56                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DDP } },
57         { "ncacn_vns_ssp", NCACN_VNS_SPP, 3, 
58                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_SPP } },
59         { "ncacn_vns_ipc", NCACN_VNS_IPC, 3, 
60                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_IPC }, },
61         { "ncadg_ipx", NCADG_IPX, 2,
62                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_IPX },
63         },
64         { "ncacn_spx", NCACN_SPX, 3,
65                 /* I guess some MS programmer confused the identifier for 
66                  * EPM_PROTOCOL_UUID (0x0D or 13) with the one for 
67                  * EPM_PROTOCOL_SPX (0x13) here. -- jelmer*/
68                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_UUID },
69         },
70 };
71
72 static const struct {
73         const char *name;
74         uint32_t flag;
75 } ncacn_options[] = {
76         {"sign", DCERPC_SIGN},
77         {"seal", DCERPC_SEAL},
78         {"connect", DCERPC_CONNECT},
79         {"spnego", DCERPC_AUTH_SPNEGO},
80         {"ntlm", DCERPC_AUTH_NTLM},
81         {"krb5", DCERPC_AUTH_KRB5},
82         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
83         {"print", DCERPC_DEBUG_PRINT_BOTH},
84         {"padcheck", DCERPC_DEBUG_PAD_CHECK},
85         {"bigendian", DCERPC_PUSH_BIGENDIAN},
86         {"smb2", DCERPC_SMB2},
87         {"hdrsign", DCERPC_HEADER_SIGNING},
88         {"ndr64", DCERPC_NDR64}
89 };
90
91 const char *epm_floor_string(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
92 {
93         struct ndr_syntax_id syntax;
94         NTSTATUS status;
95
96         switch(epm_floor->lhs.protocol) {
97                 case EPM_PROTOCOL_UUID:
98                         status = dcerpc_floor_get_lhs_data(epm_floor, &syntax);
99                         if (NT_STATUS_IS_OK(status)) {
100                                 /* lhs is used: UUID */
101                                 char *uuidstr;
102
103                                 if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax.uuid)) {
104                                         return "NDR";
105                                 } 
106
107                                 if (GUID_equal(&syntax.uuid, &ndr64_transfer_syntax.uuid)) {
108                                         return "NDR64";
109                                 } 
110
111                                 uuidstr = GUID_string(mem_ctx, &syntax.uuid);
112
113                                 return talloc_asprintf(mem_ctx, " uuid %s/0x%02x", uuidstr, syntax.if_version);
114                         } else { /* IPX */
115                                 return talloc_asprintf(mem_ctx, "IPX:%s", 
116                                                 data_blob_hex_string(mem_ctx, &epm_floor->rhs.uuid.unknown));
117                         }
118
119                 case EPM_PROTOCOL_NCACN:
120                         return "RPC-C";
121
122                 case EPM_PROTOCOL_NCADG:
123                         return "RPC";
124
125                 case EPM_PROTOCOL_NCALRPC:
126                         return "NCALRPC";
127
128                 case EPM_PROTOCOL_DNET_NSP:
129                         return "DNET/NSP";
130
131                 case EPM_PROTOCOL_IP:
132                         return talloc_asprintf(mem_ctx, "IP:%s", epm_floor->rhs.ip.ipaddr);
133
134                 case EPM_PROTOCOL_NAMED_PIPE:
135                         return talloc_asprintf(mem_ctx, "NAMED-PIPE:%s", epm_floor->rhs.named_pipe.path);
136
137                 case EPM_PROTOCOL_SMB:
138                         return talloc_asprintf(mem_ctx, "SMB:%s", epm_floor->rhs.smb.unc);
139
140                 case EPM_PROTOCOL_UNIX_DS:
141                         return talloc_asprintf(mem_ctx, "Unix:%s", epm_floor->rhs.unix_ds.path);
142
143                 case EPM_PROTOCOL_NETBIOS:
144                         return talloc_asprintf(mem_ctx, "NetBIOS:%s", epm_floor->rhs.netbios.name);
145
146                 case EPM_PROTOCOL_NETBEUI:
147                         return "NETBeui";
148
149                 case EPM_PROTOCOL_SPX:
150                         return "SPX";
151
152                 case EPM_PROTOCOL_NB_IPX:
153                         return "NB_IPX";
154
155                 case EPM_PROTOCOL_HTTP:
156                         return talloc_asprintf(mem_ctx, "HTTP:%d", epm_floor->rhs.http.port);
157
158                 case EPM_PROTOCOL_TCP:
159                         return talloc_asprintf(mem_ctx, "TCP:%d", epm_floor->rhs.tcp.port);
160
161                 case EPM_PROTOCOL_UDP:
162                         return talloc_asprintf(mem_ctx, "UDP:%d", epm_floor->rhs.udp.port);
163
164                 default:
165                         return talloc_asprintf(mem_ctx, "UNK(%02x):", epm_floor->lhs.protocol);
166         }
167 }
168
169
170 /*
171   form a binding string from a binding structure
172 */
173 _PUBLIC_ char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
174 {
175         char *s = talloc_strdup(mem_ctx, "");
176         int i;
177         const char *t_name = NULL;
178
179         if (b->transport != NCA_UNKNOWN) {
180                 t_name = derpc_transport_string_by_transport(b->transport);
181                 if (!t_name) {
182                         return NULL;
183                 }
184         }
185
186         if (!GUID_all_zero(&b->object.uuid)) { 
187                 s = talloc_asprintf(s, "%s@",
188                                     GUID_string(mem_ctx, &b->object.uuid));
189         }
190
191         if (t_name != NULL) {
192                 s = talloc_asprintf_append_buffer(s, "%s:", t_name);
193                 if (s == NULL) {
194                         return NULL;
195                 }
196         }
197
198         if (b->host) {
199                 s = talloc_asprintf_append_buffer(s, "%s", b->host);
200         }
201
202         if (!b->endpoint && !b->options && !b->flags) {
203                 return s;
204         }
205
206         s = talloc_asprintf_append_buffer(s, "[");
207
208         if (b->endpoint) {
209                 s = talloc_asprintf_append_buffer(s, "%s", b->endpoint);
210         }
211
212         /* this is a *really* inefficent way of dealing with strings,
213            but this is rarely called and the strings are always short,
214            so I don't care */
215         for (i=0;b->options && b->options[i];i++) {
216                 s = talloc_asprintf_append_buffer(s, ",%s", b->options[i]);
217                 if (!s) return NULL;
218         }
219
220         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
221                 if (b->flags & ncacn_options[i].flag) {
222                         s = talloc_asprintf_append_buffer(s, ",%s", ncacn_options[i].name);
223                         if (!s) return NULL;
224                 }
225         }
226
227         s = talloc_asprintf_append_buffer(s, "]");
228
229         return s;
230 }
231
232 /*
233   parse a binding string into a dcerpc_binding structure
234 */
235 _PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out)
236 {
237         struct dcerpc_binding *b;
238         char *options;
239         char *p;
240         int i, j, comma_count;
241
242         b = talloc(mem_ctx, struct dcerpc_binding);
243         if (!b) {
244                 return NT_STATUS_NO_MEMORY;
245         }
246
247         p = strchr(s, '@');
248
249         if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
250                 NTSTATUS status;
251                 DATA_BLOB blob = data_blob(s, 36);
252                 status = GUID_from_data_blob(&blob, &b->object.uuid);
253
254                 if (NT_STATUS_IS_ERR(status)) {
255                         DEBUG(0, ("Failed parsing UUID\n"));
256                         return status;
257                 }
258
259                 s = p + 1;
260         } else {
261                 ZERO_STRUCT(b->object);
262         }
263
264         b->object.if_version = 0;
265
266         p = strchr(s, ':');
267
268         if (p == NULL) {
269                 b->transport = NCA_UNKNOWN;
270         } else {
271                 char *type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
272                 if (!type) {
273                         return NT_STATUS_NO_MEMORY;
274                 }
275
276                 for (i=0;i<ARRAY_SIZE(transports);i++) {
277                         if (strcasecmp(type, transports[i].name) == 0) {
278                                 b->transport = transports[i].transport;
279                                 break;
280                         }
281                 }
282
283                 if (i==ARRAY_SIZE(transports)) {
284                         DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
285                         return NT_STATUS_INVALID_PARAMETER;
286                 }
287
288                 talloc_free(type);
289
290                 s = p+1;
291         }
292
293         p = strchr(s, '[');
294         if (p) {
295                 b->host = talloc_strndup(b, s, PTR_DIFF(p, s));
296                 options = talloc_strdup(mem_ctx, p+1);
297                 if (options[strlen(options)-1] != ']') {
298                         return NT_STATUS_INVALID_PARAMETER;
299                 }
300                 options[strlen(options)-1] = 0;
301         } else {
302                 b->host = talloc_strdup(b, s);
303                 options = NULL;
304         }
305         if (!b->host) {
306                 return NT_STATUS_NO_MEMORY;
307         }
308
309         b->target_hostname = b->host;
310
311         b->options = NULL;
312         b->flags = 0;
313         b->assoc_group_id = 0;
314         b->endpoint = NULL;
315
316         if (!options) {
317                 *b_out = b;
318                 return NT_STATUS_OK;
319         }
320
321         comma_count = count_chars(options, ',');
322
323         b->options = talloc_array(b, const char *, comma_count+2);
324         if (!b->options) {
325                 return NT_STATUS_NO_MEMORY;
326         }
327
328         for (i=0; (p = strchr(options, ',')); i++) {
329                 b->options[i] = talloc_strndup(b, options, PTR_DIFF(p, options));
330                 if (!b->options[i]) {
331                         return NT_STATUS_NO_MEMORY;
332                 }
333                 options = p+1;
334         }
335         b->options[i] = options;
336         b->options[i+1] = NULL;
337
338         /* some options are pre-parsed for convenience */
339         for (i=0;b->options[i];i++) {
340                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
341                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
342                                 int k;
343                                 b->flags |= ncacn_options[j].flag;
344                                 for (k=i;b->options[k];k++) {
345                                         b->options[k] = b->options[k+1];
346                                 }
347                                 i--;
348                                 break;
349                         }
350                 }
351         }
352
353         if (b->options[0]) {
354                 /* Endpoint is first option */
355                 b->endpoint = b->options[0];
356                 if (strlen(b->endpoint) == 0) b->endpoint = NULL;
357
358                 for (i=0;b->options[i];i++) {
359                         b->options[i] = b->options[i+1];
360                 }
361         }
362
363         if (b->options[0] == NULL)
364                 b->options = NULL;
365
366         *b_out = b;
367         return NT_STATUS_OK;
368 }
369
370 _PUBLIC_ NTSTATUS dcerpc_floor_get_lhs_data(const struct epm_floor *epm_floor,
371                                             struct ndr_syntax_id *syntax)
372 {
373         TALLOC_CTX *mem_ctx = talloc_init("floor_get_lhs_data");
374         struct ndr_pull *ndr;
375         enum ndr_err_code ndr_err;
376         uint16_t if_version=0;
377
378         ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx, NULL);
379         if (ndr == NULL) {
380                 talloc_free(mem_ctx);
381                 return NT_STATUS_NO_MEMORY;
382         }
383         ndr->flags |= LIBNDR_FLAG_NOALIGN;
384
385         ndr_err = ndr_pull_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
386         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
387                 talloc_free(mem_ctx);
388                 return ndr_map_error2ntstatus(ndr_err);
389         }
390
391         ndr_err = ndr_pull_uint16(ndr, NDR_SCALARS, &if_version);
392         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
393                 talloc_free(mem_ctx);
394                 return ndr_map_error2ntstatus(ndr_err);
395         }
396
397         syntax->if_version = if_version;
398
399         talloc_free(mem_ctx);
400
401         return NT_STATUS_OK;
402 }
403
404 static DATA_BLOB dcerpc_floor_pack_lhs_data(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax)
405 {
406         struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx, NULL);
407
408         ndr->flags |= LIBNDR_FLAG_NOALIGN;
409
410         ndr_push_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
411         ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version);
412
413         return ndr_push_blob(ndr);
414 }
415
416 const char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
417 {
418         switch (epm_floor->lhs.protocol) {
419         case EPM_PROTOCOL_TCP:
420                 if (epm_floor->rhs.tcp.port == 0) return NULL;
421                 return talloc_asprintf(mem_ctx, "%d", epm_floor->rhs.tcp.port);
422
423         case EPM_PROTOCOL_UDP:
424                 if (epm_floor->rhs.udp.port == 0) return NULL;
425                 return talloc_asprintf(mem_ctx, "%d", epm_floor->rhs.udp.port);
426
427         case EPM_PROTOCOL_HTTP:
428                 if (epm_floor->rhs.http.port == 0) return NULL;
429                 return talloc_asprintf(mem_ctx, "%d", epm_floor->rhs.http.port);
430
431         case EPM_PROTOCOL_IP:
432                 return talloc_strdup(mem_ctx, epm_floor->rhs.ip.ipaddr);
433
434         case EPM_PROTOCOL_NCACN:
435                 return NULL;
436
437         case EPM_PROTOCOL_NCADG:
438                 return NULL;
439
440         case EPM_PROTOCOL_SMB:
441                 if (strlen(epm_floor->rhs.smb.unc) == 0) return NULL;
442                 return talloc_strdup(mem_ctx, epm_floor->rhs.smb.unc);
443
444         case EPM_PROTOCOL_NAMED_PIPE:
445                 if (strlen(epm_floor->rhs.named_pipe.path) == 0) return NULL;
446                 return talloc_strdup(mem_ctx, epm_floor->rhs.named_pipe.path);
447
448         case EPM_PROTOCOL_NETBIOS:
449                 if (strlen(epm_floor->rhs.netbios.name) == 0) return NULL;
450                 return talloc_strdup(mem_ctx, epm_floor->rhs.netbios.name);
451
452         case EPM_PROTOCOL_NCALRPC:
453                 return NULL;
454
455         case EPM_PROTOCOL_VINES_SPP:
456                 return talloc_asprintf(mem_ctx, "%d", epm_floor->rhs.vines_spp.port);
457
458         case EPM_PROTOCOL_VINES_IPC:
459                 return talloc_asprintf(mem_ctx, "%d", epm_floor->rhs.vines_ipc.port);
460
461         case EPM_PROTOCOL_STREETTALK:
462                 return talloc_strdup(mem_ctx, epm_floor->rhs.streettalk.streettalk);
463
464         case EPM_PROTOCOL_UNIX_DS:
465                 if (strlen(epm_floor->rhs.unix_ds.path) == 0) return NULL;
466                 return talloc_strdup(mem_ctx, epm_floor->rhs.unix_ds.path);
467
468         case EPM_PROTOCOL_NULL:
469                 return NULL;
470
471         default:
472                 DEBUG(0,("Unsupported lhs protocol %d\n", epm_floor->lhs.protocol));
473                 break;
474         }
475
476         return NULL;
477 }
478
479 static NTSTATUS dcerpc_floor_set_rhs_data(TALLOC_CTX *mem_ctx, 
480                                           struct epm_floor *epm_floor,  
481                                           const char *data)
482 {
483         switch (epm_floor->lhs.protocol) {
484         case EPM_PROTOCOL_TCP:
485                 epm_floor->rhs.tcp.port = atoi(data);
486                 return NT_STATUS_OK;
487
488         case EPM_PROTOCOL_UDP:
489                 epm_floor->rhs.udp.port = atoi(data);
490                 return NT_STATUS_OK;
491
492         case EPM_PROTOCOL_HTTP:
493                 epm_floor->rhs.http.port = atoi(data);
494                 return NT_STATUS_OK;
495
496         case EPM_PROTOCOL_IP:
497                 epm_floor->rhs.ip.ipaddr = talloc_strdup(mem_ctx, data);
498                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.ip.ipaddr);
499                 return NT_STATUS_OK;
500
501         case EPM_PROTOCOL_NCACN:
502                 epm_floor->rhs.ncacn.minor_version = 0;
503                 return NT_STATUS_OK;
504
505         case EPM_PROTOCOL_NCADG:
506                 epm_floor->rhs.ncadg.minor_version = 0;
507                 return NT_STATUS_OK;
508
509         case EPM_PROTOCOL_SMB:
510                 epm_floor->rhs.smb.unc = talloc_strdup(mem_ctx, data);
511                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.smb.unc);
512                 return NT_STATUS_OK;
513
514         case EPM_PROTOCOL_NAMED_PIPE:
515                 epm_floor->rhs.named_pipe.path = talloc_strdup(mem_ctx, data);
516                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.named_pipe.path);
517                 return NT_STATUS_OK;
518
519         case EPM_PROTOCOL_NETBIOS:
520                 epm_floor->rhs.netbios.name = talloc_strdup(mem_ctx, data);
521                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.netbios.name);
522                 return NT_STATUS_OK;
523
524         case EPM_PROTOCOL_NCALRPC:
525                 return NT_STATUS_OK;
526
527         case EPM_PROTOCOL_VINES_SPP:
528                 epm_floor->rhs.vines_spp.port = atoi(data);
529                 return NT_STATUS_OK;
530
531         case EPM_PROTOCOL_VINES_IPC:
532                 epm_floor->rhs.vines_ipc.port = atoi(data);
533                 return NT_STATUS_OK;
534
535         case EPM_PROTOCOL_STREETTALK:
536                 epm_floor->rhs.streettalk.streettalk = talloc_strdup(mem_ctx, data);
537                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.streettalk.streettalk);
538                 return NT_STATUS_OK;
539
540         case EPM_PROTOCOL_UNIX_DS:
541                 epm_floor->rhs.unix_ds.path = talloc_strdup(mem_ctx, data);
542                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.unix_ds.path);
543                 return NT_STATUS_OK;
544
545         case EPM_PROTOCOL_NULL:
546                 return NT_STATUS_OK;
547
548         default:
549                 DEBUG(0,("Unsupported lhs protocol %d\n", epm_floor->lhs.protocol));
550                 break;
551         }
552
553         return NT_STATUS_NOT_SUPPORTED;
554 }
555
556 enum dcerpc_transport_t dcerpc_transport_by_endpoint_protocol(int prot)
557 {
558         int i;
559
560         /* Find a transport that has 'prot' as 4th protocol */
561         for (i=0;i<ARRAY_SIZE(transports);i++) {
562                 if (transports[i].num_protocols >= 2 && 
563                         transports[i].protseq[1] == prot) {
564                         return transports[i].transport;
565                 }
566         }
567
568         /* Unknown transport */
569         return (unsigned int)-1;
570 }
571
572 _PUBLIC_ enum dcerpc_transport_t dcerpc_transport_by_tower(const struct epm_tower *tower)
573 {
574         int i;
575
576         /* Find a transport that matches this tower */
577         for (i=0;i<ARRAY_SIZE(transports);i++) {
578                 int j;
579                 if (transports[i].num_protocols != tower->num_floors - 2) {
580                         continue; 
581                 }
582
583                 for (j = 0; j < transports[i].num_protocols; j++) {
584                         if (transports[i].protseq[j] != tower->floors[j+2].lhs.protocol) {
585                                 break;
586                         }
587                 }
588
589                 if (j == transports[i].num_protocols) {
590                         return transports[i].transport;
591                 }
592         }
593
594         /* Unknown transport */
595         return (unsigned int)-1;
596 }
597
598 _PUBLIC_ const char *derpc_transport_string_by_transport(enum dcerpc_transport_t t)
599 {
600         int i;
601
602         for (i=0; i<ARRAY_SIZE(transports); i++) {
603                 if (t == transports[i].transport) {
604                         return transports[i].name;
605                 }
606         }
607         return NULL;
608 }
609
610 _PUBLIC_ NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx, 
611                                    struct epm_tower *tower, 
612                                    struct dcerpc_binding **b_out)
613 {
614         NTSTATUS status;
615         struct dcerpc_binding *binding;
616
617         binding = talloc(mem_ctx, struct dcerpc_binding);
618         NT_STATUS_HAVE_NO_MEMORY(binding);
619
620         ZERO_STRUCT(binding->object);
621         binding->options = NULL;
622         binding->host = NULL;
623         binding->target_hostname = NULL;
624         binding->flags = 0;
625         binding->assoc_group_id = 0;
626
627         binding->transport = dcerpc_transport_by_tower(tower);
628
629         if (binding->transport == (unsigned int)-1) {
630                 return NT_STATUS_NOT_SUPPORTED;
631         }
632
633         if (tower->num_floors < 1) {
634                 return NT_STATUS_OK;
635         }
636
637         /* Set object uuid */
638         status = dcerpc_floor_get_lhs_data(&tower->floors[0], &binding->object);
639
640         if (!NT_STATUS_IS_OK(status)) {
641                 DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status)));     
642                 return status;
643         }
644
645         /* Ignore floor 1, it contains the NDR version info */
646
647         binding->options = NULL;
648
649         /* Set endpoint */
650         if (tower->num_floors >= 4) {
651                 binding->endpoint = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[3]);
652         } else {
653                 binding->endpoint = NULL;
654         }
655
656         /* Set network address */
657         if (tower->num_floors >= 5) {
658                 binding->host = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[4]);
659                 NT_STATUS_HAVE_NO_MEMORY(binding->host);
660                 binding->target_hostname = binding->host;
661         }
662         *b_out = binding;
663         return NT_STATUS_OK;
664 }
665
666 _PUBLIC_ NTSTATUS dcerpc_binding_build_tower(TALLOC_CTX *mem_ctx,
667                                              const struct dcerpc_binding *binding,
668                                              struct epm_tower *tower)
669 {
670         const enum epm_protocol *protseq = NULL;
671         int num_protocols = -1, i;
672         NTSTATUS status;
673
674         /* Find transport */
675         for (i=0;i<ARRAY_SIZE(transports);i++) {
676                 if (transports[i].transport == binding->transport) {
677                         protseq = transports[i].protseq;
678                         num_protocols = transports[i].num_protocols;
679                         break;
680                 }
681         }
682
683         if (num_protocols == -1) {
684                 DEBUG(0, ("Unable to find transport with id '%d'\n", binding->transport));
685                 return NT_STATUS_UNSUCCESSFUL;
686         }
687
688         tower->num_floors = 2 + num_protocols;
689         tower->floors = talloc_array(mem_ctx, struct epm_floor, tower->num_floors);
690
691         /* Floor 0 */
692         tower->floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
693
694         tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, &binding->object);
695
696         tower->floors[0].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
697
698         /* Floor 1 */
699         tower->floors[1].lhs.protocol = EPM_PROTOCOL_UUID;
700
701         tower->floors[1].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, 
702                                                                 &ndr_transfer_syntax);
703
704         tower->floors[1].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
705
706         /* Floor 2 to num_protocols */
707         for (i = 0; i < num_protocols; i++) {
708                 tower->floors[2 + i].lhs.protocol = protseq[i];
709                 tower->floors[2 + i].lhs.lhs_data = data_blob_talloc(mem_ctx, NULL, 0);
710                 ZERO_STRUCT(tower->floors[2 + i].rhs);
711                 dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[2 + i], "");
712         }
713
714         /* The 4th floor contains the endpoint */
715         if (num_protocols >= 2 && binding->endpoint) {
716                 status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[3], binding->endpoint);
717                 if (NT_STATUS_IS_ERR(status)) {
718                         return status;
719                 }
720         }
721
722         /* The 5th contains the network address */
723         if (num_protocols >= 3 && binding->host) {
724                 if (is_ipaddress(binding->host)) {
725                         status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[4], 
726                                                            binding->host);
727                 } else {
728                         /* note that we don't attempt to resolve the
729                            name here - when we get a hostname here we
730                            are in the client code, and want to put in
731                            a wildcard all-zeros IP for the server to
732                            fill in */
733                         status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[4], 
734                                                            "0.0.0.0");
735                 }
736                 if (NT_STATUS_IS_ERR(status)) {
737                         return status;
738                 }
739         }
740
741         return NT_STATUS_OK;
742 }