2 Unix SMB/CIFS implementation.
5 Copyright (C) Tim Potter 2000-2001
6 Copyright (C) Martin Pool 2003
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.
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.
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/>.
23 #include "popt_common.h"
24 #include "rpcclient.h"
25 #include "../libcli/auth/libcli_auth.h"
26 #include "../librpc/gen_ndr/cli_lsa.h"
27 #include "rpc_client/cli_lsarpc.h"
28 #include "../librpc/gen_ndr/ndr_netlogon.h"
29 #include "rpc_client/cli_netlogon.h"
31 struct dom_sid domain_sid;
33 static enum dcerpc_AuthType pipe_default_auth_type = DCERPC_AUTH_TYPE_NONE;
34 static enum pipe_auth_type_spnego pipe_default_auth_spnego_type = 0;
35 static enum dcerpc_AuthLevel pipe_default_auth_level = DCERPC_AUTH_LEVEL_NONE;
36 static unsigned int timeout = 0;
37 static enum dcerpc_transport_t default_transport = NCACN_NP;
39 struct user_auth_info *rpcclient_auth_info;
41 /* List to hold groups of commands.
43 * Commands are defined in a list of arrays: arrays are easy to
44 * statically declare, and lists are easier to dynamically extend.
47 static struct cmd_list {
48 struct cmd_list *prev, *next;
49 struct cmd_set *cmd_set;
52 /****************************************************************************
53 handle completion of commands for readline
54 ****************************************************************************/
55 static char **completion_fn(const char *text, int start, int end)
57 #define MAX_COMPLETIONS 100
60 struct cmd_list *commands = cmd_list;
63 /* FIXME!!! -- what to do when completing argument? */
64 /* for words not at the start of the line fallback
65 to filename completion */
70 /* make sure we have a list of valid commands */
75 matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
80 matches[count++] = SMB_STRDUP(text);
86 while (commands && count < MAX_COMPLETIONS-1) {
87 if (!commands->cmd_set) {
91 for (i=0; commands->cmd_set[i].name; i++) {
92 if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) &&
93 (( commands->cmd_set[i].returntype == RPC_RTYPE_NTSTATUS &&
94 commands->cmd_set[i].ntfn ) ||
95 ( commands->cmd_set[i].returntype == RPC_RTYPE_WERROR &&
96 commands->cmd_set[i].wfn))) {
97 matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
98 if (!matches[count]) {
99 for (i = 0; i < count; i++) {
100 SAFE_FREE(matches[count]);
108 commands = commands->next;
112 SAFE_FREE(matches[0]);
113 matches[0] = SMB_STRDUP(matches[1]);
115 matches[count] = NULL;
119 static char *next_command (char **cmdstr)
124 if (!cmdstr || !(*cmdstr))
127 p = strchr_m(*cmdstr, ';');
130 command = SMB_STRDUP(*cmdstr);
139 /* Fetch the SID for this computer */
141 static void fetch_machine_sid(struct cli_state *cli)
143 struct policy_handle pol;
144 NTSTATUS result = NT_STATUS_OK;
145 static bool got_domain_sid;
147 struct rpc_pipe_client *lsapipe = NULL;
148 union lsa_PolicyInformation *info = NULL;
150 if (got_domain_sid) return;
152 if (!(mem_ctx=talloc_init("fetch_machine_sid"))) {
153 DEBUG(0,("fetch_machine_sid: talloc_init returned NULL!\n"));
157 result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
159 if (!NT_STATUS_IS_OK(result)) {
160 fprintf(stderr, "could not initialise lsa pipe. Error was %s\n", nt_errstr(result) );
164 result = rpccli_lsa_open_policy(lsapipe, mem_ctx, True,
165 SEC_FLAG_MAXIMUM_ALLOWED,
167 if (!NT_STATUS_IS_OK(result)) {
171 result = rpccli_lsa_QueryInfoPolicy(lsapipe, mem_ctx,
173 LSA_POLICY_INFO_ACCOUNT_DOMAIN,
175 if (!NT_STATUS_IS_OK(result)) {
179 got_domain_sid = True;
180 sid_copy(&domain_sid, info->account_domain.sid);
182 rpccli_lsa_Close(lsapipe, mem_ctx, &pol);
183 TALLOC_FREE(lsapipe);
184 talloc_destroy(mem_ctx);
191 TALLOC_FREE(lsapipe);
194 fprintf(stderr, "could not obtain sid for domain %s\n", cli->domain);
196 if (!NT_STATUS_IS_OK(result)) {
197 fprintf(stderr, "error: %s\n", nt_errstr(result));
203 /* List the available commands on a given pipe */
205 static NTSTATUS cmd_listcommands(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
206 int argc, const char **argv)
208 struct cmd_list *tmp;
209 struct cmd_set *tmp_set;
215 printf("Usage: %s <pipe>\n", argv[0]);
219 /* Help on one command */
221 for (tmp = cmd_list; tmp; tmp = tmp->next)
223 tmp_set = tmp->cmd_set;
225 if (!StrCaseCmp(argv[1], tmp_set->name))
227 printf("Available commands on the %s pipe:\n\n", tmp_set->name);
231 while(tmp_set->name) {
232 printf("%30s", tmp_set->name);
239 /* drop out of the loop */
248 /* Display help on commands */
250 static NTSTATUS cmd_help(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
251 int argc, const char **argv)
253 struct cmd_list *tmp;
254 struct cmd_set *tmp_set;
259 printf("Usage: %s [command]\n", argv[0]);
263 /* Help on one command */
266 for (tmp = cmd_list; tmp; tmp = tmp->next) {
268 tmp_set = tmp->cmd_set;
270 while(tmp_set->name) {
271 if (strequal(argv[1], tmp_set->name)) {
272 if (tmp_set->usage &&
274 printf("%s\n", tmp_set->usage);
276 printf("No help for %s\n", tmp_set->name);
285 printf("No such command: %s\n", argv[1]);
289 /* List all commands */
291 for (tmp = cmd_list; tmp; tmp = tmp->next) {
293 tmp_set = tmp->cmd_set;
295 while(tmp_set->name) {
297 printf("%15s\t\t%s\n", tmp_set->name,
298 tmp_set->description ? tmp_set->description:
308 /* Change the debug level */
310 static NTSTATUS cmd_debuglevel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
311 int argc, const char **argv)
314 printf("Usage: %s [debuglevel]\n", argv[0]);
319 DEBUGLEVEL = atoi(argv[1]);
322 printf("debuglevel is %d\n", DEBUGLEVEL);
327 static NTSTATUS cmd_quit(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
328 int argc, const char **argv)
331 return NT_STATUS_OK; /* NOTREACHED */
334 static NTSTATUS cmd_set_ss_level(void)
336 struct cmd_list *tmp;
338 /* Close any existing connections not at this level. */
340 for (tmp = cmd_list; tmp; tmp = tmp->next) {
341 struct cmd_set *tmp_set;
343 for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
344 if (tmp_set->rpc_pipe == NULL) {
348 if ((tmp_set->rpc_pipe->auth->auth_type
349 != pipe_default_auth_type)
350 || (tmp_set->rpc_pipe->auth->auth_level
351 != pipe_default_auth_level)) {
352 TALLOC_FREE(tmp_set->rpc_pipe);
353 tmp_set->rpc_pipe = NULL;
360 static NTSTATUS cmd_set_transport(void)
362 struct cmd_list *tmp;
364 /* Close any existing connections not at this level. */
366 for (tmp = cmd_list; tmp; tmp = tmp->next) {
367 struct cmd_set *tmp_set;
369 for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
370 if (tmp_set->rpc_pipe == NULL) {
374 if (tmp_set->rpc_pipe->transport->transport != default_transport) {
375 TALLOC_FREE(tmp_set->rpc_pipe);
376 tmp_set->rpc_pipe = NULL;
383 static NTSTATUS cmd_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
384 int argc, const char **argv)
386 const char *p = "[KRB5|KRB5_SPNEGO|NTLMSSP|NTLMSSP_SPNEGO|SCHANNEL]";
387 const char *type = "NTLMSSP";
389 pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
390 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
393 printf("Usage: %s %s\n", argv[0], p);
399 if (strequal(type, "KRB5")) {
400 pipe_default_auth_type = DCERPC_AUTH_TYPE_KRB5;
401 } else if (strequal(type, "KRB5_SPNEGO")) {
402 pipe_default_auth_type = DCERPC_AUTH_TYPE_SPNEGO;
403 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_KRB5;
404 } else if (strequal(type, "NTLMSSP")) {
405 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
406 } else if (strequal(type, "NTLMSSP_SPNEGO")) {
407 pipe_default_auth_type = DCERPC_AUTH_TYPE_SPNEGO;
408 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
409 } else if (strequal(type, "SCHANNEL")) {
410 pipe_default_auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
412 printf("unknown type %s\n", type);
413 printf("Usage: %s %s\n", argv[0], p);
414 return NT_STATUS_INVALID_LEVEL;
418 d_printf("Setting %s - sign\n", type);
420 return cmd_set_ss_level();
423 static NTSTATUS cmd_seal(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
424 int argc, const char **argv)
426 const char *p = "[KRB5|KRB5_SPNEGO|NTLMSSP|NTLMSSP_SPNEGO|SCHANNEL]";
427 const char *type = "NTLMSSP";
429 pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
430 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
433 printf("Usage: %s %s\n", argv[0], p);
439 if (strequal(type, "KRB5")) {
440 pipe_default_auth_type = DCERPC_AUTH_TYPE_KRB5;
441 } else if (strequal(type, "KRB5_SPNEGO")) {
442 pipe_default_auth_type = DCERPC_AUTH_TYPE_SPNEGO;
443 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_KRB5;
444 } else if (strequal(type, "NTLMSSP")) {
445 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
446 } else if (strequal(type, "NTLMSSP_SPNEGO")) {
447 pipe_default_auth_type = DCERPC_AUTH_TYPE_SPNEGO;
448 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
449 } else if (strequal(type, "SCHANNEL")) {
450 pipe_default_auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
452 printf("unknown type %s\n", type);
453 printf("Usage: %s %s\n", argv[0], p);
454 return NT_STATUS_INVALID_LEVEL;
458 d_printf("Setting %s - sign and seal\n", type);
460 return cmd_set_ss_level();
463 static NTSTATUS cmd_timeout(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
464 int argc, const char **argv)
466 struct cmd_list *tmp;
469 printf("Usage: %s timeout\n", argv[0]);
474 timeout = atoi(argv[1]);
476 for (tmp = cmd_list; tmp; tmp = tmp->next) {
478 struct cmd_set *tmp_set;
480 for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
481 if (tmp_set->rpc_pipe == NULL) {
485 rpccli_set_timeout(tmp_set->rpc_pipe, timeout);
490 printf("timeout is %d\n", timeout);
496 static NTSTATUS cmd_none(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
497 int argc, const char **argv)
499 pipe_default_auth_level = DCERPC_AUTH_LEVEL_NONE;
500 pipe_default_auth_type = DCERPC_AUTH_TYPE_NONE;
501 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NONE;
503 return cmd_set_ss_level();
506 static NTSTATUS cmd_schannel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
507 int argc, const char **argv)
509 d_printf("Setting schannel - sign and seal\n");
510 pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
511 pipe_default_auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
513 return cmd_set_ss_level();
516 static NTSTATUS cmd_schannel_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
517 int argc, const char **argv)
519 d_printf("Setting schannel - sign only\n");
520 pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
521 pipe_default_auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
523 return cmd_set_ss_level();
526 static NTSTATUS cmd_choose_transport(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
527 int argc, const char **argv)
532 printf("Usage: %s [NCACN_NP|NCACN_IP_TCP]\n", argv[0]);
536 if (strequal(argv[1], "NCACN_NP")) {
537 default_transport = NCACN_NP;
538 } else if (strequal(argv[1], "NCACN_IP_TCP")) {
539 default_transport = NCACN_IP_TCP;
541 printf("transport type: %s unknown or not supported\n", argv[1]);
542 return NT_STATUS_NOT_SUPPORTED;
545 status = cmd_set_transport();
546 if (!NT_STATUS_IS_OK(status)) {
550 printf("default transport is now: %s\n", argv[1]);
555 /* Built in rpcclient commands */
557 static struct cmd_set rpcclient_commands[] = {
559 { "GENERAL OPTIONS" },
561 { "help", RPC_RTYPE_NTSTATUS, cmd_help, NULL, NULL, NULL, "Get help on commands", "[command]" },
562 { "?", RPC_RTYPE_NTSTATUS, cmd_help, NULL, NULL, NULL, "Get help on commands", "[command]" },
563 { "debuglevel", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, NULL, NULL, "Set debug level", "level" },
564 { "debug", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, NULL, NULL, "Set debug level", "level" },
565 { "list", RPC_RTYPE_NTSTATUS, cmd_listcommands, NULL, NULL, NULL, "List available commands on <pipe>", "pipe" },
566 { "exit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, NULL, NULL, "Exit program", "" },
567 { "quit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, NULL, NULL, "Exit program", "" },
568 { "sign", RPC_RTYPE_NTSTATUS, cmd_sign, NULL, NULL, NULL, "Force RPC pipe connections to be signed", "" },
569 { "seal", RPC_RTYPE_NTSTATUS, cmd_seal, NULL, NULL, NULL, "Force RPC pipe connections to be sealed", "" },
570 { "schannel", RPC_RTYPE_NTSTATUS, cmd_schannel, NULL, NULL, NULL, "Force RPC pipe connections to be sealed with 'schannel'. Assumes valid machine account to this domain controller.", "" },
571 { "schannelsign", RPC_RTYPE_NTSTATUS, cmd_schannel_sign, NULL, NULL, NULL, "Force RPC pipe connections to be signed (not sealed) with 'schannel'. Assumes valid machine account to this domain controller.", "" },
572 { "timeout", RPC_RTYPE_NTSTATUS, cmd_timeout, NULL, NULL, NULL, "Set timeout (in milliseonds) for RPC operations", "" },
573 { "transport", RPC_RTYPE_NTSTATUS, cmd_choose_transport, NULL, NULL, NULL, "Choose ncacn transport for RPC operations", "" },
574 { "none", RPC_RTYPE_NTSTATUS, cmd_none, NULL, NULL, NULL, "Force RPC pipe connections to have no special properties", "" },
579 static struct cmd_set separator_command[] = {
580 { "---------------", MAX_RPC_RETURN_TYPE, NULL, NULL, NULL, NULL, "----------------------" },
585 /* Various pipe commands */
587 extern struct cmd_set lsarpc_commands[];
588 extern struct cmd_set samr_commands[];
589 extern struct cmd_set spoolss_commands[];
590 extern struct cmd_set netlogon_commands[];
591 extern struct cmd_set srvsvc_commands[];
592 extern struct cmd_set dfs_commands[];
593 extern struct cmd_set ds_commands[];
594 extern struct cmd_set echo_commands[];
595 extern struct cmd_set epmapper_commands[];
596 extern struct cmd_set shutdown_commands[];
597 extern struct cmd_set test_commands[];
598 extern struct cmd_set wkssvc_commands[];
599 extern struct cmd_set ntsvcs_commands[];
600 extern struct cmd_set drsuapi_commands[];
601 extern struct cmd_set eventlog_commands[];
603 static struct cmd_set *rpcclient_command_list[] = {
623 static void add_command_set(struct cmd_set *cmd_set)
625 struct cmd_list *entry;
627 if (!(entry = SMB_MALLOC_P(struct cmd_list))) {
628 DEBUG(0, ("out of memory\n"));
634 entry->cmd_set = cmd_set;
635 DLIST_ADD(cmd_list, entry);
640 * Call an rpcclient function, passing an argv array.
642 * @param cmd Command to run, as a single string.
644 static NTSTATUS do_cmd(struct cli_state *cli,
645 struct user_auth_info *auth_info,
646 struct cmd_set *cmd_entry,
647 struct dcerpc_binding *binding,
648 int argc, char **argv)
657 if (!(mem_ctx = talloc_init("do_cmd"))) {
658 DEBUG(0, ("talloc_init() failed\n"));
659 return NT_STATUS_NO_MEMORY;
664 if ((cmd_entry->interface != NULL) && (cmd_entry->rpc_pipe == NULL)) {
665 switch (pipe_default_auth_type) {
666 case DCERPC_AUTH_TYPE_NONE:
667 ntresult = cli_rpc_pipe_open_noauth_transport(
668 cli, default_transport,
669 cmd_entry->interface,
670 &cmd_entry->rpc_pipe);
672 case DCERPC_AUTH_TYPE_SPNEGO:
673 switch (pipe_default_auth_spnego_type) {
674 case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
675 ntresult = cli_rpc_pipe_open_spnego_ntlmssp(
676 cli, cmd_entry->interface,
678 pipe_default_auth_level,
679 get_cmdline_auth_info_domain(auth_info),
680 get_cmdline_auth_info_username(auth_info),
681 get_cmdline_auth_info_password(auth_info),
682 &cmd_entry->rpc_pipe);
684 case PIPE_AUTH_TYPE_SPNEGO_KRB5:
685 ntresult = cli_rpc_pipe_open_spnego_krb5(
686 cli, cmd_entry->interface,
688 pipe_default_auth_level,
691 &cmd_entry->rpc_pipe);
694 ntresult = NT_STATUS_INTERNAL_ERROR;
697 case DCERPC_AUTH_TYPE_NTLMSSP:
698 ntresult = cli_rpc_pipe_open_ntlmssp(
699 cli, cmd_entry->interface,
701 pipe_default_auth_level,
702 get_cmdline_auth_info_domain(auth_info),
703 get_cmdline_auth_info_username(auth_info),
704 get_cmdline_auth_info_password(auth_info),
705 &cmd_entry->rpc_pipe);
707 case DCERPC_AUTH_TYPE_SCHANNEL:
708 ntresult = cli_rpc_pipe_open_schannel(
709 cli, cmd_entry->interface,
711 pipe_default_auth_level,
712 get_cmdline_auth_info_domain(auth_info),
713 &cmd_entry->rpc_pipe);
715 case DCERPC_AUTH_TYPE_KRB5:
716 ntresult = cli_rpc_pipe_open_krb5(
717 cli, cmd_entry->interface,
719 pipe_default_auth_level,
722 &cmd_entry->rpc_pipe);
725 DEBUG(0, ("Could not initialise %s. Invalid "
727 get_pipe_name_from_syntax(
729 cmd_entry->interface),
730 pipe_default_auth_type ));
731 return NT_STATUS_UNSUCCESSFUL;
733 if (!NT_STATUS_IS_OK(ntresult)) {
734 DEBUG(0, ("Could not initialise %s. Error was %s\n",
735 get_pipe_name_from_syntax(
736 talloc_tos(), cmd_entry->interface),
737 nt_errstr(ntresult) ));
741 if (ndr_syntax_id_equal(cmd_entry->interface,
742 &ndr_table_netlogon.syntax_id)) {
743 uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
744 enum netr_SchannelType sec_channel_type;
745 uchar trust_password[16];
746 const char *machine_account;
748 if (!get_trust_pw_hash(get_cmdline_auth_info_domain(auth_info),
749 trust_password, &machine_account,
752 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
755 ntresult = rpccli_netlogon_setup_creds(cmd_entry->rpc_pipe,
756 cli->desthost, /* server name */
757 get_cmdline_auth_info_domain(auth_info), /* domain */
758 global_myname(), /* client name */
759 machine_account, /* machine account name */
764 if (!NT_STATUS_IS_OK(ntresult)) {
765 DEBUG(0, ("Could not initialise credentials for %s.\n",
766 get_pipe_name_from_syntax(
768 cmd_entry->interface)));
776 if ( cmd_entry->returntype == RPC_RTYPE_NTSTATUS ) {
777 ntresult = cmd_entry->ntfn(cmd_entry->rpc_pipe, mem_ctx, argc, (const char **) argv);
778 if (!NT_STATUS_IS_OK(ntresult)) {
779 printf("result was %s\n", nt_errstr(ntresult));
782 wresult = cmd_entry->wfn(cmd_entry->rpc_pipe, mem_ctx, argc, (const char **) argv);
783 /* print out the DOS error */
784 if (!W_ERROR_IS_OK(wresult)) {
785 printf( "result was %s\n", win_errstr(wresult));
787 ntresult = W_ERROR_IS_OK(wresult)?NT_STATUS_OK:NT_STATUS_UNSUCCESSFUL;
792 talloc_destroy(mem_ctx);
799 * Process a command entered at the prompt or as part of -c
801 * @returns The NTSTATUS from running the command.
803 static NTSTATUS process_cmd(struct user_auth_info *auth_info,
804 struct cli_state *cli,
805 struct dcerpc_binding *binding,
808 struct cmd_list *temp_list;
809 NTSTATUS result = NT_STATUS_OK;
814 if ((ret = poptParseArgvString(cmd, &argc, (const char ***) &argv)) != 0) {
815 fprintf(stderr, "rpcclient: %s\n", poptStrerror(ret));
816 return NT_STATUS_UNSUCCESSFUL;
820 /* Walk through a dlist of arrays of commands. */
821 for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) {
822 struct cmd_set *temp_set = temp_list->cmd_set;
824 while (temp_set->name) {
825 if (strequal(argv[0], temp_set->name)) {
826 if (!(temp_set->returntype == RPC_RTYPE_NTSTATUS && temp_set->ntfn ) &&
827 !(temp_set->returntype == RPC_RTYPE_WERROR && temp_set->wfn )) {
828 fprintf (stderr, "Invalid command\n");
832 result = do_cmd(cli, auth_info, temp_set,
833 binding, argc, argv);
842 printf("command not found: %s\n", argv[0]);
847 if (!NT_STATUS_IS_OK(result)) {
848 printf("result was %s\n", nt_errstr(result));
852 /* NOTE: popt allocates the whole argv, including the
853 * strings, as a single block. So a single free is
854 * enough to release it -- we don't free the
855 * individual strings. rtfm. */
864 int main(int argc, char *argv[])
867 static char *cmdstr = NULL;
869 struct cli_state *cli = NULL;
870 static char *opt_ipaddr=NULL;
871 struct cmd_set **cmd_set;
872 struct sockaddr_storage server_ss;
874 static int opt_port = 0;
875 fstring new_workgroup;
877 TALLOC_CTX *frame = talloc_stackframe();
879 struct dcerpc_binding *binding = NULL;
880 const char *binding_string = NULL;
881 char *user, *domain, *q;
883 /* make sure the vars that get altered (4th field) are in
884 a fixed location or certain compilers complain */
886 struct poptOption long_options[] = {
888 {"command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated cmds", "COMMANDS"},
889 {"dest-ip", 'I', POPT_ARG_STRING, &opt_ipaddr, 'I', "Specify destination IP address", "IP"},
890 {"port", 'p', POPT_ARG_INT, &opt_port, 'p', "Specify port number", "PORT"},
892 POPT_COMMON_CONNECTION
893 POPT_COMMON_CREDENTIALS
899 zero_sockaddr(&server_ss);
903 /* the following functions are part of the Samba debugging
904 facilities. See lib/debug.c */
905 setup_logging("rpcclient", True);
907 rpcclient_auth_info = user_auth_info_init(frame);
908 if (rpcclient_auth_info == NULL) {
911 popt_common_set_auth_info(rpcclient_auth_info);
915 pc = poptGetContext("rpcclient", argc, (const char **) argv,
919 poptPrintHelp(pc, stderr, 0);
923 while((opt = poptGetNextOpt(pc)) != -1) {
927 if (!interpret_string_addr(&server_ss,
930 fprintf(stderr, "%s not a valid IP address\n",
938 /* Get server as remaining unparsed argument. Print usage if more
939 than one unparsed argument is present. */
941 server = poptGetArg(pc);
943 if (!server || poptGetArg(pc)) {
944 poptPrintHelp(pc, stderr, 0);
958 /* save the workgroup...
960 FIXME!! do we need to do this for other options as well
961 (or maybe a generic way to keep lp_load() from overwriting
964 fstrcpy( new_workgroup, lp_workgroup() );
966 /* Load smb.conf file */
968 if (!lp_load(get_dyn_CONFIGFILE(),True,False,False,True))
969 fprintf(stderr, "Can't load %s\n", get_dyn_CONFIGFILE());
971 if ( strlen(new_workgroup) != 0 )
972 set_global_myworkgroup( new_workgroup );
976 * from stdin if necessary
979 if (get_cmdline_auth_info_use_machine_account(rpcclient_auth_info) &&
980 !set_cmdline_auth_info_machine_account_creds(rpcclient_auth_info)) {
985 set_cmdline_auth_info_getpass(rpcclient_auth_info);
987 if ((server[0] == '/' && server[1] == '/') ||
988 (server[0] == '\\' && server[1] == '\\')) {
992 nt_status = dcerpc_parse_binding(frame, server, &binding);
994 if (!NT_STATUS_IS_OK(nt_status)) {
996 binding_string = talloc_asprintf(frame, "ncacn_np:%s",
997 strip_hostname(server));
998 if (!binding_string) {
1003 nt_status = dcerpc_parse_binding(frame, binding_string, &binding);
1004 if (!NT_STATUS_IS_OK(nt_status)) {
1010 if (binding->transport == NCA_UNKNOWN) {
1011 binding->transport = NCACN_NP;
1014 if (binding->flags & DCERPC_SIGN) {
1015 pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
1016 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
1018 if (binding->flags & DCERPC_SEAL) {
1019 pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
1020 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
1022 if (binding->flags & DCERPC_AUTH_SPNEGO) {
1023 pipe_default_auth_type = DCERPC_AUTH_TYPE_SPNEGO;
1024 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
1026 if (binding->flags & DCERPC_AUTH_NTLM) {
1027 /* If neither Integrity or Privacy are requested then
1028 * Use just Connect level */
1029 if (pipe_default_auth_level == DCERPC_AUTH_LEVEL_NONE) {
1030 pipe_default_auth_level = DCERPC_AUTH_LEVEL_CONNECT;
1033 if (pipe_default_auth_type == DCERPC_AUTH_TYPE_SPNEGO) {
1034 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
1036 pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
1039 if (binding->flags & DCERPC_AUTH_KRB5) {
1040 /* If neither Integrity or Privacy are requested then
1041 * Use just Connect level */
1042 if (pipe_default_auth_level == DCERPC_AUTH_LEVEL_NONE) {
1043 pipe_default_auth_level = DCERPC_AUTH_LEVEL_CONNECT;
1046 if (pipe_default_auth_type == DCERPC_AUTH_TYPE_SPNEGO) {
1047 pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_KRB5;
1049 pipe_default_auth_type = DCERPC_AUTH_TYPE_KRB5;
1053 if (get_cmdline_auth_info_use_kerberos(rpcclient_auth_info)) {
1054 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
1055 CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
1057 if (get_cmdline_auth_info_use_ccache(rpcclient_auth_info)) {
1058 flags |= CLI_FULL_CONNECTION_USE_CCACHE;
1061 user = talloc_strdup(frame, get_cmdline_auth_info_username(rpcclient_auth_info));
1062 SMB_ASSERT(user != NULL);
1063 domain = talloc_strdup(frame, lp_workgroup());
1064 SMB_ASSERT(domain != NULL);
1065 set_cmdline_auth_info_domain(rpcclient_auth_info, domain);
1067 if ((q = strchr_m(user,'\\'))) {
1069 set_cmdline_auth_info_domain(rpcclient_auth_info, user);
1070 set_cmdline_auth_info_username(rpcclient_auth_info, q+1);
1074 nt_status = cli_full_connection(&cli, global_myname(), binding->host,
1075 opt_ipaddr ? &server_ss : NULL, opt_port,
1077 get_cmdline_auth_info_username(rpcclient_auth_info),
1078 get_cmdline_auth_info_domain(rpcclient_auth_info),
1079 get_cmdline_auth_info_password(rpcclient_auth_info),
1081 get_cmdline_auth_info_signing_state(rpcclient_auth_info),
1084 if (!NT_STATUS_IS_OK(nt_status)) {
1085 DEBUG(0,("Cannot connect to server. Error was %s\n", nt_errstr(nt_status)));
1090 if (get_cmdline_auth_info_smb_encrypt(rpcclient_auth_info)) {
1091 nt_status = cli_cm_force_encryption(cli,
1092 get_cmdline_auth_info_username(rpcclient_auth_info),
1093 get_cmdline_auth_info_password(rpcclient_auth_info),
1094 get_cmdline_auth_info_domain(rpcclient_auth_info),
1096 if (!NT_STATUS_IS_OK(nt_status)) {
1102 #if 0 /* COMMENT OUT FOR TESTING */
1103 memset(cmdline_auth_info.password,'X',sizeof(cmdline_auth_info.password));
1106 /* Load command lists */
1108 timeout = cli_set_timeout(cli, 10000);
1110 cmd_set = rpcclient_command_list;
1113 add_command_set(*cmd_set);
1114 add_command_set(separator_command);
1118 default_transport = binding->transport;
1120 fetch_machine_sid(cli);
1122 /* Do anything specified with -c */
1123 if (cmdstr && cmdstr[0]) {
1129 while((cmd=next_command(&p)) != NULL) {
1130 NTSTATUS cmd_result = process_cmd(rpcclient_auth_info, cli,
1133 result = NT_STATUS_IS_ERR(cmd_result);
1139 /* Loop around accepting commands */
1144 line = smb_readline("rpcclient $> ", NULL, completion_fn);
1149 if (line[0] != '\n')
1150 process_cmd(rpcclient_auth_info, cli, binding, line);