Remove pstrings from client/client.c by doing a large rewrite.

Mostly compiles....
Jeremy.
(This used to be commit c87f3eba9aa52f4ab25d77e2167262bf5c43b1a6)

1 files changed, 1555 insertions, 981 deletions

diff --git a/source3/client/client.c b/source3/client/client.c
index ed33d42081..5caad192b6 100644
--- a/source3/client/client.c
+++ b/source3/client/client.c
@@ -1,21 +1,22 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    SMB client
    Copyright (C) Andrew Tridgell          1994-1998
    Copyright (C) Simo Sorce               2001-2002
    Copyright (C) Jelmer Vernooij          2003
    Copyright (C) Gerald (Jerry) Carter    2004
-   
+   Copyright (C) Jeremy Allison           1994-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/>.
 */
@@ -32,13 +33,10 @@ extern bool override_logfile;
 extern char tar_type;
 extern bool in_client;
 static int port = 0;
-pstring cur_dir = "\\";
-static pstring cd_path = "";
-static pstring service;
-static pstring desthost;
-static pstring username;
-static pstring calling_name;
-static bool grepable=False;
+static char *service;
+static char *desthost;
+static char *calling_name;
+static bool grepable = false;
 static char *cmdstr = NULL;
 
 static int io_bufsize = 64512;
@@ -46,12 +44,10 @@ static int io_bufsize = 64512;
 static int name_type = 0x20;
 extern int max_protocol;
 
-static int process_tok(pstring tok);
+static int process_tok(char *tok);
 static int cmd_help(void);
 
-static TALLOC_CTX *ctx;
 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
-static pstring cwd;
 
 /* 30 second timeout on most commands */
 #define CLIENT_TIMEOUT (30*1000)
@@ -63,7 +59,7 @@ static pstring cwd;
 time_t newer_than = 0;
 static int archive_level = 0;
 
-static bool translation = False;
+static bool translation = false;
 static bool have_ip;
 
 /* clitar bits insert */
@@ -71,23 +67,18 @@ extern int blocksize;
 extern bool tar_inc;
 extern bool tar_reset;
 /* clitar bits end */
- 
 
-static bool prompt = True;
+static bool prompt = true;
 
-static bool recurse = False;
-static bool showacls = False;
-bool lowercase = False;
+static bool recurse = false;
+static bool showacls = false;
+bool lowercase = false;
 
 static struct sockaddr_storage dest_ss;
 
 #define SEPARATORS " \t\n\r"
 
-static bool abort_mget = True;
-
-static pstring fileselection = "";
-
-extern file_info def_finfo;
+static bool abort_mget = true;
 
 /* timing globals */
 SMB_BIG_UINT get_total_size = 0;
@@ -105,8 +96,63 @@ struct cli_state *cli;
 static char CLI_DIRSEP_CHAR = '\\';
 static char CLI_DIRSEP_STR[] = { '\\', '\0' };
 
+/* Accessor functions for directory paths. */
+static char *fileselection;
+static const char *client_get_fileselection(void)
+{
+	if (fileselection) {
+		return fileselection;
+	}
+	return "";
+}
+
+static const char *client_set_fileselection(const char *new_fs)
+{
+	SAFE_FREE(fileselection);
+	if (new_fs) {
+		fileselection = SMB_STRDUP(new_fs);
+	}
+	return client_get_fileselection();
+}
+
+static char *cwd;
+static const char *client_get_cwd(void)
+{
+	if (cwd) {
+		return cwd;
+	}
+	return CLI_DIRSEP_STR;
+}
+
+static const char *client_set_cwd(const char *new_cwd)
+{
+	SAFE_FREE(cwd);
+	if (new_cwd) {
+		cwd = SMB_STRDUP(new_cwd);
+	}
+	return client_get_cwd();
+}
+
+static char *cur_dir;
+const char *client_get_cur_dir(void)
+{
+	if (cur_dir) {
+		return cur_dir;
+	}
+	return CLI_DIRSEP_STR;
+}
+
+const char *client_set_cur_dir(const char *newdir)
+{
+	SAFE_FREE(cur_dir);
+	if (newdir) {
+		cur_dir = SMB_STRDUP(newdir);
+	}
+	return client_get_cur_dir();
+}
+
 /****************************************************************************
- Write to a local file with CR/LF->LF translation if appropriate. Return the 
+ Write to a local file with CR/LF->LF translation if appropriate. Return the
  number taken from the buffer. This may not equal the number written.
 ****************************************************************************/
 
@@ -129,12 +175,12 @@ static int writefile(int f, char *b, int n)
 		b++;
 		i++;
 	}
-  
+
 	return(i);
 }
 
 /****************************************************************************
- Read from a file with LF->CR/LF translation if appropriate. Return the 
+ Read from a file with LF->CR/LF translation if appropriate. Return the
  number read. read approx n bytes.
 ****************************************************************************/
 
@@ -145,23 +191,23 @@ static int readfile(char *b, int n, XFILE *f)
 
 	if (!translation)
 		return x_fread(b,1,n,f);
-  
+
 	i = 0;
 	while (i < (n - 1) && (i < BUFFER_SIZE)) {
 		if ((c = x_getc(f)) == EOF) {
 			break;
 		}
-      
+
 		if (c == '\n') { /* change all LFs to CR/LF */
 			b[i++] = '\r';
 		}
-      
+
 		b[i++] = c;
 	}
-  
+
 	return(i);
 }
- 
+
 /****************************************************************************
  Send a message.
 ****************************************************************************/
@@ -171,7 +217,8 @@ static void send_message(void)
 	int total_len = 0;
 	int grp_id;
 
-	if (!cli_message_start(cli, desthost, username, &grp_id)) {
+	if (!cli_message_start(cli, desthost,
+				get_cmdline_auth_info_username(), &grp_id)) {
 		d_printf("message start: %s\n", cli_errstr(cli));
 		return;
 	}
@@ -181,7 +228,7 @@ static void send_message(void)
 
 	while (!feof(stdin) && total_len < 1600) {
 		int maxlen = MIN(1600 - total_len,127);
-		pstring msg;
+		char msg[1024];
 		int l=0;
 		int c;
 
@@ -190,7 +237,7 @@ static void send_message(void)
 		for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
 			if (c == '\n')
 				msg[l++] = '\r';
-			msg[l] = c;   
+			msg[l] = c;
 		}
 
 		if ((total_len > 0) && (strlen(msg) == 0)) {
@@ -200,8 +247,8 @@ static void send_message(void)
 		if (!cli_message_text(cli, msg, l, grp_id)) {
 			d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli));
 			return;
-		}      
-		
+		}
+
 		total_len += l;
 	}
 
@@ -213,7 +260,7 @@ static void send_message(void)
 	if (!cli_message_end(cli, grp_id)) {
 		d_printf("SMBsendend failed (%s)\n",cli_errstr(cli));
 		return;
-	}      
+	}
 }
 
 /****************************************************************************
@@ -223,16 +270,17 @@ static void send_message(void)
 static int do_dskattr(void)
 {
 	int total, bsize, avail;
-	struct cli_state *targetcli;
-	pstring targetpath;
+	struct cli_state *targetcli = NULL;
+	char *targetpath = NULL;
+	TALLOC_CTX *ctx = talloc_tos();
 
-	if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) {
+	if ( !cli_resolve_path(ctx, "", cli, client_get_cur_dir(), &targetcli, &targetpath)) {
 		d_printf("Error in dskattr: %s\n", cli_errstr(cli));
 		return 1;
 	}
 
 	if (!cli_dskattr(targetcli, &bsize, &total, &avail)) {
-		d_printf("Error in dskattr: %s\n",cli_errstr(targetcli)); 
+		d_printf("Error in dskattr: %s\n",cli_errstr(targetcli));
 		return 1;
 	}
 
@@ -249,7 +297,7 @@ static int do_dskattr(void)
 static int cmd_pwd(void)
 {
 	d_printf("Current directory is %s",service);
-	d_printf("%s\n",cur_dir);
+	d_printf("%s\n",client_get_cur_dir());
 	return 0;
 }
 
@@ -257,67 +305,102 @@ static int cmd_pwd(void)
  Change directory - inner section.
 ****************************************************************************/
 
-static int do_cd(char *newdir)
+static int do_cd(const char *new_dir)
 {
-	char *p = newdir;
-	pstring saved_dir;
-	pstring dname;
-	pstring targetpath;
-	struct cli_state *targetcli;
+	char *newdir = NULL;
+	char *saved_dir = NULL;
+	char *new_cd = NULL;
+	char *targetpath = NULL;
+	struct cli_state *targetcli = NULL;
 	SMB_STRUCT_STAT sbuf;
 	uint32 attributes;
 	int ret = 1;
-      
-	dos_format(newdir);
+	TALLOC_CTX *ctx = talloc_stackframe();
+
+	newdir = talloc_strdup(ctx, new_dir);
+	if (!newdir) {
+		TALLOC_FREE(ctx);
+		return 1;
+	}
+	string_replace(newdir,'/','\\');
 
 	/* Save the current directory in case the new directory is invalid */
 
-	pstrcpy(saved_dir, cur_dir);
+	saved_dir = talloc_strdup(ctx, client_get_cur_dir());
+	if (!saved_dir) {
+		TALLOC_FREE(ctx);
+		return 1;
+	}
 
-	if (*p == CLI_DIRSEP_CHAR) {
-		pstrcpy(cur_dir,p);
+	if (*newdir == CLI_DIRSEP_CHAR) {
+		client_set_cur_dir(newdir);
+		new_cd = newdir;
 	} else {
-		pstrcat(cur_dir,p);
-		if ((cur_dir[0] != '\0') && (*(cur_dir+strlen(cur_dir)-1) != CLI_DIRSEP_CHAR)) {
-			pstrcat(cur_dir, CLI_DIRSEP_STR);
+		new_cd = talloc_asprintf(ctx, "%s%s",
+				client_get_cur_dir(),
+				newdir);
+		if (!new_cd) {
+			goto out;
 		}
+		if ((new_cd[0] != '\0') && (*(new_cd+strlen(new_cd)-1) != CLI_DIRSEP_CHAR)) {
+			new_cd = talloc_asprintf_append(new_cd, CLI_DIRSEP_STR);
+			if (!new_cd) {
+				goto out;
+			}
+		}
+		client_set_cur_dir(new_cd);
 	}
-	
-	pstring_clean_name(cur_dir);
-	pstrcpy( dname, cur_dir );
-	
-	if ( !cli_resolve_path_pstring( "", cli, dname, &targetcli, targetpath ) ) {
-		d_printf("cd %s: %s\n", dname, cli_errstr(cli));
-		pstrcpy(cur_dir,saved_dir);
+	if (!new_cd) {
+		goto out;
+	}
+
+	new_cd = clean_name(ctx, new_cd);
+	client_set_cur_dir(new_cd);
+
+	if ( !cli_resolve_path(ctx, "", cli, new_cd, &targetcli, &targetpath)) {
+		d_printf("cd %s: %s\n", new_cd, cli_errstr(cli));
+		client_set_cur_dir(saved_dir);
 		goto out;
 	}
 
 	if (strequal(targetpath,CLI_DIRSEP_STR )) {
+		TALLOC_FREE(ctx);
 		return 0;
 	}
-		
+
 	/* Use a trans2_qpathinfo to test directories for modern servers.
-	   Except Win9x doesn't support the qpathinfo_basic() call..... */ 
-	
-	if ( targetcli->protocol >  PROTOCOL_LANMAN2 && !targetcli->win95 ) {
-		if ( !cli_qpathinfo_basic( targetcli, targetpath, &sbuf, &attributes ) ) {
-			d_printf("cd %s: %s\n", dname, cli_errstr(targetcli));
-			pstrcpy(cur_dir,saved_dir);
+	   Except Win9x doesn't support the qpathinfo_basic() call..... */
+
+	if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
+		if (!cli_qpathinfo_basic( targetcli, targetpath, &sbuf, &attributes ) ) {
+			d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+			client_set_cur_dir(saved_dir);
 			goto out;
 		}
-		
-		if ( !(attributes&FILE_ATTRIBUTE_DIRECTORY) ) {
-			d_printf("cd %s: not a directory\n", dname);
-			pstrcpy(cur_dir,saved_dir);
+
+		if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+			d_printf("cd %s: not a directory\n", new_cd);
+			client_set_cur_dir(saved_dir);
 			goto out;
-		}		
+		}
 	} else {
-		pstrcat( targetpath, CLI_DIRSEP_STR );
-		pstring_clean_name( targetpath );
-		
-		if ( !cli_chkpath(targetcli, targetpath) ) {
-			d_printf("cd %s: %s\n", dname, cli_errstr(targetcli));
-			pstrcpy(cur_dir,saved_dir);
+		targetpath = talloc_asprintf(ctx,
+				"%s%s",
+				targetpath,
+				CLI_DIRSEP_STR );
+		if (!targetpath) {
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+		targetpath = clean_name(ctx, targetpath);
+		if (!targetpath) {
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+
+		if (!cli_chkpath(targetcli, targetpath)) {
+			d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+			client_set_cur_dir(saved_dir);
 			goto out;
 		}
 	}
@@ -325,8 +408,8 @@ static int do_cd(char *newdir)
 	ret = 0;
 
 out:
-	
-	pstrcpy(cd_path,cur_dir);
+
+	TALLOC_FREE(ctx);
 	return ret;
 }
 
@@ -336,13 +419,14 @@ out:
 
 static int cmd_cd(void)
 {
-	pstring buf;
+	char *buf = NULL;
 	int rc = 0;
-		
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
+
+	if (next_token_nr_talloc(talloc_tos(), NULL, &buf,NULL)) {
 		rc = do_cd(buf);
-	else
-		d_printf("Current directory is %s\n",cur_dir);
+	} else {
+		d_printf("Current directory is %s\n",client_get_cur_dir());
+	}
 
 	return rc;
 }
@@ -353,89 +437,102 @@ static int cmd_cd(void)
 
 static int cmd_cd_oneup(void)
 {
-	pstring buf;
-
-	pstrcpy(buf, "..");
-	return do_cd(buf);
+	return do_cd("..");
 }
 
-
 /*******************************************************************
  Decide if a file should be operated on.
 ********************************************************************/
 
 static bool do_this_one(file_info *finfo)
 {
-	if (finfo->mode & aDIR)
-		return(True);
+	if (!finfo->name) {
+		return false;
+	}
 
-	if (*fileselection && 
-	    !mask_match(finfo->name,fileselection,False)) {
+	if (finfo->mode & aDIR) {
+		return true;
+	}
+
+	if (*client_get_fileselection() &&
+	    !mask_match(finfo->name,client_get_fileselection(),false)) {
 		DEBUG(3,("mask_match %s failed\n", finfo->name));
-		return False;
+		return false;
 	}
 
 	if (newer_than && finfo->mtime_ts.tv_sec < newer_than) {
 		DEBUG(3,("newer_than %s failed\n", finfo->name));
-		return(False);
+		return false;
 	}
 
 	if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) {
 		DEBUG(3,("archive %s failed\n", finfo->name));
-		return(False);
+		return false;
 	}
-	
-	return(True);
+
+	return true;
 }
 
 /****************************************************************************
  Display info about a file.
 ****************************************************************************/
 
-static void display_finfo(file_info *finfo)
+static void display_finfo(file_info *finfo, const char *dir)
 {
-	if (do_this_one(finfo)) {
-		time_t t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
-		if (!showacls) {
-			d_printf("  %-30s%7.7s %8.0f  %s",
-				 finfo->name,
-				 attrib_string(finfo->mode),
-			 	(double)finfo->size,
-				time_to_asc(t));
-			dir_total += finfo->size;
-		} else {
-			pstring afname;
-			int fnum;
+	time_t t;
+	TALLOC_CTX *ctx = talloc_tos();
 
-			/* skip if this is . or .. */
-			if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
-				return;
-			/* create absolute filename for cli_nt_create() FIXME */
-			pstrcpy( afname, cwd);
-			pstrcat( afname, CLI_DIRSEP_STR);
-			pstrcat( afname, finfo->name);
-			/* print file meta date header */
-			d_printf( "FILENAME:%s\n", afname);
-			d_printf( "MODE:%s\n", attrib_string(finfo->mode));
-			d_printf( "SIZE:%.0f\n", (double)finfo->size);
-			d_printf( "MTIME:%s", time_to_asc(t));
-			fnum = cli_nt_create(finfo->cli, afname, CREATE_ACCESS_READ);
-			if (fnum == -1) {
-				DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
-					afname,
+	if (!do_this_one(finfo)) {
+		return;
+	}
+
+	t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
+	if (!showacls) {
+		d_printf("  %-30s%7.7s %8.0f  %s",
+			 finfo->name,
+			 attrib_string(finfo->mode),
+		 	(double)finfo->size,
+			time_to_asc(t));
+		dir_total += finfo->size;
+	} else {
+		char *afname = NULL;
+		int fnum;
+
+		/* skip if this is . or .. */
+		if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
+			return;
+		/* create absolute filename for cli_nt_create() FIXME */
+		afname = talloc_asprintf(ctx,
+					"%s%s%s",
+					client_get_cwd(),
+					CLI_DIRSEP_STR,
+					finfo->name);
+		if (!afname) {
+			return;
+		}
+		/* print file meta date header */
+		d_printf( "FILENAME:%s\n", afname);
+		d_printf( "MODE:%s\n", attrib_string(finfo->mode));
+		d_printf( "SIZE:%.0f\n", (double)finfo->size);
+		d_printf( "MTIME:%s", time_to_asc(t));
+		fnum = cli_nt_create(finfo->cli, afname, CREATE_ACCESS_READ);
+		if (fnum == -1) {
+			DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
+				afname,
+				cli_errstr( finfo->cli)));
+		} else {
+			SEC_DESC *sd = NULL;
+			sd = cli_query_secdesc(finfo->cli, fnum, ctx);
+			if (!sd) {
+				DEBUG( 0, ("display_finfo() failed to "
+					"get security descriptor: %s",
 					cli_errstr( finfo->cli)));
 			} else {
-				SEC_DESC *sd = NULL;
-				sd = cli_query_secdesc(finfo->cli, fnum, ctx);
-				if (!sd) {
-					DEBUG( 0, ("display_finfo() failed to "
-						"get security descriptor: %s",
-						cli_errstr( finfo->cli)));
-				} else {
-					display_sec_desc(sd);
-				}
+				display_sec_desc(sd);
 			}
+			TALLOC_FREE(sd);
 		}
+		TALLOC_FREE(afname);
 	}
 }
 
@@ -443,7 +540,7 @@ static void display_finfo(file_info *finfo)
  Accumulate size of a file.
 ****************************************************************************/
 
-static void do_du(file_info *finfo)
+static void do_du(file_info *finfo, const char *dir)
 {
 	if (do_this_one(finfo)) {
 		dir_total += finfo->size;
@@ -456,7 +553,7 @@ static char *do_list_queue = 0;
 static long do_list_queue_size = 0;
 static long do_list_queue_start = 0;
 static long do_list_queue_end = 0;
-static void (*do_list_fn)(file_info *);
+static void (*do_list_fn)(file_info *, const char *dir);
 
 /****************************************************************************
  Functions for do_list_queue.
@@ -487,7 +584,7 @@ static void init_do_list_queue(void)
 	reset_do_list_queue();
 	do_list_queue_size = 1024;
 	do_list_queue = (char *)SMB_MALLOC(do_list_queue_size);
-	if (do_list_queue == 0) { 
+	if (do_list_queue == 0) {
 		d_printf("malloc fail for size %d\n",
 			 (int)do_list_queue_size);
 		reset_do_list_queue();
@@ -508,7 +605,7 @@ static void adjust_do_list_queue(void)
 		do_list_queue_start = do_list_queue_end = 0;
 		return;
 	}
-		
+
 	if (do_list_queue_start == do_list_queue_end) {
 		DEBUG(4,("do_list_queue is empty\n"));
 		do_list_queue_start = do_list_queue_end = 0;
@@ -523,7 +620,7 @@ static void adjust_do_list_queue(void)
 	}
 }
 
-static void add_to_do_list_queue(const char* entry)
+static void add_to_do_list_queue(const char *entry)
 {
 	long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
 	while (new_end > do_list_queue_size) {
@@ -541,7 +638,7 @@ static void add_to_do_list_queue(const char* entry)
 		}
 	}
 	if (do_list_queue) {
-		safe_strcpy_base(do_list_queue + do_list_queue_end, 
+		safe_strcpy_base(do_list_queue + do_list_queue_end,
 				 entry, do_list_queue, do_list_queue_size);
 		do_list_queue_end = new_end;
 		DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
@@ -575,57 +672,85 @@ static int do_list_queue_empty(void)
 
 static void do_list_helper(const char *mntpoint, file_info *f, const char *mask, void *state)
 {
-	char *dir_end;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *dir = NULL;
+	char *dir_end = NULL;
 
-	/* save the directory */
-	pstrcpy( f->dir, mask );
-	if ( (dir_end = strrchr( f->dir, CLI_DIRSEP_CHAR )) != NULL ) {
+	/* Work out the directory. */
+	dir = talloc_strdup(ctx, mask);
+	if (!dir) {
+		return;
+	}
+	if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
 		*dir_end = '\0';
 	}
 
 	if (f->mode & aDIR) {
 		if (do_list_dirs && do_this_one(f)) {
-			do_list_fn(f);
+			do_list_fn(f, dir);
 		}
-		if (do_list_recurse && 
-		    !strequal(f->name,".") && 
+		if (do_list_recurse &&
+		    f->name &&
+		    !strequal(f->name,".") &&
 		    !strequal(f->name,"..")) {
-			pstring mask2;
-			char *p;
+			char *mask2 = NULL;
+			char *p = NULL;
 
 			if (!f->name[0]) {
 				d_printf("Empty dir name returned. Possible server misconfiguration.\n");
+				TALLOC_FREE(dir);
 				return;
 			}
 
-			pstrcpy(mask2, mntpoint);
-			pstrcat(mask2, mask);
+			mask2 = talloc_asprintf(ctx,
+					"%s%s",
+					mntpoint,
+					mask);
+			if (!mask2) {
+				TALLOC_FREE(dir);
+				return;
+			}
 			p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
-			if (!p)
+			if (!p) {
+				TALLOC_FREE(dir);
 				return;
+			}
 			p[1] = 0;
-			pstrcat(mask2, f->name);
-			pstrcat(mask2,CLI_DIRSEP_STR);
-			pstrcat(mask2,"*");
+			mask2 = talloc_asprintf_append(mask2,
+					"%s%s*",
+					f->name,
+					CLI_DIRSEP_STR);
+			if (!mask2) {
+				TALLOC_FREE(dir);
+				return;
+			}
 			add_to_do_list_queue(mask2);
+			TALLOC_FREE(mask2);
 		}
+		TALLOC_FREE(dir);
 		return;
 	}
 
 	if (do_this_one(f)) {
-		do_list_fn(f);
+		do_list_fn(f,dir);
 	}
+	TALLOC_FREE(dir);
 }
 
 /****************************************************************************
  A wrapper around cli_list that adds recursion.
 ****************************************************************************/
 
-void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, bool dirs)
+void do_list(const char *mask,
+			uint16 attribute,
+			void (*fn)(file_info *, const char *dir),
+			bool rec,
+			bool dirs)
 {
 	static int in_do_list = 0;
-	struct cli_state *targetcli;
-	pstring targetpath;
+	TALLOC_CTX *ctx = talloc_tos();
+	struct cli_state *targetcli = NULL;
+	char *targetpath = NULL;
 
 	if (in_do_list && rec) {
 		fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
@@ -641,8 +766,8 @@ 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()) {
+
+		while (!do_list_queue_empty()) {
 			/*
 			 * Need to copy head so that it doesn't become
 			 * invalid inside the call to cli_list.  This
@@ -650,30 +775,35 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 			 * during the call.
 			 * Fix from E. Jay Berkenbilt (ejb@ql.org)
 			 */
-			pstring head;
-			pstrcpy(head, do_list_queue_head());
-			
+			char *head = talloc_strdup(ctx, do_list_queue_head());
+
+			if (!head) {
+				return;
+			}
+
 			/* check for dfs */
-			
-			if ( !cli_resolve_path_pstring( "", cli, head, &targetcli, targetpath ) ) {
+
+			if ( !cli_resolve_path(ctx, "", 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)) {
-				char* next_file = do_list_queue_head();
-				char* save_ch = 0;
+				char *next_file = do_list_queue_head();
+				char *save_ch = 0;
 				if ((strlen(next_file) >= 2) &&
 				    (next_file[strlen(next_file) - 1] == '*') &&
 				    (next_file[strlen(next_file) - 2] == CLI_DIRSEP_CHAR)) {
 					save_ch = next_file +
 						strlen(next_file) - 2;
 					*save_ch = '\0';
-					if (showacls) /* cwd is only used if showacls is on */
-						pstrcpy( cwd, next_file);
+					if (showacls) {
+						/* cwd is only used if showacls is on */
+						client_set_cwd(next_file);
+					}
 				}
 				if (!showacls) /* don't disturbe the showacls output */
 					d_printf("\n%s\n",next_file);
@@ -681,17 +811,20 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 					*save_ch = CLI_DIRSEP_CHAR;
 				}
 			}
+			TALLOC_FREE(head);
+			TALLOC_FREE(targetpath);
 		}
 	} else {
 		/* check for dfs */
-			
-		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);
-		}
-		else
+		if (cli_resolve_path(ctx, "", 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);
+			}
+			TALLOC_FREE(targetpath);
+		} else {
 			d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
-		
+		}
 	}
 
 	in_do_list = 0;
@@ -704,37 +837,49 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec,
 
 static int cmd_dir(void)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
-	pstring mask;
-	pstring buf;
-	char *p=buf;
-	int rc;
-	
+	char *mask = NULL;
+	char *buf = NULL;
+	int rc = 1;
+
 	dir_total = 0;
-	if (strcmp(cur_dir, CLI_DIRSEP_STR) != 0) {
-		pstrcpy(mask,cur_dir);
-		if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR))
-			pstrcat(mask,CLI_DIRSEP_STR);
+	if (strcmp(client_get_cur_dir(), CLI_DIRSEP_STR) != 0) {
+		mask = talloc_strdup(ctx, client_get_cur_dir());
+		if (!mask) {
+			return 1;
+		}
+		if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
+			mask = talloc_asprintf_append(mask, CLI_DIRSEP_STR);
+		}
 	} else {
-		pstrcpy(mask, CLI_DIRSEP_STR);
+		mask = talloc_strdup(ctx, CLI_DIRSEP_STR);
 	}
-	
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
-		dos_format(p);
-		if (*p == CLI_DIRSEP_CHAR)
-			pstrcpy(mask,p + 1);
-		else
-			pstrcat(mask,p);
+
+	if (!mask) {
+		return 1;
+	}
+
+	if (next_token_nr_talloc(ctx, NULL,&buf,NULL)) {
+		string_replace(buf,'/','\\');
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mask = talloc_strdup(ctx, buf + 1);
+		} else {
+			mask = talloc_asprintf_append(mask, buf);
+		}
 	} else {
-		pstrcat(mask,"*");
+		mask = talloc_asprintf_append(mask, "*");
+	}
+	if (!mask) {
+		return 1;
 	}
 
 	if (showacls) {
 		/* cwd is only used if showacls is on */
-		pstrcpy(cwd, cur_dir);
+		client_set_cwd(client_get_cur_dir());
 	}
 
-	do_list(mask, attribute, display_finfo, recurse, True);
+	do_list(mask, attribute, display_finfo, recurse, true);
 
 	rc = do_dskattr();
 
@@ -749,28 +894,36 @@ static int cmd_dir(void)
 
 static int cmd_du(void)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
-	pstring mask;
-	pstring buf;
-	char *p=buf;
-	int rc;
-	
+	char *mask = NULL;
+	char *buf = NULL;
+	int rc = 1;
+
 	dir_total = 0;
-	pstrcpy(mask,cur_dir);
-	if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR))
-		pstrcat(mask,CLI_DIRSEP_STR);
-	
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
-		dos_format(p);
-		if (*p == CLI_DIRSEP_CHAR)
-			pstrcpy(mask,p);
-		else
-			pstrcat(mask,p);
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+	if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
+		mask = talloc_asprintf_append(mask, CLI_DIRSEP_STR);
+		if (!mask) {
+			return 1;
+		}
+	}
+
+	if (next_token_nr_talloc(ctx, NULL,&buf,NULL)) {
+		string_replace(buf,'/','\\');
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mask = talloc_strdup(ctx, buf);
+		} else {
+			mask = talloc_asprintf_append(mask, buf);
+		}
 	} else {
-		pstrcat(mask,"*");
+		mask = talloc_strdup(ctx, "*");
 	}
 
-	do_list(mask, attribute, do_du, recurse, True);
+	do_list(mask, attribute, do_du, recurse, true);
 
 	rc = do_dskattr();
 
@@ -781,11 +934,12 @@ static int cmd_du(void)
 
 static int cmd_echo(void)
 {
-	fstring num;
-	pstring data;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *num;
+	char *data;
 
-	if (!next_token_nr(NULL, num, NULL, sizeof(num))
-	    || !next_token_nr(NULL, data, NULL, sizeof(data))) {
+	if (!next_token_nr_talloc(ctx, NULL, &num, NULL)
+	    || !next_token_nr_talloc(ctx, NULL, &data, NULL)) {
 		d_printf("echo <num> <data>\n");
 		return 1;
 	}
@@ -803,11 +957,12 @@ static int cmd_echo(void)
  Get a file from rname to lname
 ****************************************************************************/
 
-static int do_get(char *rname, char *lname, bool reget)
-{  
+static int do_get(const char *rname, const char *lname_in, bool reget)
+{
+	TALLOC_CTX *ctx = talloc_tos();
 	int handle = 0, fnum;
-	bool newhandle = False;
-	char *data;
+	bool newhandle = false;
+	char *data = NULL;
 	struct timeval tp_start;
 	int read_size = io_bufsize;
 	uint16 attr;
@@ -815,21 +970,26 @@ static int do_get(char *rname, char *lname, bool reget)
 	off_t start = 0;
 	off_t nread = 0;
 	int rc = 0;
-	struct cli_state *targetcli;
-	pstring targetname;
+	struct cli_state *targetcli = NULL;
+	char *targetname = NULL;
+	char *lname = NULL;
 
+	lname = talloc_strdup(ctx, lname_in);
+	if (!lname) {
+		return 1;
+	}
 
 	if (lowercase) {
 		strlower_m(lname);
 	}
 
-	if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, rname, &targetcli, &targetname ) ) {
 		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
 		return 1;
 	}
 
 	GetTimeOfDay(&tp_start);
-	
+
 	fnum = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE);
 
 	if (fnum == -1) {
@@ -852,7 +1012,7 @@ static int do_get(char *rname, char *lname, bool reget)
 		} else {
 			handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 		}
-		newhandle = True;
+		newhandle = true;
 	}
 	if (handle < 0) {
 		d_printf("Error opening local file %s\n",lname);
@@ -860,18 +1020,18 @@ static int do_get(char *rname, char *lname, bool reget)
 	}
 
 
-	if (!cli_qfileinfo(targetcli, fnum, 
+	if (!cli_qfileinfo(targetcli, fnum,
 			   &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
-	    !cli_getattrE(targetcli, fnum, 
+	    !cli_getattrE(targetcli, fnum,
 			  &attr, &size, NULL, NULL, NULL)) {
 		d_printf("getattrib: %s\n",cli_errstr(targetcli));
 		return 1;
 	}
 
-	DEBUG(1,("getting file %s of size %.0f as %s ", 
+	DEBUG(1,("getting file %s of size %.0f as %s ",
 		 rname, (double)size, lname));
 
-	if(!(data = (char *)SMB_MALLOC(read_size))) { 
+	if(!(data = (char *)SMB_MALLOC(read_size))) {
 		d_printf("malloc fail for size %d\n", read_size);
 		cli_close(targetcli, fnum);
 		return 1;
@@ -882,13 +1042,13 @@ static int do_get(char *rname, char *lname, bool reget)
 
 		if (n <= 0)
 			break;
- 
+
 		if (writefile(handle,data, n) != n) {
 			d_printf("Error writing local file\n");
 			rc = 1;
 			break;
 		}
-      
+
 		nread += n;
 	}
 
@@ -900,7 +1060,7 @@ static int do_get(char *rname, char *lname, bool reget)
 	}
 
 	SAFE_FREE(data);
-	
+
 	if (!cli_close(targetcli, fnum)) {
 		d_printf("Error %s closing remote file\n",cli_errstr(cli));
 		rc = 1;
@@ -917,19 +1077,20 @@ static int do_get(char *rname, char *lname, bool reget)
 	{
 		struct timeval tp_end;
 		int this_time;
-		
+
 		GetTimeOfDay(&tp_end);
-		this_time = 
+		this_time =
 			(tp_end.tv_sec - tp_start.tv_sec)*1000 +
 			(tp_end.tv_usec - tp_start.tv_usec)/1000;
 		get_total_time_ms += this_time;
 		get_total_size += nread;
-		
+
 		DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
 			 nread / (1.024*this_time + 1.0e-4),
 			 get_total_size / (1.024*get_total_time_ms)));
 	}
-	
+
+	TALLOC_FREE(targetname);
 	return rc;
 }
 
@@ -939,37 +1100,56 @@ static int do_get(char *rname, char *lname, bool reget)
 
 static int cmd_get(void)
 {
-	pstring lname;
-	pstring rname;
-	char *p;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname = NULL;
+	char *rname = NULL;
+	char *fname = NULL;
+
+	rname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			CLI_DIRSEP_STR);
+	if (!rname) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx, NULL,&fname,NULL)) {
+		d_printf("get <filename> [localname]\n");
+		return 1;
+	}
+	rname = talloc_asprintf_append(rname, fname);
+	if (!rname) {
+		return 1;
+	}
+	rname = clean_name(ctx, rname);
+	if (!rname) {
+		return 1;
+	}
 
-	pstrcpy(rname,cur_dir);
-	pstrcat(rname,CLI_DIRSEP_STR);
-	
-	p = rname + strlen(rname);
-	
-	if (!next_token_nr(NULL,p,NULL,sizeof(rname)-strlen(rname))) {
-		d_printf("get <filename>\n");
-		return 1;
-	}
-	pstrcpy(lname,p);
-	pstring_clean_name(rname);
-	
-	next_token_nr(NULL,lname,NULL,sizeof(lname));
-	
-	return do_get(rname, lname, False);
+	next_token_nr_talloc(ctx, NULL,&lname,NULL);
+	if (!lname) {
+		lname = fname;
+	}
+
+	return do_get(rname, lname, false);
 }
 
 /****************************************************************************
  Do an mget operation on one file.
 ****************************************************************************/
 
-static void do_mget(file_info *finfo)
+static void do_mget(file_info *finfo, const char *dir)
 {
-	pstring rname;
-	pstring quest;
-	pstring saved_curdir;
-	pstring mget_mask;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *rname = NULL;
+	char *quest = NULL;
+	char *saved_curdir = NULL;
+	char *mget_mask = NULL;
+	char *new_cd = NULL;
+
+	if (!finfo->name) {
+		return;
+	}
 
 	if (strequal(finfo->name,".") || strequal(finfo->name,".."))
 		return;
@@ -979,52 +1159,85 @@ static void do_mget(file_info *finfo)
 		return;
 	}
 
-	if (finfo->mode & aDIR)
-		slprintf(quest,sizeof(pstring)-1,
-			 "Get directory %s? ",finfo->name);
-	else
-		slprintf(quest,sizeof(pstring)-1,
-			 "Get file %s? ",finfo->name);
+	if (finfo->mode & aDIR) {
+		if (asprintf(&quest,
+			 "Get directory %s? ",finfo->name) < 0) {
+			return;
+		}
+	} else {
+		if (asprintf(&quest,
+			 "Get file %s? ",finfo->name) < 0) {
+			return;
+		}
+	}
 
-	if (prompt && !yesno(quest))
+	if (prompt && !yesno(quest)) {
+		SAFE_FREE(quest);
 		return;
+	}
+	SAFE_FREE(quest);
 
 	if (!(finfo->mode & aDIR)) {
-		pstrcpy(rname,cur_dir);
-		pstrcat(rname,finfo->name);
-		do_get(rname, finfo->name, False);
+		rname = talloc_asprintf(ctx,
+				"%s%s",
+				client_get_cur_dir(),
+				finfo->name);
+		if (!rname) {
+			return;
+		}
+		do_get(rname, finfo->name, false);
+		TALLOC_FREE(rname);
 		return;
 	}
 
 	/* handle directories */
-	pstrcpy(saved_curdir,cur_dir);
+	saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
+	if (!saved_curdir) {
+		return;
+	}
 
-	pstrcat(cur_dir,finfo->name);
-	pstrcat(cur_dir,CLI_DIRSEP_STR);
+	new_cd = talloc_asprintf(ctx,
+				"%s%s%s",
+				client_get_cur_dir(),
+				finfo->name,
+				CLI_DIRSEP_STR);
+	if (!new_cd) {
+		return;
+	}
+	client_set_cur_dir(new_cd);
 
-	unix_format(finfo->name);
-	if (lowercase)
+	string_replace(finfo->name,'\\','/');
+	if (lowercase) {
 		strlower_m(finfo->name);
-	
-	if (!directory_exist(finfo->name,NULL) && 
+	}
+
+	if (!directory_exist(finfo->name,NULL) &&
 	    mkdir(finfo->name,0777) != 0) {
 		d_printf("failed to create directory %s\n",finfo->name);
-		pstrcpy(cur_dir,saved_curdir);
+		client_set_cur_dir(saved_curdir);
 		return;
 	}
-	
+
 	if (chdir(finfo->name) != 0) {
 		d_printf("failed to chdir to directory %s\n",finfo->name);
-		pstrcpy(cur_dir,saved_curdir);
+		client_set_cur_dir(saved_curdir);
 		return;
 	}
 
-	pstrcpy(mget_mask,cur_dir);
-	pstrcat(mget_mask,"*");
-	
-	do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,False, True);
+	mget_mask = talloc_asprintf(ctx,
+			"%s*",
+			client_get_cur_dir());
+
+	if (!mget_mask) {
+		return;
+	}
+
+	do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
 	chdir("..");
-	pstrcpy(cur_dir,saved_curdir);
+	client_set_cur_dir(saved_curdir);
+	TALLOC_FREE(mget_mask);
+	TALLOC_FREE(saved_curdir);
+	TALLOC_FREE(new_cd);
 }
 
 /****************************************************************************
@@ -1033,15 +1246,27 @@ static void do_mget(file_info *finfo)
 
 static int cmd_more(void)
 {
-	pstring rname,lname,pager_cmd;
-	char *pager;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *rname = NULL;
+	char *fname = NULL;
+	char *lname = NULL;
+	char *pager_cmd = NULL;
+	const char *pager;
 	int fd;
 	int rc = 0;
 
-	pstrcpy(rname,cur_dir);
-	pstrcat(rname,CLI_DIRSEP_STR);
-	
-	slprintf(lname,sizeof(lname)-1, "%s/smbmore.XXXXXX",tmpdir());
+	rname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			CLI_DIRSEP_STR);
+	if (!rname) {
+		return 1;
+	}
+
+	lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
+	if (!lname) {
+		return 1;
+	}
 	fd = smb_mkstemp(lname);
 	if (fd == -1) {
 		d_printf("failed to create temporary file for more\n");
@@ -1049,22 +1274,34 @@ static int cmd_more(void)
 	}
 	close(fd);
 
-	if (!next_token_nr(NULL,rname+strlen(rname),NULL,sizeof(rname)-strlen(rname))) {
+	if (!next_token_nr_talloc(ctx,NULL,&fname,NULL)) {
 		d_printf("more <filename>\n");
 		unlink(lname);
 		return 1;
 	}
-	pstring_clean_name(rname);
+	rname = talloc_asprintf_append(rname, fname);
+	if (!rname) {
+		return 1;
+	}
+	rname = clean_name(ctx,rname);
+	if (!rname) {
+		return 1;
+	}
 
-	rc = do_get(rname, lname, False);
+	rc = do_get(rname, lname, false);
 
 	pager=getenv("PAGER");
 
-	slprintf(pager_cmd,sizeof(pager_cmd)-1,
-		 "%s %s",(pager? pager:PAGER), lname);
+	pager_cmd = talloc_asprintf(ctx,
+				"%s %s",
+				(pager? pager:PAGER),
+				lname);
+	if (!pager_cmd) {
+		return 1;
+	}
 	system(pager_cmd);
 	unlink(lname);
-	
+
 	return rc;
 }
 
@@ -1074,38 +1311,64 @@ static int cmd_more(void)
 
 static int cmd_mget(void)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	uint16 attribute = aSYSTEM | aHIDDEN;
-	pstring mget_mask;
-	pstring buf;
-	char *p=buf;
+	char *mget_mask;
+	char *buf;
 
 	*mget_mask = 0;
 
-	if (recurse)
+	if (recurse) {
 		attribute |= aDIR;
-	
-	abort_mget = False;
-
-	while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
-		pstrcpy(mget_mask,cur_dir);
-		if ((mget_mask[0] != '\0') && (mget_mask[strlen(mget_mask)-1]!=CLI_DIRSEP_CHAR))
-			pstrcat(mget_mask,CLI_DIRSEP_STR);
-		
-		if (*p == CLI_DIRSEP_CHAR)
-			pstrcpy(mget_mask,p);
-		else
-			pstrcat(mget_mask,p);
-		do_list(mget_mask, attribute,do_mget,False,True);
+	}
+
+	abort_mget = false;
+
+	while (next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
+		mget_mask = talloc_strdup(ctx, client_get_cur_dir());
+		if (!mget_mask) {
+			return 1;
+		}
+		if ((mget_mask[0] != '\0') &&
+				(mget_mask[strlen(mget_mask)-1]!=CLI_DIRSEP_CHAR)) {
+			mget_mask = talloc_asprintf_append(mget_mask,
+							CLI_DIRSEP_STR);
+			if (!mget_mask) {
+				return 1;
+			}
+		}
+
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mget_mask = talloc_strdup(ctx, buf);
+		} else {
+			mget_mask = talloc_asprintf_append(mget_mask,
+							buf);
+		}
+		if (!mget_mask) {
+			return 1;
+		}
+		do_list(mget_mask, attribute, do_mget, false, true);
 	}
 
 	if (!*mget_mask) {
-		pstrcpy(mget_mask,cur_dir);
-		if(mget_mask[strlen(mget_mask)-1]!=CLI_DIRSEP_CHAR)
-			pstrcat(mget_mask,CLI_DIRSEP_STR);
-		pstrcat(mget_mask,"*");
-		do_list(mget_mask, attribute,do_mget,False,True);
+		mget_mask = talloc_strdup(ctx, client_get_cur_dir());
+		if (!mget_mask) {
+			return 1;
+		}
+		if(mget_mask[strlen(mget_mask)-1]!=CLI_DIRSEP_CHAR) {
+			mget_mask = talloc_asprintf_append(mget_mask,
+							CLI_DIRSEP_STR);
+			if (!mget_mask) {
+				return 1;
+			}
+		}
+		mget_mask = talloc_asprintf_append(mget_mask, "*");
+		if (!mget_mask) {
+			return 1;
+		}
+		do_list(mget_mask, attribute, do_mget, false, true);
 	}
-	
+
 	return 0;
 }
 
@@ -1113,40 +1376,42 @@ static int cmd_mget(void)
  Make a directory of name "name".
 ****************************************************************************/
 
-static bool do_mkdir(char *name)
+static bool do_mkdir(const char *name)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	struct cli_state *targetcli;
-	pstring targetname;
-	
-	if ( !cli_resolve_path_pstring( "", cli, name, &targetcli, targetname ) ) {
+	char *targetname = NULL;
+
+	if (!cli_resolve_path(ctx, "", cli, name, &targetcli, &targetname)) {
 		d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
-		return False;
+		return false;
 	}
 
 	if (!cli_mkdir(targetcli, targetname)) {
 		d_printf("%s making remote directory %s\n",
 			 cli_errstr(targetcli),name);
-		return(False);
+		return false;
 	}
 
-	return(True);
+	return true;
 }
 
 /****************************************************************************
  Show 8.3 name of a file.
 ****************************************************************************/
 
-static bool do_altname(char *name)
+static bool do_altname(const char *name)
 {
-	pstring altname;
+	fstring altname;
+
 	if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
 		d_printf("%s getting alt name for %s\n",
 			 cli_errstr(cli),name);
-		return(False);
+		return false;
 	}
 	d_printf("%s\n", altname);
 
-	return(True);
+	return true;
 }
 
 /****************************************************************************
@@ -1156,7 +1421,6 @@ static bool do_altname(char *name)
 static int cmd_quit(void)
 {
 	cli_cm_shutdown();
-	talloc_destroy( ctx);
 	exit(0);
 	/* NOTREACHED */
 	return 0;
@@ -1168,45 +1432,66 @@ static int cmd_quit(void)
 
 static int cmd_mkdir(void)
 {
-	pstring mask;
-	pstring buf;
-	char *p=buf;
-  
-	pstrcpy(mask,cur_dir);
-
-	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
-		if (!recurse)
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx, NULL,&buf,NULL)) {
+		if (!recurse) {
 			d_printf("mkdir <dirname>\n");
+		}
+		return 1;
+	}
+	mask = talloc_asprintf_append(mask, buf);
+	if (!mask) {
 		return 1;
 	}
-	pstrcat(mask,p);
 
 	if (recurse) {
-		pstring ddir;
-		pstring ddir2;
+		char *ddir = NULL;
+		char *ddir2 = NULL;
 		struct cli_state *targetcli;
-		pstring targetname;
-		*ddir2 = 0;
-		
-		if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
+		char *targetname = NULL;
+		char *p = NULL;
+
+		ddir2 = talloc_strdup(ctx, "");
+		if (!ddir2) {
+			return 1;
+		}
+
+		if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 			return 1;
 		}
 
-		pstrcpy(ddir,targetname);
+		ddir = talloc_strdup(ctx, targetname);
+		if (!ddir) {
+			return 1;
+		}
 		trim_char(ddir,'.','\0');
 		p = strtok(ddir,"/\\");
 		while (p) {
-			pstrcat(ddir2,p);
-			if (!cli_chkpath(targetcli, ddir2)) { 
+			ddir2 = talloc_asprintf_append(ddir2, p);
+			if (!ddir2) {
+				return 1;
+			}
+			if (!cli_chkpath(targetcli, ddir2)) {
 				do_mkdir(ddir2);
 			}
-			pstrcat(ddir2,CLI_DIRSEP_STR);
+			ddir2 = talloc_asprintf_append(ddir2, CLI_DIRSEP_STR);
+			if (!ddir2) {
+				return 1;
+			}
 			p = strtok(NULL,"/\\");
-		}	 
+		}
 	} else {
 		do_mkdir(mask);
 	}
-	
+
 	return 0;
 }
 
@@ -1216,20 +1501,24 @@ static int cmd_mkdir(void)
 
 static int cmd_altname(void)
 {
-	pstring name;
-	pstring buf;
-	char *p=buf;
-  
-	pstrcpy(name,cur_dir);
+	TALLOC_CTX *ctx = talloc_tos();
+	char *name;
+	char *buf;
 
-	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
-		d_printf("altname <file>\n");
+	name = talloc_strdup(ctx, client_get_cur_dir());
+	if (!name) {
 		return 1;
 	}
-	pstrcat(name,p);
 
+	if (!next_token_nr_talloc(ctx, NULL, &buf, NULL)) {
+		d_printf("altname <file>\n");
+		return 1;
+	}
+	name = talloc_asprintf_append(name, buf);
+	if (!name) {
+		return 1;
+	}
 	do_altname(name);
-
 	return 0;
 }
 
@@ -1237,8 +1526,9 @@ static int cmd_altname(void)
  Put a single file.
 ****************************************************************************/
 
-static int do_put(char *rname, char *lname, bool reput)
+static int do_put(const char *rname, const char *lname, bool reput)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	int fnum;
 	XFILE *f;
 	SMB_OFF_T start = 0;
@@ -1248,13 +1538,13 @@ static int do_put(char *rname, char *lname, bool reput)
 	int rc = 0;
 	struct timeval tp_start;
 	struct cli_state *targetcli;
-	pstring targetname;
-	
-	if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) {
+	char *targetname = NULL;
+
+	if (!cli_resolve_path(ctx, "", cli, rname, &targetcli, &targetname)) {
 		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	GetTimeOfDay(&tp_start);
 
 	if (reput) {
@@ -1269,7 +1559,7 @@ static int do_put(char *rname, char *lname, bool reput)
 	} else {
 		fnum = cli_open(targetcli, targetname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
 	}
-  
+
 	if (fnum == -1) {
 		d_printf("%s opening remote file %s\n",cli_errstr(targetcli),rname);
 		return 1;
@@ -1297,10 +1587,10 @@ static int do_put(char *rname, char *lname, bool reput)
 		d_printf("Error opening local file %s\n",lname);
 		return 1;
 	}
-  
+
 	DEBUG(1,("putting file %s as %s ",lname,
 		 rname));
-  
+
 	buf = (char *)SMB_MALLOC(maxwrite);
 	if (!buf) {
 		d_printf("ERROR: Not enough memory!\n");
@@ -1325,7 +1615,7 @@ static int do_put(char *rname, char *lname, bool reput)
 			d_printf("Error writing file: %s\n", cli_errstr(cli));
 			rc = 1;
 			break;
-		} 
+		}
 
 		nread += n;
 	}
@@ -1337,7 +1627,6 @@ static int do_put(char *rname, char *lname, bool reput)
 		return 1;
 	}
 
-	
 	if (f != x_stdin) {
 		x_fclose(f);
 	}
@@ -1347,14 +1636,14 @@ static int do_put(char *rname, char *lname, bool reput)
 	{
 		struct timeval tp_end;
 		int this_time;
-		
+
 		GetTimeOfDay(&tp_end);
-		this_time = 
+		this_time =
 			(tp_end.tv_sec - tp_start.tv_sec)*1000 +
 			(tp_end.tv_usec - tp_start.tv_usec)/1000;
 		put_total_time_ms += this_time;
 		put_total_size += nread;
-		
+
 		DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
 			 nread / (1.024*this_time + 1.0e-4),
 			 put_total_size / (1.024*put_total_time_ms)));
@@ -1364,7 +1653,7 @@ static int do_put(char *rname, char *lname, bool reput)
 		cli_cm_shutdown();
 		exit(0);
 	}
-	
+
 	return rc;
 }
 
@@ -1374,26 +1663,37 @@ static int do_put(char *rname, char *lname, bool reput)
 
 static int cmd_put(void)
 {
-	pstring lname;
-	pstring rname;
-	pstring buf;
-	char *p=buf;
-	
-	pstrcpy(rname,cur_dir);
-	pstrcat(rname,CLI_DIRSEP_STR);
-  
-	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname;
+	char *rname;
+	char *buf;
+
+	rname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			CLI_DIRSEP_STR);
+	if (!rname) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx,NULL,&lname,NULL)) {
 		d_printf("put <filename>\n");
 		return 1;
 	}
-	pstrcpy(lname,p);
-  
-	if (next_token_nr(NULL,p,NULL,sizeof(buf)))
-		pstrcat(rname,p);      
-	else
-		pstrcat(rname,lname);
-	
-	pstring_clean_name(rname);
+
+	if (next_token_nr_talloc(ctx, NULL,&buf,NULL)) {
+		rname = talloc_asprintf_append(rname, buf);
+	} else {
+		rname = talloc_asprintf_append(rname, lname);
+	}
+	if (!rname) {
+		return 1;
+	}
+
+	rname = clean_name(ctx, rname);
+	if (!rname) {
+		return 1;
+	}
 
 	{
 		SMB_STRUCT_STAT st;
@@ -1406,7 +1706,7 @@ static int cmd_put(void)
 		}
 	}
 
-	return do_put(rname, lname, False);
+	return do_put(rname, lname, false);
 }
 
 /*************************************
@@ -1426,7 +1726,7 @@ static struct file_list {
 static void free_file_list (struct file_list *list_head)
 {
 	struct file_list *list, *next;
-	
+
 	for (list = list_head; list; list = next) {
 		next = list->next;
 		DLIST_REMOVE(list_head, list);
@@ -1445,12 +1745,12 @@ static bool seek_list(struct file_list *list, char *name)
 	while (list) {
 		trim_string(list->file_path,"./","\n");
 		if (strncmp(list->file_path, name, strlen(name)) != 0) {
-			return(True);
+			return true;
 		}
 		list = list->next;
 	}
-      
-	return(False);
+
+	return false;
 }
 
 /****************************************************************************
@@ -1459,18 +1759,24 @@ static bool seek_list(struct file_list *list, char *name)
 
 static int cmd_select(void)
 {
-	pstrcpy(fileselection,"");
-	next_token_nr(NULL,fileselection,NULL,sizeof(fileselection));
-
+	TALLOC_CTX *ctx = talloc_tos();
+	char *new_fs = NULL;
+	next_token_nr_talloc(ctx, NULL,&new_fs,NULL)
+		;
+	if (new_fs) {
+		client_set_fileselection(new_fs);
+	} else {
+		client_set_fileselection("");
+	}
 	return 0;
 }
 
 /****************************************************************************
   Recursive file matching function act as find
-  match must be always set to True when calling this function
+  match must be always set to true when calling this function
 ****************************************************************************/
 
-static int file_find(struct file_list **list, const char *directory, 
+static int file_find(struct file_list **list, const char *directory,
 		      const char *expression, bool match)
 {
 	SMB_STRUCT_DIR *dir;
@@ -1484,30 +1790,30 @@ static int file_find(struct file_list **list, const char *directory,
         dir = sys_opendir(directory);
 	if (!dir)
 		return -1;
-	
+
         while ((dname = readdirname(dir))) {
 		if (!strcmp("..", dname))
 			continue;
 		if (!strcmp(".", dname))
 			continue;
-		
+
 		if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
 			continue;
 		}
 
-		isdir = False;
+		isdir = false;
 		if (!match || !gen_fnmatch(expression, dname)) {
 			if (recurse) {
 				ret = stat(path, &statbuf);
 				if (ret == 0) {
 					if (S_ISDIR(statbuf.st_mode)) {
-						isdir = True;
-						ret = file_find(list, path, expression, False);
+						isdir = true;
+						ret = file_find(list, path, expression, false);
 					}
 				} else {
 					d_printf("file_find: cannot stat file %s\n", path);
 				}
-				
+
 				if (ret == -1) {
 					SAFE_FREE(path);
 					sys_closedir(dir);
@@ -1538,73 +1844,85 @@ static int file_find(struct file_list **list, const char *directory,
 
 static int cmd_mput(void)
 {
-	pstring buf;
-	char *p=buf;
-	
-	while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
+	TALLOC_CTX *ctx = talloc_tos();
+	char *p = NULL;
+
+	while (next_token_nr_talloc(ctx, NULL,&p,NULL)) {
 		int ret;
 		struct file_list *temp_list;
 		char *quest, *lname, *rname;
-	
+
 		file_list = NULL;
 
-		ret = file_find(&file_list, ".", p, True);
+		ret = file_find(&file_list, ".", p, true);
 		if (ret) {
 			free_file_list(file_list);
 			continue;
 		}
-		
+
 		quest = NULL;
 		lname = NULL;
 		rname = NULL;
-				
-		for (temp_list = file_list; temp_list; 
+
+		for (temp_list = file_list; temp_list;
 		     temp_list = temp_list->next) {
 
 			SAFE_FREE(lname);
-			if (asprintf(&lname, "%s/", temp_list->file_path) <= 0)
+			if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) {
 				continue;
+			}
 			trim_string(lname, "./", "/");
-			
+
 			/* check if it's a directory */
 			if (temp_list->isdir) {
 				/* if (!recurse) continue; */
-				
+
 				SAFE_FREE(quest);
-				if (asprintf(&quest, "Put directory %s? ", lname) < 0) break;
+				if (asprintf(&quest, "Put directory %s? ", lname) < 0) {
+					break;
+				}
 				if (prompt && !yesno(quest)) { /* No */
 					/* Skip the directory */
 					lname[strlen(lname)-1] = '/';
 					if (!seek_list(temp_list, lname))
-						break;		    
+						break;
 				} else { /* Yes */
 	      				SAFE_FREE(rname);
-					if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
-					dos_format(rname);
-					if (!cli_chkpath(cli, rname) && 
+					if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) {
+						break;
+					}
+					string_replace(rname,'/','\\');
+					if (!cli_chkpath(cli, rname) &&
 					    !do_mkdir(rname)) {
 						DEBUG (0, ("Unable to make dir, skipping..."));
 						/* Skip the directory */
 						lname[strlen(lname)-1] = '/';
-						if (!seek_list(temp_list, lname))
+						if (!seek_list(temp_list, lname)) {
 							break;
+						}
 					}
 				}
 				continue;
 			} else {
 				SAFE_FREE(quest);
-				if (asprintf(&quest,"Put file %s? ", lname) < 0) break;
-				if (prompt && !yesno(quest)) /* No */
+				if (asprintf(&quest,"Put file %s? ", lname) < 0) {
+					break;
+				}
+				if (prompt && !yesno(quest)) {
+					/* No */
 					continue;
-				
+				}
+
 				/* Yes */
 				SAFE_FREE(rname);
-				if (asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
+				if (asprintf(&rname, "%s%s", cur_dir, lname) < 0) {
+					break;
+				}
 			}
 
-			dos_format(rname);
+			string_replace(rname,'/','\\');
 
-			do_put(rname, lname, False);
+			do_put(rname, lname, false);
 		}
 		free_file_list(file_list);
 		SAFE_FREE(quest);
@@ -1636,18 +1954,19 @@ static int do_cancel(int job)
 
 static int cmd_cancel(void)
 {
-	pstring buf;
-	int job; 
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
+	int job;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx, NULL, &buf,NULL)) {
 		d_printf("cancel <jobid> ...\n");
 		return 1;
 	}
 	do {
 		job = atoi(buf);
 		do_cancel(job);
-	} while (next_token_nr(NULL,buf,NULL,sizeof(buf)));
-	
+	} while (next_token_nr_talloc(ctx,NULL,&buf,NULL));
+
 	return 0;
 }
 
@@ -1657,26 +1976,37 @@ static int cmd_cancel(void)
 
 static int cmd_print(void)
 {
-	pstring lname;
-	pstring rname;
-	char *p;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname = NULL;
+	char *rname = NULL;
+	char *p = NULL;
 
-	if (!next_token_nr(NULL,lname,NULL, sizeof(lname))) {
+	if (!next_token_nr_talloc(ctx, NULL, &lname,NULL)) {
 		d_printf("print <filename>\n");
 		return 1;
 	}
 
-	pstrcpy(rname,lname);
+	rname = talloc_strdup(ctx, lname);
+	if (!rname) {
+		return 1;
+	}
 	p = strrchr_m(rname,'/');
 	if (p) {
-		slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)sys_getpid());
+		rname = talloc_asprintf(ctx,
+					"%s-%d",
+					p+1,
+					(int)sys_getpid());
 	}
-
 	if (strequal(lname,"-")) {
-		slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)sys_getpid());
+		rname = talloc_asprintf(ctx,
+				"stdin-%d",
+				(int)sys_getpid());
+	}
+	if (!rname) {
+		return 1;
 	}
 
-	return do_put(rname, lname, False);
+	return do_put(rname, lname, false);
 }
 
 /****************************************************************************
@@ -1695,7 +2025,6 @@ static void queue_fn(struct print_job_info *p)
 static int cmd_queue(void)
 {
 	cli_print_queue(cli, queue_fn);
-	
 	return 0;
 }
 
@@ -1703,18 +2032,30 @@ static int cmd_queue(void)
  Delete some files.
 ****************************************************************************/
 
-static void do_del(file_info *finfo)
+static void do_del(file_info *finfo, const char *dir)
 {
-	pstring mask;
-
-	pstr_sprintf( mask, "%s%c%s", finfo->dir, CLI_DIRSEP_CHAR, finfo->name );
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+
+	mask = talloc_asprintf(ctx,
+				"%s%c%s",
+				dir,
+				CLI_DIRSEP_CHAR,
+				finfo->name);
+	if (!mask) {
+		return;
+	}
 
-	if (finfo->mode & aDIR) 
+	if (finfo->mode & aDIR) {
+		TALLOC_FREE(mask);
 		return;
+	}
 
 	if (!cli_unlink(finfo->cli, mask)) {
-		d_printf("%s deleting remote file %s\n",cli_errstr(finfo->cli),mask);
+		d_printf("%s deleting remote file %s\n",
+				cli_errstr(finfo->cli),mask);
 	}
+	TALLOC_FREE(mask);
 }
 
 /****************************************************************************
@@ -1723,23 +2064,29 @@ static void do_del(file_info *finfo)
 
 static int cmd_del(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
 	uint16 attribute = aSYSTEM | aHIDDEN;
 
-	if (recurse)
+	if (recurse) {
 		attribute |= aDIR;
-	
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	}
+
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("del <filename>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
+	mask = talloc_asprintf_append(mask, buf);
+	if (!mask) {
+		return 1;
+	}
 
-	do_list(mask, attribute,do_del,False,False);
-	
+	do_list(mask,attribute,do_del,false,false);
 	return 0;
 }
 
@@ -1749,32 +2096,37 @@ static int cmd_del(void)
 
 static int cmd_wdel(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
 	uint16 attribute;
 	struct cli_state *targetcli;
-	pstring targetname;
+	char *targetname = NULL;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("wdel 0x<attrib> <wcard>\n");
 		return 1;
 	}
 
 	attribute = (uint16)strtol(buf, (char **)NULL, 16);
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("wdel 0x<attrib> <wcard>\n");
 		return 1;
 	}
 
-	pstrcpy(mask,cur_dir);
-	pstrcat(mask,buf);
+	mask = talloc_asprintf(ctx, "%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
 
-	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!cli_unlink_full(targetcli, targetname, attribute)) {
 		d_printf("%s deleting remote files %s\n",cli_errstr(targetcli),targetname);
 	}
@@ -1786,25 +2138,30 @@ static int cmd_wdel(void)
 
 static int cmd_open(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
 	int fnum;
 
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("open <filename>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
 
-	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("open %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA|FILE_WRITE_DATA);
 	if (fnum == -1) {
 		fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA);
@@ -1816,7 +2173,6 @@ static int cmd_open(void)
 	} else {
 		d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
 	}
-
 	return 0;
 }
 
@@ -1825,31 +2181,37 @@ static int cmd_open(void)
 
 static int cmd_posix_open(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
 	mode_t mode;
 	int fnum;
 
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_open <filename> 0<mode>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_open <filename> 0<mode>\n");
 		return 1;
 	}
 	mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode);
 	if (fnum == -1) {
 		fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDONLY, mode);
@@ -1867,27 +2229,33 @@ static int cmd_posix_open(void)
 
 static int cmd_posix_mkdir(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
 	mode_t mode;
 	int fnum;
 
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_mkdir <filename> 0<mode>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_mkdir <filename> 0<mode>\n");
 		return 1;
 	}
 	mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
@@ -1898,30 +2266,34 @@ static int cmd_posix_mkdir(void)
 	} else {
 		d_printf("posix_mkdir created directory %s\n", targetname);
 	}
-
 	return 0;
 }
 
 static int cmd_posix_unlink(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
 
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_unlink <filename>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
 
-	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!cli_posix_unlink(targetcli, targetname)) {
 		d_printf("Failed to unlink file %s. %s\n", targetname, cli_errstr(cli));
 	} else {
@@ -1933,24 +2305,29 @@ static int cmd_posix_unlink(void)
 
 static int cmd_posix_rmdir(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
 
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("posix_rmdir <filename>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
 
-	if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname)) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!cli_posix_rmdir(targetcli, targetname)) {
 		d_printf("Failed to unlink directory %s. %s\n", targetname, cli_errstr(cli));
 	} else {
@@ -1962,10 +2339,11 @@ static int cmd_posix_rmdir(void)
 
 static int cmd_close(void)
 {
-	fstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
 	int fnum;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("close <fnum>\n");
 		return 1;
 	}
@@ -1981,9 +2359,10 @@ static int cmd_close(void)
 
 static int cmd_posix(void)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	uint16 major, minor;
 	uint32 caplow, caphigh;
-	pstring caps;
+	char *caps;
 
 	if (!SERVER_HAS_UNIX_CIFS(cli)) {
 		d_printf("Server doesn't support UNIX CIFS extensions.\n");
@@ -1997,33 +2376,56 @@ static int cmd_posix(void)
 
 	d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major, (unsigned int)minor);
 
-	*caps = '\0';
+	caps = talloc_strdup(ctx, "");
+	if (!caps) {
+		return 1;
+	}
         if (caplow & CIFS_UNIX_FCNTL_LOCKS_CAP) {
-		pstrcat(caps, "locks ");
+		caps = talloc_asprintf_append(caps, "locks ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_POSIX_ACLS_CAP) {
-		pstrcat(caps, "acls ");
+		caps = talloc_asprintf_append(caps, "acls ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_XATTTR_CAP) {
-		pstrcat(caps, "eas ");
+		caps = talloc_asprintf_append(caps, "eas ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
-		pstrcat(caps, "pathnames ");
+		caps = talloc_asprintf_append(caps, "pathnames ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP) {
-		pstrcat(caps, "posix_path_operations ");
+		caps = talloc_asprintf_append(caps, "posix_path_operations ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_LARGE_READ_CAP) {
-		pstrcat(caps, "large_read ");
+		caps = talloc_asprintf_append(caps, "large_read ");
+		if (!caps) {
+			return 1;
+		}
 	}
         if (caplow & CIFS_UNIX_LARGE_WRITE_CAP) {
-		pstrcat(caps, "large_write ");
+		caps = talloc_asprintf_append(caps, "large_write ");
+		if (!caps) {
+			return 1;
+		}
 	}
 
-	if (strlen(caps) > 0 && caps[strlen(caps)-1] == ' ') {
+	if (*caps && caps[strlen(caps)-1] == ' ') {
 		caps[strlen(caps)-1] = '\0';
 	}
-
 	if (!cli_set_unix_extensions_capabilities(cli, major, minor, caplow, caphigh)) {
 		d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n", cli_errstr(cli));
 		return 1;
@@ -2034,7 +2436,7 @@ static int cmd_posix(void)
 	if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
 		CLI_DIRSEP_CHAR = '/';
 		*CLI_DIRSEP_STR = '/';
-		pstrcpy(cur_dir, CLI_DIRSEP_STR);
+		client_set_cur_dir(CLI_DIRSEP_STR);
 	}
 
 	return 0;
@@ -2042,18 +2444,19 @@ static int cmd_posix(void)
 
 static int cmd_lock(void)
 {
-	fstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
 	SMB_BIG_UINT start, len;
 	enum brl_type lock_type;
 	int fnum;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
 		return 1;
 	}
 	fnum = atoi(buf);
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
 		return 1;
 	}
@@ -2067,21 +2470,21 @@ static int cmd_lock(void)
 		return 1;
 	}
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
 		return 1;
 	}
 
 	start = (SMB_BIG_UINT)strtol(buf, (char **)NULL, 16);
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
 		return 1;
 	}
 
 	len = (SMB_BIG_UINT)strtol(buf, (char **)NULL, 16);
 
-	if (!cli_posix_lock(cli, fnum, start, len, True, lock_type)) {
+	if (!cli_posix_lock(cli, fnum, start, len, true, lock_type)) {
 		d_printf("lock failed %d: %s\n", fnum, cli_errstr(cli));
 	}
 
@@ -2090,24 +2493,25 @@ static int cmd_lock(void)
 
 static int cmd_unlock(void)
 {
-	fstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
 	SMB_BIG_UINT start, len;
 	int fnum;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
 		return 1;
 	}
 	fnum = atoi(buf);
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
 		return 1;
 	}
 
 	start = (SMB_BIG_UINT)strtol(buf, (char **)NULL, 16);
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
 		return 1;
 	}
@@ -2128,29 +2532,34 @@ static int cmd_unlock(void)
 
 static int cmd_rmdir(void)
 {
-	pstring mask;
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	pstrcpy(mask,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("rmdir <dirname>\n");
 		return 1;
 	}
-	pstrcat(mask,buf);
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
 
-	if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
 		d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!cli_rmdir(targetcli, targetname)) {
 		d_printf("%s removing remote directory file %s\n",
 			 cli_errstr(targetcli),mask);
 	}
-	
+
 	return 0;
 }
 
@@ -2160,38 +2569,48 @@ static int cmd_rmdir(void)
 
 static int cmd_link(void)
 {
-	pstring oldname,newname;
-	pstring buf,buf2;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *oldname = NULL;
+	char *newname = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	pstrcpy(oldname,cur_dir);
-	pstrcpy(newname,cur_dir);
-  
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL)) {
 		d_printf("link <oldname> <newname>\n");
 		return 1;
 	}
+	oldname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!oldname) {
+		return 1;
+	}
+	newname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!newname) {
+		return 1;
+	}
 
-	pstrcat(oldname,buf);
-	pstrcat(newname,buf2);
-
-	if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, oldname, &targetcli, &targetname)) {
 		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
 		d_printf("Server doesn't support UNIX CIFS calls.\n");
 		return 1;
 	}
-	
+
 	if (!cli_unix_hardlink(targetcli, targetname, newname)) {
 		d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli), newname, oldname);
 		return 1;
-	}  
-
+	}
 	return 0;
 }
 
@@ -2201,37 +2620,49 @@ static int cmd_link(void)
 
 static int cmd_symlink(void)
 {
-	pstring oldname,newname;
-	pstring buf,buf2;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *oldname = NULL;
+	char *newname = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	if (!SERVER_HAS_UNIX_CIFS(cli)) {
-		d_printf("Server doesn't support UNIX CIFS calls.\n");
-		return 1;
-	}
 
-	pstrcpy(newname,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL)) {
 		d_printf("symlink <oldname> <newname>\n");
 		return 1;
 	}
+	oldname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!oldname) {
+		return 1;
+	}
+	newname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!newname) {
+		return 1;
+	}
 
-	pstrcpy(oldname,buf);
-	pstrcat(newname,buf2);
-
-	if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, oldname, &targetcli, &targetname)) {
 		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
 		return 1;
 	}
 
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
 	if (!cli_unix_symlink(targetcli, targetname, newname)) {
 		d_printf("%s symlinking files (%s -> %s)\n",
 			cli_errstr(targetcli), newname, targetname);
 		return 1;
-	} 
+	}
 
 	return 0;
 }
@@ -2242,38 +2673,44 @@ static int cmd_symlink(void)
 
 static int cmd_chmod(void)
 {
-	pstring src;
-	mode_t mode;
-	pstring buf, buf2;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	pstrcpy(src,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
+	mode_t mode;
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL)) {
 		d_printf("chmod mode file\n");
 		return 1;
 	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!src) {
+		return 1;
+	}
 
 	mode = (mode_t)strtol(buf, NULL, 8);
-	pstrcat(src,buf2);
 
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
 		d_printf("chmod %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
 		d_printf("Server doesn't support UNIX CIFS calls.\n");
 		return 1;
 	}
-	
+
 	if (!cli_unix_chmod(targetcli, targetname, mode)) {
 		d_printf("%s chmod file %s 0%o\n",
 			cli_errstr(targetcli), src, (unsigned int)mode);
 		return 1;
-	} 
+	}
 
 	return 0;
 }
@@ -2284,7 +2721,7 @@ static const char *filetype_to_str(mode_t mode)
 		return "regular file";
 	} else if (S_ISDIR(mode)) {
 		return "directory";
-	} else 
+	} else
 #ifdef S_ISCHR
 	if (S_ISCHR(mode)) {
 		return "character device";
@@ -2386,7 +2823,11 @@ static char *perms_to_string(fstring permstr, unsigned char perms)
 
 static int cmd_getfacl(void)
 {
-	pstring src, name;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *name = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
 	uint16 major, minor;
 	uint32 caplow, caphigh;
 	char *retbuf = NULL;
@@ -2395,35 +2836,38 @@ static int cmd_getfacl(void)
 	uint16 num_file_acls = 0;
 	uint16 num_dir_acls = 0;
 	uint16 i;
-	struct cli_state *targetcli;
-	pstring targetname;
- 
-	pstrcpy(src,cur_dir);
-	
-	if (!next_token_nr(NULL,name,NULL,sizeof(name))) {
-		d_printf("stat file\n");
+
+	if (!next_token_nr_talloc(ctx,NULL,&name,NULL)) {
+		d_printf("getfacl filename\n");
+		return 1;
+	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			name);
+	if (!src) {
 		return 1;
 	}
 
-	pstrcat(src,name);
-	
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
 		d_printf("stat %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
 		d_printf("Server doesn't support UNIX CIFS calls.\n");
 		return 1;
 	}
-	
-	if (!cli_unix_extensions_version(targetcli, &major, &minor, &caplow, &caphigh)) {
+
+	if (!cli_unix_extensions_version(targetcli, &major, &minor,
+				&caplow, &caphigh)) {
 		d_printf("Can't get UNIX CIFS version from server.\n");
 		return 1;
 	}
 
 	if (!(caplow & CIFS_UNIX_POSIX_ACLS_CAP)) {
-		d_printf("This server supports UNIX extensions but doesn't support POSIX ACLs.\n");
+		d_printf("This server supports UNIX extensions "
+			"but doesn't support POSIX ACLs.\n");
 		return 1;
 	}
 
@@ -2431,13 +2875,13 @@ static int cmd_getfacl(void)
 		d_printf("%s getfacl doing a stat on file %s\n",
 			cli_errstr(targetcli), src);
 		return 1;
-	} 
+	}
 
 	if (!cli_unix_getfacl(targetcli, targetname, &rb_size, &retbuf)) {
 		d_printf("%s getfacl file %s\n",
 			cli_errstr(targetcli), src);
 		return 1;
-	} 
+	}
 
 	/* ToDo : Print out the ACL values. */
 	if (SVAL(retbuf,0) != SMB_POSIX_ACL_VERSION || rb_size < 6) {
@@ -2550,38 +2994,42 @@ static int cmd_getfacl(void)
 
 static int cmd_stat(void)
 {
-	pstring src, name;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *name = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
 	fstring mode_str;
 	SMB_STRUCT_STAT sbuf;
-	struct cli_state *targetcli;
 	struct tm *lt;
-	pstring targetname;
- 
-	if (!SERVER_HAS_UNIX_CIFS(cli)) {
-		d_printf("Server doesn't support UNIX CIFS calls.\n");
-		return 1;
-	}
 
-	pstrcpy(src,cur_dir);
-	
-	if (!next_token_nr(NULL,name,NULL,sizeof(name))) {
+	if (!next_token_nr_talloc(ctx,NULL,&name,NULL)) {
 		d_printf("stat file\n");
 		return 1;
 	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			name);
+	if (!src) {
+		return 1;
+	}
 
-	pstrcat(src,name);
-
-	
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
 		d_printf("stat %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
-	
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
 	if (!cli_unix_stat(targetcli, targetname, &sbuf)) {
 		d_printf("%s stat file %s\n",
 			cli_errstr(targetcli), src);
 		return 1;
-	} 
+	}
 
 	/* Print out the stat values. */
 	d_printf("File: %s\n", src);
@@ -2597,7 +3045,7 @@ static int cmd_stat(void)
 			(unsigned int)sbuf.st_nlink,
 			unix_dev_major(sbuf.st_rdev),
 			unix_dev_minor(sbuf.st_rdev));
-	} else 
+	} else
 #endif
 		d_printf("Inode: %.0f\tLinks: %u\n",
 			(double)sbuf.st_ino,
@@ -2606,7 +3054,7 @@ static int cmd_stat(void)
 	d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
 		((int)sbuf.st_mode & 0777),
 		unix_mode_to_str(mode_str, sbuf.st_mode),
-		(unsigned int)sbuf.st_uid, 
+		(unsigned int)sbuf.st_uid,
 		(unsigned int)sbuf.st_gid);
 
 	lt = localtime(&sbuf.st_atime);
@@ -2632,7 +3080,7 @@ static int cmd_stat(void)
 		fstrcpy(mode_str, "unknown");
 	}
 	d_printf("Change: %s\n", mode_str);
-	
+
 	return 0;
 }
 
@@ -2643,27 +3091,32 @@ static int cmd_stat(void)
 
 static int cmd_chown(void)
 {
-	pstring src;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
 	uid_t uid;
 	gid_t gid;
-	pstring buf, buf2, buf3;
+	char *buf, *buf2, *buf3;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	pstrcpy(src,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2)) ||
-	    !next_token_nr(NULL,buf3,NULL, sizeof(buf3))) {
+	char *targetname = NULL;
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf3,NULL)) {
 		d_printf("chown uid gid file\n");
 		return 1;
 	}
 
 	uid = (uid_t)atoi(buf);
 	gid = (gid_t)atoi(buf2);
-	pstrcat(src,buf3);
 
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf3);
+	if (!src) {
+		return 1;
+	}
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname) ) {
 		d_printf("chown %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
@@ -2672,12 +3125,12 @@ static int cmd_chown(void)
 		d_printf("Server doesn't support UNIX CIFS calls.\n");
 		return 1;
 	}
-	
+
 	if (!cli_unix_chown(targetcli, targetname, uid, gid)) {
 		d_printf("%s chown file %s uid=%d, gid=%d\n",
 			cli_errstr(targetcli), src, (int)uid, (int)gid);
 		return 1;
-	} 
+	}
 
 	return 0;
 }
@@ -2688,30 +3141,41 @@ static int cmd_chown(void)
 
 static int cmd_rename(void)
 {
-	pstring src,dest;
-	pstring buf,buf2;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src, *dest;
+	char *buf, *buf2;
 	struct cli_state *targetcli;
-	pstring targetsrc;
-	pstring targetdest;
-  
-	pstrcpy(src,cur_dir);
-	pstrcpy(dest,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
+	char *targetsrc;
+	char *targetdest;
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL)) {
 		d_printf("rename <src> <dest>\n");
 		return 1;
 	}
 
-	pstrcat(src,buf);
-	pstrcat(dest,buf2);
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!src) {
+		return 1;
+	}
+
+	dest = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!dest) {
+		return 1;
+	}
 
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetsrc ) ) {
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetsrc)) {
 		d_printf("rename %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
 
-	if ( !cli_resolve_path_pstring( "", cli, dest, &targetcli, targetdest ) ) {
+	if (!cli_resolve_path(ctx, "", cli, dest, &targetcli, &targetdest)) {
 		d_printf("rename %s: %s\n", dest, cli_errstr(cli));
 		return 1;
 	}
@@ -2723,7 +3187,7 @@ static int cmd_rename(void)
 			targetdest);
 		return 1;
 	}
-	
+
 	return 0;
 }
 
@@ -2736,13 +3200,14 @@ static int cmd_volume(void)
 	fstring volname;
 	uint32 serial_num;
 	time_t create_date;
-  
+
 	if (!cli_get_fs_volume_info(cli, volname, &serial_num, &create_date)) {
 		d_printf("Errr %s getting volume info\n",cli_errstr(cli));
 		return 1;
 	}
-	
-	d_printf("Volume: |%s| serial number 0x%x\n", volname, (unsigned int)serial_num);
+
+	d_printf("Volume: |%s| serial number 0x%x\n",
+			volname, (unsigned int)serial_num);
 	return 0;
 }
 
@@ -2752,38 +3217,44 @@ static int cmd_volume(void)
 
 static int cmd_hardlink(void)
 {
-	pstring src,dest;
-	pstring buf,buf2;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src, *dest;
+	char *buf, *buf2;
 	struct cli_state *targetcli;
-	pstring targetname;
-  
-	pstrcpy(src,cur_dir);
-	pstrcpy(dest,cur_dir);
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || 
-	    !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
+	char *targetname;
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL) ||
+	    !next_token_nr_talloc(ctx,NULL,&buf2,NULL)) {
 		d_printf("hardlink <src> <dest>\n");
 		return 1;
 	}
 
-	pstrcat(src,buf);
-	pstrcat(dest,buf2);
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!src) {
+		return 1;
+	}
 
-	if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) {
-		d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
+	dest = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!dest) {
 		return 1;
 	}
-	
-	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
-		d_printf("Server doesn't support UNIX CIFS calls.\n");
+
+	if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
+		d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	if (!cli_nt_hardlink(targetcli, targetname, dest)) {
 		d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli));
 		return 1;
 	}
-	
+
 	return 0;
 }
 
@@ -2795,7 +3266,6 @@ static int cmd_prompt(void)
 {
 	prompt = !prompt;
 	DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
-	
 	return 1;
 }
 
@@ -2805,11 +3275,12 @@ static int cmd_prompt(void)
 
 static int cmd_newer(void)
 {
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
 	bool ok;
 	SMB_STRUCT_STAT sbuf;
 
-	ok = next_token_nr(NULL,buf,NULL,sizeof(buf));
+	ok = next_token_nr_talloc(ctx,NULL,&buf,NULL);
 	if (ok && (sys_stat(buf,&sbuf) == 0)) {
 		newer_than = sbuf.st_mtime;
 		DEBUG(1,("Getting files newer than %s",
@@ -2832,12 +3303,14 @@ static int cmd_newer(void)
 
 static int cmd_archive(void)
 {
-	pstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
 
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	if (next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		archive_level = atoi(buf);
-	} else
+	} else {
 		d_printf("Archive level is %d\n",archive_level);
+	}
 
 	return 0;
 }
@@ -2850,7 +3323,6 @@ static int cmd_lowercase(void)
 {
 	lowercase = !lowercase;
 	DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
-
 	return 0;
 }
 
@@ -2860,12 +3332,11 @@ static int cmd_lowercase(void)
 
 static int cmd_setcase(void)
 {
-	bool orig_case_sensitive = cli_set_case_sensitive(cli, False);
+	bool orig_case_sensitive = cli_set_case_sensitive(cli, false);
 
 	cli_set_case_sensitive(cli, !orig_case_sensitive);
 	DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive ?
 		"on":"off"));
-
 	return 0;
 }
 
@@ -2877,13 +3348,6 @@ static int cmd_showacls(void)
 {
 	showacls = !showacls;
 	DEBUG(2,("showacls is now %s\n",showacls?"on":"off"));
-
-	if (!ctx && showacls)
-		ctx = talloc_init("smbclient:showacls");
-		if (!ctx) {
-			DEBUG( 0, ("cmd_showacls() out of memory.  talloc_init() failed.\n"));
-	}
-
 	return 0;
 }
 
@@ -2896,7 +3360,6 @@ static int cmd_recurse(void)
 {
 	recurse = !recurse;
 	DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
-
 	return 0;
 }
 
@@ -2909,7 +3372,6 @@ static int cmd_translate(void)
 	translation = !translation;
 	DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
 		 translation?"on":"off"));
-
 	return 0;
 }
 
@@ -2919,13 +3381,18 @@ static int cmd_translate(void)
 
 static int cmd_lcd(void)
 {
-	pstring buf;
-	pstring d;
-	
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
+	char *d;
+
+	if (next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		chdir(buf);
+	}
+	d = TALLOC_ARRAY(ctx, char, PATH_MAX+1);
+	if (!d) {
+		return 1;
+	}
 	DEBUG(2,("the local directory is now %s\n",sys_getwd(d)));
-
 	return 0;
 }
 
@@ -2935,25 +3402,40 @@ static int cmd_lcd(void)
 
 static int cmd_reget(void)
 {
-	pstring local_name;
-	pstring remote_name;
-	char *p;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *local_name = NULL;
+	char *remote_name = NULL;
+	char *fname = NULL;
+	char *p = NULL;
+
+	remote_name = talloc_asprintf(ctx,
+				"%s%s",
+				client_get_cur_dir(),
+				CLI_DIRSEP_STR);
+	if (!remote_name) {
+		return 1;
+	}
 
-	pstrcpy(remote_name, cur_dir);
-	pstrcat(remote_name, CLI_DIRSEP_STR);
-	
-	p = remote_name + strlen(remote_name);
-	
-	if (!next_token_nr(NULL, p, NULL, sizeof(remote_name) - strlen(remote_name))) {
+	if (!next_token_nr_talloc(ctx, NULL, &fname, NULL)) {
 		d_printf("reget <filename>\n");
 		return 1;
 	}
-	pstrcpy(local_name, p);
-	pstring_clean_name(remote_name);
-	
-	next_token_nr(NULL, local_name, NULL, sizeof(local_name));
-	
-	return do_get(remote_name, local_name, True);
+	remote_name = talloc_asprintf_append(remote_name, fname);
+	if (!remote_name) {
+		return 1;
+	}
+	remote_name = clean_name(ctx,remote_name);
+	if (!remote_name) {
+		return 1;
+	}
+
+	local_name = fname;
+	next_token_nr_talloc(ctx, NULL, &p, NULL);
+	if (p) {
+		local_name = p;
+	}
+
+	return do_get(remote_name, local_name, true);
 }
 
 /****************************************************************************
@@ -2962,57 +3444,71 @@ static int cmd_reget(void)
 
 static int cmd_reput(void)
 {
-	pstring local_name;
-	pstring remote_name;
-	pstring buf;
-	char *p = buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *local_name = NULL;
+	char *remote_name = NULL;
+	char *buf;
 	SMB_STRUCT_STAT st;
-	
-	pstrcpy(remote_name, cur_dir);
-	pstrcat(remote_name, CLI_DIRSEP_STR);
-  
-	if (!next_token_nr(NULL, p, NULL, sizeof(buf))) {
+
+	remote_name = talloc_asprintf(ctx,
+				"%s%s",
+				client_get_cur_dir(),
+				CLI_DIRSEP_STR);
+	if (!remote_name) {
+		return 1;
+	}
+
+	if (!next_token_nr_talloc(ctx, NULL, &local_name, NULL)) {
 		d_printf("reput <filename>\n");
 		return 1;
 	}
-	pstrcpy(local_name, p);
-  
+
 	if (!file_exist(local_name, &st)) {
 		d_printf("%s does not exist\n", local_name);
 		return 1;
 	}
 
-	if (next_token_nr(NULL, p, NULL, sizeof(buf)))
-		pstrcat(remote_name, p);
-	else
-		pstrcat(remote_name, local_name);
-	
-	pstring_clean_name(remote_name);
+	if (next_token_nr_talloc(ctx, NULL, &buf, NULL)) {
+		remote_name = talloc_asprintf_append(remote_name,
+						buf);
+	} else {
+		remote_name = talloc_asprintf_append(remote_name,
+						local_name);
+	}
+	if (!remote_name) {
+		return 1;
+	}
+
+	remote_name = clean_name(ctx, remote_name);
+	if (!remote_name) {
+		return 1;
+	}
 
-	return do_put(remote_name, local_name, True);
+	return do_put(remote_name, local_name, true);
 }
 
 /****************************************************************************
  List a share name.
  ****************************************************************************/
 
-static void browse_fn(const char *name, uint32 m, 
+static void browse_fn(const char *name, uint32 m,
                       const char *comment, void *state)
 {
-        fstring typestr;
-
-        *typestr=0;
-
-        switch (m & 7)
-        {
-          case STYPE_DISKTREE:
-            fstrcpy(typestr,"Disk"); break;
-          case STYPE_PRINTQ:
-            fstrcpy(typestr,"Printer"); break;
-          case STYPE_DEVICE:
-            fstrcpy(typestr,"Device"); break;
-          case STYPE_IPC:
-            fstrcpy(typestr,"IPC"); break;
+	const char *typestr = "";
+
+        switch (m & 7) {
+	case STYPE_DISKTREE:
+		typestr = "Disk";
+		break;
+	case STYPE_PRINTQ:
+		typestr = "Printer";
+		break;
+	case STYPE_DEVICE:
+		typestr = "Device";
+		break;
+	case STYPE_IPC:
+		typestr = "IPC";
+		break;
         }
 	/* FIXME: If the remote machine returns non-ascii characters
 	   in any of these fields, they can corrupt the output.  We
@@ -3029,18 +3525,12 @@ static bool browse_host_rpc(bool sort)
 {
 	NTSTATUS status;
 	struct rpc_pipe_client *pipe_hnd;
-	TALLOC_CTX *mem_ctx;
+	TALLOC_CTX *frame = talloc_stackframe();
 	ENUM_HND enum_hnd;
 	WERROR werr;
 	SRV_SHARE_INFO_CTR ctr;
 	int i;
 
-	mem_ctx = talloc_new(NULL);
-	if (mem_ctx == NULL) {
-		DEBUG(0, ("talloc_new failed\n"));
-		return False;
-	}
-
 	init_enum_hnd(&enum_hnd, 0);
 
 	pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SRVSVC, &status);
@@ -3048,32 +3538,32 @@ static bool browse_host_rpc(bool sort)
 	if (pipe_hnd == NULL) {
 		DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
 			   nt_errstr(status)));
-		TALLOC_FREE(mem_ctx);
-		return False;
+		TALLOC_FREE(frame);
+		return false;
 	}
 
-	werr = rpccli_srvsvc_net_share_enum(pipe_hnd, mem_ctx, 1, &ctr,
+	werr = rpccli_srvsvc_net_share_enum(pipe_hnd, frame, 1, &ctr,
 					    0xffffffff, &enum_hnd);
 
 	if (!W_ERROR_IS_OK(werr)) {
-		TALLOC_FREE(mem_ctx);
 		cli_rpc_pipe_close(pipe_hnd);
-		return False;
+		TALLOC_FREE(frame);
+		return false;
 	}
 
 	for (i=0; i<ctr.num_entries; i++) {
 		SRV_SHARE_INFO_1 *info = &ctr.share.info1[i];
 		char *name, *comment;
 		name = rpcstr_pull_unistr2_talloc(
-			mem_ctx, &info->info_1_str.uni_netname);
+			frame, &info->info_1_str.uni_netname);
 		comment = rpcstr_pull_unistr2_talloc(
-			mem_ctx, &info->info_1_str.uni_remark);
+			frame, &info->info_1_str.uni_remark);
 		browse_fn(name, info->info_1.type, comment, NULL);
 	}
 
-	TALLOC_FREE(mem_ctx);
 	cli_rpc_pipe_close(pipe_hnd);
-	return True;
+	TALLOC_FREE(frame);
+	return true;
 }
 
 /****************************************************************************
@@ -3089,7 +3579,7 @@ static bool browse_host(bool sort)
 	}
 
 	if (browse_host_rpc(sort)) {
-		return True;
+		return true;
 	}
 
 	if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1)
@@ -3102,10 +3592,10 @@ static bool browse_host(bool sort)
  List a server name.
 ****************************************************************************/
 
-static void server_fn(const char *name, uint32 m, 
+static void server_fn(const char *name, uint32 m,
                       const char *comment, void *state)
 {
-	
+
 	if (!grepable){
 		d_printf("\t%-16s     %s\n", name, comment);
 	} else {
@@ -3122,7 +3612,7 @@ static bool list_servers(const char *wk_grp)
 	fstring state;
 
 	if (!cli->server_domain)
-		return False;
+		return false;
 
 	if (!grepable) {
         	d_printf("\n\tServer               Comment\n");
@@ -3135,12 +3625,12 @@ static bool list_servers(const char *wk_grp)
 	if (!grepable) {
 	        d_printf("\n\tWorkgroup            Master\n");
 	        d_printf("\t---------            -------\n");
-	}; 
+	};
 
 	fstrcpy( state, "Workgroup" );
 	cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
 			  server_fn, state);
-	return True;
+	return true;
 }
 
 /****************************************************************************
@@ -3149,9 +3639,10 @@ static bool list_servers(const char *wk_grp)
 
 static int cmd_vuid(void)
 {
-	fstring buf;
-	
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
+
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		d_printf("Current VUID is %d\n", cli->vuid);
 		return 0;
 	}
@@ -3166,26 +3657,25 @@ static int cmd_vuid(void)
 
 static int cmd_logon(void)
 {
-	pstring l_username, l_password;
-	pstring buf,buf2;
-  
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	TALLOC_CTX *ctx = talloc_tos();
+	char *l_username, *l_password;
+
+	if (!next_token_nr_talloc(ctx,NULL,&l_username,NULL)) {
 		d_printf("logon <username> [<password>]\n");
 		return 0;
 	}
 
-	pstrcpy(l_username, buf);
-
-	if (!next_token_nr(NULL,buf2,NULL,sizeof(buf))) 
-	{
+	if (!next_token_nr_talloc(ctx,NULL,&l_password,NULL)) {
 		char *pass = getpass("Password: ");
-		if (pass) 
-			pstrcpy(l_password, pass);
-	} 
-	else
-		pstrcpy(l_password, buf2);
+		if (pass) {
+			l_password = talloc_strdup(ctx,pass);
+		}
+	}
+	if (!l_password) {
+		return 1;
+	}
 
-	if (!NT_STATUS_IS_OK(cli_session_setup(cli, l_username, 
+	if (!NT_STATUS_IS_OK(cli_session_setup(cli, l_username,
 					       l_password, strlen(l_password),
 					       l_password, strlen(l_password),
 					       lp_workgroup()))) {
@@ -3205,7 +3695,6 @@ static int cmd_logon(void)
 static int cmd_list_connect(void)
 {
 	cli_cm_display();
-
 	return 0;
 }
 
@@ -3215,14 +3704,16 @@ static int cmd_list_connect(void)
 
 static int cmd_show_connect( void )
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	struct cli_state *targetcli;
-	pstring targetpath;
-	
-	if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) {
+	char *targetpath;
+
+	if (!cli_resolve_path(ctx, "", cli, client_get_cur_dir(),
+				&targetcli, &targetpath ) ) {
 		d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli));
 		return 1;
 	}
-	
+
 	d_printf("//%s/%s\n", targetcli->desthost, targetcli->share);
 	return 0;
 }
@@ -3233,20 +3724,21 @@ static int cmd_show_connect( void )
 
 int cmd_iosize(void)
 {
-	fstring buf;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
 	int iosize;
 
-	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
-		DEBUG(0, ("iosize <n> or iosize 0x<n>. "
+	if (!next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
+		d_printf("iosize <n> or iosize 0x<n>. "
 			"Minimum is 16384 (0x4000), "
-			"max is 16776960 (0xFFFF00)\n"));
+			"max is 16776960 (0xFFFF00)\n");
 		return 1;
 	}
 
 	iosize = strtol(buf,NULL,0);
 	if (iosize < 0 || iosize > 0xFFFF00) {
-		DEBUG(0, ("iosize out of range (min = 16384 (0x4000), "
-			"max = 16776960 (0x0xFFFF00)"));
+		d_printf("iosize out of range (min = 16384 (0x4000), "
+			"max = 16776960 (0x0xFFFF00)");
 		return 1;
 	}
 
@@ -3267,12 +3759,11 @@ int cmd_iosize(void)
  *       field is NULL, and NULL in that field is used in process_tok()
  *       (below) to indicate the end of the list.  crh
  */
-static struct
-{
-  const char *name;
-  int (*fn)(void);
-  const char *description;
-  char compl_args[2];      /* Completion argument info */
+static struct {
+	const char *name;
+	int (*fn)(void);
+	const char *description;
+	char compl_args[2];      /* Completion argument info */
 } commands[] = {
   {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
   {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
@@ -3350,16 +3841,16 @@ static struct
 };
 
 /*******************************************************************
- Lookup a command string in the list of commands, including 
+ Lookup a command string in the list of commands, including
  abbreviations.
 ******************************************************************/
 
-static int process_tok(pstring tok)
+static int process_tok(char *tok)
 {
 	int i = 0, matches = 0;
 	int cmd=0;
 	int tok_len = strlen(tok);
-	
+
 	while (commands[i].fn != NULL) {
 		if (strequal(commands[i].name,tok)) {
 			matches = 1;
@@ -3371,7 +3862,7 @@ static int process_tok(pstring tok)
 		}
 		i++;
 	}
-  
+
 	if (matches == 0)
 		return(-1);
 	else if (matches == 1)
@@ -3386,12 +3877,14 @@ static int process_tok(pstring tok)
 
 static int cmd_help(void)
 {
+	TALLOC_CTX *ctx = talloc_tos();
 	int i=0,j;
-	pstring buf;
-	
-	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+	char *buf;
+
+	if (next_token_nr_talloc(ctx,NULL,&buf,NULL)) {
 		if ((i = process_tok(buf)) >= 0)
-			d_printf("HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description);
+			d_printf("HELP %s:\n\t%s\n\n",
+				commands[i].name,commands[i].description);
 	} else {
 		while (commands[i].description) {
 			for (j=0; commands[i].description && (j<5); j++) {
@@ -3408,41 +3901,46 @@ static int cmd_help(void)
  Process a -c command string.
 ****************************************************************************/
 
-static int process_command_string(char *cmd)
+static int process_command_string(const char *cmd_in)
 {
-	pstring line;
-	const char *ptr;
+	TALLOC_CTX *ctx = talloc_tos();
+	char *cmd = talloc_strdup(ctx, cmd_in);
 	int rc = 0;
 
+	if (!cmd) {
+		return 1;
+	}
 	/* establish the connection if not already */
-	
+
 	if (!cli) {
-		cli = cli_cm_open(talloc_tos(), desthost, service, True);
-		if (!cli)
-			return 0;
+		cli = cli_cm_open(talloc_tos(), NULL, desthost, service, true);
+		if (!cli) {
+			return 1;
+		}
 	}
-	
+
 	while (cmd[0] != '\0')    {
+		char *line;
+		const char *ptr;
 		char *p;
-		pstring tok;
+		char *tok;
 		int i;
-		
+
 		if ((p = strchr_m(cmd, ';')) == 0) {
-			strncpy(line, cmd, 999);
-			line[1000] = '\0';
+			line = cmd;
 			cmd += strlen(cmd);
 		} else {
-			if (p - cmd > 999)
-				p = cmd + 999;
-			strncpy(line, cmd, p - cmd);
-			line[p - cmd] = '\0';
+			*p = '\0';
+			line = cmd;
 			cmd = p + 1;
 		}
-		
+
 		/* and get the first part of the command */
 		ptr = line;
-		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
-		
+		if (!next_token_nr_talloc(ctx,&ptr,&tok,NULL)) {
+			continue;
+		}
+
 		if ((i = process_tok(tok)) >= 0) {
 			rc = commands[i].fn();
 		} else if (i == -2) {
@@ -3451,71 +3949,98 @@ static int process_command_string(char *cmd)
 			d_printf("%s: command not found\n",tok);
 		}
 	}
-	
+
 	return rc;
-}	
+}
 
 #define MAX_COMPLETIONS 100
 
 typedef struct {
-	pstring dirmask;
+	char *dirmask;
 	char **matches;
 	int count, samelen;
 	const char *text;
 	int len;
 } completion_remote_t;
 
-static void completion_remote_filter(const char *mnt, file_info *f, const char *mask, void *state)
+static void completion_remote_filter(const char *mnt,
+				file_info *f,
+				const char *mask,
+				void *state)
 {
 	completion_remote_t *info = (completion_remote_t *)state;
 
-	if ((info->count < MAX_COMPLETIONS - 1) && (strncmp(info->text, f->name, info->len) == 0) && (strcmp(f->name, ".") != 0) && (strcmp(f->name, "..") != 0)) {
+	if ((info->count < MAX_COMPLETIONS - 1) &&
+			(strncmp(info->text, f->name, info->len) == 0) &&
+			(strcmp(f->name, ".") != 0) &&
+			(strcmp(f->name, "..") != 0)) {
 		if ((info->dirmask[0] == 0) && !(f->mode & aDIR))
 			info->matches[info->count] = SMB_STRDUP(f->name);
 		else {
-			pstring tmp;
-
-			if (info->dirmask[0] != 0)
-				pstrcpy(tmp, info->dirmask);
-			else
-				tmp[0] = 0;
-			pstrcat(tmp, f->name);
-			if (f->mode & aDIR)
-				pstrcat(tmp, "/");
+			TALLOC_CTX *ctx = talloc_stackframe();
+			char *tmp;
+
+			if (info->dirmask && info->dirmask[0] != 0) {
+				tmp = talloc_strdup(ctx,info->dirmask);
+			} else {
+				tmp = talloc_strdup(ctx,"");
+			}
+			if (!tmp) {
+				TALLOC_FREE(ctx);
+				return;
+			}
+			tmp = talloc_asprintf_append(tmp, f->name);
+			if (!tmp) {
+				TALLOC_FREE(ctx);
+				return;
+			}
+			if (f->mode & aDIR) {
+				tmp = talloc_asprintf_append(tmp, "/");
+			}
+			if (!tmp) {
+				TALLOC_FREE(ctx);
+				return;
+			}
 			info->matches[info->count] = SMB_STRDUP(tmp);
+			TALLOC_FREE(ctx);
 		}
-		if (info->matches[info->count] == NULL)
+		if (info->matches[info->count] == NULL) {
 			return;
-		if (f->mode & aDIR)
+		}
+		if (f->mode & aDIR) {
 			smb_readline_ca_char(0);
-
-		if (info->count == 1)
+		}
+		if (info->count == 1) {
 			info->samelen = strlen(info->matches[info->count]);
-		else
-			while (strncmp(info->matches[info->count], info->matches[info->count-1], info->samelen) != 0)
+		} else {
+			while (strncmp(info->matches[info->count],
+						info->matches[info->count-1],
+						info->samelen) != 0) {
 				info->samelen--;
+			}
+		}
 		info->count++;
 	}
 }
 
 static char **remote_completion(const char *text, int len)
 {
-	pstring dirmask;
+	TALLOC_CTX *ctx = talloc_stackframe();
+	char *dirmask = NULL;
+	char *targetpath = NULL;
+	struct cli_state *targetcli = NULL;
 	int i;
-	completion_remote_t info = { "", NULL, 1, 0, NULL, 0 };
+	completion_remote_t info = { NULL, NULL, 1, 0, NULL, 0 };
 
 	/* can't have non-static intialisation on Sun CC, so do it
 	   at run time here */
 	info.samelen = len;
 	info.text = text;
 	info.len = len;
-		
-	if (len >= MIN(PATH_MAX,sizeof(pstring))) {
-		return(NULL);
-	}
 
 	info.matches = SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS);
 	if (!info.matches) {
+		TALLOC_FREE(ctx);
 		return NULL;
 	}
 
@@ -3537,37 +4062,57 @@ static char **remote_completion(const char *text, int len)
 	info.samelen = info.len = len-i-1;
 
 	if (i > 0) {
+		info.dirmask = SMB_MALLOC(i+2);
+		if (!info.dirmask) {
+			goto cleanup;
+		}
 		strncpy(info.dirmask, text, i+1);
 		info.dirmask[i+1] = 0;
-		pstr_sprintf(dirmask, "%s%*s*", cur_dir, i-1, text);
+		dirmask = talloc_asprintf(ctx,
+					"%s%*s*",
+					client_get_cur_dir(),
+					i-1,
+					text);
 	} else {
-		pstr_sprintf(dirmask, "%s*", cur_dir);
+		info.dirmask = SMB_STRDUP("");
+		if (!info.dirmask) {
+			goto cleanup;
+		}
+		dirmask = talloc_asprintf(ctx,
+					"%s*",
+					client_get_cur_dir());
+	}
+	if (!dirmask) {
+		goto cleanup;
 	}
 
-	if (cli_list(cli, dirmask, aDIR | aSYSTEM | aHIDDEN, completion_remote_filter, &info) < 0)
+	if (!cli_resolve_path(ctx, "", cli, dirmask, &targetcli, &targetpath)) {
+		goto cleanup;
+	}
+	if (cli_list(targetcli, targetpath, aDIR | aSYSTEM | aHIDDEN,
+				completion_remote_filter, (void *)&info) < 0) {
 		goto cleanup;
+	}
 
 	if (info.count == 1) {
-
 		/*
 		 * No matches at all, NULL indicates there is nothing
 		 */
-
 		SAFE_FREE(info.matches[0]);
 		SAFE_FREE(info.matches);
+		TALLOC_FREE(ctx);
 		return NULL;
 	}
 
 	if (info.count == 2) {
-
 		/*
 		 * Exactly one match in matches[1], indicate this is the one
 		 * in matches[0].
 		 */
-
 		info.matches[0] = info.matches[1];
 		info.matches[1] = NULL;
 		info.count -= 1;
+		TALLOC_FREE(ctx);
 		return info.matches;
 	}
 
@@ -3581,9 +4126,12 @@ static char **remote_completion(const char *text, int len)
 	return info.matches;
 
 cleanup:
-	for (i = 0; i < info.count; i++)
-		free(info.matches[i]);
-	free(info.matches);
+	for (i = 0; i < info.count; i++) {
+		SAFE_FREE(info.matches[i]);
+	}
+	SAFE_FREE(info.matches);
+	SAFE_FREE(info.dirmask);
+	TALLOC_FREE(ctx);
 	return NULL;
 }
 
@@ -3599,7 +4147,7 @@ static char **completion_fn(const char *text, int start, int end)
 		buf = smb_readline_get_line_buffer();
 		if (buf == NULL)
 			return NULL;
-		
+
 		sp = strchr(buf, ' ');
 		if (sp == NULL)
 			return NULL;
@@ -3705,7 +4253,7 @@ static void readline_callback(void)
 	timeout.tv_sec = 0;
 	timeout.tv_usec = 0;
 	sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout);
-      		
+
 	/* We deliberately use receive_smb instead of
 	   client_receive_smb as we want to receive
 	   session keepalives and then drop them here.
@@ -3718,7 +4266,7 @@ static void readline_callback(void)
 		}
 		goto again;
 	}
-      
+
 	/* Ping the server to keep the connection alive using SMBecho. */
 	{
 		unsigned char garbage[16];
@@ -3738,34 +4286,36 @@ static int process_stdin(void)
 
 	while (1) {
 		TALLOC_CTX *frame = talloc_stackframe();
-		pstring tok;
-		pstring the_prompt;
-		char *cline;
-		pstring line;
+		char *tok = NULL;
+		char *the_prompt = NULL;
+		char *line = NULL;
 		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) {
+		if (asprintf(&the_prompt, "smb: %s> ", client_get_cur_dir()) < 0) {
+			TALLOC_FREE(frame);
+			break;
+		}
+		line = smb_readline(the_prompt, readline_callback, completion_fn);
+		SAFE_FREE(the_prompt);
+		if (!line) {
 			TALLOC_FREE(frame);
 			break;
 		}
-
-		pstrcpy(line, cline);
 
 		/* special case - first char is ! */
 		if (*line == '!') {
 			system(line + 1);
+			SAFE_FREE(line);
 			TALLOC_FREE(frame);
 			continue;
 		}
 
 		/* and get the first part of the command */
 		ptr = line;
-		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) {
+		if (!next_token_nr_talloc(frame,&ptr,&tok,NULL)) {
 			TALLOC_FREE(frame);
+			SAFE_FREE(line);
 			continue;
 		}
 
@@ -3776,6 +4326,7 @@ static int process_stdin(void)
 		} else {
 			d_printf("%s: command not found\n",tok);
 		}
+		SAFE_FREE(line);
 		TALLOC_FREE(frame);
 	}
 	return rc;
@@ -3785,11 +4336,11 @@ static int process_stdin(void)
  Process commands from the client.
 ****************************************************************************/
 
-static int process(char *base_directory)
+static int process(const char *base_directory)
 {
 	int rc = 0;
 
-	cli = cli_cm_open(talloc_tos(), desthost, service, True);
+	cli = cli_cm_open(talloc_tos(), NULL, desthost, service, true);
 	if (!cli) {
 		return 1;
 	}
@@ -3801,13 +4352,13 @@ static int process(char *base_directory)
 			return rc;
 		}
 	}
-	
+
 	if (cmdstr) {
 		rc = process_command_string(cmdstr);
 	} else {
 		process_stdin();
 	}
-  
+
 	cli_cm_shutdown();
 	return rc;
 }
@@ -3816,13 +4367,13 @@ static int process(char *base_directory)
  Handle a -L query.
 ****************************************************************************/
 
-static int do_host_query(char *query_host)
+static int do_host_query(const char *query_host)
 {
-	cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True);
+	cli = cli_cm_open(talloc_tos(), query_host, "IPC$", true);
 	if (!cli)
 		return 1;
 
-	browse_host(True);
+	browse_host(true);
 
 	if (port != 139) {
 
@@ -3831,7 +4382,7 @@ static int do_host_query(char *query_host)
 
 		cli_cm_shutdown();
 		cli_cm_set_port( 139 );
-		cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True);
+		cli = cli_cm_open(talloc_tos(), query_host, "IPC$", true);
 	}
 
 	if (cli == NULL) {
@@ -3842,7 +4393,7 @@ static int do_host_query(char *query_host)
 	list_servers(lp_workgroup());
 
 	cli_cm_shutdown();
-	
+
 	return(0);
 }
 
@@ -3850,18 +4401,18 @@ static int do_host_query(char *query_host)
  Handle a tar operation.
 ****************************************************************************/
 
-static int do_tar_op(char *base_directory)
+static int do_tar_op(const char *base_directory)
 {
 	int ret;
 
 	/* do we already have a connection? */
 	if (!cli) {
-		cli = cli_cm_open(talloc_tos(), desthost, service, True);
+		cli = cli_cm_open(talloc_tos(), NULL, desthost, service, true);
 		if (!cli)
 			return 1;
 	}
 
-	recurse=True;
+	recurse=true;
 
 	if (*base_directory)  {
 		ret = do_cd(base_directory);
@@ -3870,7 +4421,7 @@ static int do_tar_op(char *base_directory)
 			return ret;
 		}
 	}
-	
+
 	ret=process_tar();
 
 	cli_cm_shutdown();
@@ -3929,26 +4480,24 @@ static int do_message_op(void)
 	return 0;
 }
 
-
 /****************************************************************************
   main program
 ****************************************************************************/
 
  int main(int argc,char *argv[])
 {
-	pstring base_directory;
-	int len = 0;
+	char *base_directory = NULL;
 	int opt;
-	pstring query_host;
-	bool message = False;
-	pstring term_code;
+	char *query_host = NULL;
+	bool message = false;
+	char *term_code = NULL;
 	static const char *new_name_resolve_order = NULL;
 	poptContext pc;
 	char *p;
 	int rc = 0;
 	fstring new_workgroup;
-	bool tar_opt = False;
-	bool service_opt = False;
+	bool tar_opt = false;
+	bool service_opt = false;
 	struct poptOption long_options[] = {
 		POPT_AUTOHELP
 
@@ -3972,25 +4521,28 @@ static int do_message_op(void)
 	};
 	TALLOC_CTX *frame = talloc_stackframe();
 
+	if (!client_set_cur_dir("\\")) {
+		exit(ENOMEM);
+	}
 	load_case_tables();
 
 #ifdef KANJI
-	pstrcpy(term_code, KANJI);
+	term_code = talloc_strdup(frame,KANJI);
 #else /* KANJI */
-	*term_code = 0;
+	term_code = talloc_strdup(frame,"");
 #endif /* KANJI */
+	if (!term_code) {
+		exit(ENOMEM);
+	}
 
-	*query_host = 0;
-	*base_directory = 0;
-	
-	/* initialize the workgroup name so we can determine whether or 
+	/* initialize the workgroup name so we can determine whether or
 	   not it was set by a command line option */
-	   
+
 	set_global_myworkgroup( "" );
 	set_global_myname( "" );
 
         /* set default debug level to 0 regardless of what smb.conf sets */
-	setup_logging( "smbclient", True );
+	setup_logging( "smbclient", true );
 	DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
 	if ((dbf = x_fdup(x_stderr))) {
 		x_setbuf( dbf, NULL );
@@ -4000,50 +4552,55 @@ static int do_message_op(void)
 	pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);
 	poptSetOtherOptionHelp(pc, "service <password>");
 
-	in_client = True;   /* Make sure that we tell lp_load we are */
+	in_client = true;   /* Make sure that we tell lp_load we are */
 
 	while ((opt = poptGetNextOpt(pc)) != -1) {
 
 		/* if the tar option has been called previouslt, now we need to eat out the leftovers */
 		/* I see no other way to keep things sane --SSS */
-		if (tar_opt == True) {
+		if (tar_opt == true) {
 			while (poptPeekArg(pc)) {
 				poptGetArg(pc);
 			}
-			tar_opt = False;
+			tar_opt = false;
 		}
 
 		/* if the service has not yet been specified lets see if it is available in the popt stack */
 		if (!service_opt && poptPeekArg(pc)) {
-			pstrcpy(service, poptGetArg(pc));
-			service_opt = True;
+			service = talloc_strdup(frame, poptGetArg(pc));
+			if (!service) {
+				exit(ENOMEM);
+			}
+			service_opt = true;
 		}
 
 		/* if the service has already been retrieved then check if we have also a password */
 		if (service_opt && (!cmdline_auth_info.got_pass) && poptPeekArg(pc)) {
-			pstrcpy(cmdline_auth_info.password, poptGetArg(pc));
-			cmdline_auth_info.got_pass = True;
+			set_cmdline_auth_info_password(poptGetArg(pc));
 		}
-	
+
 		switch (opt) {
 		case 'M':
 			/* Messages are sent to NetBIOS name type 0x3
 			 * (Messenger Service).  Make sure we default
 			 * to port 139 instead of port 445. srl,crh
 			 */
-			name_type = 0x03; 
+			name_type = 0x03;
 			cli_cm_set_dest_name_type( name_type );
-			pstrcpy(desthost,poptGetOptArg(pc));
+			desthost = talloc_strdup(frame,poptGetOptArg(pc));
+			if (!desthost) {
+				exit(ENOMEM);
+			}
 			if( !port )
 				cli_cm_set_port( 139 );
- 			message = True;
+ 			message = true;
  			break;
 		case 'I':
 			{
 				if (!interpret_string_addr(&dest_ss, poptGetOptArg(pc), 0)) {
 					exit(1);
 				}
-				have_ip = True;
+				have_ip = true;
 
 				cli_cm_set_dest_ss(&dest_ss);
 			}
@@ -4057,10 +4614,16 @@ static int do_message_op(void)
 			break;
 
 		case 'L':
-			pstrcpy(query_host, poptGetOptArg(pc));
+			query_host = talloc_strdup(frame, poptGetOptArg(pc));
+			if (!query_host) {
+				exit(ENOMEM);
+			}
 			break;
 		case 't':
-			pstrcpy(term_code, poptGetOptArg(pc));
+			term_code = talloc_strdup(frame,poptGetOptArg(pc));
+			if (!term_code) {
+				exit(ENOMEM);
+			}
 			break;
 		case 'm':
 			max_protocol = interpret_protocol(poptGetOptArg(pc), max_protocol);
@@ -4081,37 +4644,42 @@ static int do_message_op(void)
 				}
 			}
 			/* this must be the last option, mark we have parsed it so that we know we have */
-			tar_opt = True;
+			tar_opt = true;
 			break;
 		case 'D':
-			pstrcpy(base_directory,poptGetOptArg(pc));
+			base_directory = talloc_strdup(frame, poptGetOptArg(pc));
+			if (!base_directory) {
+				exit(ENOMEM);
+			}
 			break;
 		case 'g':
-			grepable=True;
+			grepable=true;
 			break;
 		}
 	}
 
 	/* We may still have some leftovers after the last popt option has been called */
-	if (tar_opt == True) {
+	if (tar_opt == true) {
 		while (poptPeekArg(pc)) {
 			poptGetArg(pc);
 		}
-		tar_opt = False;
+		tar_opt = false;
 	}
 
 	/* if the service has not yet been specified lets see if it is available in the popt stack */
 	if (!service_opt && poptPeekArg(pc)) {
-		pstrcpy(service, poptGetArg(pc));
-		service_opt = True;
+		service = talloc_strdup(frame,poptGetArg(pc));
+		if (!service) {
+			exit(ENOMEM);
+		}
+		service_opt = true;
 	}
 
 	/* if the service has already been retrieved then check if we have also a password */
-	if (service_opt && (!cmdline_auth_info.got_pass) && poptPeekArg(pc)) {
-		pstrcpy(cmdline_auth_info.password, poptGetArg(pc));
-		cmdline_auth_info.got_pass = True;
+	if (service_opt && !get_cmdline_auth_info_got_pass() && poptPeekArg(pc)) {
+		set_cmdline_auth_info_password(poptGetArg(pc));
 	}
-	
+
 	/* check for the -P option */
 
 	if ( port != 0 )
@@ -4121,28 +4689,33 @@ static int do_message_op(void)
 	 * Don't load debug level from smb.conf. It should be
 	 * set by cmdline arg or remain default (0)
 	 */
-	AllowDebugChange = False;
-	
+	AllowDebugChange = false;
+
 	/* save the workgroup...
-	
-	   FIXME!! do we need to do this for other options as well 
-	   (or maybe a generic way to keep lp_load() from overwriting 
+
+	   FIXME!! do we need to do this for other options as well
+	   (or maybe a generic way to keep lp_load() from overwriting
 	   everything)?  */
-	
+
 	fstrcpy( new_workgroup, lp_workgroup() );
-	pstrcpy( calling_name, global_myname() );
-	
+	calling_name = talloc_strdup(frame, global_myname() );
+	if (!calling_name) {
+		exit(ENOMEM);
+	}
+
 	if ( override_logfile )
-		setup_logging( lp_logfile(), False );
-	
-	if (!lp_load(dyn_CONFIGFILE,True,False,False,True)) {
+		setup_logging( lp_logfile(), false );
+
+	if (!lp_load(dyn_CONFIGFILE,true,false,false,true)) {
 		fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
 			argv[0], dyn_CONFIGFILE);
 	}
-	
+
 	load_interfaces();
 
 	if (service_opt) {
+		size_t len;
+
 		/* Convert any '/' characters in the service name to '\' characters */
 		string_replace(service, '/','\\');
 		if (count_chars(service,'\\') < 3) {
@@ -4157,14 +4730,17 @@ static int do_message_op(void)
 			service[len] = '\0';
 		}
 	}
-	
-	if ( strlen(new_workgroup) != 0 )
+
+	if ( strlen(new_workgroup) != 0 ) {
 		set_global_myworkgroup( new_workgroup );
+	}
 
-	if ( strlen(calling_name) != 0 )
+	if ( strlen(calling_name) != 0 ) {
 		set_global_myname( calling_name );
-	else
-		pstrcpy( calling_name, global_myname() );
+	} else {
+		TALLOC_FREE(calling_name);
+		calling_name = talloc_strdup(frame, global_myname() );
+	}
 
 	init_names();
 
@@ -4178,10 +4754,9 @@ static int do_message_op(void)
 
 	poptFreeContext(pc);
 
-	/* store the username an password for dfs support */
+	/* Store the username and password for dfs support */
 
-	cli_cm_set_credentials( &cmdline_auth_info );
-	pstrcpy(username, cmdline_auth_info.username);
+	cli_cm_set_credentials();
 
 	DEBUG(3,("Client started (version %s).\n", SAMBA_VERSION_STRING));
 
@@ -4221,7 +4796,6 @@ static int do_message_op(void)
 		return 1;
 	}
 
-	talloc_destroy( ctx);
-	talloc_destroy(frame);
+	TALLOC_FREE(frame);
 	return rc;
 }