- add 'print' to the DCERPC 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   this ndr_size_* stuff should really be auto-generated ....
27 */
28
29 static size_t ndr_size_epm_floor(struct epm_floor *fl)
30 {
31         size_t ret = 5;
32         if (fl->lhs.protocol == EPM_PROTOCOL_UUID) {
33                 ret += 18;
34         } else {
35                 ret += fl->lhs.info.lhs_data.length;
36         }
37         ret += fl->rhs.rhs_data.length;
38         return ret;
39 }
40
41 size_t ndr_size_epm_towers(struct epm_towers *towers)
42 {
43         size_t ret = 2;
44         int i;
45         for (i=0;i<towers->num_floors;i++) {
46                 ret += ndr_size_epm_floor(&towers->floors[i]);
47         }
48         return ret;
49 }
50
51 /*
52   work out what TCP port to use for a given interface on a given host
53 */
54 NTSTATUS dcerpc_epm_map_tcp_port(const char *server, 
55                                  const char *uuid, unsigned version,
56                                  uint32 *port)
57 {
58         struct dcerpc_pipe *p;
59         NTSTATUS status;
60         struct epm_Map r;
61         struct policy_handle handle;
62         struct GUID guid;
63         struct epm_twr_t twr, *twr_r;
64
65         if (strcasecmp(uuid, DCERPC_EPMAPPER_UUID) == 0 ||
66             strcasecmp(uuid, DCERPC_MGMT_UUID) == 0) {
67                 /* don't lookup epmapper via epmapper! */
68                 *port = EPMAPPER_PORT;
69                 return NT_STATUS_OK;
70         }
71
72         status = dcerpc_pipe_open_tcp(&p, server, EPMAPPER_PORT);
73         if (!NT_STATUS_IS_OK(status)) {
74                 return status;
75         }
76
77         /* we can use the pipes memory context here as we will have a short
78            lived connection */
79         status = dcerpc_bind_byuuid(p, p->mem_ctx, 
80                                     DCERPC_EPMAPPER_UUID,
81                                     DCERPC_EPMAPPER_VERSION);
82         if (!NT_STATUS_IS_OK(status)) {
83                 dcerpc_pipe_close(p);
84                 return status;
85         }
86
87         ZERO_STRUCT(handle);
88         ZERO_STRUCT(guid);
89
90         twr.towers.num_floors = 5;
91         twr.towers.floors = talloc(p->mem_ctx, sizeof(twr.towers.floors[0]) * 5);
92
93         /* what I'd like for christmas ... */
94
95         /* an RPC interface ... */
96         twr.towers.floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
97         GUID_from_string(uuid, &twr.towers.floors[0].lhs.info.uuid.uuid);
98         twr.towers.floors[0].lhs.info.uuid.version = version;
99         twr.towers.floors[0].rhs.rhs_data = data_blob_talloc_zero(p->mem_ctx, 2);
100
101         /* encoded with NDR ... */
102         twr.towers.floors[1].lhs.protocol = EPM_PROTOCOL_UUID;
103         GUID_from_string(NDR_GUID, &twr.towers.floors[1].lhs.info.uuid.uuid);
104         twr.towers.floors[1].lhs.info.uuid.version = NDR_GUID_VERSION;
105         twr.towers.floors[1].rhs.rhs_data = data_blob_talloc_zero(p->mem_ctx, 2);
106
107         /* on an RPC connection ... */
108         twr.towers.floors[2].lhs.protocol = EPM_PROTOCOL_RPC_C;
109         twr.towers.floors[2].lhs.info.lhs_data = data_blob(NULL, 0);
110         twr.towers.floors[2].rhs.rhs_data = data_blob_talloc_zero(p->mem_ctx, 2);
111
112         /* on a TCP port ... */
113         twr.towers.floors[3].lhs.protocol = EPM_PROTOCOL_TCP;
114         twr.towers.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
115         twr.towers.floors[3].rhs.rhs_data = data_blob_talloc_zero(p->mem_ctx, 2);
116
117         /* on an IP link ... */
118         twr.towers.floors[4].lhs.protocol = EPM_PROTOCOL_IP;
119         twr.towers.floors[4].lhs.info.lhs_data = data_blob(NULL, 0);
120         twr.towers.floors[4].rhs.rhs_data = data_blob_talloc_zero(p->mem_ctx, 4);
121
122         /* with some nice pretty paper around it of course */
123         r.in.object = &guid;
124         r.in.map_tower = &twr;
125         r.in.entry_handle = &handle;
126         r.in.max_towers = 1;
127         r.out.entry_handle = &handle;
128
129         status = dcerpc_epm_Map(p, p->mem_ctx, &r);
130         if (!NT_STATUS_IS_OK(status)) {
131                 dcerpc_pipe_close(p);
132                 return status;
133         }
134         if (r.out.status != 0 || r.out.num_towers != 1) {
135                 dcerpc_pipe_close(p);
136                 return NT_STATUS_PORT_UNREACHABLE;
137         }
138
139         twr_r = r.out.towers[0].twr;
140         if (!twr_r) {
141                 dcerpc_pipe_close(p);
142                 return NT_STATUS_PORT_UNREACHABLE;
143         }
144
145         if (twr_r->towers.num_floors != 5 ||
146             twr_r->towers.floors[3].lhs.protocol != twr.towers.floors[3].lhs.protocol ||
147             twr_r->towers.floors[3].rhs.rhs_data.length != 2) {
148                 dcerpc_pipe_close(p);
149                 return NT_STATUS_PORT_UNREACHABLE;
150         }
151
152         *port = RSVAL(twr_r->towers.floors[3].rhs.rhs_data.data, 0);
153
154         dcerpc_pipe_close(p);
155
156         return NT_STATUS_OK;
157 }
158
159
160 /*
161   find the pipe name for a local IDL interface
162 */
163 const char *idl_pipe_name(const char *uuid, uint32 if_version)
164 {
165         int i;
166         for (i=0;dcerpc_pipes[i];i++) {
167                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0 &&
168                     dcerpc_pipes[i]->if_version == if_version) {
169                         return dcerpc_pipes[i]->name;
170                 }
171         }
172         return "UNKNOWN";
173 }
174
175 /*
176   find the number of calls defined by local IDL
177 */
178 int idl_num_calls(const char *uuid, uint32 if_version)
179 {
180         int i;
181         for (i=0;dcerpc_pipes[i];i++) {
182                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0 &&
183                     dcerpc_pipes[i]->if_version == if_version) {
184                         return dcerpc_pipes[i]->num_calls;
185                 }
186         }
187         return -1;
188 }
189
190
191 /*
192   find a dcerpc interface by name
193 */
194 const struct dcerpc_interface_table *idl_iface_by_name(const char *name)
195 {
196         int i;
197         for (i=0;dcerpc_pipes[i];i++) {
198                 if (strcasecmp(dcerpc_pipes[i]->name, name) == 0) {
199                         return dcerpc_pipes[i];
200                 }
201         }
202         return NULL;
203 }
204
205 /*
206   find a dcerpc interface by uuid
207 */
208 const struct dcerpc_interface_table *idl_iface_by_uuid(const char *uuid)
209 {
210         int i;
211         for (i=0;dcerpc_pipes[i];i++) {
212                 if (strcasecmp(dcerpc_pipes[i]->uuid, uuid) == 0) {
213                         return dcerpc_pipes[i];
214                 }
215         }
216         return NULL;
217 }
218
219
220
221 /* 
222    push a dcerpc_packet into a blob, potentially with auth info
223 */
224 NTSTATUS dcerpc_push_auth(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, 
225                           struct dcerpc_packet *pkt,
226                           struct dcerpc_auth *auth_info)
227 {
228         NTSTATUS status;
229         struct ndr_push *ndr;
230
231         ndr = ndr_push_init_ctx(mem_ctx);
232         if (!ndr) {
233                 return NT_STATUS_NO_MEMORY;
234         }
235
236         if (!(pkt->drep[0] & DCERPC_DREP_LE)) {
237                 ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
238         }
239
240         if (auth_info) {
241                 pkt->auth_length = auth_info->credentials.length;
242         } else {
243                 pkt->auth_length = 0;
244         }
245
246         status = ndr_push_dcerpc_packet(ndr, NDR_SCALARS|NDR_BUFFERS, pkt);
247         if (!NT_STATUS_IS_OK(status)) {
248                 return status;
249         }
250
251         if (auth_info) {
252                 status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, auth_info);
253         }
254
255         *blob = ndr_push_blob(ndr);
256
257         /* fill in the frag length */
258         dcerpc_set_frag_length(blob, blob->length);
259
260         return NT_STATUS_OK;
261 }
262
263
264 static const struct {
265         const char *name;
266         enum dcerpc_transport_t transport;
267 } ncacn_transports[] = {
268         {"ncacn_np",     NCACN_NP},
269         {"ncacn_ip_tcp", NCACN_IP_TCP}
270 };
271
272 static const struct {
273         const char *name;
274         uint32 flag;
275 } ncacn_options[] = {
276         {"sign", DCERPC_SIGN},
277         {"seal", DCERPC_SEAL},
278         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
279         {"print", DCERPC_DEBUG_PRINT_BOTH},
280         {"bigendian", DCERPC_PUSH_BIGENDIAN}
281 };
282
283 /*
284   form a binding string from a binding structure
285 */
286 const char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
287 {
288         char *s = NULL;
289         int i;
290         const char *t_name=NULL;
291
292         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
293                 if (ncacn_transports[i].transport == b->transport) {
294                         t_name = ncacn_transports[i].name;
295                 }
296         }
297         if (!t_name) {
298                 return NULL;
299         }
300
301         s = talloc_asprintf(mem_ctx, "%s:%s:[", t_name, b->host);
302         if (!s) return NULL;
303
304         /* this is a *really* inefficent way of dealing with strings,
305            but this is rarely called and the strings are always short,
306            so I don't care */
307         for (i=0;b->options && b->options[i];i++) {
308                 s = talloc_asprintf(mem_ctx, "%s%s,", s, b->options[i]);
309                 if (!s) return NULL;
310         }
311         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
312                 if (b->flags & ncacn_options[i].flag) {
313                         s = talloc_asprintf(mem_ctx, "%s%s,", s, ncacn_options[i].name);
314                         if (!s) return NULL;
315                 }
316         }
317         if (s[strlen(s)-1] == ',') {
318                 s[strlen(s)-1] = 0;
319         }
320         s = talloc_asprintf(mem_ctx, "%s]", s);
321
322         return s;
323 }
324
325 /*
326   parse a binding string into a dcerpc_binding structure
327 */
328 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
329 {
330         char *part1, *part2, *part3;
331         char *p;
332         int i, j, comma_count;
333
334         p = strchr(s, ':');
335         if (!p) {
336                 return NT_STATUS_INVALID_PARAMETER;
337         }
338         part1 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
339         if (!part1) {
340                 return NT_STATUS_NO_MEMORY;
341         }
342         s = p+1;
343
344         p = strchr(s, ':');
345         if (!p) {
346                 p = strchr(s, '[');
347                 if (p) {
348                         part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
349                         part3 = talloc_strdup(mem_ctx, p+1);
350                         if (part3[strlen(part3)-1] != ']') {
351                                 return NT_STATUS_INVALID_PARAMETER;
352                         }
353                         part3[strlen(part3)-1] = 0;
354                 } else {
355                         part2 = talloc_strdup(mem_ctx, s);
356                         part3 = NULL;
357                 }
358         } else {
359                 part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
360                 part3 = talloc_strdup(mem_ctx, p+1);
361         }
362         if (!part2) {
363                 return NT_STATUS_NO_MEMORY;
364         }
365
366         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
367                 if (strcasecmp(part1, ncacn_transports[i].name) == 0) {
368                         b->transport = ncacn_transports[i].transport;
369                         break;
370                 }
371         }
372         if (i==ARRAY_SIZE(ncacn_transports)) {
373                 DEBUG(0,("Unknown dcerpc transport '%s'\n", part1));
374                 return NT_STATUS_INVALID_PARAMETER;
375         }
376
377         b->host = part2;
378         b->options = NULL;
379         b->flags = 0;
380
381         if (!part3) {
382                 return NT_STATUS_OK;
383         }
384
385         /* the [] brackets are optional */
386         if (*part3 == '[' && part3[strlen(part3)-1] == ']') {
387                 part3++;
388                 part3[strlen(part3)-1] = 0;
389         }
390
391         comma_count = count_chars(part3, ',');
392         b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
393         if (!b->options) {
394                 return NT_STATUS_NO_MEMORY;
395         }
396
397         for (i=0; (p = strchr(part3, ',')); i++) {
398                 b->options[i] = talloc_strndup(mem_ctx, part3, PTR_DIFF(p, part3));
399                 if (!b->options[i]) {
400                         return NT_STATUS_NO_MEMORY;
401                 }
402                 part3 = p+1;
403         }
404         b->options[i] = part3;
405         b->options[i+1] = NULL;
406
407         /* some options are pre-parsed for convenience */
408         for (i=0;b->options[i];i++) {
409                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
410                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
411                                 int k;
412                                 b->flags |= ncacn_options[j].flag;
413                                 for (k=i;b->options[k];k++) {
414                                         b->options[k] = b->options[k+1];
415                                 }
416                                 i--;
417                                 break;
418                         }
419                 }
420         }
421         
422         return NT_STATUS_OK;
423 }
424
425
426 /* open a rpc connection to a rpc pipe on SMB using the binding
427    structure to determine the endpoint and options */
428 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **p, 
429                                              struct dcerpc_binding *binding,
430                                              const char *pipe_uuid, 
431                                              uint32 pipe_version,
432                                              const char *domain,
433                                              const char *username,
434                                              const char *password)
435 {
436         NTSTATUS status;
437         BOOL retry;
438         struct cli_state *cli;
439         const char *pipe_name;
440         
441         if (!binding->options || !binding->options[0]) {
442                 const struct dcerpc_interface_table *table = idl_iface_by_uuid(pipe_uuid);
443                 if (!table) {
444                         DEBUG(0,("Unknown interface endpoint '%s'\n", pipe_uuid));
445                         return NT_STATUS_INVALID_PARAMETER;
446                 }
447                 /* only try the first endpoint for now */
448                 pipe_name = table->endpoints->names[0];
449         } else {
450                 pipe_name = binding->options[0];
451         }
452
453         if (strncasecmp(pipe_name, "\\pipe\\", 6) == 0) {
454                 pipe_name += 6;
455         }
456         if (strncasecmp(pipe_name, "/pipe/", 6) == 0) {
457                 pipe_name += 6;
458         }
459             
460         status = cli_full_connection(&cli, lp_netbios_name(),
461                                      binding->host, NULL, 
462                                      "ipc$", "?????", 
463                                      username, username[0]?domain:"",
464                                      password, 0, &retry);
465         if (!NT_STATUS_IS_OK(status)) {
466                 DEBUG(0,("Failed to connect to %s - %s\n", binding->host, nt_errstr(status)));
467                 return status;
468         }
469
470         status = dcerpc_pipe_open_smb(p, cli->tree, pipe_name);
471         if (!NT_STATUS_IS_OK(status)) {
472                 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name, nt_errstr(status)));
473                 cli_tdis(cli);
474                 cli_shutdown(cli);
475                 return status;
476         }
477         
478         /* this ensures that the reference count is decremented so
479            a pipe close will really close the link */
480         cli_tree_close(cli->tree);
481         
482         (*p)->flags = binding->flags;
483
484         if (binding->flags & (DCERPC_SIGN | DCERPC_SEAL)) {
485                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
486         } else {    
487                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
488         }
489         if (!NT_STATUS_IS_OK(status)) {
490                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
491                 dcerpc_pipe_close(*p);
492                 return status;
493         }
494
495         return NT_STATUS_OK;
496 }
497
498
499 /* open a rpc connection to a rpc pipe on SMP using the binding
500    structure to determine the endpoint and options */
501 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **p, 
502                                                  struct dcerpc_binding *binding,
503                                                  const char *pipe_uuid, 
504                                                  uint32 pipe_version,
505                                                  const char *domain,
506                                                  const char *username,
507                                                  const char *password)
508 {
509         NTSTATUS status;
510         uint32 port = 0;
511
512         if (binding->options && binding->options[0]) {
513                 port = atoi(binding->options[0]);
514         }
515
516         if (port == 0) {
517                 status = dcerpc_epm_map_tcp_port(binding->host, 
518                                                  pipe_uuid, pipe_version,
519                                                  &port);
520                 if (!NT_STATUS_IS_OK(status)) {
521                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
522                                  pipe_uuid, nt_errstr(status)));
523                         return status;
524                 }
525                 DEBUG(1,("Mapped to DCERPC/TCP port %u\n", port));
526         }
527
528         status = dcerpc_pipe_open_tcp(p, binding->host, port);
529         if (!NT_STATUS_IS_OK(status)) {
530                 DEBUG(0,("Failed to connect to %s:%d\n", binding->host, port));
531                 return status;
532         }
533
534         /* it doesn't seem to work to do a null NTLMSSP session without either sign
535            or seal, so force signing if we are doing ntlmssp */
536         if (username[0] && !(binding->flags & (DCERPC_SIGN|DCERPC_SEAL))) {
537                 binding->flags |= DCERPC_SIGN;
538         }
539
540         (*p)->flags = binding->flags;
541
542         if (!(binding->flags & (DCERPC_SIGN|DCERPC_SEAL)) && !username[0]) {
543                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
544         } else {
545                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version,
546                                                domain, username, password);
547         }
548
549         if (!NT_STATUS_IS_OK(status)) {
550                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
551                 dcerpc_pipe_close(*p);
552                 return status;
553         }
554  
555         return status;
556 }
557
558
559 /* open a rpc connection to a rpc pipe, using the specified 
560    binding structure to determine the endpoint and options */
561 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **p, 
562                                struct dcerpc_binding *binding,
563                                const char *pipe_uuid, 
564                                uint32 pipe_version,
565                                const char *domain,
566                                const char *username,
567                                const char *password)
568 {
569         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
570
571         switch (binding->transport) {
572         case NCACN_NP:
573                 status = dcerpc_pipe_connect_ncacn_np(p, binding, pipe_uuid, pipe_version,
574                                                       domain, username, password);
575                 break;
576         case NCACN_IP_TCP:
577                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p, binding, pipe_uuid, pipe_version,
578                                                           domain, username, password);
579                 break;
580         }
581
582         /* remember the binding string for possible secondary connections */
583         if (NT_STATUS_IS_OK(status)) {
584                 (*p)->binding_string = dcerpc_binding_string((*p)->mem_ctx, binding);
585         }
586
587         return status;
588 }
589
590
591 /* open a rpc connection to a rpc pipe, using the specified string
592    binding to determine the endpoint and options */
593 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **p, 
594                              const char *binding,
595                              const char *pipe_uuid, 
596                              uint32 pipe_version,
597                              const char *domain,
598                              const char *username,
599                              const char *password)
600 {
601         struct dcerpc_binding b;
602         NTSTATUS status;
603         TALLOC_CTX *mem_ctx;
604
605         mem_ctx = talloc_init("dcerpc_pipe_connect");
606         if (!mem_ctx) return NT_STATUS_NO_MEMORY;
607
608         status = dcerpc_parse_binding(mem_ctx, binding, &b);
609         if (!NT_STATUS_IS_OK(status)) {
610                 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
611                 talloc_destroy(mem_ctx);
612                 return status;
613         }
614
615         DEBUG(3,("Using binding %s\n", dcerpc_binding_string(mem_ctx, &b)));
616
617         status = dcerpc_pipe_connect_b(p, &b, pipe_uuid, pipe_version, domain, username, password);
618
619         talloc_destroy(mem_ctx);
620         return status;
621 }
622
623
624 /*
625   create a secondary dcerpc connection on SMB
626   the secondary connection will be on the same SMB connection, but
627   use a new fnum
628 */
629 NTSTATUS dcerpc_secondary_smb(struct dcerpc_pipe *p, struct dcerpc_pipe **p2,
630                               const char *pipe_name,
631                               const char *pipe_uuid,
632                               uint32 pipe_version)
633 {
634         NTSTATUS status;
635         struct cli_tree *tree;
636
637         tree = dcerpc_smb_tree(p);
638         if (!tree) {
639                 return NT_STATUS_INVALID_PARAMETER;
640         }
641
642         status = dcerpc_pipe_open_smb(p2, tree, pipe_name);
643         if (!NT_STATUS_IS_OK(status)) {
644                 return status;
645         }
646         
647         (*p2)->flags = p->flags;
648
649         status = dcerpc_bind_auth_none(*p2, pipe_uuid, pipe_version);
650         if (!NT_STATUS_IS_OK(status)) {
651                 return status;
652         }
653
654         return NT_STATUS_OK;
655 }