r3032: Somewhat stricter syntax for binding strings:
[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    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25 /*
26   work out what TCP port to use for a given interface on a given host
27 */
28 NTSTATUS dcerpc_epm_map_tcp_port(const char *server, 
29                                  const char *uuid, uint_t version,
30                                  uint32_t *port)
31 {
32         struct dcerpc_pipe *p;
33         NTSTATUS status;
34         struct epm_Map r;
35         struct policy_handle handle;
36         struct GUID guid;
37         struct epm_twr_t twr, *twr_r;
38
39         if (strcasecmp(uuid, DCERPC_EPMAPPER_UUID) == 0 ||
40             strcasecmp(uuid, DCERPC_MGMT_UUID) == 0) {
41                 /* don't lookup epmapper via epmapper! */
42                 *port = EPMAPPER_PORT;
43                 return NT_STATUS_OK;
44         }
45
46         status = dcerpc_pipe_open_tcp(&p, server, EPMAPPER_PORT, AF_UNSPEC );
47         if (!NT_STATUS_IS_OK(status)) {
48                 return status;
49         }
50
51         /* we can use the pipes memory context here as we will have a short
52            lived connection */
53         status = dcerpc_bind_byuuid(p, p, 
54                                     DCERPC_EPMAPPER_UUID,
55                                     DCERPC_EPMAPPER_VERSION);
56         if (!NT_STATUS_IS_OK(status)) {
57                 dcerpc_pipe_close(p);
58                 return status;
59         }
60
61         ZERO_STRUCT(handle);
62         ZERO_STRUCT(guid);
63
64         twr.towers.num_floors = 5;
65         twr.towers.floors = talloc(p, sizeof(twr.towers.floors[0]) * 5);
66
67         /* what I'd like for christmas ... */
68
69         /* an RPC interface ... */
70         twr.towers.floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
71         GUID_from_string(uuid, &twr.towers.floors[0].lhs.info.uuid.uuid);
72         twr.towers.floors[0].lhs.info.uuid.version = version;
73         twr.towers.floors[0].rhs.uuid.unknown = 0;
74
75         /* encoded with NDR ... */
76         twr.towers.floors[1].lhs.protocol = EPM_PROTOCOL_UUID;
77         GUID_from_string(NDR_GUID, &twr.towers.floors[1].lhs.info.uuid.uuid);
78         twr.towers.floors[1].lhs.info.uuid.version = NDR_GUID_VERSION;
79         twr.towers.floors[1].rhs.uuid.unknown = 0;
80
81         /* on an RPC connection ... */
82         twr.towers.floors[2].lhs.protocol = EPM_PROTOCOL_NCACN;
83         twr.towers.floors[2].lhs.info.lhs_data = data_blob(NULL, 0);
84         twr.towers.floors[2].rhs.ncacn.minor_version = 0;
85
86         /* on a TCP port ... */
87         twr.towers.floors[3].lhs.protocol = EPM_PROTOCOL_TCP;
88         twr.towers.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
89         twr.towers.floors[3].rhs.tcp.port = 0;
90
91         /* on an IP link ... */
92         twr.towers.floors[4].lhs.protocol = EPM_PROTOCOL_IP;
93         twr.towers.floors[4].lhs.info.lhs_data = data_blob(NULL, 0);
94         twr.towers.floors[4].rhs.ip.address = 0;
95
96         /* with some nice pretty paper around it of course */
97         r.in.object = &guid;
98         r.in.map_tower = &twr;
99         r.in.entry_handle = &handle;
100         r.in.max_towers = 1;
101         r.out.entry_handle = &handle;
102
103         status = dcerpc_epm_Map(p, p, &r);
104         if (!NT_STATUS_IS_OK(status)) {
105                 dcerpc_pipe_close(p);
106                 return status;
107         }
108         if (r.out.result != 0 || r.out.num_towers != 1) {
109                 dcerpc_pipe_close(p);
110                 return NT_STATUS_PORT_UNREACHABLE;
111         }
112
113         twr_r = r.out.towers[0].twr;
114         if (!twr_r) {
115                 dcerpc_pipe_close(p);
116                 return NT_STATUS_PORT_UNREACHABLE;
117         }
118
119         if (twr_r->towers.num_floors != 5 ||
120             twr_r->towers.floors[3].lhs.protocol != twr.towers.floors[3].lhs.protocol) {
121                 dcerpc_pipe_close(p);
122                 return NT_STATUS_PORT_UNREACHABLE;
123         }
124
125         *port = twr_r->towers.floors[3].rhs.tcp.port;
126
127         dcerpc_pipe_close(p);
128
129         return NT_STATUS_OK;
130 }
131
132
133 /*
134   find the pipe name for a local IDL interface
135 */
136 const char *idl_pipe_name(const char *uuid, uint32_t if_version)
137 {
138         int i;
139         for (i=0;dcerpc_pipes[i];i++) {
140                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0 &&
141                     dcerpc_pipes[i]->if_version == if_version) {
142                         return dcerpc_pipes[i]->name;
143                 }
144         }
145         return "UNKNOWN";
146 }
147
148 /*
149   find the number of calls defined by local IDL
150 */
151 int idl_num_calls(const char *uuid, uint32_t if_version)
152 {
153         int i;
154         for (i=0;dcerpc_pipes[i];i++) {
155                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0 &&
156                     dcerpc_pipes[i]->if_version == if_version) {
157                         return dcerpc_pipes[i]->num_calls;
158                 }
159         }
160         return -1;
161 }
162
163
164 /*
165   find a dcerpc interface by name
166 */
167 const struct dcerpc_interface_table *idl_iface_by_name(const char *name)
168 {
169         int i;
170         for (i=0;dcerpc_pipes[i];i++) {
171                 if (strcasecmp(dcerpc_pipes[i]->name, name) == 0) {
172                         return dcerpc_pipes[i];
173                 }
174         }
175         return NULL;
176 }
177
178 /*
179   find a dcerpc interface by uuid
180 */
181 const struct dcerpc_interface_table *idl_iface_by_uuid(const char *uuid)
182 {
183         int i;
184         for (i=0;dcerpc_pipes[i];i++) {
185                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0) {
186                         return dcerpc_pipes[i];
187                 }
188         }
189         return NULL;
190 }
191
192
193
194 /* 
195    push a dcerpc_packet into a blob, potentially with auth info
196 */
197 NTSTATUS dcerpc_push_auth(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, 
198                           struct dcerpc_packet *pkt,
199                           struct dcerpc_auth *auth_info)
200 {
201         NTSTATUS status;
202         struct ndr_push *ndr;
203
204         ndr = ndr_push_init_ctx(mem_ctx);
205         if (!ndr) {
206                 return NT_STATUS_NO_MEMORY;
207         }
208
209         if (!(pkt->drep[0] & DCERPC_DREP_LE)) {
210                 ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
211         }
212
213         if (auth_info) {
214                 pkt->auth_length = auth_info->credentials.length;
215         } else {
216                 pkt->auth_length = 0;
217         }
218
219         status = ndr_push_dcerpc_packet(ndr, NDR_SCALARS|NDR_BUFFERS, pkt);
220         if (!NT_STATUS_IS_OK(status)) {
221                 return status;
222         }
223
224         if (auth_info) {
225                 status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, auth_info);
226         }
227
228         *blob = ndr_push_blob(ndr);
229
230         /* fill in the frag length */
231         dcerpc_set_frag_length(blob, blob->length);
232
233         return NT_STATUS_OK;
234 }
235
236
237 static const struct {
238         const char *name;
239         enum dcerpc_transport_t transport;
240 } ncacn_transports[] = {
241         {"ncacn_np",     NCACN_NP},
242         {"ncacn_ip_tcp", NCACN_IP_TCP}
243 };
244
245 static const struct {
246         const char *name;
247         uint32_t flag;
248 } ncacn_options[] = {
249         {"sign", DCERPC_SIGN},
250         {"seal", DCERPC_SEAL},
251         {"connect", DCERPC_CONNECT},
252         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
253         {"print", DCERPC_DEBUG_PRINT_BOTH},
254         {"padcheck", DCERPC_DEBUG_PAD_CHECK},
255         {"bigendian", DCERPC_PUSH_BIGENDIAN}
256 };
257
258 /*
259   form a binding string from a binding structure
260 */
261 const char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
262 {
263         char *s = NULL;
264         int i;
265         const char *t_name=NULL;
266
267         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
268                 if (ncacn_transports[i].transport == b->transport) {
269                         t_name = ncacn_transports[i].name;
270                 }
271         }
272         if (!t_name) {
273                 return NULL;
274         }
275
276         if (b->object) { 
277                 s = talloc_asprintf(mem_ctx, "%s@", GUID_string(mem_ctx, b->object));
278         }
279
280         s = talloc_asprintf_append(s, "%s:%s[", t_name, b->host);
281         if (!s) return NULL;
282
283         /* this is a *really* inefficent way of dealing with strings,
284            but this is rarely called and the strings are always short,
285            so I don't care */
286         for (i=0;b->options && b->options[i];i++) {
287                 s = talloc_asprintf(mem_ctx, "%s%s,", s, b->options[i]);
288                 if (!s) return NULL;
289         }
290         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
291                 if (b->flags & ncacn_options[i].flag) {
292                         s = talloc_asprintf(mem_ctx, "%s%s,", s, ncacn_options[i].name);
293                         if (!s) return NULL;
294                 }
295         }
296         if (s[strlen(s)-1] == ',') {
297                 s[strlen(s)-1] = 0;
298         }
299         s = talloc_asprintf(mem_ctx, "%s]", s);
300
301         return s;
302 }
303
304 /*
305   parse a binding string into a dcerpc_binding structure
306 */
307 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
308 {
309         char *options, *type;
310         char *p;
311         int i, j, comma_count;
312
313         p = strchr(s, '@');
314
315         if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
316                 NTSTATUS status;
317
318                 b->object = talloc_p(mem_ctx, struct GUID);
319                 
320                 status = GUID_from_string(s, b->object);
321
322                 if (NT_STATUS_IS_ERR(status)) {
323                         DEBUG(0, ("Failed parsing UUID\n"));
324                         return status;
325                 }
326
327                 s = p + 1;
328         } else {
329                 b->object = NULL;
330         }
331
332         p = strchr(s, ':');
333         if (!p) {
334                 return NT_STATUS_INVALID_PARAMETER;
335         }
336
337         type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
338         if (!type) {
339                 return NT_STATUS_NO_MEMORY;
340         }
341
342         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
343                 if (strcasecmp(type, ncacn_transports[i].name) == 0) {
344                         b->transport = ncacn_transports[i].transport;
345                         break;
346                 }
347         }
348         if (i==ARRAY_SIZE(ncacn_transports)) {
349                 DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
350                 return NT_STATUS_INVALID_PARAMETER;
351         }
352         
353         s = p+1;
354
355         p = strchr(s, '[');
356         if (p) {
357                 b->host = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
358                 options = talloc_strdup(mem_ctx, p+1);
359                 if (options[strlen(options)-1] != ']') {
360                         return NT_STATUS_INVALID_PARAMETER;
361                 }
362                 options[strlen(options)-1] = 0;
363         } else {
364                 b->host = talloc_strdup(mem_ctx, s);
365                 options = NULL;
366         }
367
368         if (!b->host) {
369                 return NT_STATUS_NO_MEMORY;
370         }
371
372         b->options = NULL;
373         b->flags = 0;
374
375         if (!options) {
376                 return NT_STATUS_OK;
377         }
378
379         comma_count = count_chars(options, ',');
380         b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
381         if (!b->options) {
382                 return NT_STATUS_NO_MEMORY;
383         }
384
385         for (i=0; (p = strchr(options, ',')); i++) {
386                 b->options[i] = talloc_strndup(mem_ctx, options, PTR_DIFF(p, options));
387                 if (!b->options[i]) {
388                         return NT_STATUS_NO_MEMORY;
389                 }
390                 options = p+1;
391         }
392         b->options[i] = options;
393         b->options[i+1] = NULL;
394
395         /* some options are pre-parsed for convenience */
396         for (i=0;b->options[i];i++) {
397                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
398                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
399                                 int k;
400                                 b->flags |= ncacn_options[j].flag;
401                                 for (k=i;b->options[k];k++) {
402                                         b->options[k] = b->options[k+1];
403                                 }
404                                 i--;
405                                 break;
406                         }
407                 }
408         }
409         
410         return NT_STATUS_OK;
411 }
412
413
414 /* open a rpc connection to a rpc pipe on SMB using the binding
415    structure to determine the endpoint and options */
416 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **p, 
417                                              struct dcerpc_binding *binding,
418                                              const char *pipe_uuid, 
419                                              uint32_t pipe_version,
420                                              const char *domain,
421                                              const char *username,
422                                              const char *password)
423 {
424         NTSTATUS status;
425         BOOL retry;
426         struct smbcli_state *cli;
427         const char *pipe_name;
428         
429         if (!binding->options || !binding->options[0] || !strlen(binding->options[0])) {
430                 const struct dcerpc_interface_table *table = idl_iface_by_uuid(pipe_uuid);
431                 if (!table) {
432                         DEBUG(0,("Unknown interface endpoint '%s'\n", pipe_uuid));
433                         return NT_STATUS_INVALID_PARAMETER;
434                 }
435                 /* only try the first endpoint for now */
436                 pipe_name = table->endpoints->names[0];
437         } else {
438                 pipe_name = binding->options[0];
439         }
440
441         if (strncasecmp(pipe_name, "\\pipe\\", 6) == 0) {
442                 pipe_name += 6;
443         }
444         if (strncasecmp(pipe_name, "/pipe/", 6) == 0) {
445                 pipe_name += 6;
446         }
447             
448         if (!username || !username[0]) {
449                 status = smbcli_full_connection(NULL, &cli, lp_netbios_name(),
450                                              binding->host, NULL, 
451                                              "ipc$", "?????", 
452                                              "", "", NULL, 0, &retry);
453         } else {
454                 status = smbcli_full_connection(NULL, &cli, lp_netbios_name(),
455                                              binding->host, NULL, 
456                                              "ipc$", "?????", 
457                                              username, domain,
458                                              password, 0, &retry);
459         }
460         if (!NT_STATUS_IS_OK(status)) {
461                 DEBUG(0,("Failed to connect to %s - %s\n", binding->host, nt_errstr(status)));
462                 return status;
463         }
464
465         status = dcerpc_pipe_open_smb(p, cli->tree, pipe_name);
466         if (!NT_STATUS_IS_OK(status)) {
467                 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name, nt_errstr(status)));
468                 smbcli_tdis(cli);
469                 smbcli_shutdown(cli);
470                 return status;
471         }
472         
473         /* this ensures that the reference count is decremented so
474            a pipe close will really close the link */
475         talloc_steal(*p, cli);
476
477         (*p)->flags = binding->flags;
478
479         /* remember the binding string for possible secondary connections */
480         (*p)->binding_string = dcerpc_binding_string((*p), binding);
481
482         if (username && username[0] && (binding->flags & DCERPC_SCHANNEL_ANY)) {
483                 status = dcerpc_bind_auth_schannel(*p, pipe_uuid, pipe_version, 
484                                                    domain, username, password);
485         } else if (username && username[0] &&
486                    (binding->flags & (DCERPC_CONNECT|DCERPC_SIGN|DCERPC_SEAL))) {
487                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
488         } else {    
489                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
490
491         }
492
493         if (!NT_STATUS_IS_OK(status)) {
494                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
495                 dcerpc_pipe_close(*p);
496                 *p = NULL;
497                 return status;
498         }
499
500         return NT_STATUS_OK;
501 }
502
503
504 /* open a rpc connection to a rpc pipe on SMP using the binding
505    structure to determine the endpoint and options */
506 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **p, 
507                                                  struct dcerpc_binding *binding,
508                                                  const char *pipe_uuid, 
509                                                  uint32_t pipe_version,
510                                                  const char *domain,
511                                                  const char *username,
512                                                  const char *password)
513 {
514         NTSTATUS status;
515         uint32_t port = 0;
516
517         if (binding->options && binding->options[0] && strlen(binding->options[0])) {
518                 port = atoi(binding->options[0]);
519         }
520
521         if (port == 0) {
522                 status = dcerpc_epm_map_tcp_port(binding->host, 
523                                                  pipe_uuid, pipe_version,
524                                                  &port);
525                 if (!NT_STATUS_IS_OK(status)) {
526                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
527                                  pipe_uuid, nt_errstr(status)));
528                         return status;
529                 }
530                 DEBUG(1,("Mapped to DCERPC/TCP port %u\n", port));
531         }
532
533         status = dcerpc_pipe_open_tcp(p, binding->host, port, AF_UNSPEC);
534         if (!NT_STATUS_IS_OK(status)) {
535                 DEBUG(0,("Failed to connect to %s:%d\n", binding->host, port));
536                 return status;
537         }
538
539         (*p)->flags = binding->flags;
540
541         /* remember the binding string for possible secondary connections */
542         (*p)->binding_string = dcerpc_binding_string((*p), binding);
543
544         if (username && username[0] && (binding->flags & DCERPC_SCHANNEL_ANY)) {
545                 status = dcerpc_bind_auth_schannel(*p, pipe_uuid, pipe_version, 
546                                                    domain, username, password);
547         } else if (username && username[0]) {
548                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
549         } else {    
550                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
551         }
552
553         if (!NT_STATUS_IS_OK(status)) {
554                 DEBUG(0,("Failed to bind to uuid %s - %s\n", 
555                          pipe_uuid, nt_errstr(status)));
556                 dcerpc_pipe_close(*p);
557                 *p = NULL;
558                 return status;
559         }
560  
561         return status;
562 }
563
564
565 /* open a rpc connection to a rpc pipe, using the specified 
566    binding structure to determine the endpoint and options */
567 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **p, 
568                                struct dcerpc_binding *binding,
569                                const char *pipe_uuid, 
570                                uint32_t pipe_version,
571                                const char *domain,
572                                const char *username,
573                                const char *password)
574 {
575         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
576
577         switch (binding->transport) {
578         case NCACN_NP:
579                 status = dcerpc_pipe_connect_ncacn_np(p, binding, pipe_uuid, pipe_version,
580                                                       domain, username, password);
581                 break;
582         case NCACN_IP_TCP:
583                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p, binding, pipe_uuid, pipe_version,
584                                                           domain, username, password);
585                 break;
586         }
587
588         return status;
589 }
590
591
592 /* open a rpc connection to a rpc pipe, using the specified string
593    binding to determine the endpoint and options */
594 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **p, 
595                              const char *binding,
596                              const char *pipe_uuid, 
597                              uint32_t pipe_version,
598                              const char *domain,
599                              const char *username,
600                              const char *password)
601 {
602         struct dcerpc_binding b;
603         NTSTATUS status;
604         TALLOC_CTX *mem_ctx;
605
606         mem_ctx = talloc_init("dcerpc_pipe_connect");
607         if (!mem_ctx) return NT_STATUS_NO_MEMORY;
608
609         status = dcerpc_parse_binding(mem_ctx, binding, &b);
610         if (!NT_STATUS_IS_OK(status)) {
611                 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
612                 talloc_destroy(mem_ctx);
613                 return status;
614         }
615
616         DEBUG(3,("Using binding %s\n", dcerpc_binding_string(mem_ctx, &b)));
617
618         status = dcerpc_pipe_connect_b(p, &b, pipe_uuid, pipe_version, domain, username, password);
619
620         talloc_destroy(mem_ctx);
621         return status;
622 }
623
624
625 /*
626   create a secondary dcerpc connection from a primary connection
627
628   if the primary is a SMB connection then the secondary connection
629   will be on the same SMB connection, but use a new fnum
630 */
631 NTSTATUS dcerpc_secondary_connection(struct dcerpc_pipe *p, struct dcerpc_pipe **p2,
632                                      const char *pipe_name,
633                                      const char *pipe_uuid,
634                                      uint32_t pipe_version)
635 {
636         struct smbcli_tree *tree;
637         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
638         struct dcerpc_binding b;
639
640         switch (p->transport.transport) {
641         case NCACN_NP:
642                 tree = dcerpc_smb_tree(p);
643                 if (!tree) {
644                         return NT_STATUS_INVALID_PARAMETER;
645                 }
646
647                 status = dcerpc_pipe_open_smb(p2, tree, pipe_name);
648                 break;
649
650         case NCACN_IP_TCP:
651                 status = dcerpc_parse_binding(p, p->binding_string, &b);
652                 if (!NT_STATUS_IS_OK(status)) {
653                         return status;
654                 }
655                 b.flags &= ~DCERPC_AUTH_OPTIONS;
656                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p2, &b, pipe_uuid,
657                                                           pipe_version, NULL, 
658                                                           NULL, NULL);
659                 break;
660         }
661
662         if (!NT_STATUS_IS_OK(status)) {
663                 return status;
664         }
665
666         (*p2)->flags = p->flags;
667
668         status = dcerpc_bind_auth_none(*p2, pipe_uuid, pipe_version);
669         if (!NT_STATUS_IS_OK(status)) {
670                 return status;
671         }
672
673         return NT_STATUS_OK;
674 }
675
676 NTSTATUS dcerpc_generic_session_key(struct dcerpc_pipe *p,
677                                     DATA_BLOB *session_key)
678 {
679         /* this took quite a few CPU cycles to find ... */
680         session_key->data = discard_const_p(char, "SystemLibraryDTC");
681         session_key->length = 16;
682         return NT_STATUS_OK;
683 }
684
685 /*
686   fetch the user session key - may be default (above) or the SMB session key
687 */
688 NTSTATUS dcerpc_fetch_session_key(struct dcerpc_pipe *p,
689                                   DATA_BLOB *session_key)
690 {
691         return p->security_state.session_key(p, session_key);
692 }
693
694
695 /*
696   log a rpc packet in a format suitable for ndrdump. This is especially useful
697   for sealed packets, where ethereal cannot easily see the contents
698
699   this triggers on a debug level of >= 10
700 */
701 void dcerpc_log_packet(const struct dcerpc_interface_table *ndr,
702                        uint32_t opnum, uint32_t flags, DATA_BLOB *pkt)
703 {
704         const int num_examples = 20;
705         int i;
706
707         if (DEBUGLEVEL < 10) return;
708
709         for (i=0;i<num_examples;i++) {
710                 char *name=NULL;
711                 asprintf(&name, "%s/rpclog/%s-%u.%d.%s", 
712                          lp_lockdir(), ndr->name, opnum, i,
713                          (flags&NDR_IN)?"in":"out");
714                 if (name == NULL) {
715                         return;
716                 }
717                 if (!file_exist(name, NULL)) {
718                         if (file_save(name, pkt->data, pkt->length)) {
719                                 DEBUG(10,("Logged rpc packet to %s\n", name));
720                         }
721                         free(name);
722                         break;
723                 }
724                 free(name);
725         }
726 }
727