5f3d911d15618571078d7e9a9199d415f72d7000
[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         s = talloc_asprintf(mem_ctx, "%s:%s:[", t_name, b->host);
277         if (!s) return NULL;
278
279         /* this is a *really* inefficent way of dealing with strings,
280            but this is rarely called and the strings are always short,
281            so I don't care */
282         for (i=0;b->options && b->options[i];i++) {
283                 s = talloc_asprintf(mem_ctx, "%s%s,", s, b->options[i]);
284                 if (!s) return NULL;
285         }
286         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
287                 if (b->flags & ncacn_options[i].flag) {
288                         s = talloc_asprintf(mem_ctx, "%s%s,", s, ncacn_options[i].name);
289                         if (!s) return NULL;
290                 }
291         }
292         if (s[strlen(s)-1] == ',') {
293                 s[strlen(s)-1] = 0;
294         }
295         s = talloc_asprintf(mem_ctx, "%s]", s);
296
297         return s;
298 }
299
300 /*
301   parse a binding string into a dcerpc_binding structure
302 */
303 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
304 {
305         char *part1, *part2, *part3;
306         char *p;
307         int i, j, comma_count;
308
309         p = strchr(s, ':');
310         if (!p) {
311                 return NT_STATUS_INVALID_PARAMETER;
312         }
313         part1 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
314         if (!part1) {
315                 return NT_STATUS_NO_MEMORY;
316         }
317         s = p+1;
318
319         p = strchr(s, ':');
320         if (!p) {
321                 p = strchr(s, '[');
322                 if (p) {
323                         part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
324                         part3 = talloc_strdup(mem_ctx, p+1);
325                         if (part3[strlen(part3)-1] != ']') {
326                                 return NT_STATUS_INVALID_PARAMETER;
327                         }
328                         part3[strlen(part3)-1] = 0;
329                 } else {
330                         part2 = talloc_strdup(mem_ctx, s);
331                         part3 = NULL;
332                 }
333         } else {
334                 part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
335                 part3 = talloc_strdup(mem_ctx, p+1);
336         }
337         if (!part2) {
338                 return NT_STATUS_NO_MEMORY;
339         }
340
341         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
342                 if (strcasecmp(part1, ncacn_transports[i].name) == 0) {
343                         b->transport = ncacn_transports[i].transport;
344                         break;
345                 }
346         }
347         if (i==ARRAY_SIZE(ncacn_transports)) {
348                 DEBUG(0,("Unknown dcerpc transport '%s'\n", part1));
349                 return NT_STATUS_INVALID_PARAMETER;
350         }
351
352         b->host = part2;
353         b->options = NULL;
354         b->flags = 0;
355
356         if (!part3) {
357                 return NT_STATUS_OK;
358         }
359
360         /* the [] brackets are optional */
361         if (*part3 == '[' && part3[strlen(part3)-1] == ']') {
362                 part3++;
363                 part3[strlen(part3)-1] = 0;
364         }
365
366         comma_count = count_chars(part3, ',');
367         b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
368         if (!b->options) {
369                 return NT_STATUS_NO_MEMORY;
370         }
371
372         for (i=0; (p = strchr(part3, ',')); i++) {
373                 b->options[i] = talloc_strndup(mem_ctx, part3, PTR_DIFF(p, part3));
374                 if (!b->options[i]) {
375                         return NT_STATUS_NO_MEMORY;
376                 }
377                 part3 = p+1;
378         }
379         b->options[i] = part3;
380         b->options[i+1] = NULL;
381
382         /* some options are pre-parsed for convenience */
383         for (i=0;b->options[i];i++) {
384                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
385                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
386                                 int k;
387                                 b->flags |= ncacn_options[j].flag;
388                                 for (k=i;b->options[k];k++) {
389                                         b->options[k] = b->options[k+1];
390                                 }
391                                 i--;
392                                 break;
393                         }
394                 }
395         }
396         
397         return NT_STATUS_OK;
398 }
399
400
401 /* open a rpc connection to a rpc pipe on SMB using the binding
402    structure to determine the endpoint and options */
403 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **p, 
404                                              struct dcerpc_binding *binding,
405                                              const char *pipe_uuid, 
406                                              uint32_t pipe_version,
407                                              const char *domain,
408                                              const char *username,
409                                              const char *password)
410 {
411         NTSTATUS status;
412         BOOL retry;
413         struct smbcli_state *cli;
414         const char *pipe_name;
415         
416         if (!binding->options || !binding->options[0]) {
417                 const struct dcerpc_interface_table *table = idl_iface_by_uuid(pipe_uuid);
418                 if (!table) {
419                         DEBUG(0,("Unknown interface endpoint '%s'\n", pipe_uuid));
420                         return NT_STATUS_INVALID_PARAMETER;
421                 }
422                 /* only try the first endpoint for now */
423                 pipe_name = table->endpoints->names[0];
424         } else {
425                 pipe_name = binding->options[0];
426         }
427
428         if (strncasecmp(pipe_name, "\\pipe\\", 6) == 0) {
429                 pipe_name += 6;
430         }
431         if (strncasecmp(pipe_name, "/pipe/", 6) == 0) {
432                 pipe_name += 6;
433         }
434             
435         if (!username || !username[0]) {
436                 status = smbcli_full_connection(NULL, &cli, lp_netbios_name(),
437                                              binding->host, NULL, 
438                                              "ipc$", "?????", 
439                                              "", "", NULL, 0, &retry);
440         } else {
441                 status = smbcli_full_connection(NULL, &cli, lp_netbios_name(),
442                                              binding->host, NULL, 
443                                              "ipc$", "?????", 
444                                              username, domain,
445                                              password, 0, &retry);
446         }
447         if (!NT_STATUS_IS_OK(status)) {
448                 DEBUG(0,("Failed to connect to %s - %s\n", binding->host, nt_errstr(status)));
449                 return status;
450         }
451
452         status = dcerpc_pipe_open_smb(p, cli->tree, pipe_name);
453         if (!NT_STATUS_IS_OK(status)) {
454                 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name, nt_errstr(status)));
455                 smbcli_tdis(cli);
456                 smbcli_shutdown(cli);
457                 return status;
458         }
459         
460         /* this ensures that the reference count is decremented so
461            a pipe close will really close the link */
462         talloc_steal(*p, cli);
463
464         (*p)->flags = binding->flags;
465
466         /* remember the binding string for possible secondary connections */
467         (*p)->binding_string = dcerpc_binding_string((*p), binding);
468
469         if (username && username[0] && (binding->flags & DCERPC_SCHANNEL_ANY)) {
470                 status = dcerpc_bind_auth_schannel(*p, pipe_uuid, pipe_version, 
471                                                    domain, username, password);
472         } else if (username && username[0] &&
473                    (binding->flags & (DCERPC_CONNECT|DCERPC_SIGN|DCERPC_SEAL))) {
474                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
475         } else {    
476                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
477
478         }
479
480         if (!NT_STATUS_IS_OK(status)) {
481                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
482                 dcerpc_pipe_close(*p);
483                 *p = NULL;
484                 return status;
485         }
486
487         return NT_STATUS_OK;
488 }
489
490
491 /* open a rpc connection to a rpc pipe on SMP using the binding
492    structure to determine the endpoint and options */
493 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **p, 
494                                                  struct dcerpc_binding *binding,
495                                                  const char *pipe_uuid, 
496                                                  uint32_t pipe_version,
497                                                  const char *domain,
498                                                  const char *username,
499                                                  const char *password)
500 {
501         NTSTATUS status;
502         uint32_t port = 0;
503
504         if (binding->options && binding->options[0]) {
505                 port = atoi(binding->options[0]);
506         }
507
508         if (port == 0) {
509                 status = dcerpc_epm_map_tcp_port(binding->host, 
510                                                  pipe_uuid, pipe_version,
511                                                  &port);
512                 if (!NT_STATUS_IS_OK(status)) {
513                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
514                                  pipe_uuid, nt_errstr(status)));
515                         return status;
516                 }
517                 DEBUG(1,("Mapped to DCERPC/TCP port %u\n", port));
518         }
519
520         status = dcerpc_pipe_open_tcp(p, binding->host, port, AF_UNSPEC);
521         if (!NT_STATUS_IS_OK(status)) {
522                 DEBUG(0,("Failed to connect to %s:%d\n", binding->host, port));
523                 return status;
524         }
525
526         (*p)->flags = binding->flags;
527
528         /* remember the binding string for possible secondary connections */
529         (*p)->binding_string = dcerpc_binding_string((*p), binding);
530
531         if (username && username[0] && (binding->flags & DCERPC_SCHANNEL_ANY)) {
532                 status = dcerpc_bind_auth_schannel(*p, pipe_uuid, pipe_version, 
533                                                    domain, username, password);
534         } else if (username && username[0]) {
535                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
536         } else {    
537                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
538         }
539
540         if (!NT_STATUS_IS_OK(status)) {
541                 DEBUG(0,("Failed to bind to uuid %s - %s\n", 
542                          pipe_uuid, nt_errstr(status)));
543                 dcerpc_pipe_close(*p);
544                 *p = NULL;
545                 return status;
546         }
547  
548         return status;
549 }
550
551
552 /* open a rpc connection to a rpc pipe, using the specified 
553    binding structure to determine the endpoint and options */
554 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **p, 
555                                struct dcerpc_binding *binding,
556                                const char *pipe_uuid, 
557                                uint32_t pipe_version,
558                                const char *domain,
559                                const char *username,
560                                const char *password)
561 {
562         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
563
564         switch (binding->transport) {
565         case NCACN_NP:
566                 status = dcerpc_pipe_connect_ncacn_np(p, binding, pipe_uuid, pipe_version,
567                                                       domain, username, password);
568                 break;
569         case NCACN_IP_TCP:
570                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p, binding, pipe_uuid, pipe_version,
571                                                           domain, username, password);
572                 break;
573         }
574
575         return status;
576 }
577
578
579 /* open a rpc connection to a rpc pipe, using the specified string
580    binding to determine the endpoint and options */
581 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **p, 
582                              const char *binding,
583                              const char *pipe_uuid, 
584                              uint32_t pipe_version,
585                              const char *domain,
586                              const char *username,
587                              const char *password)
588 {
589         struct dcerpc_binding b;
590         NTSTATUS status;
591         TALLOC_CTX *mem_ctx;
592
593         mem_ctx = talloc_init("dcerpc_pipe_connect");
594         if (!mem_ctx) return NT_STATUS_NO_MEMORY;
595
596         status = dcerpc_parse_binding(mem_ctx, binding, &b);
597         if (!NT_STATUS_IS_OK(status)) {
598                 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
599                 talloc_destroy(mem_ctx);
600                 return status;
601         }
602
603         DEBUG(3,("Using binding %s\n", dcerpc_binding_string(mem_ctx, &b)));
604
605         status = dcerpc_pipe_connect_b(p, &b, pipe_uuid, pipe_version, domain, username, password);
606
607         talloc_destroy(mem_ctx);
608         return status;
609 }
610
611
612 /*
613   create a secondary dcerpc connection from a primary connection
614
615   if the primary is a SMB connection then the secondary connection
616   will be on the same SMB connection, but use a new fnum
617 */
618 NTSTATUS dcerpc_secondary_connection(struct dcerpc_pipe *p, struct dcerpc_pipe **p2,
619                                      const char *pipe_name,
620                                      const char *pipe_uuid,
621                                      uint32_t pipe_version)
622 {
623         struct smbcli_tree *tree;
624         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
625         struct dcerpc_binding b;
626
627         switch (p->transport.transport) {
628         case NCACN_NP:
629                 tree = dcerpc_smb_tree(p);
630                 if (!tree) {
631                         return NT_STATUS_INVALID_PARAMETER;
632                 }
633
634                 status = dcerpc_pipe_open_smb(p2, tree, pipe_name);
635                 break;
636
637         case NCACN_IP_TCP:
638                 status = dcerpc_parse_binding(p, p->binding_string, &b);
639                 if (!NT_STATUS_IS_OK(status)) {
640                         return status;
641                 }
642                 b.flags &= ~DCERPC_AUTH_OPTIONS;
643                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p2, &b, pipe_uuid,
644                                                           pipe_version, NULL, 
645                                                           NULL, NULL);
646                 break;
647         }
648
649         if (!NT_STATUS_IS_OK(status)) {
650                 return status;
651         }
652
653         (*p2)->flags = p->flags;
654
655         status = dcerpc_bind_auth_none(*p2, pipe_uuid, pipe_version);
656         if (!NT_STATUS_IS_OK(status)) {
657                 return status;
658         }
659
660         return NT_STATUS_OK;
661 }
662
663 NTSTATUS dcerpc_generic_session_key(struct dcerpc_pipe *p,
664                                     DATA_BLOB *session_key)
665 {
666         /* this took quite a few CPU cycles to find ... */
667         session_key->data = discard_const_p(char, "SystemLibraryDTC");
668         session_key->length = 16;
669         return NT_STATUS_OK;
670 }
671
672 /*
673   fetch the user session key - may be default (above) or the SMB session key
674 */
675 NTSTATUS dcerpc_fetch_session_key(struct dcerpc_pipe *p,
676                                   DATA_BLOB *session_key)
677 {
678         return p->security_state.session_key(p, session_key);
679 }
680
681
682 /*
683   log a rpc packet in a format suitable for ndrdump. This is especially useful
684   for sealed packets, where ethereal cannot easily see the contents
685
686   this triggers on a debug level of >= 10
687 */
688 void dcerpc_log_packet(const struct dcerpc_interface_table *ndr,
689                        uint32_t opnum, uint32_t flags, DATA_BLOB *pkt)
690 {
691         const int num_examples = 20;
692         int i;
693
694         if (DEBUGLEVEL < 10) return;
695
696         for (i=0;i<num_examples;i++) {
697                 char *name=NULL;
698                 asprintf(&name, "%s/rpclog/%s-%u.%d.%s", 
699                          lp_lockdir(), ndr->name, opnum, i,
700                          (flags&NDR_IN)?"in":"out");
701                 if (name == NULL) {
702                         return;
703                 }
704                 if (!file_exist(name, NULL)) {
705                         if (file_save(name, pkt->data, pkt->length)) {
706                                 DEBUG(10,("Logged rpc packet to %s\n", name));
707                         }
708                         free(name);
709                         break;
710                 }
711                 free(name);
712         }
713 }
714