Merge branch 'master' of ssh://git.samba.org/data/git/samba

4 files changed, 121 insertions, 85 deletions

diff --git a/source3/lib/display_sec.c b/source3/lib/display_sec.c
index a0d93d6fe7..636639c11d 100644
--- a/source3/lib/display_sec.c
+++ b/source3/lib/display_sec.c
@@ -240,7 +240,7 @@ void display_sec_acl(SEC_ACL *sec_acl)
 
 void display_acl_type(uint16 type)
 {
-	static fstring typestr="";
+	fstring typestr="";
 
 	typestr[0] = 0;
 
diff --git a/source3/lib/popt_common.c b/source3/lib/popt_common.c
index 9e67c5257d..cad14ec493 100644
--- 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 074b523ae0..dd23d547b5 100644
--- 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/lib/util_str.c b/source3/lib/util_str.c
index fde4f825e8..9358061797 100644
--- a/source3/lib/util_str.c
+++ b/source3/lib/util_str.c
@@ -24,7 +24,7 @@
 
 #include "includes.h"
 
-char toupper_ascii_fast_table[128] = {
+const char toupper_ascii_fast_table[128] = {
 	0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
 	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,