s3-spoolss: fix rpcclient after setprinter IDL fixes.

[ira/wip.git] / source3 / rpcclient / rpcclient.c

diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c
index 6fd6b4f6d973091bf80815b6b9e0ccb39b389fc6..f6d56adecec4bbc63f7abc0173ec986eacebb437 100644 (file)
--- a/source3/rpcclient/rpcclient.c
+++ b/source3/rpcclient/rpcclient.c
@@ -22,12 +22,14 @@
 #include "includes.h"
 #include "rpcclient.h"
 #include "../libcli/auth/libcli_auth.h"
 #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;
 
 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 unsigned int timeout = 0;

+static enum dcerpc_transport_t default_transport = NCACN_NP;

 
 struct user_auth_info *rpcclient_auth_info;
 
 
 struct user_auth_info *rpcclient_auth_info;
 


@@ -156,7 +158,7 @@ static void fetch_machine_sid(struct cli_state *cli)
        }
        
        result = rpccli_lsa_open_policy(lsapipe, mem_ctx, True, 
        }
        
        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;
                                     &pol);
        if (!NT_STATUS_IS_OK(result)) {
                goto error;


@@ -351,12 +353,35 @@ static NTSTATUS cmd_set_ss_level(void)
        return NT_STATUS_OK;
 }
 
        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;
+                       }
+               }
+       }
+       return NT_STATUS_OK;
+}
+

 static NTSTATUS cmd_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                          int argc, const char **argv)
 {
        const char *type = "NTLMSSP";
 
 static NTSTATUS cmd_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                          int argc, const char **argv)
 {
        const char *type = "NTLMSSP";
 

-       pipe_default_auth_level = PIPE_AUTH_LEVEL_INTEGRITY;
+       pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;

        pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
 
        if (argc > 2) {
        pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
 
        if (argc > 2) {


@@ -388,7 +413,7 @@ static NTSTATUS cmd_seal(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 {
        const char *type = "NTLMSSP";
 
 {
        const char *type = "NTLMSSP";
 

-       pipe_default_auth_level = PIPE_AUTH_LEVEL_PRIVACY;
+       pipe_default_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;

        pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
 
        if (argc > 2) {
        pipe_default_auth_type = PIPE_AUTH_TYPE_NTLMSSP;
 
        if (argc > 2) {


@@ -451,7 +476,7 @@ static NTSTATUS cmd_timeout(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 static NTSTATUS cmd_none(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                          int argc, const char **argv)
 {
 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();
        pipe_default_auth_type = PIPE_AUTH_TYPE_NONE;
 
        return cmd_set_ss_level();


@@ -461,7 +486,7 @@ static NTSTATUS cmd_schannel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                             int argc, const char **argv)
 {
        d_printf("Setting schannel - sign and seal\n");
                             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();
        pipe_default_auth_type = PIPE_AUTH_TYPE_SCHANNEL;
 
        return cmd_set_ss_level();


@@ -471,12 +496,40 @@ static NTSTATUS cmd_schannel_sign(struct rpc_pipe_client *cli, TALLOC_CTX *mem_c
                             int argc, const char **argv)
 {
        d_printf("Setting schannel - sign only\n");
                             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();
 }
 
        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 */
 
 
 /* Built in rpcclient commands */
 


@@ -496,6 +549,7 @@ static struct cmd_set rpcclient_commands[] = {
        { "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", "" },
        { "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 }
        { "none", RPC_RTYPE_NTSTATUS, cmd_none, NULL,     NULL, NULL, "Force RPC pipe connections to have no special properties", "" },
 
        { NULL }


@@ -569,6 +623,7 @@ static void add_command_set(struct cmd_set *cmd_set)
 static NTSTATUS do_cmd(struct cli_state *cli,
                       struct user_auth_info *auth_info,
                       struct cmd_set *cmd_entry,
 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;
                       int argc, char **argv)
 {
        NTSTATUS ntresult;


@@ -588,15 +643,17 @@ static NTSTATUS do_cmd(struct cli_state *cli,
        if ((cmd_entry->interface != NULL) && (cmd_entry->rpc_pipe == NULL)) {
                switch (pipe_default_auth_type) {
                        case PIPE_AUTH_TYPE_NONE:
        if ((cmd_entry->interface != NULL) && (cmd_entry->rpc_pipe == NULL)) {
                switch (pipe_default_auth_type) {
                        case PIPE_AUTH_TYPE_NONE:

-                               ntresult = cli_rpc_pipe_open_noauth(
-                                       cli, cmd_entry->interface,
+                               ntresult = cli_rpc_pipe_open_noauth_transport(
+                                       cli, default_transport,
+                                       cmd_entry->interface,

                                        &cmd_entry->rpc_pipe);
                                break;
                        case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
                                ntresult = cli_rpc_pipe_open_spnego_ntlmssp(
                                        cli, cmd_entry->interface,
                                        &cmd_entry->rpc_pipe);
                                break;
                        case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
                                ntresult = cli_rpc_pipe_open_spnego_ntlmssp(
                                        cli, cmd_entry->interface,

+                                       default_transport,

                                        pipe_default_auth_level,
                                        pipe_default_auth_level,

-                                       lp_workgroup(),
+                                       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);
                                        get_cmdline_auth_info_username(auth_info),
                                        get_cmdline_auth_info_password(auth_info),
                                        &cmd_entry->rpc_pipe);


@@ -604,8 +661,9 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                        case PIPE_AUTH_TYPE_NTLMSSP:
                                ntresult = cli_rpc_pipe_open_ntlmssp(
                                        cli, cmd_entry->interface,
                        case PIPE_AUTH_TYPE_NTLMSSP:
                                ntresult = cli_rpc_pipe_open_ntlmssp(
                                        cli, cmd_entry->interface,

+                                       default_transport,

                                        pipe_default_auth_level,
                                        pipe_default_auth_level,

-                                       lp_workgroup(),
+                                       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);
                                        get_cmdline_auth_info_username(auth_info),
                                        get_cmdline_auth_info_password(auth_info),
                                        &cmd_entry->rpc_pipe);


@@ -613,22 +671,24 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                        case PIPE_AUTH_TYPE_SCHANNEL:
                                ntresult = cli_rpc_pipe_open_schannel(
                                        cli, cmd_entry->interface,
                        case PIPE_AUTH_TYPE_SCHANNEL:
                                ntresult = cli_rpc_pipe_open_schannel(
                                        cli, cmd_entry->interface,

+                                       default_transport,

                                        pipe_default_auth_level,
                                        pipe_default_auth_level,

-                                       lp_workgroup(),
+                                       get_cmdline_auth_info_domain(auth_info),

                                        &cmd_entry->rpc_pipe);
                                break;
                        default:
                                DEBUG(0, ("Could not initialise %s. Invalid "
                                          "auth type %u\n",
                                        &cmd_entry->rpc_pipe);
                                break;
                        default:
                                DEBUG(0, ("Could not initialise %s. Invalid "
                                          "auth type %u\n",

-                                         get_pipe_name_from_iface(
+                                         get_pipe_name_from_syntax(
+                                                 talloc_tos(),

                                                  cmd_entry->interface),
                                          pipe_default_auth_type ));
                                return NT_STATUS_UNSUCCESSFUL;
                }
                if (!NT_STATUS_IS_OK(ntresult)) {
                        DEBUG(0, ("Could not initialise %s. Error was %s\n",
                                                  cmd_entry->interface),
                                          pipe_default_auth_type ));
                                return NT_STATUS_UNSUCCESSFUL;
                }
                if (!NT_STATUS_IS_OK(ntresult)) {
                        DEBUG(0, ("Could not initialise %s. Error was %s\n",

-                                 get_pipe_name_from_iface(
-                                         cmd_entry->interface),
+                                 get_pipe_name_from_syntax(
+                                         talloc_tos(), cmd_entry->interface),

                                  nt_errstr(ntresult) ));
                        return ntresult;
                }
                                  nt_errstr(ntresult) ));
                        return ntresult;
                }


@@ -636,27 +696,30 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                if (ndr_syntax_id_equal(cmd_entry->interface,
                                        &ndr_table_netlogon.syntax_id)) {
                        uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
                if (ndr_syntax_id_equal(cmd_entry->interface,
                                        &ndr_table_netlogon.syntax_id)) {
                        uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;

-                       uint32 sec_channel_type;
+                       enum netr_SchannelType sec_channel_type;

                        uchar trust_password[16];
                        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 */
                        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(), /* 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",
                                                trust_password,
                                                sec_channel_type,
                                                &neg_flags);
 
                        if (!NT_STATUS_IS_OK(ntresult)) {
                                DEBUG(0, ("Could not initialise credentials for %s.\n",

-                                         get_pipe_name_from_iface(
+                                         get_pipe_name_from_syntax(
+                                                 talloc_tos(),

                                                  cmd_entry->interface)));
                                return ntresult;
                        }
                                                  cmd_entry->interface)));
                                return ntresult;
                        }


@@ -693,7 +756,9 @@ static NTSTATUS do_cmd(struct cli_state *cli,
  * @returns The NTSTATUS from running the command.
  **/
 static NTSTATUS process_cmd(struct user_auth_info *auth_info,
  * @returns The NTSTATUS from running the command.
  **/
 static NTSTATUS process_cmd(struct user_auth_info *auth_info,

-                           struct cli_state *cli, char *cmd)
+                           struct cli_state *cli,
+                           struct dcerpc_binding *binding,
+                           char *cmd)

 {
        struct cmd_list *temp_list;
        NTSTATUS result = NT_STATUS_OK;
 {
        struct cmd_list *temp_list;
        NTSTATUS result = NT_STATUS_OK;


@@ -720,7 +785,7 @@ static NTSTATUS process_cmd(struct user_auth_info *auth_info,
                                }
 
                                result = do_cmd(cli, auth_info, temp_set,
                                }
 
                                result = do_cmd(cli, auth_info, temp_set,

-                                               argc, argv);
+                                               binding, argc, argv);

 
                                goto out_free;
                        }
 
                                goto out_free;
                        }


@@ -766,6 +831,9 @@ out_free:
        int result = 0;
        TALLOC_CTX *frame = talloc_stackframe();
        uint32_t flags = 0;
        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 */
 
        /* make sure the vars that get altered (4th field) are in
           a fixed location or certain compilers complain */


@@ -876,17 +944,69 @@ out_free:
                server += 2;
        }
 
                server += 2;
        }
 

+       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;
        }
 
        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);

 
 

-       nt_status = cli_full_connection(&cli, global_myname(), server,
+       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(rpcclient_auth_info),
                                        opt_ipaddr ? &server_ss : NULL, opt_port,
                                        "IPC$", "IPC",
                                        get_cmdline_auth_info_username(rpcclient_auth_info),

-                                       lp_workgroup(),
+                                       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),
                                        get_cmdline_auth_info_password(rpcclient_auth_info),
                                        flags,
                                        get_cmdline_auth_info_signing_state(rpcclient_auth_info),


@@ -902,7 +1022,7 @@ out_free:
                nt_status = cli_cm_force_encryption(cli,
                                        get_cmdline_auth_info_username(rpcclient_auth_info),
                                        get_cmdline_auth_info_password(rpcclient_auth_info),
                nt_status = cli_cm_force_encryption(cli,
                                        get_cmdline_auth_info_username(rpcclient_auth_info),
                                        get_cmdline_auth_info_password(rpcclient_auth_info),

-                                       lp_workgroup(),
+                                       get_cmdline_auth_info_domain(rpcclient_auth_info),

                                        "IPC$");
                if (!NT_STATUS_IS_OK(nt_status)) {
                        result = 1;
                                        "IPC$");
                if (!NT_STATUS_IS_OK(nt_status)) {
                        result = 1;


@@ -926,6 +1046,8 @@ out_free:
                cmd_set++;
        }
 
                cmd_set++;
        }
 

+       default_transport = binding->transport;
+

        fetch_machine_sid(cli);
 
        /* Do anything specified with -c */
        fetch_machine_sid(cli);
 
        /* Do anything specified with -c */


@@ -936,7 +1058,8 @@ out_free:
                result = 0;
 
                 while((cmd=next_command(&p)) != NULL) {
                result = 0;
 
                 while((cmd=next_command(&p)) != NULL) {

-                        NTSTATUS cmd_result = process_cmd(rpcclient_auth_info, cli, cmd);
+                        NTSTATUS cmd_result = process_cmd(rpcclient_auth_info, cli,
+                                                         binding, cmd);

                        SAFE_FREE(cmd);
                        result = NT_STATUS_IS_ERR(cmd_result);
                 }
                        SAFE_FREE(cmd);
                        result = NT_STATUS_IS_ERR(cmd_result);
                 }


@@ -955,7 +1078,7 @@ out_free:
                        break;
 
                if (line[0] != '\n')
                        break;
 
                if (line[0] != '\n')

-                       process_cmd(rpcclient_auth_info, cli, line);
+                       process_cmd(rpcclient_auth_info, cli, binding, line);

                SAFE_FREE(line);
        }
 
                SAFE_FREE(line);
        }