#include "includes.h"
#include "rpcclient.h"
+#include "../libcli/auth/libcli_auth.h"
+#include "../librpc/gen_ndr/cli_lsa.h"
DOM_SID domain_sid;
static enum pipe_auth_type pipe_default_auth_type = PIPE_AUTH_TYPE_NONE;
-static enum pipe_auth_level pipe_default_auth_level = PIPE_AUTH_LEVEL_NONE;
+static enum dcerpc_AuthLevel pipe_default_auth_level = DCERPC_AUTH_LEVEL_NONE;
static unsigned int timeout = 0;
+static enum dcerpc_transport_t default_transport = NCACN_NP;
+
+struct user_auth_info *rpcclient_auth_info;
/* List to hold groups of commands.
*
static void fetch_machine_sid(struct cli_state *cli)
{
- POLICY_HND pol;
+ struct policy_handle pol;
NTSTATUS result = NT_STATUS_OK;
- uint32 info_class = 5;
- const char *domain_name = NULL;
static bool got_domain_sid;
TALLOC_CTX *mem_ctx;
- DOM_SID *dom_sid = NULL;
struct rpc_pipe_client *lsapipe = NULL;
+ union lsa_PolicyInformation *info = NULL;
if (got_domain_sid) return;
goto error;
}
- if ((lsapipe = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &result)) == NULL) {
+ result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+ &lsapipe);
+ if (!NT_STATUS_IS_OK(result)) {
fprintf(stderr, "could not initialise lsa pipe. Error was %s\n", nt_errstr(result) );
goto error;
}
result = rpccli_lsa_open_policy(lsapipe, mem_ctx, True,
- SEC_RIGHTS_MAXIMUM_ALLOWED,
+ SEC_FLAG_MAXIMUM_ALLOWED,
&pol);
if (!NT_STATUS_IS_OK(result)) {
goto error;
}
- result = rpccli_lsa_query_info_policy(lsapipe, mem_ctx, &pol, info_class,
- &domain_name, &dom_sid);
+ result = rpccli_lsa_QueryInfoPolicy(lsapipe, mem_ctx,
+ &pol,
+ LSA_POLICY_INFO_ACCOUNT_DOMAIN,
+ &info);
if (!NT_STATUS_IS_OK(result)) {
goto error;
}
got_domain_sid = True;
- sid_copy( &domain_sid, dom_sid );
+ sid_copy(&domain_sid, info->account_domain.sid);
rpccli_lsa_Close(lsapipe, mem_ctx, &pol);
- cli_rpc_pipe_close(lsapipe);
+ TALLOC_FREE(lsapipe);
talloc_destroy(mem_ctx);
return;
error:
if (lsapipe) {
- cli_rpc_pipe_close(lsapipe);
+ TALLOC_FREE(lsapipe);
}
fprintf(stderr, "could not obtain sid for domain %s\n", cli->domain);
continue;
}
- if (tmp_set->rpc_pipe->auth.auth_type != pipe_default_auth_type ||
- tmp_set->rpc_pipe->auth.auth_level != pipe_default_auth_level) {
- cli_rpc_pipe_close(tmp_set->rpc_pipe);
+ if ((tmp_set->rpc_pipe->auth->auth_type
+ != pipe_default_auth_type)
+ || (tmp_set->rpc_pipe->auth->auth_level
+ != pipe_default_auth_level)) {
+ TALLOC_FREE(tmp_set->rpc_pipe);
+ tmp_set->rpc_pipe = NULL;
+ }
+ }
+ }
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS cmd_set_transport(void)
+{
+ struct cmd_list *tmp;
+
+ /* Close any existing connections not at this level. */
+
+ for (tmp = cmd_list; tmp; tmp = tmp->next) {
+ struct cmd_set *tmp_set;
+
+ for (tmp_set = tmp->cmd_set; tmp_set->name; tmp_set++) {
+ if (tmp_set->rpc_pipe == NULL) {
+ continue;
+ }
+
+ if (tmp_set->rpc_pipe->transport->transport != default_transport) {
+ TALLOC_FREE(tmp_set->rpc_pipe);
tmp_set->rpc_pipe = NULL;
}
}
static NTSTATUS cmd_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- pipe_default_auth_level = PIPE_AUTH_LEVEL_INTEGRITY;
+ const char *type = "NTLMSSP";
+
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
if (argc > 2) {
}
if (argc == 2) {
- if (strequal(argv[1], "NTLMSSP")) {
+ type = argv[1];
+ if (strequal(type, "NTLMSSP")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
- } else if (strequal(argv[1], "NTLMSSP_SPNEGO")) {
+ } else if (strequal(type, "NTLMSSP_SPNEGO")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
- } else if (strequal(argv[1], "SCHANNEL")) {
+ } else if (strequal(type, "SCHANNEL")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_SCHANNEL;
} else {
- printf("unknown type %s\n", argv[1]);
+ printf("unknown type %s\n", type);
return NT_STATUS_INVALID_LEVEL;
}
}
- printf("debuglevel is %d\n", DEBUGLEVEL);
+ d_printf("Setting %s - sign\n", type);
+
return cmd_set_ss_level();
}
static NTSTATUS cmd_seal(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- pipe_default_auth_level = PIPE_AUTH_LEVEL_PRIVACY;
+ const char *type = "NTLMSSP";
+
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
if (argc > 2) {
}
if (argc == 2) {
- if (strequal(argv[1], "NTLMSSP")) {
+ type = argv[1];
+ if (strequal(type, "NTLMSSP")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
- } else if (strequal(argv[1], "NTLMSSP_SPNEGO")) {
+ } else if (strequal(type, "NTLMSSP_SPNEGO")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
- } else if (strequal(argv[1], "SCHANNEL")) {
+ } else if (strequal(type, "SCHANNEL")) {
pipe_default_auth_type = PIPE_AUTH_TYPE_SCHANNEL;
} else {
- printf("unknown type %s\n", argv[1]);
+ printf("unknown type %s\n", type);
return NT_STATUS_INVALID_LEVEL;
}
}
+
+ d_printf("Setting %s - sign and seal\n", type);
+
return cmd_set_ss_level();
}
continue;
}
- cli_set_timeout(tmp_set->rpc_pipe->cli, timeout);
+ rpccli_set_timeout(tmp_set->rpc_pipe, timeout);
}
}
}
static NTSTATUS cmd_none(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- pipe_default_auth_level = PIPE_AUTH_LEVEL_NONE;
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_NONE;
pipe_default_auth_type = PIPE_AUTH_TYPE_NONE;
return cmd_set_ss_level();
int argc, const char **argv)
{
d_printf("Setting schannel - sign and seal\n");
- pipe_default_auth_level = PIPE_AUTH_LEVEL_PRIVACY;
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
pipe_default_auth_type = PIPE_AUTH_TYPE_SCHANNEL;
return cmd_set_ss_level();
int argc, const char **argv)
{
d_printf("Setting schannel - sign only\n");
- pipe_default_auth_level = PIPE_AUTH_LEVEL_INTEGRITY;
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
pipe_default_auth_type = PIPE_AUTH_TYPE_SCHANNEL;
return cmd_set_ss_level();
}
+static NTSTATUS cmd_choose_transport(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ int argc, const char **argv)
+{
+ NTSTATUS status;
+
+ if (argc != 2) {
+ printf("Usage: %s [NCACN_NP|NCACN_IP_TCP]\n", argv[0]);
+ return NT_STATUS_OK;
+ }
+
+ if (strequal(argv[1], "NCACN_NP")) {
+ default_transport = NCACN_NP;
+ } else if (strequal(argv[1], "NCACN_IP_TCP")) {
+ default_transport = NCACN_IP_TCP;
+ } else {
+ printf("transport type: %s unknown or not supported\n", argv[1]);
+ return NT_STATUS_NOT_SUPPORTED;
+ }
+
+ status = cmd_set_transport();
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ printf("default transport is now: %s\n", argv[1]);
+
+ return NT_STATUS_OK;
+}
/* Built in rpcclient commands */
{ "GENERAL OPTIONS" },
- { "help", RPC_RTYPE_NTSTATUS, cmd_help, NULL, -1, NULL, "Get help on commands", "[command]" },
- { "?", RPC_RTYPE_NTSTATUS, cmd_help, NULL, -1, NULL, "Get help on commands", "[command]" },
- { "debuglevel", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, -1, NULL, "Set debug level", "level" },
- { "debug", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, -1, NULL, "Set debug level", "level" },
- { "list", RPC_RTYPE_NTSTATUS, cmd_listcommands, NULL, -1, NULL, "List available commands on <pipe>", "pipe" },
- { "exit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, -1, NULL, "Exit program", "" },
- { "quit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, -1, NULL, "Exit program", "" },
- { "sign", RPC_RTYPE_NTSTATUS, cmd_sign, NULL, -1, NULL, "Force RPC pipe connections to be signed", "" },
- { "seal", RPC_RTYPE_NTSTATUS, cmd_seal, NULL, -1, NULL, "Force RPC pipe connections to be sealed", "" },
- { "schannel", RPC_RTYPE_NTSTATUS, cmd_schannel, NULL, -1, NULL, "Force RPC pipe connections to be sealed with 'schannel'. Assumes valid machine account to this domain controller.", "" },
- { "schannelsign", RPC_RTYPE_NTSTATUS, cmd_schannel_sign, NULL, -1, NULL, "Force RPC pipe connections to be signed (not sealed) with 'schannel'. Assumes valid machine account to this domain controller.", "" },
- { "timeout", RPC_RTYPE_NTSTATUS, cmd_timeout, NULL, -1, NULL, "Set timeout (in milliseonds) for RPC operations", "" },
- { "none", RPC_RTYPE_NTSTATUS, cmd_none, NULL, -1, NULL, "Force RPC pipe connections to have no special properties", "" },
+ { "help", RPC_RTYPE_NTSTATUS, cmd_help, NULL, NULL, NULL, "Get help on commands", "[command]" },
+ { "?", RPC_RTYPE_NTSTATUS, cmd_help, NULL, NULL, NULL, "Get help on commands", "[command]" },
+ { "debuglevel", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, NULL, NULL, "Set debug level", "level" },
+ { "debug", RPC_RTYPE_NTSTATUS, cmd_debuglevel, NULL, NULL, NULL, "Set debug level", "level" },
+ { "list", RPC_RTYPE_NTSTATUS, cmd_listcommands, NULL, NULL, NULL, "List available commands on <pipe>", "pipe" },
+ { "exit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, NULL, NULL, "Exit program", "" },
+ { "quit", RPC_RTYPE_NTSTATUS, cmd_quit, NULL, NULL, NULL, "Exit program", "" },
+ { "sign", RPC_RTYPE_NTSTATUS, cmd_sign, NULL, NULL, NULL, "Force RPC pipe connections to be signed", "" },
+ { "seal", RPC_RTYPE_NTSTATUS, cmd_seal, NULL, NULL, NULL, "Force RPC pipe connections to be sealed", "" },
+ { "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.", "" },
+ { "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.", "" },
+ { "timeout", RPC_RTYPE_NTSTATUS, cmd_timeout, NULL, NULL, NULL, "Set timeout (in milliseonds) for RPC operations", "" },
+ { "transport", RPC_RTYPE_NTSTATUS, cmd_choose_transport, NULL, NULL, NULL, "Choose ncacn transport for RPC operations", "" },
+ { "none", RPC_RTYPE_NTSTATUS, cmd_none, NULL, NULL, NULL, "Force RPC pipe connections to have no special properties", "" },
{ NULL }
};
static struct cmd_set separator_command[] = {
- { "---------------", MAX_RPC_RETURN_TYPE, NULL, NULL, -1, NULL, "----------------------" },
+ { "---------------", MAX_RPC_RETURN_TYPE, NULL, NULL, NULL, NULL, "----------------------" },
{ NULL }
};
extern struct cmd_set dfs_commands[];
extern struct cmd_set ds_commands[];
extern struct cmd_set echo_commands[];
+extern struct cmd_set epmapper_commands[];
extern struct cmd_set shutdown_commands[];
extern struct cmd_set test_commands[];
extern struct cmd_set wkssvc_commands[];
+extern struct cmd_set ntsvcs_commands[];
+extern struct cmd_set drsuapi_commands[];
+extern struct cmd_set eventlog_commands[];
static struct cmd_set *rpcclient_command_list[] = {
rpcclient_commands,
srvsvc_commands,
dfs_commands,
echo_commands,
+ epmapper_commands,
shutdown_commands,
test_commands,
wkssvc_commands,
+ ntsvcs_commands,
+ drsuapi_commands,
+ eventlog_commands,
NULL
};
* @param cmd Command to run, as a single string.
**/
static NTSTATUS do_cmd(struct cli_state *cli,
+ struct user_auth_info *auth_info,
struct cmd_set *cmd_entry,
+ struct dcerpc_binding *binding,
int argc, char **argv)
{
NTSTATUS ntresult;
/* Open pipe */
- if (cmd_entry->pipe_idx != -1 && cmd_entry->rpc_pipe == NULL) {
+ if ((cmd_entry->interface != NULL) && (cmd_entry->rpc_pipe == NULL)) {
switch (pipe_default_auth_type) {
case PIPE_AUTH_TYPE_NONE:
- cmd_entry->rpc_pipe = cli_rpc_pipe_open_noauth(cli,
- cmd_entry->pipe_idx,
- &ntresult);
+ ntresult = cli_rpc_pipe_open_noauth_transport(
+ cli, default_transport,
+ cmd_entry->interface,
+ &cmd_entry->rpc_pipe);
break;
case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
- cmd_entry->rpc_pipe = cli_rpc_pipe_open_spnego_ntlmssp(cli,
- cmd_entry->pipe_idx,
- pipe_default_auth_level,
- lp_workgroup(),
- get_cmdline_auth_info_username(),
- get_cmdline_auth_info_password(),
- &ntresult);
+ ntresult = cli_rpc_pipe_open_spnego_ntlmssp(
+ cli, cmd_entry->interface,
+ default_transport,
+ pipe_default_auth_level,
+ get_cmdline_auth_info_domain(auth_info),
+ get_cmdline_auth_info_username(auth_info),
+ get_cmdline_auth_info_password(auth_info),
+ &cmd_entry->rpc_pipe);
break;
case PIPE_AUTH_TYPE_NTLMSSP:
- cmd_entry->rpc_pipe = cli_rpc_pipe_open_ntlmssp(cli,
- cmd_entry->pipe_idx,
- pipe_default_auth_level,
- lp_workgroup(),
- get_cmdline_auth_info_username(),
- get_cmdline_auth_info_password(),
- &ntresult);
+ ntresult = cli_rpc_pipe_open_ntlmssp(
+ cli, cmd_entry->interface,
+ default_transport,
+ pipe_default_auth_level,
+ get_cmdline_auth_info_domain(auth_info),
+ get_cmdline_auth_info_username(auth_info),
+ get_cmdline_auth_info_password(auth_info),
+ &cmd_entry->rpc_pipe);
break;
case PIPE_AUTH_TYPE_SCHANNEL:
- cmd_entry->rpc_pipe = cli_rpc_pipe_open_schannel(cli,
- cmd_entry->pipe_idx,
- pipe_default_auth_level,
- lp_workgroup(),
- &ntresult);
+ ntresult = cli_rpc_pipe_open_schannel(
+ cli, cmd_entry->interface,
+ default_transport,
+ pipe_default_auth_level,
+ get_cmdline_auth_info_domain(auth_info),
+ &cmd_entry->rpc_pipe);
break;
default:
- DEBUG(0, ("Could not initialise %s. Invalid auth type %u\n",
- cli_get_pipe_name(cmd_entry->pipe_idx),
- pipe_default_auth_type ));
+ DEBUG(0, ("Could not initialise %s. Invalid "
+ "auth type %u\n",
+ get_pipe_name_from_syntax(
+ talloc_tos(),
+ cmd_entry->interface),
+ pipe_default_auth_type ));
return NT_STATUS_UNSUCCESSFUL;
}
- if (!cmd_entry->rpc_pipe) {
+ if (!NT_STATUS_IS_OK(ntresult)) {
DEBUG(0, ("Could not initialise %s. Error was %s\n",
- cli_get_pipe_name(cmd_entry->pipe_idx),
- nt_errstr(ntresult) ));
+ get_pipe_name_from_syntax(
+ talloc_tos(), cmd_entry->interface),
+ nt_errstr(ntresult) ));
return ntresult;
}
- if (cmd_entry->pipe_idx == PI_NETLOGON) {
- uint32 neg_flags = NETLOGON_NEG_AUTH2_FLAGS;
- uint32 sec_channel_type;
+ if (ndr_syntax_id_equal(cmd_entry->interface,
+ &ndr_table_netlogon.syntax_id)) {
+ uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
+ enum netr_SchannelType sec_channel_type;
uchar trust_password[16];
-
- if (!secrets_fetch_trust_account_password(lp_workgroup(),
- trust_password,
- NULL, &sec_channel_type)) {
- return NT_STATUS_UNSUCCESSFUL;
+ const char *machine_account;
+
+ if (!get_trust_pw_hash(get_cmdline_auth_info_domain(auth_info),
+ trust_password, &machine_account,
+ &sec_channel_type))
+ {
+ return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
}
-
+
ntresult = rpccli_netlogon_setup_creds(cmd_entry->rpc_pipe,
cli->desthost, /* server name */
- lp_workgroup(), /* domain */
+ get_cmdline_auth_info_domain(auth_info), /* domain */
global_myname(), /* client name */
- global_myname(), /* machine account name */
+ machine_account, /* machine account name */
trust_password,
sec_channel_type,
&neg_flags);
if (!NT_STATUS_IS_OK(ntresult)) {
DEBUG(0, ("Could not initialise credentials for %s.\n",
- cli_get_pipe_name(cmd_entry->pipe_idx)));
+ get_pipe_name_from_syntax(
+ talloc_tos(),
+ cmd_entry->interface)));
return ntresult;
}
}
wresult = cmd_entry->wfn(cmd_entry->rpc_pipe, mem_ctx, argc, (const char **) argv);
/* print out the DOS error */
if (!W_ERROR_IS_OK(wresult)) {
- printf( "result was %s\n", dos_errstr(wresult));
+ printf( "result was %s\n", win_errstr(wresult));
}
ntresult = W_ERROR_IS_OK(wresult)?NT_STATUS_OK:NT_STATUS_UNSUCCESSFUL;
}
*
* @returns The NTSTATUS from running the command.
**/
-static NTSTATUS process_cmd(struct cli_state *cli, char *cmd)
+static NTSTATUS process_cmd(struct user_auth_info *auth_info,
+ struct cli_state *cli,
+ struct dcerpc_binding *binding,
+ char *cmd)
{
struct cmd_list *temp_list;
NTSTATUS result = NT_STATUS_OK;
goto out_free;
}
- result = do_cmd(cli, temp_set, argc, argv);
+ result = do_cmd(cli, auth_info, temp_set,
+ binding, argc, argv);
goto out_free;
}
fstring new_workgroup;
int result = 0;
TALLOC_CTX *frame = talloc_stackframe();
+ uint32_t flags = 0;
+ struct dcerpc_binding *binding = NULL;
+ const char *binding_string = NULL;
+ char *user, *domain, *q;
/* make sure the vars that get altered (4th field) are in
a fixed location or certain compilers complain */
load_case_tables();
- zero_addr(&server_ss);
+ zero_sockaddr(&server_ss);
setlinebuf(stdout);
facilities. See lib/debug.c */
setup_logging("rpcclient", True);
+ rpcclient_auth_info = user_auth_info_init(frame);
+ if (rpcclient_auth_info == NULL) {
+ exit(1);
+ }
+ popt_common_set_auth_info(rpcclient_auth_info);
+
/* Parse options */
pc = poptGetContext("rpcclient", argc, (const char **) argv,
* from stdin if necessary
*/
- if (!get_cmdline_auth_info_got_pass()) {
- char *pass = getpass("Password:");
- if (pass) {
- set_cmdline_auth_info_password(pass);
- }
+ if (get_cmdline_auth_info_use_machine_account(rpcclient_auth_info) &&
+ !set_cmdline_auth_info_machine_account_creds(rpcclient_auth_info)) {
+ result = 1;
+ goto done;
}
+ set_cmdline_auth_info_getpass(rpcclient_auth_info);
+
if ((server[0] == '/' && server[1] == '/') ||
(server[0] == '\\' && server[1] == '\\')) {
server += 2;
}
- nt_status = cli_full_connection(&cli, global_myname(), server,
+ nt_status = dcerpc_parse_binding(frame, server, &binding);
+
+ if (!NT_STATUS_IS_OK(nt_status)) {
+
+ binding_string = talloc_asprintf(frame, "ncacn_np:%s",
+ strip_hostname(server));
+ if (!binding_string) {
+ result = 1;
+ goto done;
+ }
+
+ nt_status = dcerpc_parse_binding(frame, binding_string, &binding);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ result = -1;
+ goto done;
+ }
+ }
+
+ if (binding->transport == NCA_UNKNOWN) {
+ binding->transport = NCACN_NP;
+ }
+
+ if (binding->flags & DCERPC_SIGN) {
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
+ pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
+ }
+ if (binding->flags & DCERPC_SEAL) {
+ pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
+ pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
+ }
+ if (binding->flags & DCERPC_AUTH_SPNEGO) {
+ pipe_default_auth_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
+ }
+ if (binding->flags & DCERPC_AUTH_NTLM) {
+ pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
+ }
+ if (binding->flags & DCERPC_AUTH_KRB5) {
+ pipe_default_auth_type = PIPE_AUTH_TYPE_SPNEGO_KRB5;
+ }
+
+ if (get_cmdline_auth_info_use_kerberos(rpcclient_auth_info)) {
+ flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
+ CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
+ }
+
+ user = talloc_strdup(frame, get_cmdline_auth_info_username(rpcclient_auth_info));
+ SMB_ASSERT(user != NULL);
+ domain = talloc_strdup(frame, lp_workgroup());
+ SMB_ASSERT(domain != NULL);
+ set_cmdline_auth_info_domain(rpcclient_auth_info, domain);
+
+ if ((q = strchr_m(user,'\\'))) {
+ *q = 0;
+ set_cmdline_auth_info_domain(rpcclient_auth_info, user);
+ set_cmdline_auth_info_username(rpcclient_auth_info, q+1);
+ }
+
+
+ nt_status = cli_full_connection(&cli, global_myname(), binding->host,
opt_ipaddr ? &server_ss : NULL, opt_port,
"IPC$", "IPC",
- get_cmdline_auth_info_username(),
- lp_workgroup(),
- get_cmdline_auth_info_password(),
- get_cmdline_auth_info_use_kerberos() ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
- get_cmdline_auth_info_signing_state(),NULL);
+ get_cmdline_auth_info_username(rpcclient_auth_info),
+ get_cmdline_auth_info_domain(rpcclient_auth_info),
+ get_cmdline_auth_info_password(rpcclient_auth_info),
+ flags,
+ get_cmdline_auth_info_signing_state(rpcclient_auth_info),
+ NULL);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0,("Cannot connect to server. Error was %s\n", nt_errstr(nt_status)));
goto done;
}
- if (get_cmdline_auth_info_smb_encrypt()) {
+ if (get_cmdline_auth_info_smb_encrypt(rpcclient_auth_info)) {
nt_status = cli_cm_force_encryption(cli,
- get_cmdline_auth_info_username(),
- get_cmdline_auth_info_password(),
- lp_workgroup(),
+ get_cmdline_auth_info_username(rpcclient_auth_info),
+ get_cmdline_auth_info_password(rpcclient_auth_info),
+ get_cmdline_auth_info_domain(rpcclient_auth_info),
"IPC$");
if (!NT_STATUS_IS_OK(nt_status)) {
result = 1;
cmd_set++;
}
+ default_transport = binding->transport;
+
fetch_machine_sid(cli);
/* Do anything specified with -c */
result = 0;
while((cmd=next_command(&p)) != NULL) {
- NTSTATUS cmd_result = process_cmd(cli, cmd);
+ NTSTATUS cmd_result = process_cmd(rpcclient_auth_info, cli,
+ binding, cmd);
SAFE_FREE(cmd);
result = NT_STATUS_IS_ERR(cmd_result);
}
break;
if (line[0] != '\n')
- process_cmd(cli, line);
+ process_cmd(rpcclient_auth_info, cli, binding, line);
SAFE_FREE(line);
}
git.samba.org / ira / wip.git / blobdiff