ba61f28c95d2e2394139097427baee75a2224870
[samba.git] / source / 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         {"schannel", DCERPC_SCHANNEL},
279         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
280         {"print", DCERPC_DEBUG_PRINT_BOTH},
281         {"bigendian", DCERPC_PUSH_BIGENDIAN}
282 };
283
284 /*
285   form a binding string from a binding structure
286 */
287 const char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b)
288 {
289         char *s = NULL;
290         int i;
291         const char *t_name=NULL;
292
293         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
294                 if (ncacn_transports[i].transport == b->transport) {
295                         t_name = ncacn_transports[i].name;
296                 }
297         }
298         if (!t_name) {
299                 return NULL;
300         }
301
302         s = talloc_asprintf(mem_ctx, "%s:%s:[", t_name, b->host);
303         if (!s) return NULL;
304
305         /* this is a *really* inefficent way of dealing with strings,
306            but this is rarely called and the strings are always short,
307            so I don't care */
308         for (i=0;b->options && b->options[i];i++) {
309                 s = talloc_asprintf(mem_ctx, "%s%s,", s, b->options[i]);
310                 if (!s) return NULL;
311         }
312         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
313                 if (b->flags & ncacn_options[i].flag) {
314                         s = talloc_asprintf(mem_ctx, "%s%s,", s, ncacn_options[i].name);
315                         if (!s) return NULL;
316                 }
317         }
318         if (s[strlen(s)-1] == ',') {
319                 s[strlen(s)-1] = 0;
320         }
321         s = talloc_asprintf(mem_ctx, "%s]", s);
322
323         return s;
324 }
325
326 /*
327   parse a binding string into a dcerpc_binding structure
328 */
329 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
330 {
331         char *part1, *part2, *part3;
332         char *p;
333         int i, j, comma_count;
334
335         p = strchr(s, ':');
336         if (!p) {
337                 return NT_STATUS_INVALID_PARAMETER;
338         }
339         part1 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
340         if (!part1) {
341                 return NT_STATUS_NO_MEMORY;
342         }
343         s = p+1;
344
345         p = strchr(s, ':');
346         if (!p) {
347                 p = strchr(s, '[');
348                 if (p) {
349                         part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
350                         part3 = talloc_strdup(mem_ctx, p+1);
351                         if (part3[strlen(part3)-1] != ']') {
352                                 return NT_STATUS_INVALID_PARAMETER;
353                         }
354                         part3[strlen(part3)-1] = 0;
355                 } else {
356                         part2 = talloc_strdup(mem_ctx, s);
357                         part3 = NULL;
358                 }
359         } else {
360                 part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
361                 part3 = talloc_strdup(mem_ctx, p+1);
362         }
363         if (!part2) {
364                 return NT_STATUS_NO_MEMORY;
365         }
366
367         for (i=0;i<ARRAY_SIZE(ncacn_transports);i++) {
368                 if (strcasecmp(part1, ncacn_transports[i].name) == 0) {
369                         b->transport = ncacn_transports[i].transport;
370                         break;
371                 }
372         }
373         if (i==ARRAY_SIZE(ncacn_transports)) {
374                 DEBUG(0,("Unknown dcerpc transport '%s'\n", part1));
375                 return NT_STATUS_INVALID_PARAMETER;
376         }
377
378         b->host = part2;
379         b->options = NULL;
380         b->flags = 0;
381
382         if (!part3) {
383                 return NT_STATUS_OK;
384         }
385
386         /* the [] brackets are optional */
387         if (*part3 == '[' && part3[strlen(part3)-1] == ']') {
388                 part3++;
389                 part3[strlen(part3)-1] = 0;
390         }
391
392         comma_count = count_chars(part3, ',');
393         b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
394         if (!b->options) {
395                 return NT_STATUS_NO_MEMORY;
396         }
397
398         for (i=0; (p = strchr(part3, ',')); i++) {
399                 b->options[i] = talloc_strndup(mem_ctx, part3, PTR_DIFF(p, part3));
400                 if (!b->options[i]) {
401                         return NT_STATUS_NO_MEMORY;
402                 }
403                 part3 = p+1;
404         }
405         b->options[i] = part3;
406         b->options[i+1] = NULL;
407
408         /* some options are pre-parsed for convenience */
409         for (i=0;b->options[i];i++) {
410                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
411                         if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
412                                 int k;
413                                 b->flags |= ncacn_options[j].flag;
414                                 for (k=i;b->options[k];k++) {
415                                         b->options[k] = b->options[k+1];
416                                 }
417                                 i--;
418                                 break;
419                         }
420                 }
421         }
422         
423         return NT_STATUS_OK;
424 }
425
426
427 /* open a rpc connection to a rpc pipe on SMB using the binding
428    structure to determine the endpoint and options */
429 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **p, 
430                                              struct dcerpc_binding *binding,
431                                              const char *pipe_uuid, 
432                                              uint32 pipe_version,
433                                              const char *domain,
434                                              const char *username,
435                                              const char *password)
436 {
437         NTSTATUS status;
438         BOOL retry;
439         struct cli_state *cli;
440         const char *pipe_name;
441         
442         if (!binding->options || !binding->options[0]) {
443                 const struct dcerpc_interface_table *table = idl_iface_by_uuid(pipe_uuid);
444                 if (!table) {
445                         DEBUG(0,("Unknown interface endpoint '%s'\n", pipe_uuid));
446                         return NT_STATUS_INVALID_PARAMETER;
447                 }
448                 /* only try the first endpoint for now */
449                 pipe_name = table->endpoints->names[0];
450         } else {
451                 pipe_name = binding->options[0];
452         }
453
454         if (strncasecmp(pipe_name, "\\pipe\\", 6) == 0) {
455                 pipe_name += 6;
456         }
457         if (strncasecmp(pipe_name, "/pipe/", 6) == 0) {
458                 pipe_name += 6;
459         }
460             
461         status = cli_full_connection(&cli, lp_netbios_name(),
462                                      binding->host, NULL, 
463                                      "ipc$", "?????", 
464                                      username, username[0]?domain:"",
465                                      password, 0, &retry);
466         if (!NT_STATUS_IS_OK(status)) {
467                 DEBUG(0,("Failed to connect to %s - %s\n", binding->host, nt_errstr(status)));
468                 return status;
469         }
470
471         status = dcerpc_pipe_open_smb(p, cli->tree, pipe_name);
472         if (!NT_STATUS_IS_OK(status)) {
473                 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name, nt_errstr(status)));
474                 cli_tdis(cli);
475                 cli_shutdown(cli);
476                 return status;
477         }
478         
479         /* this ensures that the reference count is decremented so
480            a pipe close will really close the link */
481         cli_tree_close(cli->tree);
482         
483         (*p)->flags = binding->flags;
484
485         if (binding->flags & DCERPC_SCHANNEL) {
486                 const char *trust_password = secrets_fetch_machine_password();
487                 if (!trust_password) {
488                         DEBUG(0,("Unable to fetch machine password\n"));
489                         goto done;
490                 }
491                 status = dcerpc_bind_auth_schannel(*p, pipe_uuid, pipe_version, 
492                                                    lp_workgroup(), 
493                                                    lp_netbios_name(), 
494                                                    trust_password);
495         } else if (binding->flags & (DCERPC_SIGN | DCERPC_SEAL)) {
496                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
497         } else {    
498                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
499         }
500
501 done:
502         if (!NT_STATUS_IS_OK(status)) {
503                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
504                 dcerpc_pipe_close(*p);
505                 return status;
506         }
507
508         return NT_STATUS_OK;
509 }
510
511
512 /* open a rpc connection to a rpc pipe on SMP using the binding
513    structure to determine the endpoint and options */
514 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **p, 
515                                                  struct dcerpc_binding *binding,
516                                                  const char *pipe_uuid, 
517                                                  uint32 pipe_version,
518                                                  const char *domain,
519                                                  const char *username,
520                                                  const char *password)
521 {
522         NTSTATUS status;
523         uint32 port = 0;
524
525         if (binding->options && binding->options[0]) {
526                 port = atoi(binding->options[0]);
527         }
528
529         if (port == 0) {
530                 status = dcerpc_epm_map_tcp_port(binding->host, 
531                                                  pipe_uuid, pipe_version,
532                                                  &port);
533                 if (!NT_STATUS_IS_OK(status)) {
534                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
535                                  pipe_uuid, nt_errstr(status)));
536                         return status;
537                 }
538                 DEBUG(1,("Mapped to DCERPC/TCP port %u\n", port));
539         }
540
541         status = dcerpc_pipe_open_tcp(p, binding->host, port);
542         if (!NT_STATUS_IS_OK(status)) {
543                 DEBUG(0,("Failed to connect to %s:%d\n", binding->host, port));
544                 return status;
545         }
546
547         /* it doesn't seem to work to do a null NTLMSSP session without either sign
548            or seal, so force signing if we are doing ntlmssp */
549         if (username[0] && !(binding->flags & (DCERPC_SIGN|DCERPC_SEAL))) {
550                 binding->flags |= DCERPC_SIGN;
551         }
552
553         (*p)->flags = binding->flags;
554
555         if (!(binding->flags & (DCERPC_SIGN|DCERPC_SEAL)) && !username[0]) {
556                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
557         } else {
558                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version,
559                                                domain, username, password);
560         }
561
562         if (!NT_STATUS_IS_OK(status)) {
563                 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid, nt_errstr(status)));
564                 dcerpc_pipe_close(*p);
565                 return status;
566         }
567  
568         return status;
569 }
570
571
572 /* open a rpc connection to a rpc pipe, using the specified 
573    binding structure to determine the endpoint and options */
574 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **p, 
575                                struct dcerpc_binding *binding,
576                                const char *pipe_uuid, 
577                                uint32 pipe_version,
578                                const char *domain,
579                                const char *username,
580                                const char *password)
581 {
582         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
583
584         switch (binding->transport) {
585         case NCACN_NP:
586                 status = dcerpc_pipe_connect_ncacn_np(p, binding, pipe_uuid, pipe_version,
587                                                       domain, username, password);
588                 break;
589         case NCACN_IP_TCP:
590                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p, binding, pipe_uuid, pipe_version,
591                                                           domain, username, password);
592                 break;
593         }
594
595         /* remember the binding string for possible secondary connections */
596         if (NT_STATUS_IS_OK(status)) {
597                 (*p)->binding_string = dcerpc_binding_string((*p)->mem_ctx, binding);
598         }
599
600         return status;
601 }
602
603
604 /* open a rpc connection to a rpc pipe, using the specified string
605    binding to determine the endpoint and options */
606 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **p, 
607                              const char *binding,
608                              const char *pipe_uuid, 
609                              uint32 pipe_version,
610                              const char *domain,
611                              const char *username,
612                              const char *password)
613 {
614         struct dcerpc_binding b;
615         NTSTATUS status;
616         TALLOC_CTX *mem_ctx;
617
618         mem_ctx = talloc_init("dcerpc_pipe_connect");
619         if (!mem_ctx) return NT_STATUS_NO_MEMORY;
620
621         status = dcerpc_parse_binding(mem_ctx, binding, &b);
622         if (!NT_STATUS_IS_OK(status)) {
623                 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
624                 talloc_destroy(mem_ctx);
625                 return status;
626         }
627
628         DEBUG(3,("Using binding %s\n", dcerpc_binding_string(mem_ctx, &b)));
629
630         status = dcerpc_pipe_connect_b(p, &b, pipe_uuid, pipe_version, domain, username, password);
631
632         talloc_destroy(mem_ctx);
633         return status;
634 }
635
636
637 /*
638   create a secondary dcerpc connection on SMB
639   the secondary connection will be on the same SMB connection, but
640   use a new fnum
641 */
642 NTSTATUS dcerpc_secondary_smb(struct dcerpc_pipe *p, struct dcerpc_pipe **p2,
643                               const char *pipe_name,
644                               const char *pipe_uuid,
645                               uint32 pipe_version)
646 {
647         NTSTATUS status;
648         struct cli_tree *tree;
649
650         tree = dcerpc_smb_tree(p);
651         if (!tree) {
652                 return NT_STATUS_INVALID_PARAMETER;
653         }
654
655         status = dcerpc_pipe_open_smb(p2, tree, pipe_name);
656         if (!NT_STATUS_IS_OK(status)) {
657                 return status;
658         }
659         
660         (*p2)->flags = p->flags;
661
662         status = dcerpc_bind_auth_none(*p2, pipe_uuid, pipe_version);
663         if (!NT_STATUS_IS_OK(status)) {
664                 return status;
665         }
666
667         return NT_STATUS_OK;
668 }