Remove PSTRING_LEN from smbd/ nmbd/.

Remove pstring from libsmb/clidfs.c except for a nasty
hack (that will be removed when pstrings are gone from
client/).
Jeremy.
(This used to be commit cc257b71d13daa47e6f2315d0f07a60eb4aaeca6)

8 files changed, 530 insertions, 390 deletions

diff --git a/source3/client/client.c b/source3/client/client.c
index 1c54b2d3f7..a65906c21a 100644
--- a/source3/client/client.c
+++ b/source3/client/client.c
@@ -226,7 +226,7 @@ static int do_dskattr(void)
 	struct cli_state *targetcli;
 	pstring targetpath;
 
-	if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) {
 		d_printf("Error in dskattr: %s\n", cli_errstr(cli));
 		return 1;
 	}
@@ -286,7 +286,7 @@ static int do_cd(char *newdir)
 	pstring_clean_name(cur_dir);
 	pstrcpy( dname, cur_dir );
 	
-	if ( !cli_resolve_path( "", cli, dname, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, dname, &targetcli, targetpath ) ) {
 		d_printf("cd %s: %s\n", dname, cli_errstr(cli));
 		pstrcpy(cur_dir,saved_dir);
 		goto out;
@@ -655,7 +655,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 			
 			/* check for dfs */
 			
-			if ( !cli_resolve_path( "", cli, head, &targetcli, targetpath ) ) {
+			if ( !cli_resolve_path_pstring( "", cli, head, &targetcli, targetpath ) ) {
 				d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
 				remove_do_list_queue_head();
 				continue;
@@ -685,7 +685,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 	} else {
 		/* check for dfs */
 			
-		if ( cli_resolve_path( "", cli, mask, &targetcli, targetpath ) ) {
+		if ( cli_resolve_path_pstring( "", cli, mask, &targetcli, targetpath ) ) {
 			if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1) 
 				d_printf("%s listing %s\n", cli_errstr(targetcli), targetpath);
 		}
@@ -823,7 +823,7 @@ static int do_get(char *rname, char *lname, bool reget)
 		strlower_m(lname);
 	}
 
-	if ( !cli_resolve_path( "", cli, rname, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) {
 		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
 		return 1;
 	}
@@ -1118,7 +1118,7 @@ static bool do_mkdir(char *name)
 	struct cli_state *targetcli;
 	pstring targetname;
 	
-	if ( !cli_resolve_path( "", cli, name, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, name, &targetcli, targetname ) ) {
 		d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
 		return False;
 	}
@@ -1188,7 +1188,7 @@ static int cmd_mkdir(void)
 		pstring targetname;
 		*ddir2 = 0;
 		
-		if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) {
+		if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
 			return 1;
 		}
 
@@ -1250,7 +1250,7 @@ static int do_put(char *rname, char *lname, bool reput)
 	struct cli_state *targetcli;
 	pstring targetname;
 	
-	if ( !cli_resolve_path( "", cli, rname, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) {
 		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
 		return 1;
 	}
@@ -1770,7 +1770,7 @@ static int cmd_wdel(void)
 	pstrcpy(mask,cur_dir);
 	pstrcat(mask,buf);
 
-	if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
 		d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1800,7 +1800,7 @@ static int cmd_open(void)
 	}
 	pstrcat(mask,buf);
 
-	if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
 		d_printf("open %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1845,7 +1845,7 @@ static int cmd_posix_open(void)
 	}
 	mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-	if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
 		d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1887,7 +1887,7 @@ static int cmd_posix_mkdir(void)
 	}
 	mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-	if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
 		d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1917,7 +1917,7 @@ static int cmd_posix_unlink(void)
 	}
 	pstrcat(mask,buf);
 
-	if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
 		d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1946,7 +1946,7 @@ static int cmd_posix_rmdir(void)
 	}
 	pstrcat(mask,buf);
 
-	if (!cli_resolve_path( "", cli, mask, &targetcli, targetname)) {
+	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname)) {
 		d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -2141,7 +2141,7 @@ static int cmd_rmdir(void)
 	}
 	pstrcat(mask,buf);
 
-	if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
 		d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -2177,7 +2177,7 @@ static int cmd_link(void)
 	pstrcat(oldname,buf);
 	pstrcat(newname,buf2);
 
-	if ( !cli_resolve_path( "", cli, oldname, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) {
 		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
 		return 1;
 	}
@@ -2222,7 +2222,7 @@ static int cmd_symlink(void)
 	pstrcpy(oldname,buf);
 	pstrcat(newname,buf2);
 
-	if ( !cli_resolve_path( "", cli, oldname, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) {
 		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
 		return 1;
 	}
@@ -2259,7 +2259,7 @@ static int cmd_chmod(void)
 	mode = (mode_t)strtol(buf, NULL, 8);
 	pstrcat(src,buf2);
 
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
 		d_printf("chmod %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -2407,7 +2407,7 @@ static int cmd_getfacl(void)
 
 	pstrcat(src,name);
 	
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
 		d_printf("stat %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -2572,7 +2572,7 @@ static int cmd_stat(void)
 	pstrcat(src,name);
 
 	
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
 		d_printf("stat %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -2663,7 +2663,7 @@ static int cmd_chown(void)
 	gid = (gid_t)atoi(buf2);
 	pstrcat(src,buf3);
 
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
 		d_printf("chown %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -2706,12 +2706,12 @@ static int cmd_rename(void)
 	pstrcat(src,buf);
 	pstrcat(dest,buf2);
 
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetsrc ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetsrc ) ) {
 		d_printf("rename %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
 
-	if ( !cli_resolve_path( "", cli, dest, &targetcli, targetdest ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, dest, &targetcli, targetdest ) ) {
 		d_printf("rename %s: %s\n", dest, cli_errstr(cli));
 		return 1;
 	}
@@ -2769,7 +2769,7 @@ static int cmd_hardlink(void)
 	pstrcat(src,buf);
 	pstrcat(dest,buf2);
 
-	if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
 		d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -3218,7 +3218,7 @@ static int cmd_show_connect( void )
 	struct cli_state *targetcli;
 	pstring targetpath;
 	
-	if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) {
 		d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli));
 		return 1;
 	}
@@ -3417,7 +3417,7 @@ static int process_command_string(char *cmd)
 	/* establish the connection if not already */
 	
 	if (!cli) {
-		cli = cli_cm_open(desthost, service, True);
+		cli = cli_cm_open(talloc_tos(), desthost, service, True);
 		if (!cli)
 			return 0;
 	}
@@ -3737,29 +3737,37 @@ static int process_stdin(void)
 	int rc = 0;
 
 	while (1) {
+		TALLOC_CTX *frame = talloc_stackframe();
 		pstring tok;
 		pstring the_prompt;
 		char *cline;
 		pstring line;
 		int i;
-		
+
 		/* display a prompt */
 		slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir);
 		cline = smb_readline(the_prompt, readline_callback, completion_fn);
-			
-		if (!cline) break;
-		
+
+		if (!cline) {
+			TALLOC_FREE(frame);
+			break;
+		}
+
 		pstrcpy(line, cline);
 
 		/* special case - first char is ! */
 		if (*line == '!') {
 			system(line + 1);
+			TALLOC_FREE(frame);
 			continue;
 		}
-      
+
 		/* and get the first part of the command */
 		ptr = line;
-		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
+		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) {
+			TALLOC_FREE(frame);
+			continue;
+		}
 
 		if ((i = process_tok(tok)) >= 0) {
 			rc = commands[i].fn();
@@ -3768,6 +3776,7 @@ static int process_stdin(void)
 		} else {
 			d_printf("%s: command not found\n",tok);
 		}
+		TALLOC_FREE(frame);
 	}
 	return rc;
 }
@@ -3780,7 +3789,7 @@ static int process(char *base_directory)
 {
 	int rc = 0;
 
-	cli = cli_cm_open(desthost, service, True);
+	cli = cli_cm_open(talloc_tos(), desthost, service, True);
 	if (!cli) {
 		return 1;
 	}
@@ -3809,7 +3818,7 @@ static int process(char *base_directory)
 
 static int do_host_query(char *query_host)
 {
-	cli = cli_cm_open(query_host, "IPC$", True);
+	cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True);
 	if (!cli)
 		return 1;
 
@@ -3822,7 +3831,7 @@ static int do_host_query(char *query_host)
 
 		cli_cm_shutdown();
 		cli_cm_set_port( 139 );
-		cli = cli_cm_open(query_host, "IPC$", True);
+		cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True);
 	}
 
 	if (cli == NULL) {
@@ -3847,7 +3856,7 @@ static int do_tar_op(char *base_directory)
 
 	/* do we already have a connection? */
 	if (!cli) {
-		cli = cli_cm_open(desthost, service, True);
+		cli = cli_cm_open(talloc_tos(), desthost, service, True);
 		if (!cli)
 			return 1;
 	}
@@ -3961,7 +3970,7 @@ static int do_message_op(void)
 		POPT_TABLEEND
 	};
 	TALLOC_CTX *frame = talloc_stackframe();
-	
+
 	load_case_tables();
 
 #ifdef KANJI
@@ -4200,7 +4209,7 @@ static int do_message_op(void)
 	if (message) {
 		return do_message_op();
 	}
-	
+
 	if (process(base_directory)) {
 		return 1;
 	}
diff --git a/source3/client/smbctool.c b/source3/client/smbctool.c
index b563a33f66..6c0a980a00 100644
--- a/source3/client/smbctool.c
+++ b/source3/client/smbctool.c
@@ -304,9 +304,9 @@ static int do_dskattr(void)
 {
 	int total, bsize, avail;
 	struct cli_state *targetcli;
-	pstring targetpath;
+	char *targetpath = NULL;
 
-	if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path(talloc_tos(), "", cli, cur_dir, &targetcli, &targetpath ) ) {
 		d_printf("Error in dskattr: %s\n", cli_errstr(cli));
 		return 1;
 	}
@@ -731,7 +731,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 {
 	static int in_do_list = 0;
 	struct cli_state *targetcli;
-	pstring targetpath;
+	char *targetpath;
 
 	if (in_do_list && rec) {
 		fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
@@ -747,7 +747,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 	if (rec) {
 		init_do_list_queue();
 		add_to_do_list_queue(mask);
-		
+
 		while (! do_list_queue_empty()) {
 			/*
 			 * Need to copy head so that it doesn't become
@@ -758,15 +758,15 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 			 */
 			pstring head;
 			pstrcpy(head, do_list_queue_head());
-			
+
 			/* check for dfs */
-			
-			if ( !cli_resolve_path( "", cli, head, &targetcli, targetpath ) ) {
+
+			if ( !cli_resolve_path(talloc_tos(), "", cli, head, &targetcli, &targetpath ) ) {
 				d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
 				remove_do_list_queue_head();
 				continue;
 			}
-			
+
 			cli_list(targetcli, targetpath, attribute, do_list_helper, NULL);
 			remove_do_list_queue_head();
 			if ((! do_list_queue_empty()) && (fn == display_finfo)) {
@@ -787,8 +787,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 		}
 	} else {
 		/* check for dfs */
-			
-		if ( cli_resolve_path( "", cli, mask, &targetcli, targetpath ) ) {
+		if (cli_resolve_path(talloc_tos(), "", cli, mask, &targetcli, &targetpath ) ) {
 			if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1) 
 				d_printf("%s listing %s\n", cli_errstr(targetcli), targetpath);
 		}
@@ -1857,21 +1856,21 @@ static int cmd_open(void)
 	pstring mask;
 	pstring buf;
 	struct cli_state *targetcli;
-	pstring targetname;
-	
+	char *targetname;
+
 	pstrcpy(mask,cur_dir);
-	
+
 	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
 		d_printf("open <filename>\n");
 		return 1;
 	}
 	pstrcat(mask,buf);
 
-	if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(talloc_tos(), "", cli, mask, &targetcli, &targetname ) ) {
 		d_printf("open %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	cli_nt_create(targetcli, targetname, FILE_READ_DATA);
 
 	return 0;
@@ -3320,31 +3319,39 @@ static int process_stdin(void)
 	int rc = 0;
 
 	while (1) {
+		TALLOC_CTX *ctx = talloc_stackframe();
 		pstring tok;
 		pstring the_prompt;
 		char *cline;
 		pstring line;
 		int i;
-		
+
 		/* display a prompt */
 		slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir);		 
 		/* Removed callback since we don't need to swallow keepalives with libsmbclient */
 		/*cline = smb_readline(the_prompt, readline_callback, completion_fn);*/
 		cline = smb_readline(the_prompt, NULL, completion_fn);
-		
-		if (!cline) break;
-		
+
+		if (!cline) {
+			TALLOC_FREE(frame);
+			break;
+		}
+
 		pstrcpy(line, cline);
 
 		/* special case - first char is ! */
 		if (*line == '!') {
 			system(line + 1);
+			TALLOC_FREE(frame);
 			continue;
 		}
-		
+
 		/* and get the first part of the command */
 		ptr = line;
-		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
+		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) {
+			TALLOC_FREE(frame);
+			continue;
+		}
 
 		if ((i = process_tok(tok)) >= 0) {
 			rc = commands[i].fn();
@@ -3353,6 +3360,7 @@ static int process_stdin(void)
 		} else {
 			d_printf("%s: command not found\n",tok);
 		}
+		TALLOC_FREE(frame);
 	}
 	return rc;
 }
@@ -3375,7 +3383,7 @@ static int process(char *base_directory)
 		d_printf("Error initializing libsmbclient: %s\n", strerror(errno));
 		return 1;
 	}
-	
+
 	if (*base_directory) {
 		rc = do_cd(base_directory);
 		if (rc) {
@@ -3386,16 +3394,17 @@ static int process(char *base_directory)
 	else	/* start the auth fn*/
 	{
 		rc = do_cd("/");
-		if (rc)
+		if (rc) {
 			return rc;
+		}
 	}
-	
+
 	if (cmdstr) {
 		rc = process_command_string(cmdstr);
 	} else {
 		process_stdin();
 	}
-  
+
 	cli_cm_shutdown();
 	return rc;
 }
diff --git a/source3/libsmb/cliconnect.c b/source3/libsmb/cliconnect.c
index e3800bfb33..14140811d2 100644
--- a/source3/libsmb/cliconnect.c
+++ b/source3/libsmb/cliconnect.c
@@ -879,8 +879,8 @@ ntlmssp:
  password is in plaintext, the same should be done.
 ****************************************************************************/
 
-NTSTATUS cli_session_setup(struct cli_state *cli, 
-			   const char *user, 
+NTSTATUS cli_session_setup(struct cli_state *cli,
+			   const char *user,
 			   const char *pass, int passlen,
 			   const char *ntpass, int ntpasslen,
 			   const char *workgroup)
@@ -888,8 +888,17 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 	char *p;
 	fstring user2;
 
+	if (user) {
+		fstrcpy(user2, user);
+	} else {
+		user2[0] ='\0';
+	}
+
+	if (!workgroup) {
+		workgroup = "";
+	}
+
 	/* allow for workgroups as part of the username */
-	fstrcpy(user2, user);
 	if ((p=strchr_m(user2,'\\')) || (p=strchr_m(user2,'/')) ||
 	    (p=strchr_m(user2,*lp_winbind_separator()))) {
 		*p = 0;
diff --git a/source3/libsmb/clidfs.c b/source3/libsmb/clidfs.c
index 469cb231d2..8ff358e26f 100644
--- a/source3/libsmb/clidfs.c
+++ b/source3/libsmb/clidfs.c
@@ -1,20 +1,20 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    client connect/disconnect routines
    Copyright (C) Andrew Tridgell                  1994-1998
    Copyright (C) Gerald (Jerry) Carter            2004
    Copyright (C) Jeremy Allison                   2007
-      
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -35,18 +35,22 @@
 struct client_connection {
 	struct client_connection *prev, *next;
 	struct cli_state *cli;
-	pstring mount;
+	char *mount;
 };
 
 /* global state....globals reek! */
-
-static pstring username;
-static pstring password;
-static bool use_kerberos;
-static bool got_pass;
-static int signing_state;
 int max_protocol = PROTOCOL_NT1;
 
+static struct cm_cred_struct {
+	char *username;
+	char *password;
+	bool got_pass;
+	bool use_kerberos;
+	int signing_state;
+} cm_creds;
+
+static void cm_set_password(const char *newpass);
+
 static int port;
 static int name_type = 0x20;
 static bool have_ip;
@@ -58,31 +62,40 @@ static struct client_connection *connections;
  Return a connection to a server.
 ********************************************************************/
 
-static struct cli_state *do_connect( const char *server, const char *share,
-                                     bool show_sessetup )
+static struct cli_state *do_connect(TALLOC_CTX *ctx,
+					const char *server,
+					const char *share,
+					bool show_sessetup)
 {
 	struct cli_state *c = NULL;
 	struct nmb_name called, calling;
 	const char *server_n;
 	struct sockaddr_storage ss;
-	pstring servicename;
+	char *servicename;
 	char *sharename;
-	fstring newserver, newshare;
+	char *newserver, *newshare;
+	const char *username;
+	const char *password;
 	NTSTATUS status;
-	
+
 	/* make a copy so we don't modify the global string 'service' */
-	pstrcpy(servicename, share);
+	servicename = talloc_strdup(ctx,share);
+	if (!servicename) {
+		return NULL;
+	}
 	sharename = servicename;
 	if (*sharename == '\\') {
 		server = sharename+2;
 		sharename = strchr_m(server,'\\');
-		if (!sharename) return NULL;
+		if (!sharename) {
+			return NULL;
+		}
 		*sharename = 0;
 		sharename++;
 	}
 
 	server_n = server;
-	
+
 	zero_addr(&ss);
 
 	make_nmb_name(&calling, global_myname(), 0x0);
@@ -100,18 +113,19 @@ static struct cli_state *do_connect( const char *server, const char *share,
 	}
 	status = cli_connect(c, server_n, &ss);
 	if (!NT_STATUS_IS_OK(status)) {
-		d_printf("Connection to %s failed (Error %s)\n", server_n, nt_errstr(status));
+		d_printf("Connection to %s failed (Error %s)\n",
+				server_n,
+				nt_errstr(status));
 		return NULL;
 	}
 
 	c->protocol = max_protocol;
-	c->use_kerberos = use_kerberos;
-	cli_setup_signing_state(c, signing_state);
-		
+	c->use_kerberos = cm_creds.use_kerberos;
+	cli_setup_signing_state(c, cm_creds.signing_state);
 
 	if (!cli_session_request(c, &calling, &called)) {
 		char *p;
-		d_printf("session request to %s failed (%s)\n", 
+		d_printf("session request to %s failed (%s)\n",
 			 called.name, cli_errstr(c));
 		cli_shutdown(c);
 		c = NULL;
@@ -134,24 +148,29 @@ static struct cli_state *do_connect( const char *server, const char *share,
 		return NULL;
 	}
 
-	if (!got_pass) {
+	if (!cm_creds.got_pass) {
 		char *pass = getpass("Password: ");
 		if (pass) {
-			pstrcpy(password, pass);
-			got_pass = 1;
+			cm_set_password(pass);
 		}
 	}
 
-	if (!NT_STATUS_IS_OK(cli_session_setup(c, username, 
+	username = cm_creds.username ? cm_creds.username : "";
+	password = cm_creds.password ? cm_creds.password : "";
+
+	if (!NT_STATUS_IS_OK(cli_session_setup(c, username,
 					       password, strlen(password),
 					       password, strlen(password),
 					       lp_workgroup()))) {
-		/* if a password was not supplied then try again with a null username */
-		if (password[0] || !username[0] || use_kerberos ||
-		    !NT_STATUS_IS_OK(cli_session_setup(c, "", "", 0, "", 0,
-						       lp_workgroup()))) { 
+		/* If a password was not supplied then
+		 * try again with a null username. */
+		if (password[0] || !username[0] || cm_creds.use_kerberos ||
+		    !NT_STATUS_IS_OK(cli_session_setup(c, "",
+				    		"", 0,
+						"", 0,
+					       lp_workgroup()))) {
 			d_printf("session setup failed: %s\n", cli_errstr(c));
-			if (NT_STATUS_V(cli_nt_error(c)) == 
+			if (NT_STATUS_V(cli_nt_error(c)) ==
 			    NT_STATUS_V(NT_STATUS_MORE_PROCESSING_REQUIRED))
 				d_printf("did you forget to run kinit?\n");
 			cli_shutdown(c);
@@ -164,55 +183,59 @@ static struct cli_state *do_connect( const char *server, const char *share,
 		if (*c->server_domain) {
 			DEBUG(0,("Domain=[%s] OS=[%s] Server=[%s]\n",
 				c->server_domain,c->server_os,c->server_type));
-		} else if (*c->server_os || *c->server_type){
+		} else if (*c->server_os || *c->server_type) {
 			DEBUG(0,("OS=[%s] Server=[%s]\n",
 				 c->server_os,c->server_type));
-		}		
+		}
 	}
 	DEBUG(4,(" session setup ok\n"));
 
 	/* here's the fun part....to support 'msdfs proxy' shares
-	   (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL 
+	   (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL
 	   here before trying to connect to the original share.
 	   check_dfs_proxy() will fail if it is a normal share. */
 
-	if ( (c->capabilities & CAP_DFS) && cli_check_msdfs_proxy( c, sharename, newserver, newshare ) ) {
+	if ((c->capabilities & CAP_DFS) &&
+			cli_check_msdfs_proxy(ctx, c, sharename,
+				&newserver, &newshare)) {
 		cli_shutdown(c);
-		return do_connect( newserver, newshare, False );
+		return do_connect(ctx, newserver, newshare, false);
 	}
 
 	/* must be a normal share */
 
-	if (!cli_send_tconX(c, sharename, "?????", password, strlen(password)+1)) {
+	if (!cli_send_tconX(c, sharename, "?????",
+				password, strlen(password)+1)) {
 		d_printf("tree connect failed: %s\n", cli_errstr(c));
 		cli_shutdown(c);
 		return NULL;
 	}
 
 	DEBUG(4,(" tconx ok\n"));
-
 	return c;
 }
 
 /****************************************************************************
 ****************************************************************************/
 
-static void cli_cm_set_mntpoint( struct cli_state *c, const char *mnt )
+static void cli_cm_set_mntpoint(struct cli_state *c, const char *mnt)
 {
 	struct client_connection *p;
 	int i;
 
-	for ( p=connections,i=0; p; p=p->next,i++ ) {
-		if ( strequal(p->cli->desthost, c->desthost) && strequal(p->cli->share, c->share) )
+	for (p=connections,i=0; p; p=p->next,i++) {
+		if (strequal(p->cli->desthost, c->desthost) &&
+				strequal(p->cli->share, c->share)) {
 			break;
+		}
 	}
-	
-	if ( p ) {
+
+	if (p) {
 		char *name = clean_name(NULL, p->mount);
 		if (!name) {
 			return;
 		}
-		pstrcpy( p->mount, name );
+		p->mount = talloc_strdup(p, name);
 		TALLOC_FREE(name);
 	}
 }
@@ -220,19 +243,21 @@ static void cli_cm_set_mntpoint( struct cli_state *c, const char *mnt )
 /****************************************************************************
 ****************************************************************************/
 
-const char *cli_cm_get_mntpoint( struct cli_state *c )
+const char *cli_cm_get_mntpoint(struct cli_state *c)
 {
 	struct client_connection *p;
 	int i;
 
-	for ( p=connections,i=0; p; p=p->next,i++ ) {
-		if ( strequal(p->cli->desthost, c->desthost) && strequal(p->cli->share, c->share) )
+	for (p=connections,i=0; p; p=p->next,i++) {
+		if (strequal(p->cli->desthost, c->desthost) &&
+				strequal(p->cli->share, c->share)) {
 			break;
+		}
 	}
-	
-	if ( p )
+
+	if (p) {
 		return p->mount;
-		
+	}
 	return NULL;
 }
 
@@ -240,27 +265,29 @@ const char *cli_cm_get_mntpoint( struct cli_state *c )
  Add a new connection to the list
 ********************************************************************/
 
-static struct cli_state *cli_cm_connect( const char *server,
+static struct cli_state *cli_cm_connect(TALLOC_CTX *ctx,
+					const char *server,
 					const char *share,
 					bool show_hdr)
 {
 	struct client_connection *node;
 
-	node = SMB_CALLOC_ARRAY( struct client_connection, 1);
+	/* NB This must be the null context here... JRA. */
+	node = TALLOC_ZERO_ARRAY(NULL, struct client_connection, 1);
 	if (!node) {
 		return NULL;
 	}
 
-	node->cli = do_connect( server, share, show_hdr );
+	node->cli = do_connect(ctx, server, share, show_hdr);
 
 	if ( !node->cli ) {
-		SAFE_FREE( node );
+		TALLOC_FREE( node );
 		return NULL;
 	}
 
 	DLIST_ADD( connections, node );
 
-	cli_cm_set_mntpoint( node->cli, "" );
+	cli_cm_set_mntpoint(node->cli, "");
 
 	return node->cli;
 
@@ -270,35 +297,37 @@ static struct cli_state *cli_cm_connect( const char *server,
  Return a connection to a server.
 ********************************************************************/
 
-static struct cli_state *cli_cm_find( const char *server, const char *share )
+static struct cli_state *cli_cm_find(const char *server, const char *share)
 {
 	struct client_connection *p;
 
-	for ( p=connections; p; p=p->next ) {
-		if ( strequal(server, p->cli->desthost) && strequal(share,p->cli->share) )
+	for (p=connections; p; p=p->next) {
+		if ( strequal(server, p->cli->desthost) &&
+				strequal(share,p->cli->share)) {
 			return p->cli;
+		}
 	}
 
 	return NULL;
 }
 
 /****************************************************************************
- open a client connection to a \\server\share.  Set's the current *cli 
+ Open a client connection to a \\server\share.  Set's the current *cli
  global variable as a side-effect (but only if the connection is successful).
 ****************************************************************************/
 
-struct cli_state *cli_cm_open(const char *server,
+struct cli_state *cli_cm_open(TALLOC_CTX *ctx,
+				const char *server,
 				const char *share,
 				bool show_hdr)
 {
 	struct cli_state *c;
-	
+
 	/* try to reuse an existing connection */
 
-	c = cli_cm_find( server, share );
-	
-	if ( !c ) {
-		c = cli_cm_connect(server, share, show_hdr);
+	c = cli_cm_find(server, share);
+	if (!c) {
+		c = cli_cm_connect(ctx, server, share, show_hdr);
 	}
 
 	return c;
@@ -307,17 +336,16 @@ struct cli_state *cli_cm_open(const char *server,
 /****************************************************************************
 ****************************************************************************/
 
-void cli_cm_shutdown( void )
+void cli_cm_shutdown(void)
 {
-
 	struct client_connection *p, *x;
 
-	for ( p=connections; p; ) {
-		cli_shutdown( p->cli );
+	for (p=connections; p;) {
+		cli_shutdown(p->cli);
 		x = p;
 		p = p->next;
 
-		SAFE_FREE( x );
+		TALLOC_FREE(x);
 	}
 
 	connections = NULL;
@@ -333,7 +361,7 @@ void cli_cm_display(void)
 	int i;
 
 	for ( p=connections,i=0; p; p=p->next,i++ ) {
-		d_printf("%d:\tserver=%s, share=%s\n", 
+		d_printf("%d:\tserver=%s, share=%s\n",
 			i, p->cli->desthost, p->cli->share );
 	}
 }
@@ -341,23 +369,32 @@ void cli_cm_display(void)
 /****************************************************************************
 ****************************************************************************/
 
-void cli_cm_set_credentials( struct user_auth_info *user )
+static void cm_set_password(const char *newpass)
+{
+	SAFE_FREE(cm_creds.password);
+	cm_creds.password = SMB_STRDUP(newpass);
+	if (cm_creds.password) {
+		cm_creds.got_pass = true;
+	}
+}
+
+void cli_cm_set_credentials(struct user_auth_info *user)
 {
-	pstrcpy( username, user->username );
-	
-	if ( user->got_pass ) {
-		pstrcpy( password, user->password );
-		got_pass = True;
-	}
-	
-	use_kerberos = user->use_kerberos;	
-	signing_state = user->signing_state;
+	SAFE_FREE(cm_creds.username);
+	cm_creds.username = SMB_STRDUP(user->username);
+
+	if (user->got_pass) {
+		cm_set_password(user->password);
+	}
+
+	cm_creds.use_kerberos = user->use_kerberos;
+	cm_creds.signing_state = user->signing_state;
 }
 
 /****************************************************************************
 ****************************************************************************/
 
-void cli_cm_set_port( int port_number )
+void cli_cm_set_port(int port_number)
 {
 	port = port_number;
 }
@@ -365,7 +402,7 @@ void cli_cm_set_port( int port_number )
 /****************************************************************************
 ****************************************************************************/
 
-void cli_cm_set_dest_name_type( int type )
+void cli_cm_set_dest_name_type(int type)
 {
 	name_type = type;
 }
@@ -383,12 +420,23 @@ void cli_cm_set_dest_ss(struct sockaddr_storage *pss)
  split a dfs path into the server, share name, and extrapath components
 **********************************************************************/
 
-static void split_dfs_path( const char *nodepath, fstring server, fstring share, pstring extrapath )
+static void split_dfs_path(TALLOC_CTX *ctx,
+				const char *nodepath,
+				char **pp_server,
+				char **pp_share,
+				char **pp_extrapath)
 {
 	char *p, *q;
-	pstring path;
+	char *path;
 
-	pstrcpy( path, nodepath );
+	*pp_server = NULL;
+	*pp_share = NULL;
+	*pp_extrapath = NULL;
+
+	path = talloc_strdup(ctx, nodepath);
+	if (!path) {
+		return;
+	}
 
 	if ( path[0] != '\\' ) {
 		return;
@@ -407,32 +455,36 @@ static void split_dfs_path( const char *nodepath, fstring server, fstring share,
 	if (q != NULL) {
 		*q = '\0';
 		q++;
-		pstrcpy( extrapath, q );
+		*pp_extrapath = talloc_strdup(ctx, q);
 	} else {
-		pstrcpy( extrapath, '\0' );
+		*pp_extrapath = talloc_strdup(ctx, "");
 	}
-	
-	fstrcpy( share, p );
-	fstrcpy( server, &path[1] );
+
+	*pp_share = talloc_strdup(ctx, p);
+	*pp_server = talloc_strdup(ctx, &path[1]);
 }
 
 /****************************************************************************
  Return the original path truncated at the directory component before
- the first wildcard character. Trust the caller to provide a NULL 
+ the first wildcard character. Trust the caller to provide a NULL
  terminated string
 ****************************************************************************/
 
-static void clean_path(const char *path, pstring path_out)
+static char *clean_path(TALLOC_CTX *ctx, const char *path)
 {
 	size_t len;
 	char *p1, *p2, *p;
-		
+	char *path_out;
+
 	/* No absolute paths. */
 	while (IS_DIRECTORY_SEP(*path)) {
 		path++;
 	}
 
-	pstrcpy(path_out, path);
+	path_out = talloc_strdup(ctx, path);
+	if (!path_out) {
+		return NULL;
+	}
 
 	p1 = strchr_m(path_out, '*');
 	p2 = strchr_m(path_out, '?');
@@ -462,21 +514,24 @@ static void clean_path(const char *path, pstring path_out)
 	if ( (len > 0) && IS_DIRECTORY_SEP(path_out[len-1])) {
 		path_out[len-1] = '\0';
 	}
+
+	return path_out;
 }
 
 /****************************************************************************
 ****************************************************************************/
 
-static void cli_dfs_make_full_path( struct cli_state *cli,
-					const char *dir,
-					pstring path_out)
+static char *cli_dfs_make_full_path(TALLOC_CTX *ctx,
+					struct cli_state *cli,
+					const char *dir)
 {
 	/* Ensure the extrapath doesn't start with a separator. */
 	while (IS_DIRECTORY_SEP(*dir)) {
 		dir++;
 	}
 
-	pstr_sprintf( path_out, "\\%s\\%s\\%s", cli->desthost, cli->share, dir);
+	return talloc_asprintf(ctx, "\\%s\\%s\\%s",
+			cli->desthost, cli->share, dir);
 }
 
 /********************************************************************
@@ -489,21 +544,22 @@ static bool cli_dfs_check_error( struct cli_state *cli, NTSTATUS status )
 
 	/* only deal with DS when we negotiated NT_STATUS codes and UNICODE */
 
-	if ( !( (flgs2&FLAGS2_32_BIT_ERROR_CODES) && (flgs2&FLAGS2_UNICODE_STRINGS) ) )
-		return False;
+	if (!((flgs2&FLAGS2_32_BIT_ERROR_CODES) &&
+				(flgs2&FLAGS2_UNICODE_STRINGS)))
+		return false;
 
-	if ( NT_STATUS_EQUAL( status, NT_STATUS(IVAL(cli->inbuf,smb_rcls)) ) )
-		return True;
+	if (NT_STATUS_EQUAL(status, NT_STATUS(IVAL(cli->inbuf,smb_rcls))))
+		return true;
 
-	return False;
+	return false;
 }
 
 /********************************************************************
- get the dfs referral link
+ Get the dfs referral link.
 ********************************************************************/
 
-bool cli_dfs_get_referral( struct cli_state *cli,
-			const char *path, 
+bool cli_dfs_get_referral(struct cli_state *cli,
+			const char *path,
 			CLIENT_DFS_REFERRAL**refs,
 			size_t *num_refs,
 			uint16 *consumed)
@@ -511,19 +567,19 @@ bool cli_dfs_get_referral( struct cli_state *cli,
 	unsigned int data_len = 0;
 	unsigned int param_len = 0;
 	uint16 setup = TRANSACT2_GET_DFS_REFERRAL;
-	char param[sizeof(pstring)+2];
-	pstring data;
+	char param[1024+2];
 	char *rparam=NULL, *rdata=NULL;
 	char *p;
 	size_t pathlen = 2*(strlen(path)+1);
 	uint16 num_referrals;
 	CLIENT_DFS_REFERRAL *referrals = NULL;
-	
+
 	memset(param, 0, sizeof(param));
 	SSVAL(param, 0, 0x03);	/* max referral level */
 	p = &param[2];
 
-	p += clistr_push(cli, p, path, MIN(pathlen, sizeof(param)-2), STR_TERMINATE);
+	p += clistr_push(cli, p, path, MIN(pathlen, sizeof(param)-2),
+			STR_TERMINATE);
 	param_len = PTR_DIFF(p, param);
 
 	if (!cli_send_trans(cli, SMBtrans2,
@@ -531,283 +587,366 @@ bool cli_dfs_get_referral( struct cli_state *cli,
 		-1, 0,                          /* fid, flags */
 		&setup, 1, 0,                   /* setup, length, max */
 		param, param_len, 2,            /* param, length, max */
-		(char *)&data,  data_len, cli->max_xmit /* data, length, max */
+		NULL, 0, cli->max_xmit /* data, length, max */
 		)) {
-			return False;
+			return false;
 	}
 
 	if (!cli_receive_trans(cli, SMBtrans2,
 		&rparam, &param_len,
 		&rdata, &data_len)) {
-			return False;
+			return false;
 	}
-	
+
 	*consumed     = SVAL( rdata, 0 );
 	num_referrals = SVAL( rdata, 2 );
-	
+
 	if ( num_referrals != 0 ) {
 		uint16 ref_version;
 		uint16 ref_size;
 		int i;
 		uint16 node_offset;
 
-		referrals = SMB_XMALLOC_ARRAY( CLIENT_DFS_REFERRAL, num_referrals );
+		referrals = SMB_XMALLOC_ARRAY( CLIENT_DFS_REFERRAL,
+				num_referrals);
 
 		/* start at the referrals array */
-	
+
 		p = rdata+8;
 		for ( i=0; i<num_referrals; i++ ) {
 			ref_version = SVAL( p, 0 );
 			ref_size    = SVAL( p, 2 );
 			node_offset = SVAL( p, 16 );
-			
+
 			if ( ref_version != 3 ) {
 				p += ref_size;
 				continue;
 			}
-			
+
 			referrals[i].proximity = SVAL( p, 8 );
 			referrals[i].ttl       = SVAL( p, 10 );
 
-			clistr_pull( cli, referrals[i].dfspath, p+node_offset, 
-				sizeof(referrals[i].dfspath), -1, STR_TERMINATE|STR_UNICODE );
+			clistr_pull( cli, referrals[i].dfspath, p+node_offset,
+				sizeof(referrals[i].dfspath), -1,
+				STR_TERMINATE|STR_UNICODE );
 
 			p += ref_size;
 		}
 	}
-	
+
 	*num_refs = num_referrals;
 	*refs = referrals;
 
 	SAFE_FREE(rdata);
 	SAFE_FREE(rparam);
 
-	return True;
+	return true;
 }
 
 
 /********************************************************************
 ********************************************************************/
 
-bool cli_resolve_path( const char *mountpt,
+bool cli_resolve_path(TALLOC_CTX *ctx,
+			const char *mountpt,
 			struct cli_state *rootcli,
 			const char *path,
 			struct cli_state **targetcli,
-			pstring targetpath)
+			char **pp_targetpath)
 {
 	CLIENT_DFS_REFERRAL *refs = NULL;
 	size_t num_refs;
 	uint16 consumed;
-	struct cli_state *cli_ipc;
-	pstring dfs_path, cleanpath, extrapath;
+	struct cli_state *cli_ipc = NULL;
+	char *dfs_path = NULL;
+	char *cleanpath = NULL;
+	char *extrapath = NULL;
 	int pathlen;
-	fstring server, share;
-	struct cli_state *newcli;
-	pstring newpath;
-	pstring newmount;
-	char *ppath, *temppath = NULL;
-	
+	char *server = NULL;
+	char *share = NULL;
+	struct cli_state *newcli = NULL;
+	char *newpath = NULL;
+	char *newmount = NULL;
+	char *ppath = NULL;
 	SMB_STRUCT_STAT sbuf;
 	uint32 attributes;
-	
+
 	if ( !rootcli || !path || !targetcli ) {
-		return False;
+		return false;
 	}
-		
+
 	/* Don't do anything if this is not a DFS root. */
 
 	if ( !rootcli->dfsroot) {
 		*targetcli = rootcli;
-		pstrcpy( targetpath, path );
-		return True;
+		*pp_targetpath = talloc_strdup(ctx, path);
+		if (!*pp_targetpath) {
+			return false;
+		}
+		return true;
 	}
 
 	*targetcli = NULL;
 
 	/* Send a trans2_query_path_info to check for a referral. */
 
-	clean_path(path, cleanpath);
-	cli_dfs_make_full_path(rootcli, cleanpath, dfs_path );
+	cleanpath = clean_path(ctx, path);
+	if (!cleanpath) {
+		return false;
+	}
+
+	dfs_path = cli_dfs_make_full_path(ctx, rootcli, cleanpath);
+	if (!dfs_path) {
+		return false;
+	}
 
-	if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes ) ) {
+	if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes)) {
 		/* This is an ordinary path, just return it. */
 		*targetcli = rootcli;
-		pstrcpy( targetpath, path );
+		*pp_targetpath = talloc_strdup(ctx, path);
+		if (!*pp_targetpath) {
+			return false;
+		}
 		goto done;
 	}
 
 	/* Special case where client asked for a path that does not exist */
 
-	if ( cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND) ) {
+	if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 		*targetcli = rootcli;
-		pstrcpy( targetpath, path );
+		*pp_targetpath = talloc_strdup(ctx, path);
+		if (!*pp_targetpath) {
+			return false;
+		}
 		goto done;
 	}
 
 	/* We got an error, check for DFS referral. */
 
-	if ( !cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED))  {
-		return False;
+	if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED)) {
+		return false;
 	}
 
 	/* Check for the referral. */
 
-	if ( !(cli_ipc = cli_cm_open( rootcli->desthost, "IPC$", False )) ) {
-		return False;
+	if (!(cli_ipc = cli_cm_open(ctx, rootcli->desthost, "IPC$", false))) {
+		return false;
 	}
-	
-	if ( !cli_dfs_get_referral(cli_ipc, dfs_path, &refs, &num_refs, &consumed) 
-			|| !num_refs ) {
-		return False;
+
+	if (!cli_dfs_get_referral(cli_ipc, dfs_path, &refs,
+			&num_refs, &consumed) || !num_refs) {
+		return false;
 	}
-	
+
 	/* Just store the first referral for now. */
 
-	split_dfs_path( refs[0].dfspath, server, share, extrapath );
+	split_dfs_path(ctx, refs[0].dfspath, &server, &share, &extrapath );
 	SAFE_FREE(refs);
 
+	if (!server || !share) {
+		return false;
+	}
+
 	/* Make sure to recreate the original string including any wildcards. */
-	
-	cli_dfs_make_full_path( rootcli, path, dfs_path);
-	pathlen = strlen( dfs_path )*2;
-	consumed = MIN(pathlen, consumed );
-	pstrcpy( targetpath, &dfs_path[consumed/2] );
+
+	dfs_path = cli_dfs_make_full_path(ctx, rootcli, path);
+	if (!dfs_path) {
+		return false;
+	}
+	pathlen = strlen(dfs_path)*2;
+	consumed = MIN(pathlen, consumed);
+	*pp_targetpath = talloc_strdup(ctx, &dfs_path[consumed/2]);
+	if (!*pp_targetpath) {
+		return false;
+	}
 	dfs_path[consumed/2] = '\0';
 
 	/*
- 	 * targetpath is now the unconsumed part of the path.
- 	 * dfs_path is now the consumed part of the path (in \server\share\path format).
+ 	 * *pp_targetpath is now the unconsumed part of the path.
+ 	 * dfs_path is now the consumed part of the path
+	 * (in \server\share\path format).
  	 */
 
 	/* Open the connection to the target server & share */
-	
-	if ( (*targetcli = cli_cm_open(server, share, False)) == NULL ) {
+	if ((*targetcli = cli_cm_open(ctx, server, share, false)) == NULL) {
 		d_printf("Unable to follow dfs referral [\\%s\\%s]\n",
 			server, share );
-		return False;
+		return false;
 	}
-	
-	if (strlen(extrapath) > 0) {
-		string_append(&temppath, extrapath);
-		string_append(&temppath, targetpath);
-		pstrcpy( targetpath, temppath );
+
+	if (extrapath && strlen(extrapath) > 0) {
+		*pp_targetpath = talloc_asprintf(ctx,
+						"%s%s",
+						extrapath,
+						*pp_targetpath);
+		if (!*pp_targetpath) {
+			return false;
+		}
 	}
-	
+
 	/* parse out the consumed mount path */
 	/* trim off the \server\share\ */
 
 	ppath = dfs_path;
 
 	if (*ppath != '\\') {
-		d_printf("cli_resolve_path: dfs_path (%s) not in correct format.\n",
+		d_printf("cli_resolve_path: "
+			"dfs_path (%s) not in correct format.\n",
 			dfs_path );
-		return False;
+		return false;
 	}
 
 	ppath++; /* Now pointing at start of server name. */
-	
+
 	if ((ppath = strchr_m( dfs_path, '\\' )) == NULL) {
-		return False;
+		return false;
 	}
 
 	ppath++; /* Now pointing at start of share name. */
 
 	if ((ppath = strchr_m( ppath+1, '\\' )) == NULL) {
-		return False;
+		return false;
 	}
 
 	ppath++; /* Now pointing at path component. */
 
-	pstr_sprintf( newmount, "%s\\%s", mountpt, ppath );
+	newmount = talloc_asprintf(ctx, "%s\\%s", mountpt, ppath );
+	if (!newmount) {
+		return false;
+	}
 
-	cli_cm_set_mntpoint( *targetcli, newmount );
+	cli_cm_set_mntpoint(*targetcli, newmount);
 
-	/* Check for another dfs referral, note that we are not 
+	/* Check for another dfs referral, note that we are not
 	   checking for loops here. */
 
-	if ( !strequal( targetpath, "\\" ) &&  !strequal( targetpath, "/")) {
-		if ( cli_resolve_path( newmount, *targetcli, targetpath, &newcli, newpath ) ) {
+	if (!strequal(*pp_targetpath, "\\") && !strequal(*pp_targetpath, "/")) {
+		if (cli_resolve_path(ctx,
+					newmount,
+					*targetcli,
+					*pp_targetpath,
+					&newcli,
+					&newpath)) {
 			/*
 			 * When cli_resolve_path returns true here it's always
  			 * returning the complete path in newpath, so we're done
  			 * here.
  			 */
 			*targetcli = newcli;
-			pstrcpy( targetpath, newpath );
-			return True;
+			*pp_targetpath = newpath;
+			return true;
 		}
 	}
 
   done:
 
-	/* If returning True ensure we return a dfs root full path. */
-	if ( (*targetcli)->dfsroot ) {
-		pstrcpy(dfs_path, targetpath );
-		cli_dfs_make_full_path( *targetcli, dfs_path, targetpath); 
+	/* If returning true ensure we return a dfs root full path. */
+	if ((*targetcli)->dfsroot) {
+		dfs_path = talloc_strdup(ctx, *pp_targetpath);
+		if (!dfs_path) {
+			return false;
+		}
+		*pp_targetpath = cli_dfs_make_full_path(ctx, *targetcli, dfs_path);
 	}
 
-	return True;
+	return true;
+}
+
+/********************************************************************
+ Temporary hack - remove when pstring is dead. JRA.
+********************************************************************/
+
+bool cli_resolve_path_pstring( const char *mountpt,
+			struct cli_state *rootcli,
+			const char *path,
+			struct cli_state **targetcli,
+			pstring targetpath)
+{
+	char *tpath = NULL;
+	TALLOC_CTX *ctx = talloc_stackframe();
+	bool ret = cli_resolve_path(ctx,
+				mountpt,
+				rootcli,
+				path,
+				targetcli,
+				&tpath);
+	if (tpath) {
+		pstrcpy(targetpath, tpath);
+	}
+	return ret;
 }
 
 /********************************************************************
 ********************************************************************/
 
-bool cli_check_msdfs_proxy( struct cli_state *cli, const char *sharename,
-                            fstring newserver, fstring newshare )
+bool cli_check_msdfs_proxy(TALLOC_CTX *ctx,
+				struct cli_state *cli,
+				const char *sharename,
+				char **pp_newserver,
+				char **pp_newshare )
 {
 	CLIENT_DFS_REFERRAL *refs = NULL;
 	size_t num_refs;
 	uint16 consumed;
-	pstring fullpath;
+	char *fullpath = NULL;
 	bool res;
 	uint16 cnum;
-	pstring newextrapath;
-	
-	if ( !cli || !sharename )
-		return False;
+	char *newextrapath = NULL;
+
+	if (!cli || !sharename) {
+		return false;
+	}
 
 	cnum = cli->cnum;
 
 	/* special case.  never check for a referral on the IPC$ share */
 
-	if ( strequal( sharename, "IPC$" ) ) {
-		return False;
+	if (strequal(sharename, "IPC$")) {
+		return false;
 	}
-		
+
 	/* send a trans2_query_path_info to check for a referral */
-	
-	pstr_sprintf( fullpath, "\\%s\\%s", cli->desthost, sharename );
+
+	fullpath = talloc_asprintf(ctx, "\\%s\\%s", cli->desthost, sharename );
+	if (!fullpath) {
+		return false;
+	}
 
 	/* check for the referral */
 
 	if (!cli_send_tconX(cli, "IPC$", "IPC", NULL, 0)) {
-		return False;
+		return false;
 	}
 
 	res = cli_dfs_get_referral(cli, fullpath, &refs, &num_refs, &consumed);
 
 	if (!cli_tdis(cli)) {
-		SAFE_FREE( refs );
-		return False;
+		SAFE_FREE(refs);
+		return false;
 	}
 
 	cli->cnum = cnum;
 
-	if (!res || !num_refs ) {
-		SAFE_FREE( refs );
-		return False;
+	if (!res || !num_refs) {
+		SAFE_FREE(refs);
+		return false;
+	}
+
+	split_dfs_path(ctx, refs[0].dfspath, pp_newserver,
+			pp_newshare, &newextrapath );
+
+	SAFE_FREE(refs);
+
+	if (!pp_newserver || !pp_newshare) {
+		return false;
 	}
-	
-	split_dfs_path( refs[0].dfspath, newserver, newshare, newextrapath );
 
 	/* check that this is not a self-referral */
 
-	if ( strequal( cli->desthost, newserver ) && strequal( sharename, newshare ) ) {
-		SAFE_FREE( refs );
-		return False;
+	if (strequal(cli->desthost, *pp_newserver) &&
+			strequal(sharename, *pp_newshare)) {
+		return false;
 	}
-	
-	SAFE_FREE( refs );
-	
-	return True;
+
+	return true;
 }
diff --git a/source3/libsmb/libsmbclient.c b/source3/libsmb/libsmbclient.c
index 4f2503731d..b20b1cadaf 100644
--- a/source3/libsmb/libsmbclient.c
+++ b/source3/libsmb/libsmbclient.c
@@ -1055,7 +1055,7 @@ smbc_open_ctx(SMBCCTX *context,
 {
 	fstring server, share, user, password, workgroup;
 	pstring path;
-        pstring targetpath;
+	char *targetpath = NULL;
 	struct cli_state *targetcli;
 	SMBCSRV *srv   = NULL;
 	SMBCFILE *file = NULL;
@@ -1102,18 +1102,14 @@ smbc_open_ctx(SMBCCTX *context,
 		if (errno == EPERM) errno = EACCES;
 		TALLOC_FREE(frame);
 		return NULL;  /* smbc_server sets errno */
-    
+
 	}
 
 	/* Hmmm, the test for a directory is suspect here ... FIXME */
 
 	if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
-    
 		fd = -1;
-
-	}
-	else {
-	  
+	} else {
 		file = SMB_MALLOC_P(SMBCFILE);
 
 		if (!file) {
@@ -1127,7 +1123,7 @@ smbc_open_ctx(SMBCCTX *context,
 		ZERO_STRUCTP(file);
 
 		/*d_printf(">>>open: resolving %s\n", path);*/
-		if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath))
+		if (!cli_resolve_path(frame, "", srv->cli, path, &targetcli, &targetpath))
 		{
 			d_printf("Could not resolve %s\n", path);
 			SAFE_FREE(file);
@@ -1135,7 +1131,7 @@ smbc_open_ctx(SMBCCTX *context,
 			return NULL;
 		}
 		/*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/
-		
+
 		if ((fd = cli_open(targetcli, targetpath, flags,
                                    context->internal->_share_mode)) < 0) {
 
@@ -1248,7 +1244,8 @@ smbc_read_ctx(SMBCCTX *context,
 {
 	int ret;
 	fstring server, share, user, password;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath = NULL;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
@@ -1307,17 +1304,17 @@ smbc_read_ctx(SMBCCTX *context,
 		TALLOC_FREE(frame);
                 return -1;
         }
-	
+
 	/*d_printf(">>>read: resolving %s\n", path);*/
-	if (!cli_resolve_path("", file->srv->cli, path,
-                              &targetcli, targetpath))
+	if (!cli_resolve_path(frame, "", file->srv->cli, path,
+                              &targetcli, &targetpath))
 	{
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
 	}
 	/*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
-	
+
 	ret = cli_read(targetcli, file->cli_fd, (char *)buf, offset, count);
 
 	if (ret < 0) {
@@ -1350,15 +1347,15 @@ smbc_write_ctx(SMBCCTX *context,
 	int ret;
         off_t offset;
 	fstring server, share, user, password;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath = NULL;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
 	/* First check all pointers before dereferencing them */
-	
+
 	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
@@ -1366,17 +1363,14 @@ smbc_write_ctx(SMBCCTX *context,
 	}
 
 	if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
-
 		errno = EBADF;
 		TALLOC_FREE(frame);
 		return -1;
-    
 	}
 
 	/* Check that the buffer exists ... */
 
 	if (buf == NULL) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
@@ -1398,22 +1392,19 @@ smbc_write_ctx(SMBCCTX *context,
 		TALLOC_FREE(frame);
                 return -1;
         }
-	
+
 	/*d_printf(">>>write: resolving %s\n", path);*/
-	if (!cli_resolve_path("", file->srv->cli, path,
-                              &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", file->srv->cli, path,
+                              &targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
 	}
 	/*d_printf(">>>write: resolved path as %s\n", targetpath);*/
 
-
 	ret = cli_write(targetcli, file->cli_fd, 0, (char *)buf, offset, count);
 
 	if (ret <= 0) {
-
 		errno = smbc_errno(context, targetcli);
 		TALLOC_FREE(frame);
 		return -1;
@@ -1425,7 +1416,7 @@ smbc_write_ctx(SMBCCTX *context,
 	TALLOC_FREE(frame);
 	return ret;  /* Success, 0 bytes of data ... */
 }
- 
+
 /*
  * Routine to close() a file ...
  */
@@ -1434,9 +1425,10 @@ static int
 smbc_close_ctx(SMBCCTX *context,
                SMBCFILE *file)
 {
-        SMBCSRV *srv; 
+        SMBCSRV *srv;
 	fstring server, share, user, password;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath = NULL;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
@@ -1450,7 +1442,6 @@ smbc_close_ctx(SMBCCTX *context,
 	}
 
 	if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
-   
 		errno = EBADF;
 		TALLOC_FREE(frame);
 		return -1;
@@ -1459,7 +1450,6 @@ smbc_close_ctx(SMBCCTX *context,
 
 	/* IS a dir ... */
 	if (!file->file) {
-		
 		TALLOC_FREE(frame);
 		return (context->closedir)(context, file);
 
@@ -1478,11 +1468,10 @@ smbc_close_ctx(SMBCCTX *context,
 		TALLOC_FREE(frame);
                 return -1;
         }
-	
+
 	/*d_printf(">>>close: resolving %s\n", path);*/
-	if (!cli_resolve_path("", file->srv->cli, path,
-                              &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", file->srv->cli, path,
+                              &targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
@@ -1531,18 +1520,16 @@ smbc_getatr(SMBCCTX * context,
             SMB_INO_T *ino)
 {
 	pstring fixedpath;
-	pstring targetpath;
+	char *targetpath = NULL;
 	struct cli_state *targetcli;
 	time_t write_time;
 	TALLOC_CTX *frame = talloc_stackframe();
 
 	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
- 
 		errno = EINVAL;
 		TALLOC_FREE(frame);
  		return -1;
- 
  	}
 
 	/* path fixup for . and .. */
@@ -1555,14 +1542,14 @@ smbc_getatr(SMBCCTX * context,
 		trim_string(fixedpath, NULL, "\\.");
 	}
 	DEBUG(4,("smbc_getatr: sending qpathinfo\n"));
-  
-	if (!cli_resolve_path( "", srv->cli, fixedpath, &targetcli, targetpath))
-	{
+
+	if (!cli_resolve_path(frame, "", srv->cli, fixedpath,
+				&targetcli, &targetpath)) {
 		d_printf("Couldn't resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return False;
 	}
-	
+
 	if (!srv->no_pathinfo2 &&
             cli_qpathinfo2(targetcli, targetpath,
                            create_time_ts,
@@ -1710,7 +1697,8 @@ smbc_unlink_ctx(SMBCCTX *context,
                 const char *fname)
 {
 	fstring server, share, user, password, workgroup;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath;
 	struct cli_state *targetcli;
 	SMBCSRV *srv = NULL;
 	TALLOC_CTX *frame = talloc_stackframe();
@@ -1758,8 +1746,8 @@ smbc_unlink_ctx(SMBCCTX *context,
 	}
 
 	/*d_printf(">>>unlink: resolving %s\n", path);*/
-	if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", srv->cli, path,
+				&targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
@@ -1835,16 +1823,16 @@ smbc_rename_ctx(SMBCCTX *ocontext,
         fstring workgroup;
 	pstring path1;
         pstring path2;
-        pstring targetpath1;
-        pstring targetpath2;
+        char *targetpath1;
+        char *targetpath2;
 	struct cli_state *targetcli1;
         struct cli_state *targetcli2;
 	SMBCSRV *srv = NULL;
 	TALLOC_CTX *frame = talloc_stackframe();
 
-	if (!ocontext || !ncontext || 
+	if (!ocontext || !ncontext ||
 	    !ocontext->internal || !ncontext->internal ||
-	    !ocontext->internal->_initialized || 
+	    !ocontext->internal->_initialized ||
 	    !ncontext->internal->_initialized) {
 
 		errno = EINVAL;  /* Best I can think of ... */
@@ -1852,15 +1840,14 @@ smbc_rename_ctx(SMBCCTX *ocontext,
 		return -1;
 
 	}
-	
-	if (!oname || !nname) {
 
+	if (!oname || !nname) {
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
 
 	}
-	
+
 	DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname));
 
 	smbc_parse_path(ocontext, oname,
@@ -1887,9 +1874,7 @@ smbc_rename_ctx(SMBCCTX *ocontext,
 
 	if (strcmp(server1, server2) || strcmp(share1, share2) ||
 	    strcmp(user1, user2)) {
-
 		/* Can't rename across file systems, or users?? */
-
 		errno = EXDEV;
 		TALLOC_FREE(frame);
 		return -1;
@@ -1906,27 +1891,26 @@ smbc_rename_ctx(SMBCCTX *ocontext,
 	}
 
 	/*d_printf(">>>rename: resolving %s\n", path1);*/
-	if (!cli_resolve_path( "", srv->cli, path1, &targetcli1, targetpath1))
-	{
+	if (!cli_resolve_path(frame, "", srv->cli, path1,
+				&targetcli1, &targetpath1)) {
 		d_printf("Could not resolve %s\n", path1);
 		TALLOC_FREE(frame);
 		return -1;
 	}
 	/*d_printf(">>>rename: resolved path as %s\n", targetpath1);*/
 	/*d_printf(">>>rename: resolving %s\n", path2);*/
-	if (!cli_resolve_path( "", srv->cli, path2, &targetcli2, targetpath2))
-	{
+	if (!cli_resolve_path(frame, "", srv->cli, path2,
+				&targetcli2, &targetpath2)) {
 		d_printf("Could not resolve %s\n", path2);
 		TALLOC_FREE(frame);
 		return -1;
 	}
 	/*d_printf(">>>rename: resolved path as %s\n", targetpath2);*/
-	
+
 	if (strcmp(targetcli1->desthost, targetcli2->desthost) ||
             strcmp(targetcli1->share, targetcli2->share))
 	{
 		/* can't rename across file systems */
-		
 		errno = EXDEV;
 		TALLOC_FREE(frame);
 		return -1;
@@ -1962,17 +1946,16 @@ smbc_lseek_ctx(SMBCCTX *context,
 {
 	SMB_OFF_T size;
 	fstring server, share, user, password;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
 	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
-		
 	}
 
 	if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
@@ -2010,28 +1993,26 @@ smbc_lseek_ctx(SMBCCTX *context,
                                     user, sizeof(user),
                                     password, sizeof(password),
                                     NULL, 0)) {
-                        
 					errno = EINVAL;
 					TALLOC_FREE(frame);
 					return -1;
 			}
-		
+
 		/*d_printf(">>>lseek: resolving %s\n", path);*/
-		if (!cli_resolve_path("", file->srv->cli, path,
-                                      &targetcli, targetpath))
-		{
+		if (!cli_resolve_path(frame, "", file->srv->cli, path,
+                                      &targetcli, &targetpath)) {
 			d_printf("Could not resolve %s\n", path);
 			TALLOC_FREE(frame);
 			return -1;
 		}
 		/*d_printf(">>>lseek: resolved path as %s\n", targetpath);*/
-		
+
 		if (!cli_qfileinfo(targetcli, file->cli_fd, NULL,
-                                   &size, NULL, NULL, NULL, NULL, NULL)) 
+                                   &size, NULL, NULL, NULL, NULL, NULL))
 		{
 		    SMB_OFF_T b_size = size;
 			if (!cli_getattrE(targetcli, file->cli_fd,
-                                          NULL, &b_size, NULL, NULL, NULL)) 
+                                          NULL, &b_size, NULL, NULL, NULL))
 		    {
 			errno = EINVAL;
 			TALLOC_FREE(frame);
@@ -2238,14 +2219,13 @@ smbc_fstat_ctx(SMBCCTX *context,
         fstring user;
         fstring password;
 	pstring path;
-        pstring targetpath;
+        char *targetpath;
 	struct cli_state *targetcli;
 	SMB_INO_T ino = 0;
 	TALLOC_CTX *frame = talloc_stackframe();
 
 	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
@@ -2253,7 +2233,6 @@ smbc_fstat_ctx(SMBCCTX *context,
 	}
 
 	if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
-
 		errno = EBADF;
 		TALLOC_FREE(frame);
 		return -1;
@@ -2261,7 +2240,6 @@ smbc_fstat_ctx(SMBCCTX *context,
 	}
 
 	if (!file->file) {
-
 		TALLOC_FREE(frame);
 		return (context->fstatdir)(context, file, st);
 
@@ -2280,11 +2258,10 @@ smbc_fstat_ctx(SMBCCTX *context,
 		TALLOC_FREE(frame);
                 return -1;
         }
-	
+
 	/*d_printf(">>>fstat: resolving %s\n", path);*/
-	if (!cli_resolve_path("", file->srv->cli, path,
-                              &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", file->srv->cli, path,
+                              &targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
@@ -2979,7 +2956,7 @@ smbc_opendir_ctx(SMBCCTX *context,
                          * The server and share are specified ... work from
                          * there ...
                          */
-			pstring targetpath;
+			char *targetpath;
 			struct cli_state *targetcli;
 
 			/* We connect to the server and list the directory */
@@ -3006,9 +2983,8 @@ smbc_opendir_ctx(SMBCCTX *context,
                         p = path + strlen(path);
 			pstrcat(path, "\\*");
 
-			if (!cli_resolve_path("", srv->cli, path,
-                                              &targetcli, targetpath))
-			{
+			if (!cli_resolve_path(frame, "", srv->cli, path,
+                                              &targetcli, &targetpath)) {
 				d_printf("Could not resolve %s\n", path);
 				if (dir) {
 					SAFE_FREE(dir->fname);
@@ -3017,7 +2993,7 @@ smbc_opendir_ctx(SMBCCTX *context,
 				TALLOC_FREE(frame);
 				return NULL;
 			}
-			
+
 			if (cli_list(targetcli, targetpath,
                                      aDIR | aSYSTEM | aHIDDEN,
                                      dir_list_fn, (void *)dir) < 0) {
@@ -3358,13 +3334,13 @@ smbc_mkdir_ctx(SMBCCTX *context,
         fstring user;
         fstring password;
         fstring workgroup;
-	pstring path, targetpath;
+	pstring path;
+	char *targetpath;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
-	if (!context || !context->internal || 
+	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
@@ -3372,13 +3348,12 @@ smbc_mkdir_ctx(SMBCCTX *context,
 	}
 
 	if (!fname) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
 
 	}
-  
+
 	DEBUG(4, ("smbc_mkdir(%s)\n", fname));
 
 	if (smbc_parse_path(context, fname,
@@ -3407,8 +3382,8 @@ smbc_mkdir_ctx(SMBCCTX *context,
 	}
 
 	/*d_printf(">>>mkdir: resolving %s\n", path);*/
-	if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", srv->cli, path,
+				&targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
@@ -3462,13 +3437,12 @@ smbc_rmdir_ctx(SMBCCTX *context,
         fstring password;
         fstring workgroup;
 	pstring path;
-        pstring targetpath;
+        char *targetpath;
 	struct cli_state *targetcli;
 	TALLOC_CTX *frame = talloc_stackframe();
 
-	if (!context || !context->internal || 
+	if (!context || !context->internal ||
 	    !context->internal->_initialized) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
@@ -3476,13 +3450,12 @@ smbc_rmdir_ctx(SMBCCTX *context,
 	}
 
 	if (!fname) {
-
 		errno = EINVAL;
 		TALLOC_FREE(frame);
 		return -1;
 
 	}
-  
+
 	DEBUG(4, ("smbc_rmdir(%s)\n", fname));
 
 	if (smbc_parse_path(context, fname,
@@ -3512,8 +3485,8 @@ smbc_rmdir_ctx(SMBCCTX *context,
 	}
 
 	/*d_printf(">>>rmdir: resolving %s\n", path);*/
-	if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath))
-	{
+	if (!cli_resolve_path(frame, "", srv->cli, path,
+				&targetcli, &targetpath)) {
 		d_printf("Could not resolve %s\n", path);
 		TALLOC_FREE(frame);
 		return -1;
diff --git a/source3/nmbd/nmbd_sendannounce.c b/source3/nmbd/nmbd_sendannounce.c
index 73c875d248..a4e646771f 100644
--- a/source3/nmbd/nmbd_sendannounce.c
+++ b/source3/nmbd/nmbd_sendannounce.c
@@ -34,7 +34,7 @@ extern bool found_lm_clients;
 
 void send_browser_reset(int reset_type, const char *to_name, int to_type, struct in_addr to_ip)
 {
-	char outbuf[PSTRING_LEN];
+	char outbuf[1024];
 	char *p;
 
 	DEBUG(3,("send_browser_reset: sending reset request type %d to %s<%02x> IP %s.\n",
@@ -59,7 +59,7 @@ void send_browser_reset(int reset_type, const char *to_name, int to_type, struct
 
 void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work)
 {
-	char outbuf[PSTRING_LEN];
+	char outbuf[1024];
 	char *p;
 
 	work->needannounce = True;
@@ -90,7 +90,7 @@ static void send_announcement(struct subnet_record *subrec, int announce_type,
                               time_t announce_interval,
                               const char *server_name, int server_type, const char *server_comment)
 {
-	char outbuf[PSTRING_LEN];
+	char outbuf[1024];
 	unstring upper_server_name;
 	char *p;
 
@@ -131,7 +131,7 @@ static void send_lm_announcement(struct subnet_record *subrec, int announce_type
                               time_t announce_interval,
                               char *server_name, int server_type, char *server_comment)
 {
-	char outbuf[PSTRING_LEN];
+	char outbuf[1024];
 	char *p=outbuf;
 
 	memset(outbuf,'\0',sizeof(outbuf));
diff --git a/source3/smbd/password.c b/source3/smbd/password.c
index 7bba458218..75f05dea67 100644
--- a/source3/smbd/password.c
+++ b/source3/smbd/password.c
@@ -402,14 +402,14 @@ void add_session_user(const char *user)
 	     len_session_userlist) ) {
 		char *newlist;
 
-		if (len_session_userlist > 128 * PSTRING_LEN) {
+		if (len_session_userlist > 128 * 1024) {
 			DEBUG(3,("add_session_user: session userlist already "
 				 "too large.\n"));
 			return;
 		}
 		newlist = (char *)SMB_REALLOC_KEEP_OLD_ON_ERROR(
 			session_userlist,
-			len_session_userlist + PSTRING_LEN );
+			len_session_userlist + 1024 );
 		if( newlist == NULL ) {
 			DEBUG(1,("Unable to resize session_userlist\n"));
 			return;
@@ -418,7 +418,7 @@ void add_session_user(const char *user)
 			*newlist = '\0';
 		}
 		session_userlist = newlist;
-		len_session_userlist += PSTRING_LEN;
+		len_session_userlist += 1024;
 	}
 
 	safe_strcat(session_userlist," ",len_session_userlist-1);
diff --git a/source3/utils/net_rpc.c b/source3/utils/net_rpc.c
index a89f1bf81a..e6a7e954fd 100644
--- a/source3/utils/net_rpc.c
+++ b/source3/utils/net_rpc.c
@@ -3591,11 +3591,12 @@ static void copy_fn(const char *mnt, file_info *f, const char *mask, void *state
 bool sync_files(struct copy_clistate *cp_clistate, pstring mask)
 {
 	struct cli_state *targetcli;
-	pstring targetpath;
+	char *targetpath = NULL;
 
 	DEBUG(3,("calling cli_list with mask: %s\n", mask));
 
-	if ( !cli_resolve_path( "", cp_clistate->cli_share_src, mask, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path(talloc_tos(), "", cp_clistate->cli_share_src,
+				mask, &targetcli, &targetpath ) ) {
 		d_fprintf(stderr, "cli_resolve_path %s failed with error: %s\n", 
 			mask, cli_errstr(cp_clistate->cli_share_src));
 		return False;