3697d2f181be9c4c1e662ad4b02fe2fe64632873
[samba.git] / source4 / librpc / rpc / dcerpc_util.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    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program 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
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "system/network.h"
26 #include "librpc/gen_ndr/ndr_epmapper.h"
27
28 /*
29   find the pipe name for a local IDL interface
30 */
31 const char *idl_pipe_name(const char *uuid, uint32_t if_version)
32 {
33         const struct dcerpc_interface_list *l;
34         for (l=librpc_dcerpc_pipes();l;l=l->next) {
35                 if (strcasecmp(l->table->uuid, uuid) == 0 &&
36                     l->table->if_version == if_version) {
37                         return l->table->name;
38                 }
39         }
40         return "UNKNOWN";
41 }
42
43 /*
44   find the number of calls defined by local IDL
45 */
46 int idl_num_calls(const char *uuid, uint32_t if_version)
47 {
48         const struct dcerpc_interface_list *l;
49         for (l=librpc_dcerpc_pipes();l;l=l->next){
50                 if (strcasecmp(l->table->uuid, uuid) == 0 &&
51                     l->table->if_version == if_version) {
52                         return l->table->num_calls;
53                 }
54         }
55         return -1;
56 }
57
58
59 /*
60   find a dcerpc interface by name
61 */
62 const struct dcerpc_interface_table *idl_iface_by_name(const char *name)
63 {
64         const struct dcerpc_interface_list *l;
65         for (l=librpc_dcerpc_pipes();l;l=l->next) {
66                 if (strcasecmp(l->table->name, name) == 0) {
67                         return l->table;
68                 }
69         }
70         return NULL;
71 }
72
73 /*
74   find a dcerpc interface by uuid
75 */
76 const struct dcerpc_interface_table *idl_iface_by_uuid(const char *uuid)
77 {
78         const struct dcerpc_interface_list *l;
79         for (l=librpc_dcerpc_pipes();l;l=l->next) {
80                 if (strcasecmp(l->table->uuid, uuid) == 0) {
81                         return l->table;
82                 }
83         }
84         return NULL;
85 }
86
87
88 /* 
89    push a dcerpc_packet into a blob, potentially with auth info
90 */
91 NTSTATUS dcerpc_push_auth(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, 
92                           struct dcerpc_packet *pkt,
93                           struct dcerpc_auth *auth_info)
94 {
95         NTSTATUS status;
96         struct ndr_push *ndr;
97
98         ndr = ndr_push_init_ctx(mem_ctx);
99         if (!ndr) {
100                 return NT_STATUS_NO_MEMORY;
101         }
102
103         if (!(pkt->drep[0] & DCERPC_DREP_LE)) {
104                 ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
105         }
106
107         if (pkt->pfc_flags & DCERPC_PFC_FLAG_ORPC) {
108                 ndr->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
109         }
110
111         if (auth_info) {
112                 pkt->auth_length = auth_info->credentials.length;
113         } else {
114                 pkt->auth_length = 0;
115         }
116
117         status = ndr_push_dcerpc_packet(ndr, NDR_SCALARS|NDR_BUFFERS, pkt);
118         if (!NT_STATUS_IS_OK(status)) {
119                 return status;
120         }
121
122         if (auth_info) {
123                 status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, auth_info);
124         }
125
126         *blob = ndr_push_blob(ndr);
127
128         /* fill in the frag length */
129         dcerpc_set_frag_length(blob, blob->length);
130
131         return NT_STATUS_OK;
132 }
133
134 #define MAX_PROTSEQ             10
135
136 static const struct {
137         const char *name;
138         enum dcerpc_transport_t transport;
139         int num_protocols;
140         enum epm_protocol protseq[MAX_PROTSEQ];
141 } transports[] = {
142         { "ncacn_np",     NCACN_NP, 3, 
143                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB, EPM_PROTOCOL_NETBIOS }},
144         { "ncacn_ip_tcp", NCACN_IP_TCP, 3, 
145                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP, EPM_PROTOCOL_IP } }, 
146         { "ncacn_http", NCACN_HTTP, 3, 
147                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_HTTP, EPM_PROTOCOL_IP } }, 
148         { "ncadg_ip_udp", NCACN_IP_UDP, 3, 
149                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UDP, EPM_PROTOCOL_IP } },
150         { "ncalrpc", NCALRPC, 2, 
151                 { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_PIPE } },
152         { "ncacn_unix_stream", NCACN_UNIX_STREAM, 2, 
153                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_UNIX_DS } },
154         { "ncadg_unix_dgram", NCADG_UNIX_DGRAM, 2, 
155                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_UNIX_DS } },
156         { "ncacn_at_dsp", NCACN_AT_DSP, 3, 
157                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DSP } },
158         { "ncadg_at_ddp", NCADG_AT_DDP, 3, 
159                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_APPLETALK, EPM_PROTOCOL_DDP } },
160         { "ncacn_vns_ssp", NCACN_VNS_SPP, 3, 
161                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_SPP } },
162         { "ncacn_vns_ipc", NCACN_VNS_IPC, 3, 
163                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_STREETTALK, EPM_PROTOCOL_VINES_IPC }, },
164         { "ncadg_ipx", NCADG_IPX, 2,
165                 { EPM_PROTOCOL_NCADG, EPM_PROTOCOL_IPX },
166         },
167         { "ncacn_spx", NCACN_SPX, 2,
168                 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SPX },
169         },
170 };
171
172 static const struct {
173         const char *name;
174         uint32_t flag;
175 } ncacn_options[] = {
176         {"sign", DCERPC_SIGN},
177         {"seal", DCERPC_SEAL},
178         {"connect", DCERPC_CONNECT},
179         {"spnego", DCERPC_AUTH_SPNEGO},
180         {"krb5", DCERPC_AUTH_KRB5},
181         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
182         {"print", DCERPC_DEBUG_PRINT_BOTH},
183         {"padcheck", DCERPC_DEBUG_PAD_CHECK},
184         {"bigendian", DCERPC_PUSH_BIGENDIAN}
185 };
186
187 const char *epm_floor_string(TALLOC_CTX *mem_ctx, struct epm_floor *fl)
188 {
189         struct GUID uuid;
190         uint16_t if_version;
191         NTSTATUS status;
192
193         switch(fl->lhs.protocol) {
194                 case EPM_PROTOCOL_UUID:
195                         status = dcerpc_floor_get_lhs_data(fl, &uuid, &if_version);
196                         if (NT_STATUS_IS_OK(status)) {
197                                 /* lhs is used: UUID */
198                                 char *uuidstr;
199
200                                 uuidstr = GUID_string(mem_ctx, &uuid);
201
202                                 if (strcasecmp(uuidstr, NDR_GUID) == 0) {
203                                         return "NDR";
204                                 } 
205
206                                 return talloc_asprintf(mem_ctx, " uuid %s/0x%02x", uuidstr, if_version);
207                         } else { /* IPX */
208                                 return talloc_asprintf(mem_ctx, "IPX:%s", 
209                                                 data_blob_hex_string(mem_ctx, &fl->rhs.uuid.unknown));
210                         }
211
212                 case EPM_PROTOCOL_NCACN:
213                         return "RPC-C";
214
215                 case EPM_PROTOCOL_NCADG:
216                         return "RPC";
217
218                 case EPM_PROTOCOL_NCALRPC:
219                         return "NCALRPC";
220
221                 case EPM_PROTOCOL_DNET_NSP:
222                         return "DNET/NSP";
223
224                 case EPM_PROTOCOL_IP:
225                         return talloc_asprintf(mem_ctx, "IP:%s", fl->rhs.ip.ipaddr);
226
227                 case EPM_PROTOCOL_PIPE:
228                         return talloc_asprintf(mem_ctx, "PIPE:%s", fl->rhs.pipe.path);
229
230                 case EPM_PROTOCOL_SMB:
231                         return talloc_asprintf(mem_ctx, "SMB:%s", fl->rhs.smb.unc);
232
233                 case EPM_PROTOCOL_UNIX_DS:
234                         return talloc_asprintf(mem_ctx, "Unix:%s", fl->rhs.unix_ds.path);
235
236                 case EPM_PROTOCOL_NETBIOS:
237                         return talloc_asprintf(mem_ctx, "NetBIOS:%s", fl->rhs.netbios.name);
238
239                 case EPM_PROTOCOL_NETBEUI:
240                         return "NETBeui";
241
242                 case EPM_PROTOCOL_SPX:
243                         return "SPX";
244
245                 case EPM_PROTOCOL_NB_IPX:
246                         return "NB_IPX";
247
248                 case EPM_PROTOCOL_HTTP:
249                         return talloc_asprintf(mem_ctx, "HTTP:%d", fl->rhs.http.port);
250
251                 case EPM_PROTOCOL_TCP:
252                         return talloc_asprintf(mem_ctx, "TCP:%d", fl->rhs.tcp.port);
253
254                 case EPM_PROTOCOL_UDP:
255                         return talloc_asprintf(mem_ctx, "UDP:%d", fl->rhs.udp.port);
256
257                 default:
258                         return talloc_asprintf(mem_ctx, "UNK(%02x):", fl->lhs.protocol);
259         }
260 }
261
262
263 /*
264   form a binding string from a binding structure
265 */
266 const char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
267 {
268         char *s = talloc_strdup(mem_ctx, "");
269         int i;
270         const char *t_name=NULL;
271
272         for (i=0;i<ARRAY_SIZE(transports);i++) {
273                 if (transports[i].transport == b->transport) {
274                         t_name = transports[i].name;
275                 }
276         }
277         if (!t_name) {
278                 return NULL;
279         }
280
281         if (!GUID_all_zero(&b->object)) { 
282                 s = talloc_asprintf(s, "%s@",
283                                     GUID_string(mem_ctx, &b->object));
284         }
285
286         s = talloc_asprintf_append(s, "%s:", t_name);
287         if (!s) return NULL;
288
289         if (b->host) {
290                 s = talloc_asprintf_append(s, "%s", b->host);
291         }
292
293         if (!b->endpoint && !b->options && !b->flags) {
294                 return s;
295         }
296
297         s = talloc_asprintf_append(s, "[");
298
299         if (b->endpoint) {
300                 s = talloc_asprintf_append(s, "%s", b->endpoint);
301         }
302
303         /* this is a *really* inefficent way of dealing with strings,
304            but this is rarely called and the strings are always short,
305            so I don't care */
306         for (i=0;b->options && b->options[i];i++) {
307                 s = talloc_asprintf_append(s, ",%s", b->options[i]);
308                 if (!s) return NULL;
309         }
310
311         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
312                 if (b->flags & ncacn_options[i].flag) {
313                         s = talloc_asprintf_append(s, ",%s", ncacn_options[i].name);
314                         if (!s) return NULL;
315                 }
316         }
317
318         s = talloc_asprintf_append(s, "]");
319
320         return s;
321 }
322
323 /*
324   parse a binding string into a dcerpc_binding structure
325 */
326 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
327 {
328         char *options, *type;
329         char *p;
330         int i, j, comma_count;
331
332         p = strchr(s, '@');
333
334         if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
335                 NTSTATUS status;
336
337                 status = GUID_from_string(s, &b->object);
338
339                 if (NT_STATUS_IS_ERR(status)) {
340                         DEBUG(0, ("Failed parsing UUID\n"));
341                         return status;
342                 }
343
344                 s = p + 1;
345         } else {
346                 ZERO_STRUCT(b->object);
347         }
348
349         b->object_version = 0;
350
351         p = strchr(s, ':');
352         if (!p) {
353                 return NT_STATUS_INVALID_PARAMETER;
354         }
355
356         type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
357         if (!type) {
358                 return NT_STATUS_NO_MEMORY;
359         }
360
361         for (i=0;i<ARRAY_SIZE(transports);i++) {
362                 if (strcasecmp(type, transports[i].name) == 0) {
363                         b->transport = transports[i].transport;
364                         break;
365                 }
366         }
367         if (i==ARRAY_SIZE(transports)) {
368                 DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
369                 return NT_STATUS_INVALID_PARAMETER;
370         }
371         
372         s = p+1;
373
374         p = strchr(s, '[');
375         if (p) {
376                 b->host = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
377                 options = talloc_strdup(mem_ctx, p+1);
378                 if (options[strlen(options)-1] != ']') {
379                         return NT_STATUS_INVALID_PARAMETER;
380                 }
381                 options[strlen(options)-1] = 0;
382         } else {
383                 b->host = talloc_strdup(mem_ctx, s);
384                 options = NULL;
385         }
386
387         if (!b->host) {
388                 return NT_STATUS_NO_MEMORY;
389         }
390
391         b->options = NULL;
392         b->flags = 0;
393         b->endpoint = NULL;
394
395         if (!options) {
396                 return NT_STATUS_OK;
397         }
398
399         comma_count = count_chars(options, ',');
400
401         b->options = talloc_array(mem_ctx, const char *, comma_count+2);
402         if (!b->options) {
403                 return NT_STATUS_NO_MEMORY;
404         }
405
406         for (i=0; (p = strchr(options, ',')); i++) {
407                 b->options[i] = talloc_strndup(mem_ctx, options, PTR_DIFF(p, options));
408                 if (!b->options[i]) {
409                         return NT_STATUS_NO_MEMORY;
410                 }
411                 options = p+1;
412         }
413         b->options[i] = options;
414         b->options[i+1] = NULL;
415
416         /* some options are pre-parsed for convenience */
417         for (i=0;b->options[i];i++) {
418                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
419                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
420                                 int k;
421                                 b->flags |= ncacn_options[j].flag;
422                                 for (k=i;b->options[k];k++) {
423                                         b->options[k] = b->options[k+1];
424                                 }
425                                 i--;
426                                 break;
427                         }
428                 }
429         }
430
431         if (b->options[0]) {
432                 /* Endpoint is first option */
433                 b->endpoint = b->options[0];
434                 if (strlen(b->endpoint) == 0) b->endpoint = NULL;
435
436                 for (i=0;b->options[i];i++) {
437                         b->options[i] = b->options[i+1];
438                 }
439         }
440
441         if (b->options[0] == NULL)
442                 b->options = NULL;
443         
444         return NT_STATUS_OK;
445 }
446
447 NTSTATUS dcerpc_floor_get_lhs_data(struct epm_floor *floor, struct GUID *uuid, uint16_t *if_version)
448 {
449         TALLOC_CTX *mem_ctx = talloc_init("floor_get_lhs_data");
450         struct ndr_pull *ndr = ndr_pull_init_blob(&floor->lhs.lhs_data, mem_ctx);
451         NTSTATUS status;
452         
453         ndr->flags |= LIBNDR_FLAG_NOALIGN;
454
455         status = ndr_pull_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, uuid);
456         if (NT_STATUS_IS_ERR(status)) {
457                 talloc_free(mem_ctx);
458                 return status;
459         }
460
461         status = ndr_pull_uint16(ndr, NDR_SCALARS, if_version);
462
463         talloc_free(mem_ctx);
464
465         return status;
466 }
467
468 DATA_BLOB dcerpc_floor_pack_lhs_data(TALLOC_CTX *mem_ctx, struct GUID *uuid, uint32_t if_version)
469 {
470         struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
471
472         ndr->flags |= LIBNDR_FLAG_NOALIGN;
473
474         ndr_push_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, uuid);
475         ndr_push_uint16(ndr, NDR_SCALARS, if_version);
476
477         return ndr_push_blob(ndr);
478 }
479
480 const char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *floor)
481 {
482         switch (floor->lhs.protocol) {
483         case EPM_PROTOCOL_TCP:
484                 if (floor->rhs.tcp.port == 0) return NULL;
485                 return talloc_asprintf(mem_ctx, "%d", floor->rhs.tcp.port);
486                 
487         case EPM_PROTOCOL_UDP:
488                 if (floor->rhs.udp.port == 0) return NULL;
489                 return talloc_asprintf(mem_ctx, "%d", floor->rhs.udp.port);
490
491         case EPM_PROTOCOL_HTTP:
492                 if (floor->rhs.http.port == 0) return NULL;
493                 return talloc_asprintf(mem_ctx, "%d", floor->rhs.http.port);
494
495         case EPM_PROTOCOL_IP:
496                 return talloc_strdup(mem_ctx, floor->rhs.ip.ipaddr);
497
498         case EPM_PROTOCOL_NCACN:
499                 return NULL;
500
501         case EPM_PROTOCOL_NCADG:
502                 return NULL;
503
504         case EPM_PROTOCOL_SMB:
505                 if (strlen(floor->rhs.smb.unc) == 0) return NULL;
506                 return talloc_strdup(mem_ctx, floor->rhs.smb.unc);
507
508         case EPM_PROTOCOL_PIPE:
509                 if (strlen(floor->rhs.pipe.path) == 0) return NULL;
510                 return talloc_strdup(mem_ctx, floor->rhs.pipe.path);
511
512         case EPM_PROTOCOL_NETBIOS:
513                 if (strlen(floor->rhs.netbios.name) == 0) return NULL;
514                 return talloc_strdup(mem_ctx, floor->rhs.netbios.name);
515
516         case EPM_PROTOCOL_NCALRPC:
517                 return NULL;
518                 
519         case EPM_PROTOCOL_VINES_SPP:
520                 return talloc_asprintf(mem_ctx, "%d", floor->rhs.vines_spp.port);
521                 
522         case EPM_PROTOCOL_VINES_IPC:
523                 return talloc_asprintf(mem_ctx, "%d", floor->rhs.vines_ipc.port);
524                 
525         case EPM_PROTOCOL_STREETTALK:
526                 return talloc_strdup(mem_ctx, floor->rhs.streettalk.streettalk);
527                 
528         case EPM_PROTOCOL_UNIX_DS:
529                 if (strlen(floor->rhs.unix_ds.path) == 0) return NULL;
530                 return talloc_strdup(mem_ctx, floor->rhs.unix_ds.path);
531                 
532         case EPM_PROTOCOL_NULL:
533                 return NULL;
534
535         default:
536                 DEBUG(0,("Unsupported lhs protocol %d\n", floor->lhs.protocol));
537                 break;
538         }
539
540         return NULL;
541 }
542
543 static NTSTATUS dcerpc_floor_set_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *floor,  const char *data)
544 {
545         switch (floor->lhs.protocol) {
546         case EPM_PROTOCOL_TCP:
547                 floor->rhs.tcp.port = atoi(data);
548                 return NT_STATUS_OK;
549                 
550         case EPM_PROTOCOL_UDP:
551                 floor->rhs.udp.port = atoi(data);
552                 return NT_STATUS_OK;
553
554         case EPM_PROTOCOL_HTTP:
555                 floor->rhs.http.port = atoi(data);
556                 return NT_STATUS_OK;
557
558         case EPM_PROTOCOL_IP:
559                 floor->rhs.ip.ipaddr = talloc_strdup(mem_ctx, data);
560                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.ip.ipaddr);
561                 return NT_STATUS_OK;
562
563         case EPM_PROTOCOL_NCACN:
564                 floor->rhs.ncacn.minor_version = 0;
565                 return NT_STATUS_OK;
566
567         case EPM_PROTOCOL_NCADG:
568                 floor->rhs.ncadg.minor_version = 0;
569                 return NT_STATUS_OK;
570
571         case EPM_PROTOCOL_SMB:
572                 floor->rhs.smb.unc = talloc_strdup(mem_ctx, data);
573                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.smb.unc);
574                 return NT_STATUS_OK;
575
576         case EPM_PROTOCOL_PIPE:
577                 floor->rhs.pipe.path = talloc_strdup(mem_ctx, data);
578                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.pipe.path);
579                 return NT_STATUS_OK;
580
581         case EPM_PROTOCOL_NETBIOS:
582                 floor->rhs.netbios.name = talloc_strdup(mem_ctx, data);
583                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.netbios.name);
584                 return NT_STATUS_OK;
585
586         case EPM_PROTOCOL_NCALRPC:
587                 return NT_STATUS_OK;
588                 
589         case EPM_PROTOCOL_VINES_SPP:
590                 floor->rhs.vines_spp.port = atoi(data);
591                 return NT_STATUS_OK;
592                 
593         case EPM_PROTOCOL_VINES_IPC:
594                 floor->rhs.vines_ipc.port = atoi(data);
595                 return NT_STATUS_OK;
596                 
597         case EPM_PROTOCOL_STREETTALK:
598                 floor->rhs.streettalk.streettalk = talloc_strdup(mem_ctx, data);
599                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.streettalk.streettalk);
600                 return NT_STATUS_OK;
601                 
602         case EPM_PROTOCOL_UNIX_DS:
603                 floor->rhs.unix_ds.path = talloc_strdup(mem_ctx, data);
604                 NT_STATUS_HAVE_NO_MEMORY(floor->rhs.unix_ds.path);
605                 return NT_STATUS_OK;
606                 
607         case EPM_PROTOCOL_NULL:
608                 return NT_STATUS_OK;
609
610         default:
611                 DEBUG(0,("Unsupported lhs protocol %d\n", floor->lhs.protocol));
612                 break;
613         }
614
615         return NT_STATUS_NOT_SUPPORTED;
616 }
617
618 enum dcerpc_transport_t dcerpc_transport_by_endpoint_protocol(int prot)
619 {
620         int i;
621
622         /* Find a transport that has 'prot' as 4th protocol */
623         for (i=0;i<ARRAY_SIZE(transports);i++) {
624                 if (transports[i].num_protocols >= 2 && 
625                         transports[i].protseq[1] == prot) {
626                         return transports[i].transport;
627                 }
628         }
629         
630         /* Unknown transport */
631         return -1;
632 }
633
634 enum dcerpc_transport_t dcerpc_transport_by_tower(struct epm_tower *tower)
635 {
636         int i;
637
638         /* Find a transport that matches this tower */
639         for (i=0;i<ARRAY_SIZE(transports);i++) {
640                 int j;
641                 if (transports[i].num_protocols != tower->num_floors - 2) {
642                         continue; 
643                 }
644
645                 for (j = 0; j < transports[i].num_protocols; j++) {
646                         if (transports[i].protseq[j] != tower->floors[j+2].lhs.protocol) {
647                                 break;
648                         }
649                 }
650
651                 if (j == transports[i].num_protocols) {
652                         return transports[i].transport;
653                 }
654         }
655         
656         /* Unknown transport */
657         return -1;
658 }
659
660 NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx, struct epm_tower *tower, struct dcerpc_binding *binding)
661 {
662         NTSTATUS status;
663
664         ZERO_STRUCT(binding->object);
665         binding->options = NULL;
666         binding->host = NULL;
667         binding->flags = 0;
668
669         binding->transport = dcerpc_transport_by_tower(tower);
670
671         if (binding->transport == -1) {
672                 return NT_STATUS_NOT_SUPPORTED;
673         }
674
675         if (tower->num_floors < 1) {
676                 return NT_STATUS_OK;
677         }
678
679         /* Set object uuid */
680         status = dcerpc_floor_get_lhs_data(&tower->floors[0], &binding->object, &binding->object_version);
681         
682         if (!NT_STATUS_IS_OK(status)) {
683                 DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status)));     
684                 return status;
685         }
686
687         /* Ignore floor 1, it contains the NDR version info */
688         
689         binding->options = NULL;
690
691         /* Set endpoint */
692         if (tower->num_floors >= 4) {
693                 binding->endpoint = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[3]);
694         } else {
695                 binding->endpoint = NULL;
696         }
697
698         /* Set network address */
699         if (tower->num_floors >= 5) {
700                 binding->host = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[4]);
701         }
702         return NT_STATUS_OK;
703 }
704
705 NTSTATUS dcerpc_binding_build_tower(TALLOC_CTX *mem_ctx, struct dcerpc_binding *binding, struct epm_tower *tower)
706 {
707         const enum epm_protocol *protseq = NULL;
708         int num_protocols = -1, i;
709         struct GUID ndr_guid;
710         NTSTATUS status;
711         
712         /* Find transport */
713         for (i=0;i<ARRAY_SIZE(transports);i++) {
714                 if (transports[i].transport == binding->transport) {
715                         protseq = transports[i].protseq;
716                         num_protocols = transports[i].num_protocols;
717                         break;
718                 }
719         }
720
721         if (num_protocols == -1) {
722                 DEBUG(0, ("Unable to find transport with id '%d'\n", binding->transport));
723                 return NT_STATUS_UNSUCCESSFUL;
724         }
725
726         tower->num_floors = 2 + num_protocols;
727         tower->floors = talloc_array(mem_ctx, struct epm_floor, tower->num_floors);
728
729         /* Floor 0 */
730         tower->floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
731
732         tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, &binding->object, binding->object_version);
733
734         tower->floors[0].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
735         
736         /* Floor 1 */
737         tower->floors[1].lhs.protocol = EPM_PROTOCOL_UUID;
738
739         status = GUID_from_string(NDR_GUID, &ndr_guid);
740         if (NT_STATUS_IS_ERR(status)) {
741                 return status;
742         }
743
744         tower->floors[1].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, &ndr_guid, NDR_GUID_VERSION);
745         
746         tower->floors[1].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
747         
748         /* Floor 2 to num_protocols */
749         for (i = 0; i < num_protocols; i++) {
750                 tower->floors[2 + i].lhs.protocol = protseq[i];
751                 tower->floors[2 + i].lhs.lhs_data = data_blob_talloc(mem_ctx, NULL, 0);
752                 ZERO_STRUCT(tower->floors[2 + i].rhs);
753                 dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[2 + i], "");
754         }
755
756         /* The 4th floor contains the endpoint */
757         if (num_protocols >= 2 && binding->endpoint) {
758                 status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[3], binding->endpoint);
759                 if (NT_STATUS_IS_ERR(status)) {
760                         return status;
761                 }
762         }
763         
764         /* The 5th contains the network address */
765         if (num_protocols >= 3 && binding->host) {
766                 status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[4], binding->host);
767                 if (NT_STATUS_IS_ERR(status)) {
768                         return status;
769                 }
770         }
771
772         return NT_STATUS_OK;
773 }
774
775 NTSTATUS dcerpc_epm_map_binding(TALLOC_CTX *mem_ctx, struct dcerpc_binding *binding,
776                                  const char *uuid, uint_t version)
777 {
778         struct dcerpc_pipe *p;
779         NTSTATUS status;
780         struct epm_Map r;
781         struct policy_handle handle;
782         struct GUID guid;
783         struct epm_twr_t twr, *twr_r;
784         struct dcerpc_binding epmapper_binding;
785         const struct dcerpc_interface_table *table = idl_iface_by_uuid(uuid);
786         int i;
787
788         /* First, check if there is a default endpoint specified in the IDL */
789
790         if (table) {
791                 struct dcerpc_binding default_binding;
792                 
793                 /* Find one of the default pipes for this interface */
794                 for (i = 0; i < table->endpoints->count; i++) {
795                         status = dcerpc_parse_binding(mem_ctx, table->endpoints->names[i], &default_binding);
796
797                         if (NT_STATUS_IS_OK(status) && default_binding.transport == binding->transport && default_binding.endpoint) {
798                                 binding->endpoint = talloc_strdup(mem_ctx, default_binding.endpoint);   
799                                 return NT_STATUS_OK;
800                         }
801                 }
802         }
803
804
805         ZERO_STRUCT(epmapper_binding);
806         epmapper_binding.transport = binding->transport;
807         epmapper_binding.host = binding->host;
808         epmapper_binding.options = NULL;
809         epmapper_binding.flags = 0;
810         epmapper_binding.endpoint = NULL;
811         
812         status = dcerpc_pipe_connect_b(&p,
813                                         &epmapper_binding,
814                                    DCERPC_EPMAPPER_UUID,
815                                    DCERPC_EPMAPPER_VERSION,
816                                    NULL, NULL, NULL);
817
818         if (!NT_STATUS_IS_OK(status)) {
819                 return status;
820         }
821
822         ZERO_STRUCT(handle);
823         ZERO_STRUCT(guid);
824
825         status = GUID_from_string(uuid, &binding->object);
826         if (NT_STATUS_IS_ERR(status)) {
827                 return status;
828         }
829
830         binding->object_version = version;
831
832         status = dcerpc_binding_build_tower(p, binding, &twr.tower);
833         if (NT_STATUS_IS_ERR(status)) {
834                 return status;
835         }
836
837         /* with some nice pretty paper around it of course */
838         r.in.object = &guid;
839         r.in.map_tower = &twr;
840         r.in.entry_handle = &handle;
841         r.in.max_towers = 1;
842         r.out.entry_handle = &handle;
843
844         status = dcerpc_epm_Map(p, p, &r);
845         if (!NT_STATUS_IS_OK(status)) {
846                 dcerpc_pipe_close(p);
847                 return status;
848         }
849         if (r.out.result != 0 || r.out.num_towers != 1) {
850                 dcerpc_pipe_close(p);
851                 return NT_STATUS_PORT_UNREACHABLE;
852         }
853
854         twr_r = r.out.towers[0].twr;
855         if (!twr_r) {
856                 dcerpc_pipe_close(p);
857                 return NT_STATUS_PORT_UNREACHABLE;
858         }
859
860         if (twr_r->tower.num_floors != twr.tower.num_floors ||
861             twr_r->tower.floors[3].lhs.protocol != twr.tower.floors[3].lhs.protocol) {
862                 dcerpc_pipe_close(p);
863                 return NT_STATUS_PORT_UNREACHABLE;
864         }
865
866         binding->endpoint = dcerpc_floor_get_rhs_data(mem_ctx, &twr_r->tower.floors[3]);
867
868         dcerpc_pipe_close(p);
869
870         return NT_STATUS_OK;
871 }
872
873
874 /* 
875    perform an authenticated bind if needed
876 */
877 static NTSTATUS dcerpc_pipe_auth(struct dcerpc_pipe *p, 
878                                  struct dcerpc_binding *binding,
879                                  const char *pipe_uuid, 
880                                  uint32_t pipe_version,
881                                  const char *domain,
882                                  const char *username,
883                                  const char *password)
884 {
885         NTSTATUS status;
886         p->conn->flags = binding->flags;
887
888         /* remember the binding string for possible secondary connections */
889         p->conn->binding_string = dcerpc_binding_string(p, binding);
890
891         if (username && username[0] && (binding->flags & DCERPC_SCHANNEL_ANY)) {
892                 status = dcerpc_bind_auth_schannel(p, pipe_uuid, pipe_version, 
893                                                    domain, username, password);
894         } else if (username && username[0]) {
895                 uint8_t auth_type;
896                 if (binding->flags & DCERPC_AUTH_SPNEGO) {
897                         auth_type = DCERPC_AUTH_TYPE_SPNEGO;
898                 } else if (binding->flags & DCERPC_AUTH_KRB5) {
899                         auth_type = DCERPC_AUTH_TYPE_KRB5;
900                 } else {
901                         auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
902                 }
903
904                 status = dcerpc_bind_auth_password(p, pipe_uuid, pipe_version, 
905                                                    domain, username, password, 
906                                                    auth_type);
907         } else {    
908                 status = dcerpc_bind_auth_none(p, pipe_uuid, pipe_version);
909         }
910
911         if (!NT_STATUS_IS_OK(status)) {
912                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
913         }
914         return status;
915 }
916
917
918 /* open a rpc connection to a rpc pipe on SMB using the binding
919    structure to determine the endpoint and options */
920 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **pp, 
921                                              struct dcerpc_binding *binding,
922                                              const char *pipe_uuid, 
923                                              uint32_t pipe_version,
924                                              const char *domain,
925                                              const char *username,
926                                              const char *password)
927 {
928         struct dcerpc_pipe *p;
929         NTSTATUS status;
930         struct smbcli_state *cli;
931         const char *pipe_name = NULL;
932         TALLOC_CTX *tmp_ctx;
933
934         *pp = NULL;
935
936         p = dcerpc_pipe_init(NULL);
937         if (p == NULL) {
938                 return NT_STATUS_NO_MEMORY;
939         }
940         tmp_ctx = talloc_new(p);
941         
942         /* Look up identifier using the epmapper */
943         if (!binding->endpoint) {
944                 status = dcerpc_epm_map_binding(tmp_ctx, binding, pipe_uuid, pipe_version);
945                 if (!NT_STATUS_IS_OK(status)) {
946                         DEBUG(0,("Failed to map DCERPC/TCP NCACN_NP pipe for '%s' - %s\n", 
947                                  pipe_uuid, nt_errstr(status)));
948                         talloc_free(p);
949                         return status;
950                 }
951                 DEBUG(1,("Mapped to DCERPC/NP pipe %s\n", binding->endpoint));
952         }
953
954         pipe_name = binding->endpoint;
955
956         if (!strncasecmp(pipe_name, "/pipe/", 6) || 
957             !strncasecmp(pipe_name, "\\pipe\\", 6)) {
958                 pipe_name += 6;
959         }
960
961         if (pipe_name[0] != '\\') {
962                 pipe_name = talloc_asprintf(tmp_ctx, "\\%s", pipe_name);
963         }
964         
965         if (!username || !username[0] || 
966             (binding->flags & DCERPC_SCHANNEL_ANY)) {
967                 status = smbcli_full_connection(p->conn, &cli, lp_netbios_name(),
968                                                 binding->host, 
969                                                 "ipc$", NULL, 
970                                                 "", "", NULL);
971         } else {
972                 status = smbcli_full_connection(p->conn, &cli, lp_netbios_name(),
973                                                 binding->host, 
974                                                 "ipc$", NULL,
975                                                 username, domain,
976                                                 password);
977         }
978         if (!NT_STATUS_IS_OK(status)) {
979                 DEBUG(0,("Failed to connect to %s - %s\n", binding->host, nt_errstr(status)));
980                 talloc_free(p);
981                 return status;
982         }
983
984         status = dcerpc_pipe_open_smb(p->conn, cli->tree, pipe_name);
985         if (!NT_STATUS_IS_OK(status)) {
986                 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name, nt_errstr(status)));
987                 talloc_free(p);
988                 return status;
989         }
990
991         if (!(binding->flags & DCERPC_AUTH_OPTIONS)) {
992                 username = NULL;
993         }
994         
995         status = dcerpc_pipe_auth(p, binding, pipe_uuid, pipe_version, domain, username, password);
996         if (!NT_STATUS_IS_OK(status)) {
997                 talloc_free(p);
998                 return status;
999         }
1000
1001         (*pp) = p;
1002         talloc_free(tmp_ctx);
1003
1004         return NT_STATUS_OK;
1005 }
1006
1007 /* open a rpc connection to a rpc pipe on SMP using the binding
1008    structure to determine the endpoint and options */
1009 static NTSTATUS dcerpc_pipe_connect_ncalrpc(struct dcerpc_pipe **pp, 
1010                                             struct dcerpc_binding *binding,
1011                                             const char *pipe_uuid, 
1012                                             uint32_t pipe_version,
1013                                             const char *domain,
1014                                             const char *username,
1015                                             const char *password)
1016 {
1017         NTSTATUS status;
1018         struct dcerpc_pipe *p;
1019         TALLOC_CTX *tmp_ctx;
1020
1021         (*pp) = NULL;
1022
1023         p = dcerpc_pipe_init(NULL);
1024         if (p == NULL) {
1025                 return NT_STATUS_NO_MEMORY;
1026         }
1027         tmp_ctx = talloc_new(p);
1028
1029         /* Look up identifier using the epmapper */
1030         if (!binding->endpoint) {
1031                 status = dcerpc_epm_map_binding(tmp_ctx, binding, pipe_uuid, pipe_version);
1032                 if (!NT_STATUS_IS_OK(status)) {
1033                         DEBUG(0,("Failed to map DCERPC/TCP NCALRPC identifier for '%s' - %s\n", 
1034                                  pipe_uuid, nt_errstr(status)));
1035                         talloc_free(p);
1036                         return status;
1037                 }
1038                 DEBUG(1,("Mapped to DCERPC/LRPC identifier %s\n", binding->endpoint));
1039         }
1040
1041         status = dcerpc_pipe_open_pipe(p->conn, binding->endpoint);
1042         if (!NT_STATUS_IS_OK(status)) {
1043                 DEBUG(0,("Failed to open ncalrpc pipe '%s' - %s\n", 
1044                          binding->endpoint, nt_errstr(status)));
1045                 talloc_free(p);
1046                 return status;
1047         }
1048
1049         status = dcerpc_pipe_auth(p, binding, pipe_uuid, pipe_version, domain, username, password);
1050         if (!NT_STATUS_IS_OK(status)) {
1051                 talloc_free(p);
1052                 return status;
1053         }
1054
1055         (*pp) = p;
1056         talloc_free(tmp_ctx);
1057
1058         return status;
1059 }
1060
1061
1062
1063 /* open a rpc connection to a rpc pipe on SMP using the binding
1064    structure to determine the endpoint and options */
1065 static NTSTATUS dcerpc_pipe_connect_ncacn_unix_stream(struct dcerpc_pipe **pp, 
1066                                                       struct dcerpc_binding *binding,
1067                                                       const char *pipe_uuid, 
1068                                                       uint32_t pipe_version,
1069                                                       const char *domain,
1070                                                       const char *username,
1071                                                       const char *password)
1072 {
1073         NTSTATUS status;
1074         struct dcerpc_pipe *p;
1075
1076         (*pp) = NULL;
1077
1078         if (!binding->endpoint) {
1079                 DEBUG(0, ("Path to unix socket not specified\n"));
1080                 return NT_STATUS_INVALID_PARAMETER;
1081         }
1082
1083         p = dcerpc_pipe_init(NULL);
1084         if (p == NULL) {
1085                 return NT_STATUS_NO_MEMORY;
1086         }
1087
1088         status = dcerpc_pipe_open_unix_stream(p->conn, binding->endpoint);
1089         if (!NT_STATUS_IS_OK(status)) {
1090                 DEBUG(0,("Failed to open unix socket %s - %s\n", 
1091                          binding->endpoint, nt_errstr(status)));
1092                 talloc_free(p);
1093                 return status;
1094         }
1095
1096         status = dcerpc_pipe_auth(p, binding, pipe_uuid, pipe_version, domain, username, password);
1097         if (!NT_STATUS_IS_OK(status)) {
1098                 talloc_free(p);
1099                 return status;
1100         }
1101
1102         (*pp) = p;
1103  
1104         return status;
1105 }
1106
1107 /* open a rpc connection to a rpc pipe on SMP using the binding
1108    structure to determine the endpoint and options */
1109 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **pp, 
1110                                                  struct dcerpc_binding *binding,
1111                                                  const char *pipe_uuid, 
1112                                                  uint32_t pipe_version,
1113                                                  const char *domain,
1114                                                  const char *username,
1115                                                  const char *password)
1116 {
1117         NTSTATUS status;
1118         uint32_t port = 0;
1119         struct dcerpc_pipe *p;
1120         TALLOC_CTX *tmp_ctx;
1121
1122         (*pp) = NULL;
1123
1124         p = dcerpc_pipe_init(NULL);
1125         if (p == NULL) {
1126                 return NT_STATUS_NO_MEMORY;
1127         }
1128         tmp_ctx = talloc_new(p);
1129
1130         if (!binding->endpoint) {
1131                 status = dcerpc_epm_map_binding(tmp_ctx, binding, 
1132                                                 pipe_uuid, pipe_version);
1133                 if (!NT_STATUS_IS_OK(status)) {
1134                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
1135                                  pipe_uuid, nt_errstr(status)));
1136                         talloc_free(p);
1137                         return status;
1138                 }
1139                 DEBUG(1,("Mapped to DCERPC/TCP port %s\n", binding->endpoint));
1140         }
1141
1142         port = atoi(binding->endpoint);
1143
1144         status = dcerpc_pipe_open_tcp(p->conn, binding->host, port);
1145         if (!NT_STATUS_IS_OK(status)) {
1146                 DEBUG(0,("Failed to connect to %s:%d - %s\n", 
1147                          binding->host, port, nt_errstr(status)));
1148                 talloc_free(p);
1149                 return status;
1150         }
1151
1152         status = dcerpc_pipe_auth(p, binding, pipe_uuid, pipe_version, domain, username, password);
1153         if (!NT_STATUS_IS_OK(status)) {
1154                 talloc_free(p);
1155                 return status;
1156         }
1157
1158         (*pp) = p;
1159         talloc_free(tmp_ctx);
1160  
1161         return status;
1162 }
1163
1164
1165 /* open a rpc connection to a rpc pipe, using the specified 
1166    binding structure to determine the endpoint and options */
1167 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **pp, 
1168                                struct dcerpc_binding *binding,
1169                                const char *pipe_uuid, 
1170                                uint32_t pipe_version,
1171                                const char *domain,
1172                                const char *username,
1173                                const char *password)
1174 {
1175         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
1176
1177         switch (binding->transport) {
1178         case NCACN_NP:
1179                 status = dcerpc_pipe_connect_ncacn_np(pp, binding, pipe_uuid, pipe_version,
1180                                                       domain, username, password);
1181                 break;
1182         case NCACN_IP_TCP:
1183                 status = dcerpc_pipe_connect_ncacn_ip_tcp(pp, binding, pipe_uuid, pipe_version,
1184                                                           domain, username, password);
1185                 break;
1186         case NCACN_UNIX_STREAM:
1187                 status = dcerpc_pipe_connect_ncacn_unix_stream(pp, binding, pipe_uuid, pipe_version, 
1188                                                                domain, username, password);
1189                 break;
1190         case NCALRPC:
1191                 status = dcerpc_pipe_connect_ncalrpc(pp, binding, pipe_uuid, pipe_version, 
1192                                                      domain, username, password);
1193                 break;
1194         default:
1195                 return NT_STATUS_NOT_SUPPORTED;
1196         }
1197
1198         return status;
1199 }
1200
1201
1202 /* open a rpc connection to a rpc pipe, using the specified string
1203    binding to determine the endpoint and options */
1204 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **pp, 
1205                              const char *binding,
1206                              const char *pipe_uuid, 
1207                              uint32_t pipe_version,
1208                              const char *domain,
1209                              const char *username,
1210                              const char *password)
1211 {
1212         struct dcerpc_binding b;
1213         NTSTATUS status;
1214         TALLOC_CTX *tmp_ctx;
1215
1216         tmp_ctx = talloc_new(NULL);
1217
1218         status = dcerpc_parse_binding(tmp_ctx, binding, &b);
1219         if (!NT_STATUS_IS_OK(status)) {
1220                 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
1221                 talloc_free(tmp_ctx);
1222                 return status;
1223         }
1224
1225         DEBUG(3,("Using binding %s\n", dcerpc_binding_string(tmp_ctx, &b)));
1226
1227         status = dcerpc_pipe_connect_b(pp, &b, pipe_uuid, pipe_version, domain, username, password);
1228
1229         talloc_free(tmp_ctx);
1230
1231         return status;
1232 }
1233
1234
1235 /*
1236   create a secondary dcerpc connection from a primary connection
1237
1238   if the primary is a SMB connection then the secondary connection
1239   will be on the same SMB connection, but use a new fnum
1240 */
1241 NTSTATUS dcerpc_secondary_connection(struct dcerpc_pipe *p, struct dcerpc_pipe **p2,
1242                                      const char *pipe_name,
1243                                      const char *pipe_uuid,
1244                                      uint32_t pipe_version)
1245 {
1246         struct smbcli_tree *tree;
1247         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
1248         struct dcerpc_binding b;
1249
1250         (*p2) = dcerpc_pipe_init(p);
1251         if (*p2 == NULL) {
1252                 return NT_STATUS_NO_MEMORY;
1253         }
1254         
1255         switch (p->conn->transport.transport) {
1256         case NCACN_NP:
1257                 tree = dcerpc_smb_tree(p->conn);
1258                 if (!tree) {
1259                         return NT_STATUS_INVALID_PARAMETER;
1260                 }
1261                 status = dcerpc_pipe_open_smb((*p2)->conn, tree, pipe_name);
1262                 break;
1263
1264         case NCACN_IP_TCP:
1265                 status = dcerpc_parse_binding(p, p->conn->binding_string, &b);
1266                 if (!NT_STATUS_IS_OK(status)) {
1267                         return status;
1268                 }
1269                 status = dcerpc_pipe_open_tcp((*p2)->conn, b.host, atoi(b.endpoint));
1270                 break;
1271
1272         case NCALRPC:
1273                 status = dcerpc_parse_binding(p, p->conn->binding_string, &b);
1274                 if (!NT_STATUS_IS_OK(status)) {
1275                         return status;
1276                 }
1277                 status = dcerpc_pipe_open_pipe((*p2)->conn, b.endpoint);
1278                 break;
1279
1280         default:
1281                 return NT_STATUS_NOT_SUPPORTED;
1282         }
1283
1284         if (!NT_STATUS_IS_OK(status)) {
1285                 talloc_free(*p2);
1286                 return status;
1287         }
1288
1289         (*p2)->conn->flags = p->conn->flags;
1290
1291         status = dcerpc_bind_auth_none(*p2, pipe_uuid, pipe_version);
1292         if (!NT_STATUS_IS_OK(status)) {
1293                 talloc_free(*p2);
1294                 return status;
1295         }
1296
1297         return NT_STATUS_OK;
1298 }
1299
1300 NTSTATUS dcerpc_generic_session_key(struct dcerpc_connection *c,
1301                                     DATA_BLOB *session_key)
1302 {
1303         /* this took quite a few CPU cycles to find ... */
1304         session_key->data = discard_const_p(unsigned char, "SystemLibraryDTC");
1305         session_key->length = 16;
1306         return NT_STATUS_OK;
1307 }
1308
1309 /*
1310   fetch the user session key - may be default (above) or the SMB session key
1311 */
1312 NTSTATUS dcerpc_fetch_session_key(struct dcerpc_pipe *p,
1313                                   DATA_BLOB *session_key)
1314 {
1315         return p->conn->security_state.session_key(p->conn, session_key);
1316 }
1317
1318
1319 /*
1320   log a rpc packet in a format suitable for ndrdump. This is especially useful
1321   for sealed packets, where ethereal cannot easily see the contents
1322
1323   this triggers on a debug level of >= 10
1324 */
1325 void dcerpc_log_packet(const struct dcerpc_interface_table *ndr,
1326                        uint32_t opnum, uint32_t flags, DATA_BLOB *pkt)
1327 {
1328         const int num_examples = 20;
1329         int i;
1330
1331         if (DEBUGLEVEL < 10) return;
1332
1333         for (i=0;i<num_examples;i++) {
1334                 char *name=NULL;
1335                 asprintf(&name, "%s/rpclog/%s-%u.%d.%s", 
1336                          lp_lockdir(), ndr->name, opnum, i,
1337                          (flags&NDR_IN)?"in":"out");
1338                 if (name == NULL) {
1339                         return;
1340                 }
1341                 if (!file_exist(name)) {
1342                         if (file_save(name, pkt->data, pkt->length)) {
1343                                 DEBUG(10,("Logged rpc packet to %s\n", name));
1344                         }
1345                         free(name);
1346                         break;
1347                 }
1348                 free(name);
1349         }
1350 }
1351
1352
1353
1354 /*
1355   create a secondary context from a primary connection
1356
1357   this uses dcerpc_alter_context() to create a new dcerpc context_id
1358 */
1359 NTSTATUS dcerpc_secondary_context(struct dcerpc_pipe *p, 
1360                                   struct dcerpc_pipe **pp2,
1361                                   const char *pipe_uuid,
1362                                   uint32_t pipe_version)
1363 {
1364         NTSTATUS status;
1365         struct dcerpc_pipe *p2;
1366         
1367         p2 = talloc_zero(p, struct dcerpc_pipe);
1368         if (p2 == NULL) {
1369                 return NT_STATUS_NO_MEMORY;
1370         }
1371         p2->conn = talloc_reference(p2, p->conn);
1372
1373         p2->context_id = ++p->conn->next_context_id;
1374
1375         status = GUID_from_string(pipe_uuid, &p2->syntax.uuid);
1376         if (!NT_STATUS_IS_OK(status)) {
1377                 talloc_free(p2);
1378                 return status;
1379         }
1380         p2->syntax.if_version = pipe_version;
1381
1382         status = GUID_from_string(NDR_GUID, &p2->transfer_syntax.uuid);
1383         if (!NT_STATUS_IS_OK(status)) {
1384                 talloc_free(p2);
1385                 return status;
1386         }
1387         p2->transfer_syntax.if_version = NDR_GUID_VERSION;
1388
1389         status = dcerpc_alter_context(p2, p2, &p2->syntax, &p2->transfer_syntax);
1390         if (!NT_STATUS_IS_OK(status)) {
1391                 talloc_free(p2);
1392                 return status;
1393         }
1394
1395         *pp2 = p2;
1396
1397         return status;
1398 }