Remove the global "cmdline_auth_info" from source3/lib/util.c

This involves changing all our clients, that's why it's so large.

diff --git a/source3/client/client.c b/source3/client/client.c
index da789161c9829869e03fc05cb415ca598e3d0107..c88b918dc8c0eba265cb384d57668b621fe434ba 100644 (file)
--- a/source3/client/client.c
+++ b/source3/client/client.c
@@ -218,13 +218,12 @@ static int readfile(char *b, int n, XFILE *f)
  Send a message.
 ****************************************************************************/
 
-static void send_message(void)
+static void send_message(const char *username)
 {
        int total_len = 0;
        int grp_id;
 
-       if (!cli_message_start(cli, desthost,
-                               get_cmdline_auth_info_username(), &grp_id)) {
+       if (!cli_message_start(cli, desthost, username, &grp_id)) {
                d_printf("message start: %s\n", cli_errstr(cli));
                return;
        }
@@ -4607,7 +4606,7 @@ static int do_tar_op(const char *base_directory)
  Handle a message operation.
 ****************************************************************************/
 
-static int do_message_op(void)
+static int do_message_op(struct user_auth_info *auth_info)
 {
        struct sockaddr_storage ss;
        struct nmb_name called, calling;
@@ -4648,7 +4647,7 @@ static int do_message_op(void)
                return 1;
        }
 
-       send_message();
+       send_message(get_cmdline_auth_info_username(auth_info));
        cli_cm_shutdown();
 
        return 0;
@@ -4695,6 +4694,7 @@ static int do_message_op(void)
                POPT_TABLEEND
        };
        TALLOC_CTX *frame = talloc_stackframe();
+       struct user_auth_info *auth_info;
 
        if (!client_set_cur_dir("\\")) {
                exit(ENOMEM);
@@ -4724,6 +4724,12 @@ static int do_message_op(void)
 
        load_case_tables();
 
+       auth_info = user_auth_info_init(frame);
+       if (auth_info == NULL) {
+               exit(1);
+       }
+       popt_common_set_auth_info(auth_info);
+
        /* skip argv(0) */
        pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);
        poptSetOtherOptionHelp(pc, "service <password>");
@@ -4751,8 +4757,11 @@ static int do_message_op(void)
                }
 
                /* if the service has already been retrieved then check if we have also a password */
-               if (service_opt && (!get_cmdline_auth_info_got_pass()) && poptPeekArg(pc)) {
-                       set_cmdline_auth_info_password(poptGetArg(pc));
+               if (service_opt
+                   && (!get_cmdline_auth_info_got_pass(auth_info))
+                   && poptPeekArg(pc)) {
+                       set_cmdline_auth_info_password(auth_info,
+                                                      poptGetArg(pc));
                }
 
                switch (opt) {
@@ -4858,8 +4867,11 @@ static int do_message_op(void)
        }
 
        /* if the service has already been retrieved then check if we have also a password */
-       if (service_opt && !get_cmdline_auth_info_got_pass() && poptPeekArg(pc)) {
-               set_cmdline_auth_info_password(poptGetArg(pc));
+       if (service_opt
+           && !get_cmdline_auth_info_got_pass(auth_info)
+           && poptPeekArg(pc)) {
+               set_cmdline_auth_info_password(auth_info,
+                                              poptGetArg(pc));
        }
 
        /* check for the -P option */
@@ -4893,8 +4905,8 @@ static int do_message_op(void)
                        argv[0], get_dyn_CONFIGFILE());
        }
 
-       if (get_cmdline_auth_info_use_machine_account() &&
-           !set_cmdline_auth_info_machine_account_creds()) {
+       if (get_cmdline_auth_info_use_machine_account(auth_info) &&
+           !set_cmdline_auth_info_machine_account_creds(auth_info)) {
                exit(-1);
        }
 
@@ -4929,7 +4941,7 @@ static int do_message_op(void)
                calling_name = talloc_strdup(frame, global_myname() );
        }
 
-       smb_encrypt = get_cmdline_auth_info_smb_encrypt();
+       smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);
        if (!init_names()) {
                fprintf(stderr, "init_names() failed\n");
                exit(1);
@@ -4947,7 +4959,7 @@ static int do_message_op(void)
 
        /* Store the username and password for dfs support */
 
-       cli_cm_set_credentials();
+       cli_cm_set_credentials(auth_info);
 
        DEBUG(3,("Client started (version %s).\n", SAMBA_VERSION_STRING));
 
@@ -4980,7 +4992,7 @@ static int do_message_op(void)
        }
 
        if (message) {
-               return do_message_op();
+               return do_message_op(auth_info);
        }
 
        if (process(base_directory)) {

diff --git a/source3/include/proto.h b/source3/include/proto.h
index 69194ec6b2f69179a539a529189afca974f4efde..2a8f83847fe9dcf77ccc32e82c1086bbf9b99a6e 100644 (file)
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -637,6 +637,7 @@ void pidfile_create(const char *program_name);
 
 /* The following definitions come from lib/popt_common.c  */
 
+void popt_common_set_auth_info(struct user_auth_info *auth_info);
 
 /* The following definitions come from lib/privileges.c  */
 
@@ -1139,22 +1140,28 @@ void gfree_all( void );
 const char *my_netbios_names(int i);
 bool set_netbios_aliases(const char **str_array);
 bool init_names(void);
-const char *get_cmdline_auth_info_username(void);
-void set_cmdline_auth_info_username(const char *username);
-const char *get_cmdline_auth_info_password(void);
-void set_cmdline_auth_info_password(const char *password);
-bool set_cmdline_auth_info_signing_state(const char *arg);
-int get_cmdline_auth_info_signing_state(void);
-void set_cmdline_auth_info_use_kerberos(bool b);
-bool get_cmdline_auth_info_use_kerberos(void);
-void set_cmdline_auth_info_use_krb5_ticket(void);
-void set_cmdline_auth_info_smb_encrypt(void);
-void set_cmdline_auth_info_use_machine_account(void);
-bool get_cmdline_auth_info_got_pass(void);
-bool get_cmdline_auth_info_smb_encrypt(void);
-bool get_cmdline_auth_info_use_machine_account(void);
-bool get_cmdline_auth_info_copy(struct user_auth_info *info);
-bool set_cmdline_auth_info_machine_account_creds(void);
+struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx);
+const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info);
+void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
+                                   const char *username);
+void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
+                                   const char *password);
+const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info);
+bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
+                                        const char *arg);
+int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info);
+void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
+                                       bool b);
+bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info);
+void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info);
+void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
+void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
+struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
+                                                struct user_auth_info *info);
+bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info);
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
                             gid_t **gids, size_t *num_gids);
 const char *get_numlist(const char *p, uint32 **num, int *count);
@@ -2419,7 +2426,7 @@ struct cli_state *cli_cm_open(TALLOC_CTX *ctx,
                                bool force_encrypt);
 void cli_cm_shutdown(void);
 void cli_cm_display(void);
-void cli_cm_set_credentials(void);
+void cli_cm_set_credentials(struct user_auth_info *auth_info);
 void cli_cm_set_port(int port_number);
 void cli_cm_set_dest_name_type(int type);
 void cli_cm_set_signing_state(int state);

diff --git a/source3/lib/popt_common.c b/source3/lib/popt_common.c
index 9e67c5257d444ff09a97529152513c6fe8592d69..cad14ec493092ebd18b4fd1a4c48795681e0f9f9 100644 (file)
--- a/source3/lib/popt_common.c
+++ b/source3/lib/popt_common.c
@@ -318,7 +318,7 @@ const struct poptOption popt_common_dynconfig[] = {
  * exit on failure
  * ****************************************************************************/
 
-static void get_password_file(void)
+static void get_password_file(struct user_auth_info *auth_info)
 {
        int fd = -1;
        char *p;
@@ -377,13 +377,14 @@ static void get_password_file(void)
        }
        SAFE_FREE(spec);
 
-       set_cmdline_auth_info_password(pass);
+       set_cmdline_auth_info_password(auth_info, pass);
        if (close_it) {
                close(fd);
        }
 }
 
-static void get_credentials_file(const char *file)
+static void get_credentials_file(struct user_auth_info *auth_info,
+                                const char *file)
 {
        XFILE *auth;
        fstring buf;
@@ -426,9 +427,9 @@ static void get_credentials_file(const char *file)
                        val++;
 
                if (strwicmp("password", param) == 0) {
-                       set_cmdline_auth_info_password(val);
+                       set_cmdline_auth_info_password(auth_info, val);
                } else if (strwicmp("username", param) == 0) {
-                       set_cmdline_auth_info_username(val);
+                       set_cmdline_auth_info_username(auth_info, val);
                } else if (strwicmp("domain", param) == 0) {
                        set_global_myworkgroup(val);
                }
@@ -453,13 +454,16 @@ static void popt_common_credentials_callback(poptContext con,
                                        const struct poptOption *opt,
                                        const char *arg, const void *data)
 {
+       struct user_auth_info *auth_info = talloc_get_type_abort(
+               *((const char **)data), struct user_auth_info);
        char *p;
 
        if (reason == POPT_CALLBACK_REASON_PRE) {
-               set_cmdline_auth_info_username("GUEST");
+               set_cmdline_auth_info_username(auth_info, "GUEST");
 
                if (getenv("LOGNAME")) {
-                       set_cmdline_auth_info_username(getenv("LOGNAME"));
+                       set_cmdline_auth_info_username(auth_info,
+                                                      getenv("LOGNAME"));
                }
 
                if (getenv("USER")) {
@@ -467,24 +471,25 @@ static void popt_common_credentials_callback(poptContext con,
                        if (!puser) {
                                exit(ENOMEM);
                        }
-                       set_cmdline_auth_info_username(puser);
+                       set_cmdline_auth_info_username(auth_info, puser);
 
                        if ((p = strchr_m(puser,'%'))) {
                                size_t len;
                                *p = 0;
                                len = strlen(p+1);
-                               set_cmdline_auth_info_password(p+1);
+                               set_cmdline_auth_info_password(auth_info, p+1);
                                memset(strchr_m(getenv("USER"),'%')+1,'X',len);
                        }
                        SAFE_FREE(puser);
                }
 
                if (getenv("PASSWD")) {
-                       set_cmdline_auth_info_password(getenv("PASSWD"));
+                       set_cmdline_auth_info_password(auth_info,
+                                                      getenv("PASSWD"));
                }
 
                if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
-                       get_password_file();
+                       get_password_file(auth_info);
                }
 
                return;
@@ -499,19 +504,22 @@ static void popt_common_credentials_callback(poptContext con,
                        if ((lp=strchr_m(puser,'%'))) {
                                size_t len;
                                *lp = 0;
-                               set_cmdline_auth_info_username(puser);
-                               set_cmdline_auth_info_password(lp+1);
+                               set_cmdline_auth_info_username(auth_info,
+                                                              puser);
+                               set_cmdline_auth_info_password(auth_info,
+                                                              lp+1);
                                len = strlen(lp+1);
                                memset(strchr_m(arg,'%')+1,'X',len);
                        } else {
-                               set_cmdline_auth_info_username(puser);
+                               set_cmdline_auth_info_username(auth_info,
+                                                              puser);
                        }
                        SAFE_FREE(puser);
                }
                break;
 
        case 'A':
-               get_credentials_file(arg);
+               get_credentials_file(auth_info, arg);
                break;
 
        case 'k':
@@ -519,31 +527,40 @@ static void popt_common_credentials_callback(poptContext con,
                d_printf("No kerberos support compiled in\n");
                exit(1);
 #else
-               set_cmdline_auth_info_use_krb5_ticket();
+               set_cmdline_auth_info_use_krb5_ticket(auth_info);
 #endif
                break;
 
        case 'S':
-               if (!set_cmdline_auth_info_signing_state(arg)) {
+               if (!set_cmdline_auth_info_signing_state(auth_info, arg)) {
                        fprintf(stderr, "Unknown signing option %s\n", arg );
                        exit(1);
                }
                break;
        case 'P':
-               set_cmdline_auth_info_use_machine_account();
+               set_cmdline_auth_info_use_machine_account(auth_info);
                break;
        case 'N':
-               set_cmdline_auth_info_password("");
+               set_cmdline_auth_info_password(auth_info, "");
                break;
        case 'e':
-               set_cmdline_auth_info_smb_encrypt();
+               set_cmdline_auth_info_smb_encrypt(auth_info);
                break;
 
        }
 }
 
+static struct user_auth_info *global_auth_info;
+
+void popt_common_set_auth_info(struct user_auth_info *auth_info)
+{
+       global_auth_info = auth_info;
+}
+
 struct poptOption popt_common_credentials[] = {
-       { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_PRE, (void *)popt_common_credentials_callback },
+       { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_PRE,
+         (void *)popt_common_credentials_callback, 0,
+         (const char *)&global_auth_info },
        { "user", 'U', POPT_ARG_STRING, NULL, 'U', "Set the network username", "USERNAME" },
        { "no-pass", 'N', POPT_ARG_NONE, NULL, 'N', "Don't ask for a password" },
        { "kerberos", 'k', POPT_ARG_NONE, NULL, 'k', "Use kerberos (active directory) authentication" },

diff --git a/source3/lib/util.c b/source3/lib/util.c
index 074b523ae0b8a320076629d7284ebfd0b9f366ff..dd23d547b5d240425617587792ae87aafc6141a2 100644 (file)
--- a/source3/lib/util.c
+++ b/source3/lib/util.c
@@ -280,135 +280,154 @@ bool init_names(void)
   Used mainly in client tools.
 ****************************************************************************/
 
-static struct user_auth_info cmdline_auth_info = {
-       NULL,   /* username */
-       NULL,   /* password */
-       false,  /* got_pass */
-       false,  /* use_kerberos */
-       Undefined, /* signing state */
-       false,  /* smb_encrypt */
-       false   /* use machine account */
-};
-
-const char *get_cmdline_auth_info_username(void)
-{
-       if (!cmdline_auth_info.username) {
+struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
+{
+       struct user_auth_info *result;
+
+       result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
+       if (result == NULL) {
+               return NULL;
+       }
+
+       result->signing_state = Undefined;
+       return result;
+}
+
+const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info)
+{
+       if (!auth_info->username) {
                return "";
        }
-       return cmdline_auth_info.username;
+       return auth_info->username;
 }
 
-void set_cmdline_auth_info_username(const char *username)
+void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
+                                   const char *username)
 {
-       SAFE_FREE(cmdline_auth_info.username);
-       cmdline_auth_info.username = SMB_STRDUP(username);
-       if (!cmdline_auth_info.username) {
+       TALLOC_FREE(auth_info->username);
+       auth_info->username = talloc_strdup(auth_info, username);
+       if (!auth_info->username) {
                exit(ENOMEM);
        }
 }
 
-const char *get_cmdline_auth_info_password(void)
+const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info)
 {
-       if (!cmdline_auth_info.password) {
+       if (!auth_info->password) {
                return "";
        }
-       return cmdline_auth_info.password;
+       return auth_info->password;
 }
 
-void set_cmdline_auth_info_password(const char *password)
+void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
+                                   const char *password)
 {
-       SAFE_FREE(cmdline_auth_info.password);
-       cmdline_auth_info.password = SMB_STRDUP(password);
-       if (!cmdline_auth_info.password) {
+       TALLOC_FREE(auth_info->password);
+       auth_info->password = talloc_strdup(auth_info, password);
+       if (!auth_info->password) {
                exit(ENOMEM);
        }
-       cmdline_auth_info.got_pass = true;
+       auth_info->got_pass = true;
 }
 
-bool set_cmdline_auth_info_signing_state(const char *arg)
+bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
+                                        const char *arg)
 {
-       cmdline_auth_info.signing_state = -1;
+       auth_info->signing_state = -1;
        if (strequal(arg, "off") || strequal(arg, "no") ||
                        strequal(arg, "false")) {
-               cmdline_auth_info.signing_state = false;
+               auth_info->signing_state = false;
        } else if (strequal(arg, "on") || strequal(arg, "yes") ||
                        strequal(arg, "true") || strequal(arg, "auto")) {
-               cmdline_auth_info.signing_state = true;
+               auth_info->signing_state = true;
        } else if (strequal(arg, "force") || strequal(arg, "required") ||
                        strequal(arg, "forced")) {
-               cmdline_auth_info.signing_state = Required;
+               auth_info->signing_state = Required;
        } else {
                return false;
        }
        return true;
 }
 
-int get_cmdline_auth_info_signing_state(void)
+int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info)
 {
-       return cmdline_auth_info.signing_state;
+       return auth_info->signing_state;
 }
 
-void set_cmdline_auth_info_use_kerberos(bool b)
+void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
+                                       bool b)
 {
-        cmdline_auth_info.use_kerberos = b;
+        auth_info->use_kerberos = b;
 }
 
-bool get_cmdline_auth_info_use_kerberos(void)
+bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info)
 {
-       return cmdline_auth_info.use_kerberos;
+       return auth_info->use_kerberos;
 }
 
 /* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_use_krb5_ticket(void)
+void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
 {
-       cmdline_auth_info.use_kerberos = true;
-       cmdline_auth_info.got_pass = true;
+       auth_info->use_kerberos = true;
+       auth_info->got_pass = true;
 }
 
 /* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_smb_encrypt(void)
+void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 {
-       cmdline_auth_info.smb_encrypt = true;
+       auth_info->smb_encrypt = true;
 }
 
-void set_cmdline_auth_info_use_machine_account(void)
+void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 {
-       cmdline_auth_info.use_machine_account = true;
+       auth_info->use_machine_account = true;
 }
 
-bool get_cmdline_auth_info_got_pass(void)
+bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info)
 {
-       return cmdline_auth_info.got_pass;
+       return auth_info->got_pass;
 }
 
-bool get_cmdline_auth_info_smb_encrypt(void)
+bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 {
-       return cmdline_auth_info.smb_encrypt;
+       return auth_info->smb_encrypt;
 }
 
-bool get_cmdline_auth_info_use_machine_account(void)
+bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 {
-       return cmdline_auth_info.use_machine_account;
+       return auth_info->use_machine_account;
 }
 
-bool get_cmdline_auth_info_copy(struct user_auth_info *info)
+struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
+                                                 struct user_auth_info *src)
 {
-       *info = cmdline_auth_info;
-       /* Now re-alloc the strings. */
-       info->username = SMB_STRDUP(get_cmdline_auth_info_username());
-       info->password = SMB_STRDUP(get_cmdline_auth_info_password());
-       if (!info->username || !info->password) {
-               return false;
+       struct user_auth_info *result;
+
+       result = user_auth_info_init(mem_ctx);
+       if (result == NULL) {
+               return NULL;
        }
-       return true;
+
+       *result = *src;
+
+       result->username = talloc_strdup(
+               result, get_cmdline_auth_info_username(src));
+       result->password = talloc_strdup(
+               result, get_cmdline_auth_info_password(src));
+       if ((result->username == NULL) || (result->password == NULL)) {
+               TALLOC_FREE(result);
+               return NULL;
+       }
+
+       return result;
 }
 
-bool set_cmdline_auth_info_machine_account_creds(void)
+bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
 {
        char *pass = NULL;
        char *account = NULL;
 
-       if (!get_cmdline_auth_info_use_machine_account()) {
+       if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
                return false;
        }
 
@@ -430,8 +449,8 @@ bool set_cmdline_auth_info_machine_account_creds(void)
                return false;
        }
 
-       set_cmdline_auth_info_username(account);
-       set_cmdline_auth_info_password(pass);
+       set_cmdline_auth_info_username(auth_info, account);
+       set_cmdline_auth_info_password(auth_info, pass);
 
        SAFE_FREE(account);
        SAFE_FREE(pass);

diff --git a/source3/librpc/rpc/dcerpc.c b/source3/librpc/rpc/dcerpc.c
index 77bb7b33a2f9a8113faee6b03f33438ab1972172..69bfc6f329a3e91d25f31c386c90e4139125618c 100644 (file)
--- a/source3/librpc/rpc/dcerpc.c
+++ b/source3/librpc/rpc/dcerpc.c
@@ -117,6 +117,10 @@ NTSTATUS dcerpc_ndr_request_recv(struct rpc_request *req)
        return NT_STATUS_OK;
 }
 
+#if 0
+
+Completely unfinished and unused -- vl :-)
+
 /**
  * Connect to a DCE/RPC interface.
  * 
@@ -178,3 +182,5 @@ _PUBLIC_ NTSTATUS dcerpc_pipe_connect(TALLOC_CTX *parent_ctx, struct dcerpc_pipe
 
        return nt_status;
 }
+
+#endif

diff --git a/source3/libsmb/clidfs.c b/source3/libsmb/clidfs.c
index 35922b13e9493d942160485a443e4e7a220c4067..f0ac39fed0582e435d0c3e5e724c7c891bcd2fb5 100644 (file)
--- a/source3/libsmb/clidfs.c
+++ b/source3/libsmb/clidfs.c
@@ -471,18 +471,19 @@ static void cm_set_password(const char *newpass)
 /****************************************************************************
 ****************************************************************************/
 
-void cli_cm_set_credentials(void)
+void cli_cm_set_credentials(struct user_auth_info *auth_info)
 {
        SAFE_FREE(cm_creds.username);
-       cm_creds.username = SMB_STRDUP(get_cmdline_auth_info_username());
+       cm_creds.username = SMB_STRDUP(get_cmdline_auth_info_username(
+                                              auth_info));
 
-       if (get_cmdline_auth_info_got_pass()) {
-               cm_set_password(get_cmdline_auth_info_password());
+       if (get_cmdline_auth_info_got_pass(auth_info)) {
+               cm_set_password(get_cmdline_auth_info_password(auth_info));
        }
 
-       cm_creds.use_kerberos = get_cmdline_auth_info_use_kerberos();
+       cm_creds.use_kerberos = get_cmdline_auth_info_use_kerberos(auth_info);
        cm_creds.fallback_after_kerberos = false;
-       cm_creds.signing_state = get_cmdline_auth_info_signing_state();
+       cm_creds.signing_state = get_cmdline_auth_info_signing_state(auth_info);
 }
 
 /****************************************************************************

diff --git a/source3/libsmb/libsmb_context.c b/source3/libsmb/libsmb_context.c
index 19843383de2bc864a130e57d1384b7e3e41c5117..becee17f655658e714ea4d764871bb0ec19e2f3e 100644 (file)
--- a/source3/libsmb/libsmb_context.c
+++ b/source3/libsmb/libsmb_context.c
@@ -633,13 +633,19 @@ smbc_set_credentials(char *workgroup,
                      smbc_bool use_kerberos,
                      char *signing_state)
 {
-        
-        set_cmdline_auth_info_username(user);
-        set_cmdline_auth_info_password(password);
-        set_cmdline_auth_info_use_kerberos(use_kerberos);
-        if (! set_cmdline_auth_info_signing_state(signing_state)) {
+        struct user_auth_info *auth_info;
+
+       auth_info = user_auth_info_init(talloc_tos());
+       if (auth_info == NULL) {
+               return;
+       }
+        set_cmdline_auth_info_username(auth_info, user);
+        set_cmdline_auth_info_password(auth_info, password);
+        set_cmdline_auth_info_use_kerberos(auth_info, use_kerberos);
+        if (! set_cmdline_auth_info_signing_state(auth_info, signing_state)) {
                 DEBUG(0, ("Invalid signing state: %s", signing_state));
         }
         set_global_myworkgroup(workgroup);
-        cli_cm_set_credentials();
+        cli_cm_set_credentials(auth_info);
+       TALLOC_FREE(auth_info);
 }

diff --git a/source3/rpcclient/cmd_spoolss.c b/source3/rpcclient/cmd_spoolss.c
index 26a73203b910c79228c80f69ff3172585c4731ab..038acfbcdc89fe3d456b0085714df7633df69422 100644 (file)
--- a/source3/rpcclient/cmd_spoolss.c
+++ b/source3/rpcclient/cmd_spoolss.c
@@ -2641,6 +2641,8 @@ done:
 /****************************************************************************
 ****************************************************************************/
 
+extern struct user_auth_info *rpcclient_auth_info;
+
 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli, 
                                     TALLOC_CTX *mem_ctx, int argc, 
                                     const char **argv)
@@ -2671,11 +2673,11 @@ static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
        nt_status = cli_full_connection(&cli_server2, global_myname(), servername2, 
                                        NULL, 0,
                                        "IPC$", "IPC",
-                                       get_cmdline_auth_info_username(),
+                                       get_cmdline_auth_info_username(rpcclient_auth_info),
                                        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_password(rpcclient_auth_info),
+                                       get_cmdline_auth_info_use_kerberos(rpcclient_auth_info) ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
+                                       get_cmdline_auth_info_signing_state(rpcclient_auth_info), NULL);
 
        if ( !NT_STATUS_IS_OK(nt_status) )
                return WERR_GENERAL_FAILURE;

diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c
index e8ffddb6dc4bc6e7e24f4d3d5e05da5cd235f50b..dc125007e3a0cc8f3898aed4c3aa91da8905498a 100644 (file)
--- a/source3/rpcclient/rpcclient.c
+++ b/source3/rpcclient/rpcclient.c
@@ -28,6 +28,8 @@ 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 unsigned int timeout = 0;
 
+struct user_auth_info *rpcclient_auth_info;
+
 /* List to hold groups of commands.
  *
  * Commands are defined in a list of arrays: arrays are easy to
@@ -560,6 +562,7 @@ static void add_command_set(struct cmd_set *cmd_set)
  * @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,
                       int argc, char **argv)
 {
@@ -589,8 +592,8 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                                        cli, cmd_entry->interface,
                                        pipe_default_auth_level,
                                        lp_workgroup(),
-                                       get_cmdline_auth_info_username(),
-                                       get_cmdline_auth_info_password(),
+                                       get_cmdline_auth_info_username(auth_info),
+                                       get_cmdline_auth_info_password(auth_info),
                                        &cmd_entry->rpc_pipe);
                                break;
                        case PIPE_AUTH_TYPE_NTLMSSP:
@@ -598,8 +601,8 @@ static NTSTATUS do_cmd(struct cli_state *cli,
                                        cli, cmd_entry->interface,
                                        pipe_default_auth_level,
                                        lp_workgroup(),
-                                       get_cmdline_auth_info_username(),
-                                       get_cmdline_auth_info_password(),
+                                       get_cmdline_auth_info_username(auth_info),
+                                       get_cmdline_auth_info_password(auth_info),
                                        &cmd_entry->rpc_pipe);
                                break;
                        case PIPE_AUTH_TYPE_SCHANNEL:
@@ -687,7 +690,8 @@ static NTSTATUS do_cmd(struct cli_state *cli,
  *
  * @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, char *cmd)
 {
        struct cmd_list *temp_list;
        NTSTATUS result = NT_STATUS_OK;
@@ -713,7 +717,8 @@ static NTSTATUS process_cmd(struct cli_state *cli, char *cmd)
                                        goto out_free;
                                }
 
-                               result = do_cmd(cli, temp_set, argc, argv);
+                               result = do_cmd(cli, auth_info, temp_set,
+                                               argc, argv);
 
                                goto out_free;
                        }
@@ -784,6 +789,12 @@ out_free:
           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,
@@ -850,16 +861,16 @@ out_free:
         * from stdin if necessary
         */
 
-       if (get_cmdline_auth_info_use_machine_account() &&
-           !set_cmdline_auth_info_machine_account_creds()) {
+       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;
        }
 
-       if (!get_cmdline_auth_info_got_pass()) {
+       if (!get_cmdline_auth_info_got_pass(rpcclient_auth_info)) {
                char *pass = getpass("Password:");
                if (pass) {
-                       set_cmdline_auth_info_password(pass);
+                       set_cmdline_auth_info_password(rpcclient_auth_info, pass);
                }
        }
 
@@ -868,7 +879,7 @@ out_free:
                server += 2;
        }
 
-       if (get_cmdline_auth_info_use_kerberos()) {
+       if (get_cmdline_auth_info_use_kerberos(rpcclient_auth_info)) {
                flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
                         CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
        }
@@ -877,11 +888,12 @@ out_free:
        nt_status = cli_full_connection(&cli, global_myname(), server,
                                        opt_ipaddr ? &server_ss : NULL, opt_port,
                                        "IPC$", "IPC",
-                                       get_cmdline_auth_info_username(),
+                                       get_cmdline_auth_info_username(rpcclient_auth_info),
                                        lp_workgroup(),
-                                       get_cmdline_auth_info_password(),
+                                       get_cmdline_auth_info_password(rpcclient_auth_info),
                                        flags,
-                                       get_cmdline_auth_info_signing_state(),NULL);
+                                       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)));
@@ -889,10 +901,10 @@ out_free:
                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(),
+                                       get_cmdline_auth_info_username(rpcclient_auth_info),
+                                       get_cmdline_auth_info_password(rpcclient_auth_info),
                                        lp_workgroup(),
                                        "IPC$");
                if (!NT_STATUS_IS_OK(nt_status)) {
@@ -927,7 +939,7 @@ out_free:
                result = 0;
 
                 while((cmd=next_command(&p)) != NULL) {
-                        NTSTATUS cmd_result = process_cmd(cli, cmd);
+                        NTSTATUS cmd_result = process_cmd(rpcclient_auth_info, cli, cmd);
                        SAFE_FREE(cmd);
                        result = NT_STATUS_IS_ERR(cmd_result);
                 }
@@ -946,7 +958,7 @@ out_free:
                        break;
 
                if (line[0] != '\n')
-                       process_cmd(cli, line);
+                       process_cmd(rpcclient_auth_info, cli, line);
                SAFE_FREE(line);
        }
 

diff --git a/source3/utils/smbcacls.c b/source3/utils/smbcacls.c
index f7f12722158548cfc2f5876e6168cb900bb6ba1a..f07b5011c8ac10c09d9f9c29f7e87420b8502f61 100644 (file)
--- a/source3/utils/smbcacls.c
+++ b/source3/utils/smbcacls.c
@@ -951,7 +951,8 @@ static int cacl_set(struct cli_state *cli, char *filename,
 /*****************************************************
  Return a connection to a server.
 *******************************************************/
-static struct cli_state *connect_one(const char *server, const char *share)
+static struct cli_state *connect_one(struct user_auth_info *auth_info,
+                                    const char *server, const char *share)
 {
        struct cli_state *c = NULL;
        struct sockaddr_storage ss;
@@ -960,41 +961,41 @@ static struct cli_state *connect_one(const char *server, const char *share)
 
        zero_sockaddr(&ss);
 
-       if (get_cmdline_auth_info_use_kerberos()) {
+       if (get_cmdline_auth_info_use_kerberos(auth_info)) {
                flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
                         CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
        }
 
-       if (get_cmdline_auth_info_use_machine_account() &&
-           !set_cmdline_auth_info_machine_account_creds()) {
+       if (get_cmdline_auth_info_use_machine_account(auth_info) &&
+           !set_cmdline_auth_info_machine_account_creds(auth_info)) {
                return NULL;
        }
 
-       if (!get_cmdline_auth_info_got_pass()) {
+       if (!get_cmdline_auth_info_got_pass(auth_info)) {
                char *pass = getpass("Password: ");
                if (pass) {
-                       set_cmdline_auth_info_password(pass);
+                       set_cmdline_auth_info_password(auth_info, pass);
                }
        }
 
        nt_status = cli_full_connection(&c, global_myname(), server, 
                                &ss, 0,
                                share, "?????",
-                               get_cmdline_auth_info_username(),
+                               get_cmdline_auth_info_username(auth_info),
                                lp_workgroup(),
-                               get_cmdline_auth_info_password(),
+                               get_cmdline_auth_info_password(auth_info),
                                flags,
-                               get_cmdline_auth_info_signing_state(),
+                               get_cmdline_auth_info_signing_state(auth_info),
                                NULL);
        if (!NT_STATUS_IS_OK(nt_status)) {
                DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
                return NULL;
        }
 
-       if (get_cmdline_auth_info_smb_encrypt()) {
+       if (get_cmdline_auth_info_smb_encrypt(auth_info)) {
                nt_status = cli_cm_force_encryption(c,
-                                       get_cmdline_auth_info_username(),
-                                       get_cmdline_auth_info_password(),
+                                       get_cmdline_auth_info_username(auth_info),
+                                       get_cmdline_auth_info_password(auth_info),
                                        lp_workgroup(),
                                        share);
                 if (!NT_STATUS_IS_OK(nt_status)) {
@@ -1040,6 +1041,7 @@ static struct cli_state *connect_one(const char *server, const char *share)
        TALLOC_CTX *frame = talloc_stackframe();
        const char *owner_username = "";
        char *server;
+       struct user_auth_info *auth_info;
 
        load_case_tables();
 
@@ -1055,6 +1057,12 @@ static struct cli_state *connect_one(const char *server, const char *share)
        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
        load_interfaces();
 
+       auth_info = user_auth_info_init(frame);
+       if (auth_info == NULL) {
+               exit(1);
+       }
+       popt_common_set_auth_info(auth_info);
+
        pc = poptGetContext("smbcacls", argc, argv, long_options, 0);
 
        poptSetOtherOptionHelp(pc, "//server1/share1 filename\nACLs look like: "
@@ -1131,7 +1139,7 @@ static struct cli_state *connect_one(const char *server, const char *share)
        share++;
 
        if (!test_args) {
-               cli = connect_one(server, share);
+               cli = connect_one(auth_info, server, share);
                if (!cli) {
                        exit(EXIT_FAILED);
                }

diff --git a/source3/utils/smbcquotas.c b/source3/utils/smbcquotas.c
index 8938cc5e65e544eea00d12b2079997988f294994..a95394b125ced5349f90e261175cfa94bf6bce6a 100644 (file)
--- a/source3/utils/smbcquotas.c
+++ b/source3/utils/smbcquotas.c
@@ -37,6 +37,7 @@ static struct cli_state *cli_ipc;
 static struct rpc_pipe_client *global_pipe_hnd;
 static POLICY_HND pol;
 static bool got_policy_hnd;
+static struct user_auth_info *smbcquotas_auth_info;
 
 static struct cli_state *connect_one(const char *share);
 
@@ -373,42 +374,42 @@ static struct cli_state *connect_one(const char *share)
 
        zero_sockaddr(&ss);
 
-       if (get_cmdline_auth_info_use_machine_account() &&
-           !set_cmdline_auth_info_machine_account_creds()) {
+       if (get_cmdline_auth_info_use_machine_account(smbcquotas_auth_info) &&
+           !set_cmdline_auth_info_machine_account_creds(smbcquotas_auth_info)) {
                return NULL;
        }
 
-       if (get_cmdline_auth_info_use_kerberos()) {
+       if (get_cmdline_auth_info_use_kerberos(smbcquotas_auth_info)) {
                flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
                         CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
 
        }
 
-       if (!get_cmdline_auth_info_got_pass()) {
+       if (!get_cmdline_auth_info_got_pass(smbcquotas_auth_info)) {
                char *pass = getpass("Password: ");
                if (pass) {
-                       set_cmdline_auth_info_password(pass);
+                       set_cmdline_auth_info_password(smbcquotas_auth_info, pass);
                }
        }
 
        nt_status = cli_full_connection(&c, global_myname(), server, 
                                            &ss, 0,
                                            share, "?????",
-                                           get_cmdline_auth_info_username(),
+                                           get_cmdline_auth_info_username(smbcquotas_auth_info),
                                            lp_workgroup(),
-                                           get_cmdline_auth_info_password(),
+                                           get_cmdline_auth_info_password(smbcquotas_auth_info),
                                            flags,
-                                           get_cmdline_auth_info_signing_state(),
+                                           get_cmdline_auth_info_signing_state(smbcquotas_auth_info),
                                            NULL);
        if (!NT_STATUS_IS_OK(nt_status)) {
                DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
                return NULL;
        }
 
-       if (get_cmdline_auth_info_smb_encrypt()) {
+       if (get_cmdline_auth_info_smb_encrypt(smbcquotas_auth_info)) {
                nt_status = cli_cm_force_encryption(c,
-                                       get_cmdline_auth_info_username(),
-                                       get_cmdline_auth_info_password(),
+                                       get_cmdline_auth_info_username(smbcquotas_auth_info),
+                                       get_cmdline_auth_info_password(smbcquotas_auth_info),
                                        lp_workgroup(),
                                        share);
                if (!NT_STATUS_IS_OK(nt_status)) {
@@ -475,6 +476,12 @@ FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
        load_interfaces();
 
+       smbcquotas_auth_info = user_auth_info_init(frame);
+       if (smbcquotas_auth_info == NULL) {
+               exit(1);
+       }
+       popt_common_set_auth_info(smbcquotas_auth_info);
+
        pc = poptGetContext("smbcquotas", argc, argv, long_options, 0);
 
        poptSetOtherOptionHelp(pc, "//server1/share1");
@@ -537,7 +544,8 @@ FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
                todo = USER_QUOTA;
 
        if (!fix_user) {
-               username_str = talloc_strdup(frame, get_cmdline_auth_info_username());
+               username_str = talloc_strdup(
+                       frame, get_cmdline_auth_info_username(smbcquotas_auth_info));
                if (!username_str) {
                        exit(EXIT_PARSE_ERROR);
                }

diff --git a/source3/utils/smbtree.c b/source3/utils/smbtree.c
index 9fc02bac13a07678e36040dccce05f76ba9ccdf6..6c69300e85b205c6125749f6a8a850c5d5600f09 100644 (file)
--- a/source3/utils/smbtree.c
+++ b/source3/utils/smbtree.c
@@ -272,7 +272,7 @@ static bool print_tree(struct user_auth_info *user_info)
  int main(int argc,char *argv[])
 {
        TALLOC_CTX *frame = talloc_stackframe();
-       struct user_auth_info local_auth_info;
+       struct user_auth_info *auth_info;
        struct poptOption long_options[] = {
                POPT_AUTOHELP
                { "broadcast", 'b', POPT_ARG_VAL, &use_bcast, True, "Use broadcast instead of using the master browser" },
@@ -293,6 +293,12 @@ static bool print_tree(struct user_auth_info *user_info)
 
        setup_logging(argv[0],True);
 
+       auth_info = user_auth_info_init(frame);
+       if (auth_info == NULL) {
+               exit(1);
+       }
+       popt_common_set_auth_info(auth_info);
+
        pc = poptGetContext("smbtree", argc, (const char **)argv, long_options,
                                                POPT_CONTEXT_KEEP_FIRST);
        while(poptGetNextOpt(pc) != -1);
@@ -303,26 +309,22 @@ static bool print_tree(struct user_auth_info *user_info)
 
        /* Parse command line args */
 
-       if (get_cmdline_auth_info_use_machine_account() &&
-           !set_cmdline_auth_info_machine_account_creds()) {
+       if (get_cmdline_auth_info_use_machine_account(auth_info) &&
+           !set_cmdline_auth_info_machine_account_creds(auth_info)) {
                TALLOC_FREE(frame);
                return 1;
        }
 
-       if (!get_cmdline_auth_info_got_pass()) {
+       if (!get_cmdline_auth_info_got_pass(auth_info)) {
                char *pass = getpass("Password: ");
                if (pass) {
-                       set_cmdline_auth_info_password(pass);
+                       set_cmdline_auth_info_password(auth_info, pass);
                }
        }
 
        /* Now do our stuff */
 
-       if (!get_cmdline_auth_info_copy(&local_auth_info)) {
-               return 1;
-       }
-
-        if (!print_tree(&local_auth_info)) {
+        if (!print_tree(auth_info)) {
                TALLOC_FREE(frame);
                 return 1;
        }