allow the specification of full dcerpc endpoint binding strings on the
[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         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 (auth_info) {
237                 pkt->auth_length = auth_info->credentials.length;
238         } else {
239                 pkt->auth_length = 0;
240         }
241
242         status = ndr_push_dcerpc_packet(ndr, NDR_SCALARS|NDR_BUFFERS, pkt);
243         if (!NT_STATUS_IS_OK(status)) {
244                 return status;
245         }
246
247         if (auth_info) {
248                 status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, auth_info);
249         }
250
251         *blob = ndr_push_blob(ndr);
252
253         /* fill in the frag length */
254         SSVAL(blob->data, DCERPC_FRAG_LEN_OFFSET, blob->length);
255
256         return NT_STATUS_OK;
257 }
258
259
260 /*
261   parse a binding string into a dcerpc_binding structure
262 */
263 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding *b)
264 {
265         char *part1, *part2, *part3;
266         char *p;
267         int i, j, comma_count;
268         const struct {
269                 const char *name;
270                 enum dcerpc_transport_t transport;
271         } transports[] = {
272                 {"ncacn_np",     NCACN_NP},
273                 {"ncacn_ip_tcp", NCACN_IP_TCP}
274         };
275         const struct {
276                 const char *name;
277                 uint32 flag;
278         } options[] = {
279                 {"sign", DCERPC_SIGN},
280                 {"seal", DCERPC_SEAL},
281                 {"validate", DCERPC_DEBUG_VALIDATE_BOTH}
282         };
283
284         p = strchr(s, ':');
285         if (!p) {
286                 return NT_STATUS_INVALID_PARAMETER;
287         }
288         part1 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
289         if (!part1) {
290                 return NT_STATUS_NO_MEMORY;
291         }
292         s = p+1;
293
294         p = strchr(s, ':');
295         if (!p) {
296                 part2 = talloc_strdup(mem_ctx, s);
297                 part3 = NULL;
298         } else {
299                 part2 = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
300                 part3 = talloc_strdup(mem_ctx, p+1);
301         }
302         if (!part2) {
303                 return NT_STATUS_NO_MEMORY;
304         }
305
306         for (i=0;i<ARRAY_SIZE(transports);i++) {
307                 if (strcasecmp(part1, transports[i].name) == 0) {
308                         b->transport = transports[i].transport;
309                         break;
310                 }
311         }
312         if (i==ARRAY_SIZE(transports)) {
313                 DEBUG(1,("Unknown dcerpc transport '%s'\n", part1));
314                 return NT_STATUS_INVALID_PARAMETER;
315         }
316
317         b->host = part2;
318         b->options = NULL;
319         b->flags = 0;
320
321         if (!part3) {
322                 return NT_STATUS_OK;
323         }
324
325         /* the [] brackets are optional */
326         if (*part3 == '[' && part3[strlen(part3)-1] == ']') {
327                 part3++;
328                 part3[strlen(part3)-1] = 0;
329         }
330
331         comma_count = count_chars(part3, ',');
332         b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
333         if (!b->options) {
334                 return NT_STATUS_NO_MEMORY;
335         }
336
337         for (i=0; (p = strchr(part3, ',')); i++) {
338                 b->options[i] = talloc_strndup(mem_ctx, part3, PTR_DIFF(p, part3));
339                 if (!b->options[i]) {
340                         return NT_STATUS_NO_MEMORY;
341                 }
342                 part3 = p+1;
343         }
344         b->options[i] = part3;
345         b->options[i+1] = NULL;
346
347         /* some options are pre-parsed for convenience */
348         for (i=0;b->options[i];i++) {
349                 for (j=0;j<ARRAY_SIZE(options);j++) {
350                         if (strcasecmp(options[j].name, b->options[i]) == 0) {
351                                 b->flags |= options[j].flag;
352                                 break;
353                         }
354                 }
355         }
356         
357         return NT_STATUS_OK;
358 }
359
360
361 /* open a rpc connection to a rpc pipe on SMP using the binding
362    structure to determine the endpoint and options */
363 static NTSTATUS dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe **p, 
364                                              struct dcerpc_binding *binding,
365                                              const char *pipe_uuid, 
366                                              uint32 pipe_version,
367                                              const char *domain,
368                                              const char *username,
369                                              const char *password)
370 {
371         NTSTATUS status;
372         BOOL retry;
373         struct cli_state *cli;
374         const char *pipe_name;
375         
376         if (!binding->options || !binding->options[0]) {
377                 const struct dcerpc_interface_table *table = idl_iface_by_uuid(pipe_uuid);
378                 if (!table) {
379                         DEBUG(0,("Unknown interface endpoint '%s'\n", pipe_uuid));
380                         return NT_STATUS_INVALID_PARAMETER;
381                 }
382                 pipe_name = table->endpoints->names[0];
383         } else {
384                 pipe_name = binding->options[0];
385         }
386
387         if (strncasecmp(pipe_name, "\\pipe\\", 6) == 0) {
388                 pipe_name += 6;
389         }
390         if (strncasecmp(pipe_name, "/pipe/", 6) == 0) {
391                 pipe_name += 6;
392         }
393             
394         status = cli_full_connection(&cli, lp_netbios_name(),
395                                      binding->host, NULL, 
396                                      "ipc$", "?????", 
397                                      username, username[0]?domain:"",
398                                      password, 0, &retry);
399         if (!NT_STATUS_IS_OK(status)) {
400                 return status;
401         }
402
403         status = dcerpc_pipe_open_smb(p, cli->tree, pipe_name);
404         if (!NT_STATUS_IS_OK(status)) {
405                 cli_tdis(cli);
406                 cli_shutdown(cli);
407                 return status;
408         }
409         
410         /* this ensures that the reference count is decremented so
411            a pipe close will really close the link */
412         cli_tree_close(cli->tree);
413         
414         (*p)->flags = binding->flags;
415
416         if (binding->flags & (DCERPC_SIGN | DCERPC_SEAL)) {
417                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version, domain, username, password);
418         } else {    
419                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
420         }
421         if (!NT_STATUS_IS_OK(status)) {
422                 dcerpc_pipe_close(*p);
423                 return status;
424         }
425
426         return NT_STATUS_OK;
427 }
428
429
430 /* open a rpc connection to a rpc pipe on SMP using the binding
431    structure to determine the endpoint and options */
432 static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe **p, 
433                                                  struct dcerpc_binding *binding,
434                                                  const char *pipe_uuid, 
435                                                  uint32 pipe_version,
436                                                  const char *domain,
437                                                  const char *username,
438                                                  const char *password)
439 {
440         NTSTATUS status;
441         uint32 port = 0;
442
443         if (binding->options && binding->options[0]) {
444                 port = atoi(binding->options[0]);
445         }
446
447         if (port == 0) {
448                 status = dcerpc_epm_map_tcp_port(binding->host, 
449                                                  pipe_uuid, pipe_version,
450                                                  &port);
451                 if (!NT_STATUS_IS_OK(status)) {
452                         DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n", 
453                                  pipe_uuid, nt_errstr(status)));
454                         return status;
455                 }
456                 DEBUG(1,("Mapped to DCERPC/TCP port %u\n", port));
457         }
458
459         status = dcerpc_pipe_open_tcp(p, binding->host, port);
460         if (!NT_STATUS_IS_OK(status)) {
461                 return status;
462         }
463
464         /* it doesn't seem to work to do a null NTLMSSP session without either sign
465            or seal, so force signing if we are doing ntlmssp */
466         if (username[0] && !(binding->flags & (DCERPC_SIGN|DCERPC_SEAL))) {
467                 binding->flags |= DCERPC_SIGN;
468         }
469
470         (*p)->flags = binding->flags;
471
472         if (!(binding->flags & (DCERPC_SIGN|DCERPC_SEAL)) && !username[0]) {
473                 status = dcerpc_bind_auth_none(*p, pipe_uuid, pipe_version);
474         } else {
475                 status = dcerpc_bind_auth_ntlm(*p, pipe_uuid, pipe_version,
476                                                domain, username, password);
477         }
478
479         if (!NT_STATUS_IS_OK(status)) {
480                 dcerpc_pipe_close(*p);
481                 return status;
482         }
483  
484         return status;
485 }
486
487
488 /* open a rpc connection to a rpc pipe, using the specified 
489    binding structure to determine the endpoint and options */
490 NTSTATUS dcerpc_pipe_connect_b(struct dcerpc_pipe **p, 
491                                struct dcerpc_binding *binding,
492                                const char *pipe_uuid, 
493                                uint32 pipe_version,
494                                const char *domain,
495                                const char *username,
496                                const char *password)
497 {
498         NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
499
500         switch (binding->transport) {
501         case NCACN_NP:
502                 status = dcerpc_pipe_connect_ncacn_np(p, binding, pipe_uuid, pipe_version,
503                                                       domain, username, password);
504                 break;
505         case NCACN_IP_TCP:
506                 status = dcerpc_pipe_connect_ncacn_ip_tcp(p, binding, pipe_uuid, pipe_version,
507                                                           domain, username, password);
508                 break;
509         }
510
511         return status;
512 }
513
514
515 /* open a rpc connection to a rpc pipe, using the specified string
516    binding to determine the endpoint and options */
517 NTSTATUS dcerpc_pipe_connect(struct dcerpc_pipe **p, 
518                              const char *binding,
519                              const char *pipe_uuid, 
520                              uint32 pipe_version,
521                              const char *domain,
522                              const char *username,
523                              const char *password)
524 {
525         struct dcerpc_binding b;
526         NTSTATUS status;
527         TALLOC_CTX *mem_ctx;
528
529         mem_ctx = talloc_init("dcerpc_pipe_connect");
530         if (!mem_ctx) return NT_STATUS_NO_MEMORY;
531
532         status = dcerpc_parse_binding(mem_ctx, binding, &b);
533         if (!NT_STATUS_IS_OK(status)) {
534                 talloc_destroy(mem_ctx);
535                 return status;
536         }
537
538         status = dcerpc_pipe_connect_b(p, &b, pipe_uuid, pipe_version, domain, username, password);
539
540         talloc_destroy(mem_ctx);
541         return status;
542 }