?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:idmap_ad: add support for ADS_AUTH_SASL_{STARTTLS,LDAPS}
[Samba.git] / source3 / rpcclient / rpcclient.c
blobf59bf6b0c982a5b77c798f2df63a23a7f46fd67c
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Tim Potter 2000-2001
6 Copyright (C) Martin Pool 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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "../libcli/auth/netlogon_creds_cli.h"
24 #include "rpcclient.h"
25 #include "../libcli/auth/libcli_auth.h"
26 #include "../librpc/gen_ndr/ndr_lsa_c.h"
27 #include "rpc_client/cli_lsarpc.h"
28 #include "../librpc/gen_ndr/ndr_netlogon.h"
29 #include "rpc_client/cli_netlogon.h"
30 #include "../libcli/smbreadline/smbreadline.h"
31 #include "../libcli/security/security.h"
32 #include "passdb.h"
33 #include "libsmb/libsmb.h"
34 #include "auth/gensec/gensec.h"
35 #include "../libcli/smb/smbXcli_base.h"
36 #include "messages.h"
37 #include "cmdline_contexts.h"
38 #include "../librpc/gen_ndr/ndr_samr.h"
39 #include "lib/cmdline/cmdline.h"
40 #include "lib/param/param.h"
41
42 enum pipe_auth_type_spnego {
43 PIPE_AUTH_TYPE_SPNEGO_NONE = 0,
44 PIPE_AUTH_TYPE_SPNEGO_NTLMSSP,
45 PIPE_AUTH_TYPE_SPNEGO_KRB5
46 };
47
48 static unsigned int timeout = 10000;
49
50 struct messaging_context *rpcclient_msg_ctx;
51 struct netlogon_creds_cli_context *rpcclient_netlogon_creds;
52 static const char *rpcclient_netlogon_domain;
53
54 /* List to hold groups of commands.
55 *
56 * Commands are defined in a list of arrays: arrays are easy to
57 * statically declare, and lists are easier to dynamically extend.
58 */
59
60 static struct cmd_list {
61 struct cmd_list *prev, *next;
62 struct cmd_set *cmd_set;
63 } *cmd_list;
64
65 /****************************************************************************
66 handle completion of commands for readline
67 ****************************************************************************/
68 static char **completion_fn(const char *text, int start, int end)
69 {
70 #define MAX_COMPLETIONS 1000
71 char **matches;
72 size_t i, count=0;
73 struct cmd_list *commands = cmd_list;
74
75 #if 0 /* JERRY */
76 /* FIXME!!! -- what to do when completing argument? */
77 /* for words not at the start of the line fallback
78 to filename completion */
79 if (start)
80 return NULL;
81 #endif
82
83 /* make sure we have a list of valid commands */
84 if (!commands) {
85 return NULL;
86 }
87
88 matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
89 if (!matches) {
90 return NULL;
91 }
92
93 matches[count++] = SMB_STRDUP(text);
94 if (!matches[0]) {
95 SAFE_FREE(matches);
96 return NULL;
97 }
98
99 while (commands && count < MAX_COMPLETIONS-1) {
100 if (!commands->cmd_set) {
101 break;
102 }
103
104 for (i=0; commands->cmd_set[i].name; i++) {
105 if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) &&
106 (( commands->cmd_set[i].returntype == RPC_RTYPE_NTSTATUS &&
107 commands->cmd_set[i].ntfn ) ||
108 ( commands->cmd_set[i].returntype == RPC_RTYPE_WERROR &&
109 commands->cmd_set[i].wfn))) {
110 matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
111 if (!matches[count]) {
112 for (i = 0; i < count; i++) {
113 SAFE_FREE(matches[count]);
114 }
115 SAFE_FREE(matches);
116 return NULL;
117 }
118 count++;
119 }
120 }
121 commands = commands->next;
122 }
123
124 if (count == 2) {
125 SAFE_FREE(matches[0]);
126 matches[0] = SMB_STRDUP(matches[1]);
127 }
128 matches[count] = NULL;
129 return matches;
130 }
131
132 static char *next_command (char **cmdstr)
133 {
134 char *command;
135 char *p;
136
137 if (!cmdstr || !(*cmdstr))
138 return NULL;
139
140 p = strchr_m(*cmdstr, ';');
141 if (p)
142 *p = '\0';
143 command = SMB_STRDUP(*cmdstr);
144 if (p)
145 *cmdstr = p + 1;
146 else
147 *cmdstr = NULL;
148
149 return command;
150 }
151
152 static void binding_get_auth_info(
153 const struct dcerpc_binding *b,
154 enum dcerpc_AuthType *_auth_type,
155 enum dcerpc_AuthLevel *_auth_level,
156 enum credentials_use_kerberos *_krb5_state)
157 {
158 uint32_t bflags = dcerpc_binding_get_flags(b);
159 enum dcerpc_AuthLevel auth_level = DCERPC_AUTH_LEVEL_NONE;
160 enum dcerpc_AuthType auth_type = DCERPC_AUTH_TYPE_NONE;
161 enum credentials_use_kerberos krb5_state = CRED_USE_KERBEROS_DESIRED;
162
163 if (_krb5_state != NULL) {
164 krb5_state = *_krb5_state;
165 }
166
167 if (bflags & DCERPC_CONNECT) {
168 auth_level = DCERPC_AUTH_LEVEL_CONNECT;
169 }
170 if (bflags & DCERPC_PACKET) {
171 auth_level = DCERPC_AUTH_LEVEL_PACKET;
172 }
173 if (bflags & DCERPC_SIGN) {
174 auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
175 }
176 if (bflags & DCERPC_SEAL) {
177 auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
178 }
179
180 if (bflags & DCERPC_SCHANNEL) {
181 auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
182 }
183
184 if ((auth_level != DCERPC_AUTH_LEVEL_NONE) &&
185 (auth_type == DCERPC_AUTH_TYPE_NONE)) {
186 auth_type = (krb5_state == CRED_USE_KERBEROS_REQUIRED) ?
187 DCERPC_AUTH_TYPE_KRB5 : DCERPC_AUTH_TYPE_NTLMSSP;
188 }
189
190 if (bflags & DCERPC_AUTH_SPNEGO) {
191 auth_type = DCERPC_AUTH_TYPE_SPNEGO;
192
193 if (bflags & DCERPC_AUTH_NTLM) {
194 krb5_state = CRED_USE_KERBEROS_DISABLED;
195 }
196 if (bflags & DCERPC_AUTH_KRB5) {
197 krb5_state = CRED_USE_KERBEROS_REQUIRED;
198 }
199 }
200
201 if (auth_type != DCERPC_AUTH_TYPE_NONE) {
202 /* If nothing is requested then default to integrity */
203 if (auth_level == DCERPC_AUTH_LEVEL_NONE) {
204 auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
205 }
206 }
207
208 if (_auth_type != NULL) {
209 *_auth_type = auth_type;
210 }
211 if (_auth_level != NULL) {
212 *_auth_level = auth_level;
213 }
214 if (_krb5_state != NULL) {
215 *_krb5_state = krb5_state;
216 }
217 }
218
219 /* List the available commands on a given pipe */
220
221 static NTSTATUS cmd_listcommands(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
222 int argc, const char **argv)
223 {
224 struct cmd_list *tmp;
225 struct cmd_set *tmp_set;
226 int i;
227
228 /* Usage */
229
230 if (argc != 2) {
231 printf("Usage: %s <pipe>\n", argv[0]);
232 return NT_STATUS_OK;
233 }
234
235 /* Help on one command */
236
237 for (tmp = cmd_list; tmp; tmp = tmp->next)
238 {
239 tmp_set = tmp->cmd_set;
240
241 if (!strcasecmp_m(argv[1], tmp_set->name))
242 {
243 printf("Available commands on the %s pipe:\n\n", tmp_set->name);
244
245 i = 0;
246 tmp_set++;
247 while(tmp_set->name) {
248 printf("%30s", tmp_set->name);
249 tmp_set++;
250 i++;
251 if (i%3 == 0)
252 printf("\n");
253 }
254
255 /* drop out of the loop */
256 break;
257 }
258 }
259 printf("\n\n");
260
261 return NT_STATUS_OK;
262 }
263
264 /* Display help on commands */
265
266 static NTSTATUS cmd_help(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
267 int argc, const char **argv)
268 {
269 struct cmd_list *tmp;
270 struct cmd_set *tmp_set;
271
272 /* Usage */
273
274 if (argc > 2) {
275 printf("Usage: %s [command]\n", argv[0]);
276 return NT_STATUS_OK;
277 }
278
279 /* Help on one command */
280
281 if (argc == 2) {
282 for (tmp = cmd_list; tmp; tmp = tmp->next) {
283
284 tmp_set = tmp->cmd_set;
285
286 while(tmp_set->name) {
287 if (strequal(argv[1], tmp_set->name)) {
288 if (tmp_set->usage &&
289 tmp_set->usage[0])
290 printf("%s\n", tmp_set->usage);
291 else
292 printf("No help for %s\n", tmp_set->name);
293
294 return NT_STATUS_OK;
295 }
296
297 tmp_set++;
298 }
299 }
300
301 printf("No such command: %s\n", argv[1]);
302 return NT_STATUS_OK;
303 }
304
305 /* List all commands */
306
307 for (tmp = cmd_list; tmp; tmp = tmp->next) {
308
309 tmp_set = tmp->cmd_set;
310
311 while(tmp_set->name) {
312
313 printf("%15s\t\t%s\n", tmp_set->name,
314 tmp_set->description ? tmp_set->description:
315 "");
316
317 tmp_set++;
318 }
319 }
320
321 return NT_STATUS_OK;
322 }
323
324 /* Change the debug level */
325
326 static NTSTATUS cmd_debuglevel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
327 int argc, const char **argv)
328 {
329 if (argc > 2) {
330 printf("Usage: %s [debuglevel]\n", argv[0]);
331 return NT_STATUS_OK;
332 }
333
334 if (argc == 2) {
335 struct loadparm_context *lp_ctx = samba_cmdline_get_lp_ctx();
336 lpcfg_set_cmdline(lp_ctx, "log level", argv[1]);
337 }
338
339 printf("debuglevel is %d\n", DEBUGLEVEL);
340
341 return NT_STATUS_OK;
342 }
343
344 static NTSTATUS cmd_quit(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
345 int argc, const char **argv)
346 {
347 exit(0);
348 return NT_STATUS_OK; /* NOTREACHED */
349 }
350
351 static NTSTATUS cmd_set_ss_level(struct dcerpc_binding *binding)
352 {
353 struct cmd_list *tmp;
354 enum dcerpc_AuthType auth_type;
355 enum dcerpc_AuthLevel auth_level;
356
357 /* Close any existing connections not at this level. */
358
359 binding_get_auth_info(binding, &auth_type, &auth_level, NULL);
360
361 for (tmp = cmd_list; tmp; tmp = tmp->next) {
362 struct cmd_set *tmp_set;
363
364 for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
365 if (tmp_set->rpc_pipe == NULL) {
366 continue;
367 }
368
369 if ((tmp_set->rpc_pipe->auth->auth_type
370 != auth_type)
371 || (tmp_set->rpc_pipe->auth->auth_level
372 != auth_level)) {
373 TALLOC_FREE(tmp_set->rpc_pipe);
374 tmp_set->rpc_pipe = NULL;
375 }
376 }
377 }
378 return NT_STATUS_OK;
379 }
380
381 static NTSTATUS cmd_set_transport(struct dcerpc_binding *b)
382 {
383 enum dcerpc_transport_t t = dcerpc_binding_get_transport(b);
384 struct cmd_list *tmp;
385
386 /* Close any existing connections not at this level. */
387
388 for (tmp = cmd_list; tmp; tmp = tmp->next) {
389 struct cmd_set *tmp_set;
390
391 for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
392 if (tmp_set->rpc_pipe == NULL) {
393 continue;
394 }
395
396 if (tmp_set->rpc_pipe->transport->transport != t) {
397 TALLOC_FREE(tmp_set->rpc_pipe);
398 tmp_set->rpc_pipe = NULL;
399 }
400 }
401 }
402 return NT_STATUS_OK;
403 }
404
405 static NTSTATUS binding_reset_auth(struct dcerpc_binding *b)
406 {
407 NTSTATUS status = dcerpc_binding_set_flags(
408 b,
409 0,
410 DCERPC_PACKET|
411 DCERPC_CONNECT|
412 DCERPC_SIGN|
413 DCERPC_SEAL|
414 DCERPC_SCHANNEL|
415 DCERPC_AUTH_SPNEGO|
416 DCERPC_AUTH_KRB5|
417 DCERPC_AUTH_NTLM);
418 return status;
419 }
420
421 static NTSTATUS binding_set_auth(
422 struct dcerpc_binding *b, const char *level, const char *type)
423 {
424 NTSTATUS status;
425
426 status = binding_reset_auth(b);
427 if (!NT_STATUS_IS_OK(status)) {
428 return status;
429 }
430
431 if (level != NULL) {
432 status = dcerpc_binding_set_string_option(b, level, level);
433 if (!NT_STATUS_IS_OK(status)) {
434 return status;
435 }
436 }
437
438 if (strequal(type, "SPNEGO")) {
439 status = dcerpc_binding_set_string_option(
440 b, "spnego", "spnego");
441 return status;
442 }
443 if (strequal(type, "NTLMSSP")) {
444 status = dcerpc_binding_set_string_option(b, "ntlm", "ntlm");
445 return status;
446 }
447 if (strequal(type, "NTLMSSP_SPNEGO")) {
448 status = dcerpc_binding_set_string_option(
449 b, "spnego", "spnego");
450 if (!NT_STATUS_IS_OK(status)) {
451 return status;
452 }
453 status = dcerpc_binding_set_string_option(b, "ntlm", "ntlm");
454 return status;
455 }
456 if (strequal(type, "KRB5")) {
457 status = dcerpc_binding_set_string_option(b, "krb5", "krb5");
458 return status;
459 }
460 if (strequal(type, "KRB5_SPNEGO")) {
461 status = dcerpc_binding_set_string_option(
462 b, "spnego", "spnego");
463 if (!NT_STATUS_IS_OK(status)) {
464 return status;
465 }
466 status = dcerpc_binding_set_string_option(b, "krb5", "krb5");
467 return status;
468 }
469 if (strequal(type, "SCHANNEL")) {
470 status = dcerpc_binding_set_string_option(
471 b, "schannel", "schannel");
472 return status;
473 }
474
475 return NT_STATUS_INVALID_PARAMETER;
476 }
477
478 static NTSTATUS cmd_set_auth(
479 struct dcerpc_binding *binding,
480 const char *level,
481 const char *display,
482 int argc,
483 const char **argv)
484 {
485 const char *p = "[KRB5|KRB5_SPNEGO|NTLMSSP|NTLMSSP_SPNEGO|SCHANNEL]";
486 const char *type = "NTLMSSP";
487 NTSTATUS status;
488
489 if (argc > 2) {
490 printf("Usage: %s %s\n", argv[0], p);
491 return NT_STATUS_OK;
492 }
493
494 if (argc == 2) {
495 type = argv[1];
496 }
497
498 status = binding_set_auth(binding, level, type);
499 if (!NT_STATUS_IS_OK(status)) {
500 printf("Usage: %s %s\n", argv[0], p);
501 return status;
502 }
503
504 d_printf("Setting %s - %s: %s\n", type, display, nt_errstr(status));
505
506 status = cmd_set_ss_level(binding);
507 return status;
508 }
509
510 static NTSTATUS cmd_sign(
511 struct dcerpc_binding *binding,
512 TALLOC_CTX *mem_ctx,
513 int argc,
514 const char **argv)
515 {
516 NTSTATUS status = cmd_set_auth(binding, "sign", "sign", argc, argv);
517 return status;
518 }
519
520 static NTSTATUS cmd_seal(
521 struct dcerpc_binding *binding,
522 TALLOC_CTX *mem_ctx,
523 int argc,
524 const char **argv)
525 {
526 NTSTATUS status = cmd_set_auth(
527 binding, "seal", "sign and seal", argc, argv);
528 return status;
529 }
530
531 static NTSTATUS cmd_packet(
532 struct dcerpc_binding *binding,
533 TALLOC_CTX *mem_ctx,
534 int argc,
535 const char **argv)
536 {
537 NTSTATUS status = cmd_set_auth(
538 binding, "packet", "packet", argc, argv);
539 return status;
540 }
541
542 static NTSTATUS cmd_timeout(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
543 int argc, const char **argv)
544 {
545 if (argc > 2) {
546 printf("Usage: %s timeout\n", argv[0]);
547 return NT_STATUS_OK;
548 }
549
550 if (argc == 2) {
551 timeout = atoi(argv[1]);
552 }
553
554 printf("timeout is %d\n", timeout);
555
556 return NT_STATUS_OK;
557 }
558
559
560 static NTSTATUS cmd_none(
561 struct dcerpc_binding *binding,
562 TALLOC_CTX *mem_ctx,
563 int argc,
564 const char **argv)
565 {
566 NTSTATUS status = binding_reset_auth(binding);
567 if (!NT_STATUS_IS_OK(status)) {
568 return status;
569 }
570 status = cmd_set_ss_level(binding);
571 return status;
572 }
573
574 static NTSTATUS cmd_schannel(
575 struct dcerpc_binding *binding,
576 TALLOC_CTX *mem_ctx,
577 int argc,
578 const char **_argv)
579 {
580 const char *argv[] = { "schannel", "SCHANNEL" };
581 NTSTATUS status = cmd_set_auth(
582 binding, "seal", "sign and seal", 2, argv);
583 return status;
584 }
585
586 static NTSTATUS cmd_schannel_sign(
587 struct dcerpc_binding *binding,
588 TALLOC_CTX *mem_ctx,
589 int argc,
590 const char **_argv)
591 {
592 const char *argv[] = { "schannel_sign", "SCHANNEL" };
593 NTSTATUS status = cmd_set_auth(binding, "sign", "sign only", 2, argv);
594 return status;
595 }
596
597 static NTSTATUS cmd_choose_transport(
598 struct dcerpc_binding *binding,
599 TALLOC_CTX *mem_ctx,
600 int argc,
601 const char **argv)
602 {
603 NTSTATUS status;
604 enum dcerpc_transport_t transport;
605
606 if (argc != 2) {
607 printf("Usage: %s [NCACN_NP|NCACN_IP_TCP]\n", argv[0]);
608 return NT_STATUS_OK;
609 }
610
611 transport = dcerpc_transport_by_name(argv[1]);
612 if (transport == NCA_UNKNOWN) {
613 printf("transport type %s unknown\n", argv[1]);
614 return NT_STATUS_NOT_SUPPORTED;
615 }
616 if (!((transport == NCACN_IP_TCP) ||
617 (transport == NCACN_NP) ||
618 (transport == NCALRPC))) {
619 printf("transport %s not supported\n", argv[1]);
620 return NT_STATUS_NOT_SUPPORTED;
621 }
622
623 status = dcerpc_binding_set_transport(binding, transport);
624 if (!NT_STATUS_IS_OK(status)) {
625 return status;
626 }
627
628 status = cmd_set_transport(binding);
629 if (!NT_STATUS_IS_OK(status)) {
630 return status;
631 }
632
633 printf("default transport is now: %s\n", argv[1]);
634
635 return NT_STATUS_OK;
636 }
637
638 /* Built in rpcclient commands */
639
640 static struct cmd_set rpcclient_commands[] = {
641
642 {
643 .name = "GENERAL OPTIONS",
644 },
645
646 {
647 .name = "help",
648 .returntype = RPC_RTYPE_NTSTATUS,
649 .ntfn = cmd_help,
650 .description = "Get help on commands",
651 .usage = "[command]",
652 },
653 {
654 .name = "?",
655 .returntype = RPC_RTYPE_NTSTATUS,
656 .ntfn = cmd_help,
657 .description = "Get help on commands",
658 .usage = "[command]",
659 },
660 {
661 .name = "debuglevel",
662 .returntype = RPC_RTYPE_NTSTATUS,
663 .ntfn = cmd_debuglevel,
664 .description = "Set debug level",
665 .usage = "level",
666 },
667 {
668 .name = "debug",
669 .returntype = RPC_RTYPE_NTSTATUS,
670 .ntfn = cmd_debuglevel,
671 .description = "Set debug level",
672 .usage = "level",
673 },
674 {
675 .name = "list",
676 .returntype = RPC_RTYPE_NTSTATUS,
677 .ntfn = cmd_listcommands,
678 .description = "List available commands on <pipe>",
679 .usage = "pipe",
680 },
681 {
682 .name = "exit",
683 .returntype = RPC_RTYPE_NTSTATUS,
684 .ntfn = cmd_quit,
685 .description = "Exit program",
686 .usage = "",
687 },
688 {
689 .name = "quit",
690 .returntype = RPC_RTYPE_NTSTATUS,
691 .ntfn = cmd_quit,
692 .description = "Exit program",
693 .usage = "",
694 },
695 {
696 .name = "sign",
697 .returntype = RPC_RTYPE_BINDING,
698 .bfn = cmd_sign,
699 .description = "Force RPC pipe connections to be signed",
700 .usage = "",
701 },
702 {
703 .name = "seal",
704 .returntype = RPC_RTYPE_BINDING,
705 .bfn = cmd_seal,
706 .description = "Force RPC pipe connections to be sealed",
707 .usage = "",
708 },
709 {
710 .name = "packet",
711 .returntype = RPC_RTYPE_BINDING,
712 .bfn = cmd_packet,
713 .description = "Force RPC pipe connections with packet authentication level",
714 .usage = "",
715 },
716 {
717 .name = "schannel",
718 .returntype = RPC_RTYPE_BINDING,
719 .bfn = cmd_schannel,
720 .description = "Force RPC pipe connections to be sealed with 'schannel'. "
721 "Assumes valid machine account to this domain controller.",
722 .usage = "",
723 },
724 {
725 .name = "schannelsign",
726 .returntype = RPC_RTYPE_BINDING,
727 .bfn = cmd_schannel_sign,
728 .description = "Force RPC pipe connections to be signed (not sealed) with "
729 "'schannel'. Assumes valid machine account to this domain "
730 "controller.",
731 .usage = "",
732 },
733 {
734 .name = "timeout",
735 .returntype = RPC_RTYPE_NTSTATUS,
736 .ntfn = cmd_timeout,
737 .description = "Set timeout (in milliseconds) for RPC operations",
738 .usage = "",
739 },
740 {
741 .name = "transport",
742 .returntype = RPC_RTYPE_BINDING,
743 .bfn = cmd_choose_transport,
744 .description = "Choose ncacn transport for RPC operations",
745 .usage = "",
746 },
747 {
748 .name = "none",
749 .returntype = RPC_RTYPE_BINDING,
750 .bfn = cmd_none,
751 .description = "Force RPC pipe connections to have no special properties",
752 .usage = "",
753 },
754
755 { .name = NULL, },
756 };
757
758 static struct cmd_set separator_command[] = {
759 {
760 .name = "---------------",
761 .returntype = MAX_RPC_RETURN_TYPE,
762 .description = "----------------------"
763 },
764 { .name = NULL, },
765 };
766
767
768 /* Various pipe commands */
769
770 extern struct cmd_set lsarpc_commands[];
771 extern struct cmd_set samr_commands[];
772 extern struct cmd_set spoolss_commands[];
773 extern struct cmd_set iremotewinspool_commands[];
774 extern struct cmd_set netlogon_commands[];
775 extern struct cmd_set srvsvc_commands[];
776 extern struct cmd_set dfs_commands[];
777 extern struct cmd_set ds_commands[];
778 extern struct cmd_set echo_commands[];
779 extern struct cmd_set epmapper_commands[];
780 extern struct cmd_set shutdown_commands[];
781 extern struct cmd_set wkssvc_commands[];
782 extern struct cmd_set ntsvcs_commands[];
783 extern struct cmd_set drsuapi_commands[];
784 extern struct cmd_set eventlog_commands[];
785 extern struct cmd_set winreg_commands[];
786 extern struct cmd_set fss_commands[];
787 extern struct cmd_set witness_commands[];
788 extern struct cmd_set clusapi_commands[];
789 extern struct cmd_set spotlight_commands[];
790 extern struct cmd_set unixinfo_commands[];
791
792 static struct cmd_set *rpcclient_command_list[] = {
793 rpcclient_commands,
794 lsarpc_commands,
795 ds_commands,
796 samr_commands,
797 spoolss_commands,
798 iremotewinspool_commands,
799 netlogon_commands,
800 srvsvc_commands,
801 dfs_commands,
802 echo_commands,
803 epmapper_commands,
804 shutdown_commands,
805 wkssvc_commands,
806 ntsvcs_commands,
807 drsuapi_commands,
808 eventlog_commands,
809 winreg_commands,
810 fss_commands,
811 witness_commands,
812 clusapi_commands,
813 spotlight_commands,
814 unixinfo_commands,
815 NULL
816 };
817
818 static void add_command_set(struct cmd_set *cmd_set)
819 {
820 struct cmd_list *entry;
821
822 if (!(entry = SMB_MALLOC_P(struct cmd_list))) {
823 DEBUG(0, ("out of memory\n"));
824 return;
825 }
826
827 ZERO_STRUCTP(entry);
828
829 entry->cmd_set = cmd_set;
830 DLIST_ADD(cmd_list, entry);
831 }
832
833 static NTSTATUS rpccli_ncalrpc_connect(
834 const struct ndr_interface_table *iface,
835 TALLOC_CTX *mem_ctx,
836 struct rpc_pipe_client **prpccli)
837 {
838 struct rpc_pipe_client *rpccli = NULL;
839 struct pipe_auth_data *auth = NULL;
840 NTSTATUS status;
841
842 status = rpc_pipe_open_ncalrpc(mem_ctx, iface, &rpccli);
843 if (!NT_STATUS_IS_OK(status)) {
844 DBG_DEBUG("rpc_pipe_open_ncalrpc failed: %s\n",
845 nt_errstr(status));
846 goto fail;
847 }
848
849 status = rpccli_ncalrpc_bind_data(rpccli, &auth);
850 if (!NT_STATUS_IS_OK(status)) {
851 DBG_DEBUG("rpccli_ncalrpc_bind_data failed: %s\n",
852 nt_errstr(status));
853 goto fail;
854 }
855
856 status = rpc_pipe_bind(rpccli, auth);
857 if (!NT_STATUS_IS_OK(status)) {
858 DBG_DEBUG("rpc_pipe_bind failed: %s\n", nt_errstr(status));
859 goto fail;
860 }
861
862 *prpccli = rpccli;
863 return NT_STATUS_OK;
864 fail:
865 TALLOC_FREE(rpccli);
866 return status;
867 }
868 /**
869 * Call an rpcclient function, passing an argv array.
870 *
871 * @param cmd Command to run, as a single string.
872 **/
873 static NTSTATUS do_cmd(struct cli_state *cli,
874 struct cli_credentials *creds,
875 struct cmd_set *cmd_entry,
876 struct dcerpc_binding *binding,
877 int argc, const char **argv)
878 {
879 NTSTATUS ntresult;
880 WERROR wresult;
881 enum dcerpc_transport_t transport;
882
883 TALLOC_CTX *mem_ctx = talloc_stackframe();
884 const char *remote_name = NULL;
885 const struct sockaddr_storage *remote_sockaddr = NULL;
886 struct sockaddr_storage remote_ss = {
887 .ss_family = AF_UNSPEC,
888 };
889
890 transport = dcerpc_binding_get_transport(binding);
891
892 if (cli != NULL) {
893 remote_name = smbXcli_conn_remote_name(cli->conn);
894 remote_sockaddr = smbXcli_conn_remote_sockaddr(cli->conn);
895 } else {
896 const char *remote_host =
897 dcerpc_binding_get_string_option(binding, "host");
898 remote_name = dcerpc_binding_get_string_option(
899 binding, "target_hostname");
900
901 if (remote_host != NULL) {
902 bool ok = interpret_string_addr(
903 &remote_ss, remote_host, 0);
904 if (ok) {
905 remote_sockaddr = &remote_ss;
906 }
907 }
908 }
909
910 /* Open pipe */
911
912 if ((cmd_entry->table != NULL) && (cmd_entry->rpc_pipe == NULL)) {
913 if (transport == NCALRPC) {
914 ntresult = rpccli_ncalrpc_connect(
915 cmd_entry->table, cli, &cmd_entry->rpc_pipe);
916 if (!NT_STATUS_IS_OK(ntresult)) {
917 TALLOC_FREE(mem_ctx);
918 return ntresult;
919 }
920 } else {
921 enum dcerpc_AuthType auth_type;
922 enum dcerpc_AuthLevel auth_level;
923 enum credentials_use_kerberos krb5_state =
924 cli_credentials_get_kerberos_state(creds);
925
926 binding_get_auth_info(
927 binding, &auth_type, &auth_level, &krb5_state);
928
929 switch (auth_type) {
930 case DCERPC_AUTH_TYPE_NONE:
931 ntresult = cli_rpc_pipe_open_noauth_transport(
932 cli, transport,
933 cmd_entry->table,
934 remote_name,
935 remote_sockaddr,
936 &cmd_entry->rpc_pipe);
937 break;
938 case DCERPC_AUTH_TYPE_SPNEGO:
939 case DCERPC_AUTH_TYPE_NTLMSSP:
940 case DCERPC_AUTH_TYPE_KRB5:
941 cli_credentials_set_kerberos_state(creds,
942 krb5_state,
943 CRED_SPECIFIED);
944
945 ntresult = cli_rpc_pipe_open_with_creds(
946 cli, cmd_entry->table,
947 transport,
948 auth_type,
949 auth_level,
950 remote_name,
951 remote_sockaddr,
952 creds,
953 &cmd_entry->rpc_pipe);
954 break;
955 case DCERPC_AUTH_TYPE_SCHANNEL:
956 TALLOC_FREE(rpcclient_netlogon_creds);
957 ntresult = cli_rpc_pipe_open_schannel(
958 cli, rpcclient_msg_ctx,
959 cmd_entry->table,
960 transport,
961 rpcclient_netlogon_domain,
962 remote_name,
963 remote_sockaddr,
964 &cmd_entry->rpc_pipe,
965 rpcclient_msg_ctx,
966 &rpcclient_netlogon_creds);
967 break;
968 default:
969 DEBUG(0, ("Could not initialise %s. Invalid "
970 "auth type %u\n",
971 cmd_entry->table->name,
972 auth_type ));
973 talloc_free(mem_ctx);
974 return NT_STATUS_UNSUCCESSFUL;
975 }
976 if (!NT_STATUS_IS_OK(ntresult)) {
977 DBG_ERR("Could not initialise %s. "
978 "Error was %s\n",
979 cmd_entry->table->name,
980 nt_errstr(ntresult));
981 talloc_free(mem_ctx);
982 return ntresult;
983 }
984
985 if (rpcclient_netlogon_creds == NULL &&
986 cmd_entry->use_netlogon_creds) {
987 const char *dc_name =
988 cmd_entry->rpc_pipe->desthost;
989 const char *domain = rpcclient_netlogon_domain;
990 struct cli_credentials *trust_creds = NULL;
991
992 ntresult = pdb_get_trust_credentials(
993 domain,
994 NULL,
995 mem_ctx,
996 &trust_creds);
997 if (!NT_STATUS_IS_OK(ntresult)) {
998 DBG_ERR("Failed to fetch trust "
999 "credentials for "
1000 "%s to connect to %s: %s\n",
1001 domain,
1002 cmd_entry->table->name,
1003 nt_errstr(ntresult));
1004 TALLOC_FREE(cmd_entry->rpc_pipe);
1005 talloc_free(mem_ctx);
1006 return ntresult;
1007 }
1008
1009 ntresult = rpccli_create_netlogon_creds_ctx(
1010 trust_creds,
1011 dc_name,
1012 rpcclient_msg_ctx,
1013 rpcclient_msg_ctx,
1014 &rpcclient_netlogon_creds);
1015 if (!NT_STATUS_IS_OK(ntresult)) {
1016 DBG_ERR("Could not initialise "
1017 "credentials for %s.\n",
1018 cmd_entry->table->name);
1019 TALLOC_FREE(cmd_entry->rpc_pipe);
1020 TALLOC_FREE(mem_ctx);
1021 return ntresult;
1022 }
1023
1024 ntresult = rpccli_setup_netlogon_creds(
1025 cli,
1026 NCACN_NP,
1027 rpcclient_netlogon_creds,
1028 false, /* force_reauth */
1029 trust_creds);
1030 TALLOC_FREE(trust_creds);
1031 if (!NT_STATUS_IS_OK(ntresult)) {
1032 DBG_ERR("Could not initialise "
1033 "credentials for %s.\n",
1034 cmd_entry->table->name);
1035 TALLOC_FREE(cmd_entry->rpc_pipe);
1036 TALLOC_FREE(rpcclient_netlogon_creds);
1037 TALLOC_FREE(mem_ctx);
1038 return ntresult;
1039 }
1040 }
1041 }
1042 }
1043
1044 /* Set timeout for new connections */
1045 if (cmd_entry->rpc_pipe) {
1046 rpccli_set_timeout(cmd_entry->rpc_pipe, timeout);
1047 }
1048
1049 /* Run command */
1050
1051 if ( cmd_entry->returntype == RPC_RTYPE_NTSTATUS ) {
1052 ntresult = cmd_entry->ntfn(cmd_entry->rpc_pipe, mem_ctx, argc, argv);
1053 if (!NT_STATUS_IS_OK(ntresult)) {
1054 printf("result was %s\n", nt_errstr(ntresult));
1055 }
1056 } else if (cmd_entry->returntype == RPC_RTYPE_BINDING) {
1057 ntresult = cmd_entry->bfn(binding, mem_ctx, argc, argv);
1058 if (!NT_STATUS_IS_OK(ntresult)) {
1059 printf("result was %s\n", nt_errstr(ntresult));
1060 }
1061 } else {
1062 wresult = cmd_entry->wfn(cmd_entry->rpc_pipe, mem_ctx, argc, argv);
1063 /* print out the DOS error */
1064 if (!W_ERROR_IS_OK(wresult)) {
1065 printf( "result was %s\n", win_errstr(wresult));
1066 }
1067 ntresult = W_ERROR_IS_OK(wresult)?NT_STATUS_OK:NT_STATUS_UNSUCCESSFUL;
1068 }
1069
1070 /* Cleanup */
1071
1072 talloc_free(mem_ctx);
1073
1074 return ntresult;
1075 }
1076
1077
1078 /**
1079 * Process a command entered at the prompt or as part of -c
1080 *
1081 * @returns The NTSTATUS from running the command.
1082 **/
1083 static NTSTATUS process_cmd(struct cli_credentials *creds,
1084 struct cli_state *cli,
1085 struct dcerpc_binding *binding,
1086 char *cmd)
1087 {
1088 struct cmd_list *temp_list;
1089 NTSTATUS result = NT_STATUS_OK;
1090 int ret;
1091 int argc;
1092 const char **argv = NULL;
1093
1094 if ((ret = poptParseArgvString(cmd, &argc, &argv)) != 0) {
1095 fprintf(stderr, "rpcclient: %s\n", poptStrerror(ret));
1096 return NT_STATUS_UNSUCCESSFUL;
1097 }
1098
1099
1100 /* Walk through a dlist of arrays of commands. */
1101 for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) {
1102 struct cmd_set *set = temp_list->cmd_set;
1103
1104 while (set->name != NULL) {
1105 if (!strequal(argv[0], set->name)) {
1106 set += 1;
1107 continue;
1108 }
1109
1110 if (((set->returntype == RPC_RTYPE_NTSTATUS) &&
1111 (set->ntfn == NULL)) ||
1112 ((set->returntype == RPC_RTYPE_WERROR) &&
1113 (set->wfn == NULL)) ||
1114 ((set->returntype == RPC_RTYPE_BINDING) &&
1115 (set->bfn == NULL))) {
1116 fprintf (stderr, "Invalid command\n");
1117 goto out_free;
1118 }
1119
1120 result = do_cmd(
1121 cli, creds, set, binding, argc, argv);
1122 goto out_free;
1123 }
1124 }
1125
1126 if (argv[0]) {
1127 printf("command not found: %s\n", argv[0]);
1128 }
1129
1130 out_free:
1131 /* moved to do_cmd()
1132 if (!NT_STATUS_IS_OK(result)) {
1133 printf("result was %s\n", nt_errstr(result));
1134 }
1135 */
1136
1137 /* NOTE: popt allocates the whole argv, including the
1138 * strings, as a single block. So a single free is
1139 * enough to release it -- we don't free the
1140 * individual strings. rtfm. */
1141 free(argv);
1142
1143 return result;
1144 }
1145
1146
1147 /* Main function */
1148
1149 int main(int argc, char *argv[])
1150 {
1151 const char **const_argv = discard_const_p(const char *, argv);
1152 int opt;
1153 static char *cmdstr = NULL;
1154 const char *server;
1155 struct cli_state *cli = NULL;
1156 static char *opt_ipaddr=NULL;
1157 struct cmd_set **cmd_set;
1158 struct sockaddr_storage server_ss;
1159 NTSTATUS nt_status;
1160 static int opt_port = 0;
1161 int result = 0;
1162 TALLOC_CTX *frame = talloc_stackframe();
1163 uint32_t flags = CLI_FULL_CONNECTION_IPC;
1164 struct dcerpc_binding *binding = NULL;
1165 enum dcerpc_transport_t transport;
1166 const char *binding_string = NULL;
1167 const char *host;
1168 struct cli_credentials *creds = NULL;
1169 struct loadparm_context *lp_ctx = NULL;
1170 bool ok;
1171
1172 /* make sure the vars that get altered (4th field) are in
1173 a fixed location or certain compilers complain */
1174 poptContext pc;
1175 struct poptOption long_options[] = {
1176 POPT_AUTOHELP
1177 {"command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated cmds", "COMMANDS"},
1178 {"dest-ip", 'I', POPT_ARG_STRING, &opt_ipaddr, 'I', "Specify destination IP address", "IP"},
1179 {"port", 'p', POPT_ARG_INT, &opt_port, 'p', "Specify port number", "PORT"},
1180 POPT_COMMON_SAMBA
1181 POPT_COMMON_CONNECTION
1182 POPT_COMMON_CREDENTIALS
1183 POPT_LEGACY_S3
1184 POPT_COMMON_VERSION
1185 POPT_TABLEEND
1186 };
1187
1188 smb_init_locale();
1189
1190 zero_sockaddr(&server_ss);
1191
1192 setlinebuf(stdout);
1193
1194 ok = samba_cmdline_init(frame,
1195 SAMBA_CMDLINE_CONFIG_CLIENT,
1196 false /* require_smbconf */);
1197 if (!ok) {
1198 DBG_ERR("Failed to init cmdline parser!\n");
1199 }
1200 lp_ctx = samba_cmdline_get_lp_ctx();
1201 lpcfg_set_cmdline(lp_ctx, "log level", "0");
1202
1203 /* Parse options */
1204 pc = samba_popt_get_context(getprogname(),
1205 argc,
1206 const_argv,
1207 long_options,
1208 0);
1209 if (pc == NULL) {
1210 DBG_ERR("Failed to setup popt context!\n");
1211 exit(1);
1212 }
1213
1214 poptSetOtherOptionHelp(pc, "[OPTION...] BINDING-STRING|HOST\nOptions:");
1215
1216 if (argc == 1) {
1217 poptPrintHelp(pc, stderr, 0);
1218 goto done;
1219 }
1220
1221 while((opt = poptGetNextOpt(pc)) != -1) {
1222 switch (opt) {
1223
1224 case 'I':
1225 if (!interpret_string_addr(&server_ss,
1226 opt_ipaddr,
1227 AI_NUMERICHOST)) {
1228 fprintf(stderr, "%s not a valid IP address\n",
1229 opt_ipaddr);
1230 result = 1;
1231 goto done;
1232 }
1233 break;
1234 case POPT_ERROR_BADOPT:
1235 fprintf(stderr, "\nInvalid option %s: %s\n\n",
1236 poptBadOption(pc, 0), poptStrerror(opt));
1237 poptPrintUsage(pc, stderr, 0);
1238 exit(1);
1239 }
1240 }
1241
1242 /* Get server as remaining unparsed argument. Print usage if more
1243 than one unparsed argument is present. */
1244
1245 server = talloc_strdup(frame, poptGetArg(pc));
1246
1247 if (!server || poptGetArg(pc)) {
1248 poptPrintHelp(pc, stderr, 0);
1249 result = 1;
1250 goto done;
1251 }
1252
1253 poptFreeContext(pc);
1254 samba_cmdline_burn(argc, argv);
1255
1256 rpcclient_msg_ctx = cmdline_messaging_context(get_dyn_CONFIGFILE());
1257 creds = samba_cmdline_get_creds();
1258
1259 /*
1260 * Get password
1261 * from stdin if necessary
1262 */
1263
1264 if ((server[0] == '/' && server[1] == '/') ||
1265 (server[0] == '\\' && server[1] == '\\')) {
1266 server += 2;
1267 }
1268
1269 nt_status = dcerpc_parse_binding(frame, server, &binding);
1270
1271 if (!NT_STATUS_IS_OK(nt_status)) {
1272
1273 binding_string = talloc_asprintf(frame, "ncacn_np:%s",
1274 strip_hostname(server));
1275 if (!binding_string) {
1276 result = 1;
1277 goto done;
1278 }
1279
1280 nt_status = dcerpc_parse_binding(frame, binding_string, &binding);
1281 if (!NT_STATUS_IS_OK(nt_status)) {
1282 result = -1;
1283 goto done;
1284 }
1285 }
1286
1287 transport = dcerpc_binding_get_transport(binding);
1288
1289 if (transport == NCA_UNKNOWN) {
1290 transport = NCACN_NP;
1291 nt_status = dcerpc_binding_set_transport(binding, transport);
1292 if (!NT_STATUS_IS_OK(nt_status)) {
1293 result = -1;
1294 goto done;
1295 }
1296 }
1297
1298 host = dcerpc_binding_get_string_option(binding, "host");
1299
1300 rpcclient_netlogon_domain = cli_credentials_get_domain(creds);
1301 if (rpcclient_netlogon_domain == NULL ||
1302 rpcclient_netlogon_domain[0] == '\0')
1303 {
1304 rpcclient_netlogon_domain = lp_workgroup();
1305 }
1306
1307 if (transport == NCACN_NP) {
1308 nt_status = cli_full_connection_creds(
1309 &cli,
1310 lp_netbios_name(),
1311 host,
1312 opt_ipaddr ? &server_ss : NULL,
1313 opt_port,
1314 "IPC$",
1315 "IPC",
1316 creds,
1317 flags);
1318
1319 if (!NT_STATUS_IS_OK(nt_status)) {
1320 DEBUG(0, ("Cannot connect to server. Error was %s\n",
1321 nt_errstr(nt_status)));
1322 result = 1;
1323 goto done;
1324 }
1325
1326 /* Load command lists */
1327 cli_set_timeout(cli, timeout);
1328 }
1329
1330 #if 0 /* COMMENT OUT FOR TESTING */
1331 memset(cmdline_auth_info.password,'X',sizeof(cmdline_auth_info.password));
1332 #endif
1333
1334 cmd_set = rpcclient_command_list;
1335
1336 while(*cmd_set) {
1337 add_command_set(*cmd_set);
1338 add_command_set(separator_command);
1339 cmd_set++;
1340 }
1341
1342 /* Do anything specified with -c */
1343 if (cmdstr && cmdstr[0]) {
1344 char *cmd;
1345 char *p = cmdstr;
1346
1347 result = 0;
1348
1349 while((cmd=next_command(&p)) != NULL) {
1350 NTSTATUS cmd_result = process_cmd(creds,
1351 cli,
1352 binding,
1353 cmd);
1354 SAFE_FREE(cmd);
1355 result = NT_STATUS_IS_ERR(cmd_result);
1356 }
1357
1358 goto done;
1359 }
1360
1361 /* Loop around accepting commands */
1362
1363 while(1) {
1364 char *line = NULL;
1365
1366 line = smb_readline("rpcclient $> ", NULL, completion_fn);
1367
1368 if (line == NULL) {
1369 printf("\n");
1370 break;
1371 }
1372
1373 if (line[0] != '\n')
1374 process_cmd(creds,
1375 cli,
1376 binding,
1377 line);
1378 SAFE_FREE(line);
1379 }
1380
1381 done:
1382 if (cli != NULL) {
1383 cli_shutdown(cli);
1384 }
1385 netlogon_creds_cli_close_global_db();
1386 TALLOC_FREE(rpcclient_msg_ctx);
1387 TALLOC_FREE(frame);
1388 return result;
1389 }
Samba GIT mirror