This commit was generated by cvs2svn to compensate for changes in r30,

which included commits to RCS files with non-trunk default branches.
(This used to be commit 3a69cffb062d4f1238b8cae10481c1f2ea4d3d8b)

9 files changed, 8034 insertions, 0 deletions

diff --git a/source4/client/.cvsignore b/source4/client/.cvsignore
new file mode 100644
index 0000000000..49a52f7616
--- /dev/null
+++ b/source4/client/.cvsignore
@@ -0,0 +1 @@
+client_proto.h
\ No newline at end of file
diff --git a/source4/client/client.c b/source4/client/client.c
new file mode 100644
index 0000000000..5c72da1731
--- /dev/null
+++ b/source4/client/client.c
@@ -0,0 +1,3025 @@
+/* 
+   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) James J Myers   2003 <myersjj@samba.org>
+   
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "../client/client_proto.h"
+#ifndef REGISTER
+#define REGISTER 0
+#endif
+
+struct cli_state *cli;
+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 password;
+static BOOL use_kerberos;
+static BOOL got_pass;
+static char *cmdstr = NULL;
+
+static int io_bufsize = 64512;
+
+static int name_type = 0x20;
+
+static int process_tok(fstring tok);
+static int cmd_help(void);
+
+/* 30 second timeout on most commands */
+#define CLIENT_TIMEOUT (30*1000)
+#define SHORT_TIMEOUT (5*1000)
+
+/* value for unused fid field in trans2 secondary request */
+#define FID_UNUSED (0xFFFF)
+
+time_t newer_than = 0;
+static int archive_level = 0;
+
+static BOOL translation = False;
+
+static BOOL have_ip;
+
+/* clitar bits insert */
+extern int blocksize;
+extern BOOL tar_inc;
+extern BOOL tar_reset;
+/* clitar bits end */
+ 
+
+static BOOL prompt = True;
+
+static int printmode = 1;
+
+static BOOL recurse = False;
+BOOL lowercase = False;
+
+static struct in_addr dest_ip;
+
+#define SEPARATORS " \t\n\r"
+
+static BOOL abort_mget = True;
+
+static pstring fileselection = "";
+
+extern file_info def_finfo;
+
+/* timing globals */
+SMB_BIG_UINT get_total_size = 0;
+unsigned int get_total_time_ms = 0;
+static SMB_BIG_UINT put_total_size = 0;
+static unsigned int put_total_time_ms = 0;
+
+/* totals globals */
+static double dir_total;
+
+#define USENMB
+
+/* some forward declarations */
+static struct cli_state *do_connect(const char *server, const char *share);
+
+
+/*******************************************************************
+ Reduce a file name, removing .. elements.
+********************************************************************/
+void dos_clean_name(char *s)
+{
+	char *p=NULL;
+
+	DEBUG(3,("dos_clean_name [%s]\n",s));
+
+	/* remove any double slashes */
+	all_string_sub(s, "\\\\", "\\", 0);
+
+	while ((p = strstr(s,"\\..\\")) != NULL) {
+		pstring s1;
+
+		*p = 0;
+		pstrcpy(s1,p+3);
+
+		if ((p=strrchr_m(s,'\\')) != NULL)
+			*p = 0;
+		else
+			*s = 0;
+		pstrcat(s,s1);
+	}  
+
+	trim_string(s,NULL,"\\..");
+
+	all_string_sub(s, "\\.\\", "\\", 0);
+}
+
+/****************************************************************************
+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.
+****************************************************************************/
+static int writefile(int f, char *b, int n)
+{
+	int i;
+
+	if (!translation) {
+		return write(f,b,n);
+	}
+
+	i = 0;
+	while (i < n) {
+		if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
+			b++;i++;
+		}
+		if (write(f, b, 1) != 1) {
+			break;
+		}
+		b++;
+		i++;
+	}
+  
+	return(i);
+}
+
+/****************************************************************************
+  read from a file with LF->CR/LF translation if appropriate. return the 
+  number read. read approx n bytes.
+****************************************************************************/
+static int readfile(char *b, int n, XFILE *f)
+{
+	int i;
+	int c;
+
+	if (!translation)
+		return x_fread(b,1,n,f);
+  
+	i = 0;
+	while (i < (n - 1) && (i < CLI_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
+****************************************************************************/
+static void send_message(void)
+{
+	int total_len = 0;
+	int grp_id;
+
+	if (!cli_message_start(cli, desthost, username, &grp_id)) {
+		d_printf("message start: %s\n", cli_errstr(cli));
+		return;
+	}
+
+
+	d_printf("Connected. Type your message, ending it with a Control-D\n");
+
+	while (!feof(stdin) && total_len < 1600) {
+		int maxlen = MIN(1600 - total_len,127);
+		pstring msg;
+		int l=0;
+		int c;
+
+		ZERO_ARRAY(msg);
+
+		for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
+			if (c == '\n')
+				msg[l++] = '\r';
+			msg[l] = c;   
+		}
+
+		if (!cli_message_text(cli, msg, l, grp_id)) {
+			d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli));
+			return;
+		}      
+		
+		total_len += l;
+	}
+
+	if (total_len >= 1600)
+		d_printf("the message was truncated to 1600 bytes\n");
+	else
+		d_printf("sent %d bytes\n",total_len);
+
+	if (!cli_message_end(cli, grp_id)) {
+		d_printf("SMBsendend failed (%s)\n",cli_errstr(cli));
+		return;
+	}      
+}
+
+
+
+/****************************************************************************
+check the space on a device
+****************************************************************************/
+static int do_dskattr(void)
+{
+	int total, bsize, avail;
+
+	if (!cli_dskattr(cli, &bsize, &total, &avail)) {
+		d_printf("Error in dskattr: %s\n",cli_errstr(cli)); 
+		return 1;
+	}
+
+	d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
+		 total, bsize, avail);
+
+	return 0;
+}
+
+/****************************************************************************
+show cd/pwd
+****************************************************************************/
+static int cmd_pwd(void)
+{
+	d_printf("Current directory is %s",service);
+	d_printf("%s\n",cur_dir);
+	return 0;
+}
+
+
+/****************************************************************************
+change directory - inner section
+****************************************************************************/
+static int do_cd(char *newdir)
+{
+	char *p = newdir;
+	pstring saved_dir;
+	pstring dname;
+      
+	dos_format(newdir);
+
+	/* Save the current directory in case the
+	   new directory is invalid */
+	pstrcpy(saved_dir, cur_dir);
+	if (*p == '\\')
+		pstrcpy(cur_dir,p);
+	else
+		pstrcat(cur_dir,p);
+	if (*(cur_dir+strlen(cur_dir)-1) != '\\') {
+		pstrcat(cur_dir, "\\");
+	}
+	dos_clean_name(cur_dir);
+	pstrcpy(dname,cur_dir);
+	pstrcat(cur_dir,"\\");
+	dos_clean_name(cur_dir);
+	
+	if (!strequal(cur_dir,"\\")) {
+		if (!cli_chkpath(cli, dname)) {
+			d_printf("cd %s: %s\n", dname, cli_errstr(cli));
+			pstrcpy(cur_dir,saved_dir);
+		}
+	}
+	
+	pstrcpy(cd_path,cur_dir);
+
+	return 0;
+}
+
+/****************************************************************************
+change directory
+****************************************************************************/
+static int cmd_cd(void)
+{
+	fstring buf;
+	int rc = 0;
+
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
+		rc = do_cd(buf);
+	else
+		d_printf("Current directory is %s\n",cur_dir);
+
+	return rc;
+}
+
+
+/*******************************************************************
+  decide if a file should be operated on
+  ********************************************************************/
+static BOOL do_this_one(file_info *finfo)
+{
+	if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) return(True);
+
+	if (*fileselection && 
+	    !mask_match(cli, finfo->name,fileselection,False)) {
+		DEBUG(3,("mask_match %s failed\n", finfo->name));
+		return False;
+	}
+
+	if (newer_than && finfo->mtime < newer_than) {
+		DEBUG(3,("newer_than %s failed\n", finfo->name));
+		return(False);
+	}
+
+	if ((archive_level==1 || archive_level==2) && !(finfo->mode & FILE_ATTRIBUTE_ARCHIVE)) {
+		DEBUG(3,("archive %s failed\n", finfo->name));
+		return(False);
+	}
+	
+	return(True);
+}
+
+/*******************************************************************
+ Return a string representing an attribute for a file.
+********************************************************************/
+static const char *attrib_string(uint16 mode)
+{
+	static fstring attrstr;
+	int i, len;
+	const struct {
+		char c;
+		uint16 attr;
+	} attr_strs[] = {
+		{'V', FILE_ATTRIBUTE_VOLUME},
+		{'D', FILE_ATTRIBUTE_DIRECTORY},
+		{'A', FILE_ATTRIBUTE_ARCHIVE},
+		{'H', FILE_ATTRIBUTE_HIDDEN},
+		{'S', FILE_ATTRIBUTE_SYSTEM},
+		{'R', FILE_ATTRIBUTE_READONLY},
+		{'d', FILE_ATTRIBUTE_DEVICE},
+		{'t', FILE_ATTRIBUTE_TEMPORARY},
+		{'s', FILE_ATTRIBUTE_SPARSE},
+		{'r', FILE_ATTRIBUTE_REPARSE_POINT},
+		{'c', FILE_ATTRIBUTE_COMPRESSED},
+		{'o', FILE_ATTRIBUTE_OFFLINE},
+		{'n', FILE_ATTRIBUTE_NONINDEXED},
+		{'e', FILE_ATTRIBUTE_ENCRYPTED}
+	};
+
+	for (len=i=0; i<ARRAY_SIZE(attr_strs); i++) {
+		if (mode & attr_strs[i].attr) {
+			attrstr[len++] = attr_strs[i].c;
+		}
+	}
+
+	attrstr[len] = 0;
+
+	return(attrstr);
+}
+
+/****************************************************************************
+  display info about a file
+  ****************************************************************************/
+static void display_finfo(file_info *finfo)
+{
+	if (do_this_one(finfo)) {
+		time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
+		d_printf("  %-30s%7.7s %8.0f  %s",
+			 finfo->name,
+			 attrib_string(finfo->mode),
+			 (double)finfo->size,
+			 asctime(LocalTime(&t)));
+		dir_total += finfo->size;
+	}
+}
+
+
+/****************************************************************************
+   accumulate size of a file
+  ****************************************************************************/
+static void do_du(file_info *finfo)
+{
+	if (do_this_one(finfo)) {
+		dir_total += finfo->size;
+	}
+}
+
+static BOOL do_list_recurse;
+static BOOL do_list_dirs;
+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 *);
+
+/****************************************************************************
+functions for do_list_queue
+  ****************************************************************************/
+
+/*
+ * The do_list_queue is a NUL-separated list of strings stored in a
+ * char*.  Since this is a FIFO, we keep track of the beginning and
+ * ending locations of the data in the queue.  When we overflow, we
+ * double the size of the char*.  When the start of the data passes
+ * the midpoint, we move everything back.  This is logically more
+ * complex than a linked list, but easier from a memory management
+ * angle.  In any memory error condition, do_list_queue is reset.
+ * Functions check to ensure that do_list_queue is non-NULL before
+ * accessing it.
+ */
+static void reset_do_list_queue(void)
+{
+	SAFE_FREE(do_list_queue);
+	do_list_queue_size = 0;
+	do_list_queue_start = 0;
+	do_list_queue_end = 0;
+}
+
+static void init_do_list_queue(void)
+{
+	reset_do_list_queue();
+	do_list_queue_size = 1024;
+	do_list_queue = malloc(do_list_queue_size);
+	if (do_list_queue == 0) { 
+		d_printf("malloc fail for size %d\n",
+			 (int)do_list_queue_size);
+		reset_do_list_queue();
+	} else {
+		memset(do_list_queue, 0, do_list_queue_size);
+	}
+}
+
+static void adjust_do_list_queue(void)
+{
+	/*
+	 * If the starting point of the queue is more than half way through,
+	 * move everything toward the beginning.
+	 */
+	if (do_list_queue && (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;
+		*do_list_queue = '\0';
+	}
+	else if (do_list_queue_start > (do_list_queue_size / 2))
+	{
+		DEBUG(4,("sliding do_list_queue backward\n"));
+		memmove(do_list_queue,
+			do_list_queue + do_list_queue_start,
+			do_list_queue_end - do_list_queue_start);
+		do_list_queue_end -= do_list_queue_start;
+		do_list_queue_start = 0;
+	}
+	   
+}
+
+static void add_to_do_list_queue(const char* entry)
+{
+	char *dlq;
+	long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
+	while (new_end > do_list_queue_size)
+	{
+		do_list_queue_size *= 2;
+		DEBUG(4,("enlarging do_list_queue to %d\n",
+			 (int)do_list_queue_size));
+		dlq = Realloc(do_list_queue, do_list_queue_size);
+		if (! dlq) {
+			d_printf("failure enlarging do_list_queue to %d bytes\n",
+				 (int)do_list_queue_size);
+			reset_do_list_queue();
+		}
+		else
+		{
+			do_list_queue = dlq;
+			memset(do_list_queue + do_list_queue_size / 2,
+			       0, do_list_queue_size / 2);
+		}
+	}
+	if (do_list_queue)
+	{
+		safe_strcpy(do_list_queue + do_list_queue_end, entry, 
+			    do_list_queue_size - do_list_queue_end - 1);
+		do_list_queue_end = new_end;
+		DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
+			 entry, (int)do_list_queue_start, (int)do_list_queue_end));
+	}
+}
+
+static char *do_list_queue_head(void)
+{
+	return do_list_queue + do_list_queue_start;
+}
+
+static void remove_do_list_queue_head(void)
+{
+	if (do_list_queue_end > do_list_queue_start)
+	{
+		do_list_queue_start += strlen(do_list_queue_head()) + 1;
+		adjust_do_list_queue();
+		DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
+			 (int)do_list_queue_start, (int)do_list_queue_end));
+	}
+}
+
+static int do_list_queue_empty(void)
+{
+	return (! (do_list_queue && *do_list_queue));
+}
+
+/****************************************************************************
+a helper for do_list
+  ****************************************************************************/
+static void do_list_helper(file_info *f, const char *mask, void *state)
+{
+	if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
+		if (do_list_dirs && do_this_one(f)) {
+			do_list_fn(f);
+		}
+		if (do_list_recurse && 
+		    !strequal(f->name,".") && 
+		    !strequal(f->name,"..")) {
+			pstring mask2;
+			char *p;
+
+			pstrcpy(mask2, mask);
+			p = strrchr_m(mask2,'\\');
+			if (!p) return;
+			p[1] = 0;
+			pstrcat(mask2, f->name);
+			pstrcat(mask2,"\\*");
+			add_to_do_list_queue(mask2);
+		}
+		return;
+	}
+
+	if (do_this_one(f)) {
+		do_list_fn(f);
+	}
+}
+
+
+/****************************************************************************
+a wrapper around cli_list that adds recursion
+  ****************************************************************************/
+void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),BOOL rec, BOOL dirs)
+{
+	static int in_do_list = 0;
+
+	if (in_do_list && rec)
+	{
+		fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
+		exit(1);
+	}
+
+	in_do_list = 1;
+
+	do_list_recurse = rec;
+	do_list_dirs = dirs;
+	do_list_fn = fn;
+
+	if (rec)
+	{
+		init_do_list_queue();
+		add_to_do_list_queue(mask);
+		
+		while (! do_list_queue_empty())
+		{
+			/*
+			 * Need to copy head so that it doesn't become
+			 * invalid inside the call to cli_list.  This
+			 * would happen if the list were expanded
+			 * during the call.
+			 * Fix from E. Jay Berkenbilt (ejb@ql.org)
+			 */
+			pstring head;
+			pstrcpy(head, do_list_queue_head());
+			cli_list(cli, head, 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;
+				if ((strlen(next_file) >= 2) &&
+				    (next_file[strlen(next_file) - 1] == '*') &&
+				    (next_file[strlen(next_file) - 2] == '\\'))
+				{
+					save_ch = next_file +
+						strlen(next_file) - 2;
+					*save_ch = '\0';
+				}
+				d_printf("\n%s\n",next_file);
+				if (save_ch)
+				{
+					*save_ch = '\\';
+				}
+			}
+		}
+	}
+	else
+	{
+		if (cli_list(cli, mask, attribute, do_list_helper, NULL) == -1)
+		{
+			d_printf("%s listing %s\n", cli_errstr(cli), mask);
+		}
+	}
+
+	in_do_list = 0;
+	reset_do_list_queue();
+}
+
+/****************************************************************************
+  get a directory listing
+  ****************************************************************************/
+static int cmd_dir(void)
+{
+	uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+	pstring mask;
+	fstring buf;
+	char *p=buf;
+	int rc;
+	
+	dir_total = 0;
+	pstrcpy(mask,cur_dir);
+	if(mask[strlen(mask)-1]!='\\')
+		pstrcat(mask,"\\");
+	
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		dos_format(p);
+		if (*p == '\\')
+			pstrcpy(mask,p);
+		else
+			pstrcat(mask,p);
+	}
+	else {
+		pstrcat(mask,"*");
+	}
+
+	do_list(mask, attribute, display_finfo, recurse, True);
+
+	rc = do_dskattr();
+
+	DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
+
+	return rc;
+}
+
+
+/****************************************************************************
+  get a directory listing
+  ****************************************************************************/
+static int cmd_du(void)
+{
+	uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+	pstring mask;
+	fstring buf;
+	char *p=buf;
+	int rc;
+	
+	dir_total = 0;
+	pstrcpy(mask,cur_dir);
+	if(mask[strlen(mask)-1]!='\\')
+		pstrcat(mask,"\\");
+	
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		dos_format(p);
+		if (*p == '\\')
+			pstrcpy(mask,p);
+		else
+			pstrcat(mask,p);
+	} else {
+		pstrcat(mask,"*");
+	}
+
+	do_list(mask, attribute, do_du, recurse, True);
+
+	rc = do_dskattr();
+
+	d_printf("Total number of bytes: %.0f\n", dir_total);
+
+	return rc;
+}
+
+
+/****************************************************************************
+  get a file from rname to lname
+  ****************************************************************************/
+static int do_get(char *rname, const char *lname, BOOL reget)
+{  
+	int handle = 0, fnum;
+	BOOL newhandle = False;
+	char *data;
+	struct timeval tp_start;
+	int read_size = io_bufsize;
+	uint16 attr;
+	size_t size;
+	off_t start = 0;
+	off_t nread = 0;
+	int rc = 0;
+
+	GetTimeOfDay(&tp_start);
+
+	if (lowercase) {
+		strlower(lname);
+	}
+
+	fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE);
+
+	if (fnum == -1) {
+		d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
+		return 1;
+	}
+
+	if(!strcmp(lname,"-")) {
+		handle = fileno(stdout);
+	} else {
+		if (reget) {
+			handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
+			if (handle >= 0) {
+				start = sys_lseek(handle, 0, SEEK_END);
+				if (start == -1) {
+					d_printf("Error seeking local file\n");
+					return 1;
+				}
+			}
+		} else {
+			handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+		}
+		newhandle = True;
+	}
+	if (handle < 0) {
+		d_printf("Error opening local file %s\n",lname);
+		return 1;
+	}
+
+
+	if (!cli_qfileinfo(cli, fnum, 
+			   &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
+	    !cli_getattrE(cli, fnum, 
+			  &attr, &size, NULL, NULL, NULL)) {
+		d_printf("getattrib: %s\n",cli_errstr(cli));
+		return 1;
+	}
+
+	DEBUG(2,("getting file %s of size %.0f as %s ", 
+		 rname, (double)size, lname));
+
+	if(!(data = (char *)malloc(read_size))) { 
+		d_printf("malloc fail for size %d\n", read_size);
+		cli_close(cli, fnum);
+		return 1;
+	}
+
+	while (1) {
+		int n = cli_read(cli, fnum, data, nread + start, read_size);
+
+		if (n <= 0) break;
+ 
+		if (writefile(handle,data, n) != n) {
+			d_printf("Error writing local file\n");
+			rc = 1;
+			break;
+		}
+      
+		nread += n;
+	}
+
+	if (nread + start < size) {
+		DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n",
+			    rname, (long)nread));
+
+		rc = 1;
+	}
+
+	SAFE_FREE(data);
+	
+	if (!cli_close(cli, fnum)) {
+		d_printf("Error %s closing remote file\n",cli_errstr(cli));
+		rc = 1;
+	}
+
+	if (newhandle) {
+		close(handle);
+	}
+
+	if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
+		cli_setatr(cli, rname, attr & ~(uint16)FILE_ATTRIBUTE_ARCHIVE, 0);
+	}
+
+	{
+		struct timeval tp_end;
+		int this_time;
+		
+		GetTimeOfDay(&tp_end);
+		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(2,("(%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)));
+	}
+	
+	return rc;
+}
+
+
+/****************************************************************************
+  get a file
+  ****************************************************************************/
+static int cmd_get(void)
+{
+	pstring lname;
+	pstring rname;
+	char *p;
+
+	pstrcpy(rname,cur_dir);
+	pstrcat(rname,"\\");
+	
+	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);
+	dos_clean_name(rname);
+	
+	next_token_nr(NULL,lname,NULL,sizeof(lname));
+	
+	return do_get(rname, lname, False);
+}
+
+
+/****************************************************************************
+  do a mget operation on one file
+  ****************************************************************************/
+static void do_mget(file_info *finfo)
+{
+	pstring rname;
+	pstring quest;
+	pstring saved_curdir;
+	pstring mget_mask;
+
+	if (strequal(finfo->name,".") || strequal(finfo->name,".."))
+		return;
+
+	if (abort_mget)	{
+		d_printf("mget aborted\n");
+		return;
+	}
+
+	if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY)
+		slprintf(quest,sizeof(pstring)-1,
+			 "Get directory %s? ",finfo->name);
+	else
+		slprintf(quest,sizeof(pstring)-1,
+			 "Get file %s? ",finfo->name);
+
+	if (prompt && !yesno(quest)) return;
+
+	if (!(finfo->mode & FILE_ATTRIBUTE_DIRECTORY)) {
+		pstrcpy(rname,cur_dir);
+		pstrcat(rname,finfo->name);
+		do_get(rname, finfo->name, False);
+		return;
+	}
+
+	/* handle directories */
+	pstrcpy(saved_curdir,cur_dir);
+
+	pstrcat(cur_dir,finfo->name);
+	pstrcat(cur_dir,"\\");
+
+	unix_format(finfo->name);
+	if (lowercase)
+		strlower(finfo->name);
+	
+	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);
+		return;
+	}
+	
+	if (chdir(finfo->name) != 0) {
+		d_printf("failed to chdir to directory %s\n",finfo->name);
+		pstrcpy(cur_dir,saved_curdir);
+		return;
+	}
+
+	pstrcpy(mget_mask,cur_dir);
+	pstrcat(mget_mask,"*");
+	
+	do_list(mget_mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,do_mget,False, True);
+	chdir("..");
+	pstrcpy(cur_dir,saved_curdir);
+}
+
+
+/****************************************************************************
+view the file using the pager
+****************************************************************************/
+static int cmd_more(void)
+{
+	fstring rname,lname,pager_cmd;
+	char *pager;
+	int fd;
+	int rc = 0;
+
+	fstrcpy(rname,cur_dir);
+	fstrcat(rname,"\\");
+	
+	slprintf(lname,sizeof(lname)-1, "%s/smbmore.XXXXXX",tmpdir());
+	fd = smb_mkstemp(lname);
+	if (fd == -1) {
+		d_printf("failed to create temporary file for more\n");
+		return 1;
+	}
+	close(fd);
+
+	if (!next_token_nr(NULL,rname+strlen(rname),NULL,sizeof(rname)-strlen(rname))) {
+		d_printf("more <filename>\n");
+		unlink(lname);
+		return 1;
+	}
+	dos_clean_name(rname);
+
+	rc = do_get(rname, lname, False);
+
+	pager=getenv("PAGER");
+
+	slprintf(pager_cmd,sizeof(pager_cmd)-1,
+		 "%s %s",(pager? pager:PAGER), lname);
+	system(pager_cmd);
+	unlink(lname);
+	
+	return rc;
+}
+
+
+
+/****************************************************************************
+do a mget command
+****************************************************************************/
+static int cmd_mget(void)
+{
+	uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+	pstring mget_mask;
+	fstring buf;
+	char *p=buf;
+
+	*mget_mask = 0;
+
+	if (recurse)
+		attribute |= FILE_ATTRIBUTE_DIRECTORY;
+	
+	abort_mget = False;
+
+	while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
+		pstrcpy(mget_mask,cur_dir);
+		if(mget_mask[strlen(mget_mask)-1]!='\\')
+			pstrcat(mget_mask,"\\");
+		
+		if (*p == '\\')
+			pstrcpy(mget_mask,p);
+		else
+			pstrcat(mget_mask,p);
+		do_list(mget_mask, attribute,do_mget,False,True);
+	}
+
+	if (!*mget_mask) {
+		pstrcpy(mget_mask,cur_dir);
+		if(mget_mask[strlen(mget_mask)-1]!='\\')
+			pstrcat(mget_mask,"\\");
+		pstrcat(mget_mask,"*");
+		do_list(mget_mask, attribute,do_mget,False,True);
+	}
+	
+	return 0;
+}
+
+
+/****************************************************************************
+make a directory of name "name"
+****************************************************************************/
+static BOOL do_mkdir(char *name)
+{
+	if (!cli_mkdir(cli, name)) {
+		d_printf("%s making remote directory %s\n",
+			 cli_errstr(cli),name);
+		return(False);
+	}
+
+	return(True);
+}
+
+/****************************************************************************
+show 8.3 name of a file
+****************************************************************************/
+static BOOL do_altname(char *name)
+{
+	const char *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);
+	}
+	d_printf("%s\n", altname);
+
+	return(True);
+}
+
+
+/****************************************************************************
+ Exit client.
+****************************************************************************/
+static int cmd_quit(void)
+{
+	cli_shutdown(cli);
+	exit(0);
+	/* NOTREACHED */
+	return 0;
+}
+
+
+/****************************************************************************
+  make a directory
+  ****************************************************************************/
+static int cmd_mkdir(void)
+{
+	pstring mask;
+	fstring buf;
+	char *p=buf;
+  
+	pstrcpy(mask,cur_dir);
+
+	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
+		if (!recurse)
+			d_printf("mkdir <dirname>\n");
+		return 1;
+	}
+	pstrcat(mask,p);
+
+	if (recurse) {
+		pstring ddir;
+		pstring ddir2;
+		*ddir2 = 0;
+		
+		pstrcpy(ddir,mask);
+		trim_string(ddir,".",NULL);
+		p = strtok(ddir,"/\\");
+		while (p) {
+			pstrcat(ddir2,p);
+			if (!cli_chkpath(cli, ddir2)) { 
+				do_mkdir(ddir2);
+			}
+			pstrcat(ddir2,"\\");
+			p = strtok(NULL,"/\\");
+		}	 
+	} else {
+		do_mkdir(mask);
+	}
+	
+	return 0;
+}
+
+
+/****************************************************************************
+  show alt name
+  ****************************************************************************/
+static int cmd_altname(void)
+{
+	pstring name;
+	fstring buf;
+	char *p=buf;
+  
+	pstrcpy(name,cur_dir);
+
+	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
+		d_printf("altname <file>\n");
+		return 1;
+	}
+	pstrcat(name,p);
+
+	do_altname(name);
+
+	return 0;
+}
+
+
+/****************************************************************************
+  put a single file
+  ****************************************************************************/
+static int do_put(char *rname, char *lname, BOOL reput)
+{
+	int fnum;
+	XFILE *f;
+	size_t start = 0;
+	off_t nread = 0;
+	char *buf = NULL;
+	int maxwrite = io_bufsize;
+	int rc = 0;
+	
+	struct timeval tp_start;
+	GetTimeOfDay(&tp_start);
+
+	if (reput) {
+		fnum = cli_open(cli, rname, O_RDWR|O_CREAT, DENY_NONE);
+		if (fnum >= 0) {
+			if (!cli_qfileinfo(cli, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
+			    !cli_getattrE(cli, fnum, NULL, &start, NULL, NULL, NULL)) {
+				d_printf("getattrib: %s\n",cli_errstr(cli));
+				return 1;
+			}
+		}
+	} else {
+		fnum = cli_open(cli, rname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
+	}
+  
+	if (fnum == -1) {
+		d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
+		return 1;
+	}
+
+	/* allow files to be piped into smbclient
+	   jdblair 24.jun.98
+
+	   Note that in this case this function will exit(0) rather
+	   than returning. */
+	if (!strcmp(lname, "-")) {
+		f = x_stdin;
+		/* size of file is not known */
+	} else {
+		f = x_fopen(lname,O_RDONLY, 0);
+		if (f && reput) {
+			if (x_tseek(f, start, SEEK_SET) == -1) {
+				d_printf("Error seeking local file\n");
+				return 1;
+			}
+		}
+	}
+
+	if (!f) {
+		d_printf("Error opening local file %s\n",lname);
+		return 1;
+	}
+
+  
+	DEBUG(1,("putting file %s as %s ",lname,
+		 rname));
+  
+	buf = (char *)malloc(maxwrite);
+	if (!buf) {
+		d_printf("ERROR: Not enough memory!\n");
+		return 1;
+	}
+	while (!x_feof(f)) {
+		int n = maxwrite;
+		int ret;
+
+		if ((n = readfile(buf,n,f)) < 1) {
+			if((n == 0) && x_feof(f))
+				break; /* Empty local file. */
+
+			d_printf("Error reading local file: %s\n", strerror(errno));
+			rc = 1;
+			break;
+		}
+
+		ret = cli_write(cli, fnum, 0, buf, nread + start, n);
+
+		if (n != ret) {
+			d_printf("Error writing file: %s\n", cli_errstr(cli));
+			rc = 1;
+			break;
+		} 
+
+		nread += n;
+	}
+
+	if (!cli_close(cli, fnum)) {
+		d_printf("%s closing remote file %s\n",cli_errstr(cli),rname);
+		x_fclose(f);
+		SAFE_FREE(buf);
+		return 1;
+	}
+
+	
+	if (f != x_stdin) {
+		x_fclose(f);
+	}
+
+	SAFE_FREE(buf);
+
+	{
+		struct timeval tp_end;
+		int this_time;
+		
+		GetTimeOfDay(&tp_end);
+		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)));
+	}
+
+	if (f == x_stdin) {
+		cli_shutdown(cli);
+		exit(0);
+	}
+	
+	return rc;
+}
+
+ 
+
+/****************************************************************************
+  put a file
+  ****************************************************************************/
+static int cmd_put(void)
+{
+	pstring lname;
+	pstring rname;
+	fstring buf;
+	char *p=buf;
+	
+	pstrcpy(rname,cur_dir);
+	pstrcat(rname,"\\");
+  
+	if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
+		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);
+	
+	dos_clean_name(rname);
+
+	{
+		SMB_STRUCT_STAT st;
+		/* allow '-' to represent stdin
+		   jdblair, 24.jun.98 */
+		if (!file_exist(lname,&st) &&
+		    (strcmp(lname,"-"))) {
+			d_printf("%s does not exist\n",lname);
+			return 1;
+		}
+	}
+
+	return do_put(rname, lname, False);
+}
+
+/*************************************
+  File list structure
+*************************************/
+
+static struct file_list {
+	struct file_list *prev, *next;
+	char *file_path;
+	BOOL isdir;
+} *file_list;
+
+/****************************************************************************
+  Free a file_list structure
+****************************************************************************/
+
+static void free_file_list (struct file_list * list)
+{
+	struct file_list *tmp;
+	
+	while (list)
+	{
+		tmp = list;
+		DLIST_REMOVE(list, list);
+		SAFE_FREE(tmp->file_path);
+		SAFE_FREE(tmp);
+	}
+}
+
+/****************************************************************************
+  seek in a directory/file list until you get something that doesn't start with
+  the specified name
+  ****************************************************************************/
+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);
+		}
+		list = list->next;
+	}
+      
+	return(False);
+}
+
+/****************************************************************************
+  set the file selection mask
+  ****************************************************************************/
+static int cmd_select(void)
+{
+	pstrcpy(fileselection,"");
+	next_token_nr(NULL,fileselection,NULL,sizeof(fileselection));
+
+	return 0;
+}
+
+/****************************************************************************
+  Recursive file matching function act as find
+  match must be always set to True when calling this function
+****************************************************************************/
+static int file_find(struct file_list **list, const char *directory, 
+		      const char *expression, BOOL match)
+{
+	DIR *dir;
+	struct file_list *entry;
+        struct stat statbuf;
+        int ret;
+        char *path;
+	BOOL isdir;
+	const char *dname;
+
+        dir = 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;
+		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);
+					}
+				} else {
+					d_printf("file_find: cannot stat file %s\n", path);
+				}
+				
+				if (ret == -1) {
+					SAFE_FREE(path);
+					closedir(dir);
+					return -1;
+				}
+			}
+			entry = (struct file_list *) malloc(sizeof (struct file_list));
+			if (!entry) {
+				d_printf("Out of memory in file_find\n");
+				closedir(dir);
+				return -1;
+			}
+			entry->file_path = path;
+			entry->isdir = isdir;
+                        DLIST_ADD(*list, entry);
+		} else {
+			SAFE_FREE(path);
+		}
+        }
+
+	closedir(dir);
+	return 0;
+}
+
+/****************************************************************************
+  mput some files
+  ****************************************************************************/
+static int cmd_mput(void)
+{
+	fstring buf;
+	char *p=buf;
+	
+	while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
+		int ret;
+		struct file_list *temp_list;
+		char *quest, *lname, *rname;
+	
+		file_list = NULL;
+
+		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; 
+		     temp_list = temp_list->next) {
+
+			SAFE_FREE(lname);
+			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 (prompt && !yesno(quest)) { /* No */
+					/* Skip the directory */
+					lname[strlen(lname)-1] = '/';
+					if (!seek_list(temp_list, lname))
+						break;		    
+				} else { /* Yes */
+	      				SAFE_FREE(rname);
+					if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
+					dos_format(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))
+							break;
+					}
+				}
+				continue;
+			} else {
+				SAFE_FREE(quest);
+				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;
+			}
+
+			dos_format(rname);
+
+			do_put(rname, lname, False);
+		}
+		free_file_list(file_list);
+		SAFE_FREE(quest);
+		SAFE_FREE(lname);
+		SAFE_FREE(rname);
+	}
+
+	return 0;
+}
+
+
+/****************************************************************************
+  cancel a print job
+  ****************************************************************************/
+static int do_cancel(int job)
+{
+	d_printf("REWRITE: print job cancel not implemented\n");
+	return 1;
+}
+
+
+/****************************************************************************
+  cancel a print job
+  ****************************************************************************/
+static int cmd_cancel(void)
+{
+	fstring buf;
+	int job; 
+
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("cancel <jobid> ...\n");
+		return 1;
+	}
+	do {
+		job = atoi(buf);
+		do_cancel(job);
+	} while (next_token_nr(NULL,buf,NULL,sizeof(buf)));
+	
+	return 0;
+}
+
+
+/****************************************************************************
+  print a file
+  ****************************************************************************/
+static int cmd_print(void)
+{
+	pstring lname;
+	pstring rname;
+	char *p;
+
+	if (!next_token_nr(NULL,lname,NULL, sizeof(lname))) {
+		d_printf("print <filename>\n");
+		return 1;
+	}
+
+	pstrcpy(rname,lname);
+	p = strrchr_m(rname,'/');
+	if (p) {
+		slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)getpid());
+	}
+
+	if (strequal(lname,"-")) {
+		slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)getpid());
+	}
+
+	return do_put(rname, lname, False);
+}
+
+
+/****************************************************************************
+ show a print queue
+****************************************************************************/
+static int cmd_queue(void)
+{
+	d_printf("REWRITE: print job queue not implemented\n");
+	
+	return 0;
+}
+
+/****************************************************************************
+delete some files
+****************************************************************************/
+static void do_del(file_info *finfo)
+{
+	pstring mask;
+
+	pstrcpy(mask,cur_dir);
+	pstrcat(mask,finfo->name);
+
+	if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) 
+		return;
+
+	if (!cli_unlink(cli, mask)) {
+		d_printf("%s deleting remote file %s\n",cli_errstr(cli),mask);
+	}
+}
+
+/****************************************************************************
+delete some files
+****************************************************************************/
+static int cmd_del(void)
+{
+	pstring mask;
+	fstring buf;
+	uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+
+	if (recurse)
+		attribute |= FILE_ATTRIBUTE_DIRECTORY;
+	
+	pstrcpy(mask,cur_dir);
+	
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("del <filename>\n");
+		return 1;
+	}
+	pstrcat(mask,buf);
+
+	do_list(mask, attribute,do_del,False,False);
+	
+	return 0;
+}
+
+
+/****************************************************************************
+delete a whole directory tree
+****************************************************************************/
+static int cmd_deltree(void)
+{
+	pstring dname;
+	fstring buf;
+	int ret;
+
+	pstrcpy(dname,cur_dir);
+	
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("deltree <dirname>\n");
+		return 1;
+	}
+	pstrcat(dname,buf);
+
+	ret = cli_deltree(cli, dname);
+
+	if (ret == -1) {
+		printf("Failed to delete tree %s - %s\n", dname, cli_errstr(cli));
+		return -1;
+	}
+
+	printf("Deleted %d files in %s\n", ret, dname);
+	
+	return 0;
+}
+
+
+/****************************************************************************
+show as much information as possible about a file
+****************************************************************************/
+static int cmd_allinfo(void)
+{
+	pstring fname;
+	fstring buf;
+	int ret = 0;
+	TALLOC_CTX *mem_ctx;
+	union smb_fileinfo finfo;
+	NTSTATUS status;
+
+	pstrcpy(fname,cur_dir);
+	
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("deltree <dirname>\n");
+		return 1;
+	}
+	pstrcat(fname,buf);
+
+	mem_ctx = talloc_init(fname);
+
+	/* first a ALL_INFO QPATHINFO */
+	finfo.generic.level = RAW_FILEINFO_ALL_INFO;
+	finfo.generic.in.fname = fname;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("%s - %s\n", fname, nt_errstr(status));
+		ret = 1;
+		goto done;
+	}
+
+	d_printf("\tcreate_time:    %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.create_time));
+	d_printf("\taccess_time:    %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.access_time));
+	d_printf("\twrite_time:     %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.write_time));
+	d_printf("\tchange_time:    %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.change_time));
+	d_printf("\tattrib:         0x%x\n", finfo.all_info.out.attrib);
+	d_printf("\talloc_size:     %lu\n", (unsigned long)finfo.all_info.out.alloc_size);
+	d_printf("\tsize:           %lu\n", (unsigned long)finfo.all_info.out.size);
+	d_printf("\tnlink:          %u\n", finfo.all_info.out.nlink);
+	d_printf("\tdelete_pending: %u\n", finfo.all_info.out.delete_pending);
+	d_printf("\tdirectory:      %u\n", finfo.all_info.out.directory);
+	d_printf("\tea_size:        %u\n", finfo.all_info.out.ea_size);
+	d_printf("\tfname:          '%s'\n", finfo.all_info.out.fname.s);
+
+	/* 8.3 name if any */
+	finfo.generic.level = RAW_FILEINFO_ALT_NAME_INFO;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (NT_STATUS_IS_OK(status)) {
+		d_printf("\talt_name:       %s\n", finfo.alt_name_info.out.fname.s);
+	}
+
+	/* dev/inode if available */
+	finfo.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (NT_STATUS_IS_OK(status)) {
+		d_printf("\tdevice          0x%x\n", finfo.internal_information.out.device);
+		d_printf("\tinode           0x%x\n", finfo.internal_information.out.inode);
+	}
+
+	/* the EAs, if any */
+	finfo.generic.level = RAW_FILEINFO_ALL_EAS;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (NT_STATUS_IS_OK(status)) {
+		int i;
+		for (i=0;i<finfo.all_eas.out.num_eas;i++) {
+			d_printf("\tEA[%d] flags=%d %s=%*.*s\n", i,
+				 finfo.all_eas.out.eas[i].flags,
+				 finfo.all_eas.out.eas[i].name.s,
+				 finfo.all_eas.out.eas[i].value.length,
+				 finfo.all_eas.out.eas[i].value.length,
+				 finfo.all_eas.out.eas[i].value.data);
+		}
+	}
+
+	/* streams, if available */
+	finfo.generic.level = RAW_FILEINFO_STREAM_INFO;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (NT_STATUS_IS_OK(status)) {
+		int i;
+		for (i=0;i<finfo.stream_info.out.num_streams;i++) {
+			d_printf("\tstream %d:\n", i);
+			d_printf("\t\tsize       %ld\n", 
+				 (long)finfo.stream_info.out.streams[i].size);
+			d_printf("\t\talloc size %ld\n", 
+				 (long)finfo.stream_info.out.streams[i].alloc_size);
+			d_printf("\t\tname       %s\n", finfo.stream_info.out.streams[i].stream_name.s);
+		}
+	}	
+
+	/* dev/inode if available */
+	finfo.generic.level = RAW_FILEINFO_COMPRESSION_INFORMATION;
+	status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+	if (NT_STATUS_IS_OK(status)) {
+		d_printf("\tcompressed size %ld\n", (long)finfo.compression_info.out.compressed_size);
+		d_printf("\tformat          %ld\n", (long)finfo.compression_info.out.format);
+		d_printf("\tunit_shift      %ld\n", (long)finfo.compression_info.out.unit_shift);
+		d_printf("\tchunk_shift     %ld\n", (long)finfo.compression_info.out.chunk_shift);
+		d_printf("\tcluster_shift   %ld\n", (long)finfo.compression_info.out.cluster_shift);
+	}
+
+	talloc_destroy(mem_ctx);
+
+done:
+	return ret;
+}
+
+
+/****************************************************************************
+****************************************************************************/
+static int cmd_open(void)
+{
+	pstring mask;
+	fstring buf;
+	
+	pstrcpy(mask,cur_dir);
+	
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("open <filename>\n");
+		return 1;
+	}
+	pstrcat(mask,buf);
+
+	cli_open(cli, mask, O_RDWR, DENY_ALL);
+
+	return 0;
+}
+
+
+/****************************************************************************
+remove a directory
+****************************************************************************/
+static int cmd_rmdir(void)
+{
+	pstring mask;
+	fstring buf;
+  
+	pstrcpy(mask,cur_dir);
+	
+	if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		d_printf("rmdir <dirname>\n");
+		return 1;
+	}
+	pstrcat(mask,buf);
+
+	if (!cli_rmdir(cli, mask)) {
+		d_printf("%s removing remote directory file %s\n",
+			 cli_errstr(cli),mask);
+	}
+	
+	return 0;
+}
+
+/****************************************************************************
+ UNIX hardlink.
+****************************************************************************/
+static int cmd_link(void)
+{
+	pstring src,dest;
+	fstring buf,buf2;
+  
+	if (!(cli->transport->negotiate.capabilities & CAP_UNIX)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	pstrcpy(src,cur_dir);
+	pstrcpy(dest,cur_dir);
+  
+	if (!next_token(NULL,buf,NULL,sizeof(buf)) || 
+	    !next_token(NULL,buf2,NULL, sizeof(buf2))) {
+		d_printf("link <src> <dest>\n");
+		return 1;
+	}
+
+	pstrcat(src,buf);
+	pstrcat(dest,buf2);
+
+	if (!cli_unix_hardlink(cli, src, dest)) {
+		d_printf("%s linking files (%s -> %s)\n", cli_errstr(cli), src, dest);
+		return 1;
+	}  
+
+	return 0;
+}
+
+/****************************************************************************
+ UNIX symlink.
+****************************************************************************/
+
+static int cmd_symlink(void)
+{
+	pstring src,dest;
+	fstring buf,buf2;
+  
+	if (!(cli->transport->negotiate.capabilities & CAP_UNIX)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	pstrcpy(src,cur_dir);
+	pstrcpy(dest,cur_dir);
+	
+	if (!next_token(NULL,buf,NULL,sizeof(buf)) || 
+	    !next_token(NULL,buf2,NULL, sizeof(buf2))) {
+		d_printf("symlink <src> <dest>\n");
+		return 1;
+	}
+
+	pstrcat(src,buf);
+	pstrcat(dest,buf2);
+
+	if (!cli_unix_symlink(cli, src, dest)) {
+		d_printf("%s symlinking files (%s -> %s)\n",
+			cli_errstr(cli), src, dest);
+		return 1;
+	} 
+
+	return 0;
+}
+
+/****************************************************************************
+ UNIX chmod.
+****************************************************************************/
+
+static int cmd_chmod(void)
+{
+	pstring src;
+	mode_t mode;
+	fstring buf, buf2;
+  
+	if (!(cli->transport->negotiate.capabilities & CAP_UNIX)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	pstrcpy(src,cur_dir);
+	
+	if (!next_token(NULL,buf,NULL,sizeof(buf)) || 
+	    !next_token(NULL,buf2,NULL, sizeof(buf2))) {
+		d_printf("chmod mode file\n");
+		return 1;
+	}
+
+	mode = (mode_t)strtol(buf, NULL, 8);
+	pstrcat(src,buf2);
+
+	if (!cli_unix_chmod(cli, src, mode)) {
+		d_printf("%s chmod file %s 0%o\n",
+			cli_errstr(cli), src, (unsigned int)mode);
+		return 1;
+	} 
+
+	return 0;
+}
+
+/****************************************************************************
+ UNIX chown.
+****************************************************************************/
+
+static int cmd_chown(void)
+{
+	pstring src;
+	uid_t uid;
+	gid_t gid;
+	fstring buf, buf2, buf3;
+  
+	if (!(cli->transport->negotiate.capabilities & CAP_UNIX)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	pstrcpy(src,cur_dir);
+	
+	if (!next_token(NULL,buf,NULL,sizeof(buf)) || 
+	    !next_token(NULL,buf2,NULL, sizeof(buf2)) ||
+	    !next_token(NULL,buf3,NULL, sizeof(buf3))) {
+		d_printf("chown uid gid file\n");
+		return 1;
+	}
+
+	uid = (uid_t)atoi(buf);
+	gid = (gid_t)atoi(buf2);
+	pstrcat(src,buf3);
+
+	if (!cli_unix_chown(cli, src, uid, gid)) {
+		d_printf("%s chown file %s uid=%d, gid=%d\n",
+			cli_errstr(cli), src, (int)uid, (int)gid);
+		return 1;
+	} 
+
+	return 0;
+}
+
+/****************************************************************************
+rename some files
+****************************************************************************/
+static int cmd_rename(void)
+{
+	pstring src,dest;
+	fstring buf,buf2;
+  
+	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))) {
+		d_printf("rename <src> <dest>\n");
+		return 1;
+	}
+
+	pstrcat(src,buf);
+	pstrcat(dest,buf2);
+
+	if (!cli_rename(cli, src, dest)) {
+		d_printf("%s renaming files\n",cli_errstr(cli));
+		return 1;
+	}
+	
+	return 0;
+}
+
+
+/****************************************************************************
+toggle the prompt flag
+****************************************************************************/
+static int cmd_prompt(void)
+{
+	prompt = !prompt;
+	DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
+	
+	return 1;
+}
+
+
+/****************************************************************************
+set the newer than time
+****************************************************************************/
+static int cmd_newer(void)
+{
+	fstring buf;
+	BOOL ok;
+	SMB_STRUCT_STAT sbuf;
+
+	ok = next_token_nr(NULL,buf,NULL,sizeof(buf));
+	if (ok && (sys_stat(buf,&sbuf) == 0)) {
+		newer_than = sbuf.st_mtime;
+		DEBUG(1,("Getting files newer than %s",
+			 asctime(LocalTime(&newer_than))));
+	} else {
+		newer_than = 0;
+	}
+
+	if (ok && newer_than == 0) {
+		d_printf("Error setting newer-than time\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+set the archive level
+****************************************************************************/
+static int cmd_archive(void)
+{
+	fstring buf;
+
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		archive_level = atoi(buf);
+	} else
+		d_printf("Archive level is %d\n",archive_level);
+
+	return 0;
+}
+
+/****************************************************************************
+toggle the lowercaseflag
+****************************************************************************/
+static int cmd_lowercase(void)
+{
+	lowercase = !lowercase;
+	DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
+
+	return 0;
+}
+
+
+
+
+/****************************************************************************
+toggle the recurse flag
+****************************************************************************/
+static int cmd_recurse(void)
+{
+	recurse = !recurse;
+	DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
+
+	return 0;
+}
+
+/****************************************************************************
+toggle the translate flag
+****************************************************************************/
+static int cmd_translate(void)
+{
+	translation = !translation;
+	DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
+		 translation?"on":"off"));
+
+	return 0;
+}
+
+
+/****************************************************************************
+do a printmode command
+****************************************************************************/
+static int cmd_printmode(void)
+{
+	fstring buf;
+	fstring mode;
+
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		if (strequal(buf,"text")) {
+			printmode = 0;      
+		} else {
+			if (strequal(buf,"graphics"))
+				printmode = 1;
+			else
+				printmode = atoi(buf);
+		}
+	}
+
+	switch(printmode)
+		{
+		case 0: 
+			fstrcpy(mode,"text");
+			break;
+		case 1: 
+			fstrcpy(mode,"graphics");
+			break;
+		default: 
+			slprintf(mode,sizeof(mode)-1,"%d",printmode);
+			break;
+		}
+	
+	DEBUG(2,("the printmode is now %s\n",mode));
+
+	return 0;
+}
+
+/****************************************************************************
+ do the lcd command
+ ****************************************************************************/
+static int cmd_lcd(void)
+{
+	fstring buf;
+	pstring d;
+	
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
+		chdir(buf);
+	DEBUG(2,("the local directory is now %s\n",sys_getwd(d)));
+
+	return 0;
+}
+
+/****************************************************************************
+ get a file restarting at end of local file
+ ****************************************************************************/
+static int cmd_reget(void)
+{
+	pstring local_name;
+	pstring remote_name;
+	char *p;
+
+	pstrcpy(remote_name, cur_dir);
+	pstrcat(remote_name, "\\");
+	
+	p = remote_name + strlen(remote_name);
+	
+	if (!next_token_nr(NULL, p, NULL, sizeof(remote_name) - strlen(remote_name))) {
+		d_printf("reget <filename>\n");
+		return 1;
+	}
+	pstrcpy(local_name, p);
+	dos_clean_name(remote_name);
+	
+	next_token_nr(NULL, local_name, NULL, sizeof(local_name));
+	
+	return do_get(remote_name, local_name, True);
+}
+
+/****************************************************************************
+ put a file restarting at end of local file
+ ****************************************************************************/
+static int cmd_reput(void)
+{
+	pstring local_name;
+	pstring remote_name;
+	fstring buf;
+	char *p = buf;
+	SMB_STRUCT_STAT st;
+	
+	pstrcpy(remote_name, cur_dir);
+	pstrcat(remote_name, "\\");
+  
+	if (!next_token_nr(NULL, p, NULL, sizeof(buf))) {
+		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);
+	
+	dos_clean_name(remote_name);
+
+	return do_put(remote_name, local_name, True);
+}
+
+
+/****************************************************************************
+try and browse available connections on a host
+****************************************************************************/
+static BOOL browse_host(BOOL sort)
+{
+	d_printf("REWRITE: host browsing not implemented\n");
+
+	return False;
+}
+
+/****************************************************************************
+try and browse available connections on a host
+****************************************************************************/
+static BOOL list_servers(char *wk_grp)
+{
+	d_printf("REWRITE: list servers not implemented\n");
+	return False;
+}
+
+/* Some constants for completing filename arguments */
+
+#define COMPL_NONE        0          /* No completions */
+#define COMPL_REMOTE      1          /* Complete remote filename */
+#define COMPL_LOCAL       2          /* Complete local filename */
+
+/* This defines the commands supported by this client.
+ * NOTE: The "!" must be the last one in the list because it's fn pointer
+ *       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 */
+} commands[] = 
+{
+  {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
+  {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
+  {"allinfo",cmd_allinfo,"<file> show all possible info about a file",{COMPL_NONE,COMPL_NONE}},
+  {"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE,COMPL_NONE}},
+  {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
+  {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
+  {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
+  {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
+  {"deltree",cmd_deltree,"<dir> delete a whole directory tree",{COMPL_REMOTE,COMPL_NONE}},
+  {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
+  {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
+  {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
+  {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
+  {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
+  {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
+  {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
+  {"link",cmd_link,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},  
+  {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
+  {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
+  {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
+  {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
+  {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
+  {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},  
+  {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
+  {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
+  {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
+  {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
+  {"printmode",cmd_printmode,"<graphics or text> set the print mode",{COMPL_NONE,COMPL_NONE}},
+  {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},  
+  {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
+  {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
+  {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
+  {"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}},
+  {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
+  {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
+  {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},  
+  {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
+  {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
+  {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
+  {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
+  {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
+  {"symlink",cmd_symlink,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
+  {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
+  {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
+  
+  /* Yes, this must be here, see crh's comment above. */
+  {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
+  {NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}
+};
+
+
+/*******************************************************************
+  lookup a command string in the list of commands, including 
+  abbreviations
+  ******************************************************************/
+static int process_tok(fstring 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;
+			cmd = i;
+			break;
+		} else if (strnequal(commands[i].name, tok, tok_len)) {
+			matches++;
+			cmd = i;
+		}
+		i++;
+	}
+  
+	if (matches == 0)
+		return(-1);
+	else if (matches == 1)
+		return(cmd);
+	else
+		return(-2);
+}
+
+/****************************************************************************
+help
+****************************************************************************/
+static int cmd_help(void)
+{
+	int i=0,j;
+	fstring buf;
+	
+	if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+		if ((i = process_tok(buf)) >= 0)
+			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++) {
+				d_printf("%-15s",commands[i].name);
+				i++;
+			}
+			d_printf("\n");
+		}
+	}
+	return 0;
+}
+
+/****************************************************************************
+process a -c command string
+****************************************************************************/
+static int process_command_string(char *cmd)
+{
+	pstring line;
+	const char *ptr;
+	int rc = 0;
+
+	/* establish the connection if not already */
+	
+	if (!cli) {
+		cli = do_connect(desthost, service);
+		if (!cli)
+			return 0;
+	}
+	
+	while (cmd[0] != '\0')    {
+		char *p;
+		fstring tok;
+		int i;
+		
+		if ((p = strchr_m(cmd, ';')) == 0) {
+			strncpy(line, cmd, 999);
+			line[1000] = '\0';
+			cmd += strlen(cmd);
+		} else {
+			if (p - cmd > 999) p = cmd + 999;
+			strncpy(line, cmd, p - cmd);
+			line[p - cmd] = '\0';
+			cmd = p + 1;
+		}
+		
+		/* and get the first part of the command */
+		ptr = line;
+		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
+		
+		if ((i = process_tok(tok)) >= 0) {
+			rc = commands[i].fn();
+		} else if (i == -2) {
+			d_printf("%s: command abbreviation ambiguous\n",tok);
+		} else {
+			d_printf("%s: command not found\n",tok);
+		}
+	}
+	
+	return rc;
+}	
+
+#define MAX_COMPLETIONS 100
+
+typedef struct {
+	pstring dirmask;
+	char **matches;
+	int count, samelen;
+	const char *text;
+	int len;
+} completion_remote_t;
+
+static void completion_remote_filter(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->dirmask[0] == 0) && !(f->mode & FILE_ATTRIBUTE_DIRECTORY))
+			info->matches[info->count] = 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 & FILE_ATTRIBUTE_DIRECTORY)
+				pstrcat(tmp, "/");
+			info->matches[info->count] = strdup(tmp);
+		}
+		if (info->matches[info->count] == NULL)
+			return;
+		if (f->mode & FILE_ATTRIBUTE_DIRECTORY)
+			smb_readline_ca_char(0);
+
+		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)
+				info->samelen--;
+		info->count++;
+	}
+}
+
+static char **remote_completion(const char *text, int len)
+{
+	pstring dirmask;
+	int i;
+	completion_remote_t info = { "", NULL, 1, len, text, len };
+
+	if (len >= PATH_MAX)
+		return(NULL);
+
+	info.matches = (char **)malloc(sizeof(info.matches[0])*MAX_COMPLETIONS);
+	if (!info.matches) return NULL;
+	info.matches[0] = NULL;
+
+	for (i = len-1; i >= 0; i--)
+		if ((text[i] == '/') || (text[i] == '\\'))
+			break;
+	info.text = text+i+1;
+	info.samelen = info.len = len-i-1;
+
+	if (i > 0) {
+		strncpy(info.dirmask, text, i+1);
+		info.dirmask[i+1] = 0;
+		snprintf(dirmask, sizeof(dirmask), "%s%*s*", cur_dir, i-1, text);
+	} else
+		snprintf(dirmask, sizeof(dirmask), "%s*", cur_dir);
+
+	if (cli_list(cli, dirmask, 
+		     FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN, 
+		     completion_remote_filter, &info) < 0)
+		goto cleanup;
+
+	if (info.count == 2)
+		info.matches[0] = strdup(info.matches[1]);
+	else {
+		info.matches[0] = malloc(info.samelen+1);
+		if (!info.matches[0])
+			goto cleanup;
+		strncpy(info.matches[0], info.matches[1], info.samelen);
+		info.matches[0][info.samelen] = 0;
+	}
+	info.matches[info.count] = NULL;
+	return info.matches;
+
+cleanup:
+	for (i = 0; i < info.count; i++)
+		free(info.matches[i]);
+	free(info.matches);
+	return NULL;
+}
+
+static char **completion_fn(const char *text, int start, int end)
+{
+	smb_readline_ca_char(' ');
+
+	if (start) {
+		const char *buf, *sp;
+		int i;
+		char compl_type;
+
+		buf = smb_readline_get_line_buffer();
+		if (buf == NULL)
+			return NULL;
+		
+		sp = strchr(buf, ' ');
+		if (sp == NULL)
+			return NULL;
+		
+		for (i = 0; commands[i].name; i++)
+			if ((strncmp(commands[i].name, text, sp - buf) == 0) && (commands[i].name[sp - buf] == 0))
+				break;
+		if (commands[i].name == NULL)
+			return NULL;
+
+		while (*sp == ' ')
+			sp++;
+
+		if (sp == (buf + start))
+			compl_type = commands[i].compl_args[0];
+		else
+			compl_type = commands[i].compl_args[1];
+
+		if (compl_type == COMPL_REMOTE)
+			return remote_completion(text, end - start);
+		else /* fall back to local filename completion */
+			return NULL;
+	} else {
+		char **matches;
+		int i, len, samelen, count=1;
+
+		matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS);
+		if (!matches) return NULL;
+		matches[0] = NULL;
+
+		len = strlen(text);
+		for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
+			if (strncmp(text, commands[i].name, len) == 0) {
+				matches[count] = strdup(commands[i].name);
+				if (!matches[count])
+					goto cleanup;
+				if (count == 1)
+					samelen = strlen(matches[count]);
+				else
+					while (strncmp(matches[count], matches[count-1], samelen) != 0)
+						samelen--;
+				count++;
+			}
+		}
+
+		switch (count) {
+		case 0:	/* should never happen */
+		case 1:
+			goto cleanup;
+		case 2:
+			matches[0] = strdup(matches[1]);
+			break;
+		default:
+			matches[0] = malloc(samelen+1);
+			if (!matches[0])
+				goto cleanup;
+			strncpy(matches[0], matches[1], samelen);
+			matches[0][samelen] = 0;
+		}
+		matches[count] = NULL;
+		return matches;
+
+cleanup:
+		while (i >= 0) {
+			free(matches[i]);
+			i--;
+		}
+		free(matches);
+		return NULL;
+	}
+}
+
+/****************************************************************************
+make sure we swallow keepalives during idle time
+****************************************************************************/
+static void readline_callback(void)
+{
+	fd_set fds;
+	struct timeval timeout;
+	static time_t last_t;
+	time_t t;
+
+	t = time(NULL);
+
+	if (t - last_t < 5) return;
+
+	last_t = t;
+
+ again:
+	if (cli->transport->socket->fd == -1)
+		return;
+
+	FD_ZERO(&fds);
+	FD_SET(cli->transport->socket->fd, &fds);
+
+	timeout.tv_sec = 0;
+	timeout.tv_usec = 0;
+	sys_select_intr(cli->transport->socket->fd+1,&fds,NULL,NULL,&timeout);
+      		
+	/* We deliberately use cli_swallow_keepalives instead of
+	   client_receive_smb as we want to receive
+	   session keepalives and then drop them here.
+	*/
+	if (FD_ISSET(cli->transport->socket->fd, &fds)) {
+		if (!cli_request_receive_next(cli->transport)) {
+			d_printf("Lost connection to server\n");
+			exit(1);
+		}
+		goto again;
+	}
+
+	if (cli->tree) {
+		cli_chkpath(cli, "\\");
+	}
+}
+
+
+/****************************************************************************
+process commands on stdin
+****************************************************************************/
+static void process_stdin(void)
+{
+	const char *ptr;
+
+	while (1) {
+		fstring tok;
+		fstring the_prompt;
+		char *cline;
+		pstring line;
+		int i;
+		
+		/* display a prompt */
+		slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir);
+		cline = smb_readline(the_prompt, readline_callback, completion_fn);
+			
+		if (!cline) break;
+		
+		pstrcpy(line, cline);
+
+		/* special case - first char is ! */
+		if (*line == '!') {
+			system(line + 1);
+			continue;
+		}
+      
+		/* and get the first part of the command */
+		ptr = line;
+		if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
+
+		if ((i = process_tok(tok)) >= 0) {
+			commands[i].fn();
+		} else if (i == -2) {
+			d_printf("%s: command abbreviation ambiguous\n",tok);
+		} else {
+			d_printf("%s: command not found\n",tok);
+		}
+	}
+}
+
+
+/***************************************************** 
+return a connection to a server
+*******************************************************/
+static struct cli_state *do_connect(const char *server, const char *share)
+{
+	struct cli_state *c;
+	struct nmb_name called, calling;
+	const char *server_n;
+	struct in_addr ip;
+	fstring servicename;
+	char *sharename;
+	
+	/* make a copy so we don't modify the global string 'service' */
+	fstrcpy(servicename, share);
+	sharename = servicename;
+	if (*sharename == '\\') {
+		server = sharename+2;
+		sharename = strchr_m(server,'\\');
+		if (!sharename) return NULL;
+		*sharename = 0;
+		sharename++;
+	}
+
+	server_n = server;
+	
+	zero_ip(&ip);
+
+	make_nmb_name(&calling, lp_netbios_name(), 0x0);
+	make_nmb_name(&called , server, name_type);
+
+ again:
+	zero_ip(&ip);
+	if (have_ip) ip = dest_ip;
+
+	/* have to open a new connection */
+	if (!(c=cli_state_init()) || !cli_socket_connect(c, server_n, &ip)) {
+		d_printf("Connection to %s failed\n", server_n);
+		return NULL;
+	}
+
+	if (!cli_transport_establish(c, &calling, &called)) {
+		char *p;
+		d_printf("session request to %s failed (%s)\n", 
+			 called.name, cli_errstr(c));
+		cli_shutdown(c);
+		if ((p=strchr_m(called.name, '.'))) {
+			*p = 0;
+			goto again;
+		}
+		if (strcmp(called.name, "*SMBSERVER")) {
+			make_nmb_name(&called , "*SMBSERVER", 0x20);
+			goto again;
+		}
+		return NULL;
+	}
+
+	DEBUG(4,(" session request ok\n"));
+
+	if (!cli_negprot(c)) {
+		d_printf("protocol negotiation failed\n");
+		cli_shutdown(c);
+		return NULL;
+	}
+
+	if (!got_pass) {
+		const char *pass = getpass("Password: ");
+		if (pass) {
+			pstrcpy(password, pass);
+		}
+	}
+
+	if (!cli_session_setup(c, username, password, 
+			       lp_workgroup())) {
+		/* if a password was not supplied then try again with a null username */
+		if (password[0] || !username[0] || use_kerberos ||
+		    !cli_session_setup(c, "", "", lp_workgroup())) { 
+			d_printf("session setup failed: %s\n", cli_errstr(c));
+			cli_shutdown(c);
+			return NULL;
+		}
+		d_printf("Anonymous login successful\n");
+	}
+
+	DEBUG(4,(" session setup ok\n"));
+
+	if (!cli_send_tconX(c, sharename, "?????", password)) {
+		d_printf("tree connect failed: %s\n", cli_errstr(c));
+		cli_shutdown(c);
+		return NULL;
+	}
+
+	DEBUG(4,(" tconx ok\n"));
+
+	return c;
+}
+
+
+/****************************************************************************
+  process commands from the client
+****************************************************************************/
+static int process(char *base_directory)
+{
+	int rc = 0;
+
+	cli = do_connect(desthost, service);
+	if (!cli) {
+		return 1;
+	}
+
+	if (*base_directory) do_cd(base_directory);
+	
+	if (cmdstr) {
+		rc = process_command_string(cmdstr);
+	} else {
+		process_stdin();
+	}
+  
+	cli_shutdown(cli);
+	return rc;
+}
+
+/****************************************************************************
+handle a -L query
+****************************************************************************/
+static int do_host_query(char *query_host)
+{
+	cli = do_connect(query_host, "IPC$");
+	if (!cli)
+		return 1;
+
+	browse_host(True);
+	list_servers(lp_workgroup());
+
+	cli_shutdown(cli);
+	
+	return(0);
+}
+
+
+/****************************************************************************
+handle a tar operation
+****************************************************************************/
+static int do_tar_op(char *base_directory)
+{
+	int ret;
+
+	/* do we already have a connection? */
+	if (!cli) {
+		cli = do_connect(desthost, service);	
+		if (!cli)
+			return 1;
+	}
+
+	recurse=True;
+
+	if (*base_directory) do_cd(base_directory);
+	
+	ret=process_tar();
+
+	cli_shutdown(cli);
+
+	return(ret);
+}
+
+/****************************************************************************
+handle a message operation
+****************************************************************************/
+static int do_message_op(void)
+{
+	struct in_addr ip;
+	struct nmb_name called, calling;
+	fstring server_name;
+	char name_type_hex[10];
+
+	make_nmb_name(&calling, lp_netbios_name(), 0x0);
+	make_nmb_name(&called , desthost, name_type);
+
+	fstrcpy(server_name, desthost);
+	snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
+	fstrcat(server_name, name_type_hex);
+
+	zero_ip(&ip);
+	if (have_ip) ip = dest_ip;
+
+	if (!(cli=cli_state_init()) || !cli_socket_connect(cli, server_name, &ip)) {
+		d_printf("Connection to %s failed\n", desthost);
+		return 1;
+	}
+
+	if (!cli_transport_establish(cli, &calling, &called)) {
+		d_printf("session request failed\n");
+		cli_shutdown(cli);
+		return 1;
+	}
+
+	send_message();
+	cli_shutdown(cli);
+
+	return 0;
+}
+
+
+/**
+ * Process "-L hostname" option.
+ *
+ * We don't actually do anything yet -- we just stash the name in a
+ * global variable and do the query when all options have been read.
+ **/
+static void remember_query_host(const char *arg,
+				pstring query_host)
+{
+	char *slash;
+	
+	while (*arg == '\\' || *arg == '/')
+		arg++;
+	pstrcpy(query_host, arg);
+	if ((slash = strchr(query_host, '/'))
+	    || (slash = strchr(query_host, '\\'))) {
+		*slash = 0;
+	}
+}
+
+
+/****************************************************************************
+  main program
+****************************************************************************/
+ int main(int argc,char *argv[])
+{
+	fstring base_directory;
+	int opt;
+	pstring query_host;
+	BOOL message = False;
+	extern char tar_type;
+	pstring term_code;
+	poptContext pc;
+	char *p;
+	int rc = 0;
+	TALLOC_CTX *mem_ctx;
+	struct poptOption long_options[] = {
+		POPT_AUTOHELP
+
+		{ "name-resolve", 'R', POPT_ARG_STRING, NULL, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
+		{ "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },
+		{ "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },
+		{ "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },
+		{ "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },
+		{ "terminal", 't', POPT_ARG_STRING, NULL, 't', "Terminal I/O code {sjis|euc|jis7|jis8|junet|hex}", "CODE" },
+		{ "max-protocol", 'm', POPT_ARG_STRING, NULL, 'm', "Set the max protocol level", "LEVEL" },
+		{ "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },
+		{ "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
+		{ "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" }, 
+		{ "send-buffer", 'b', POPT_ARG_INT, NULL, 'b', "Changes the transmit/send buffer", "BYTES" },
+		{ "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
+		POPT_COMMON_SAMBA
+		POPT_COMMON_CONNECTION
+		POPT_COMMON_CREDENTIALS
+		POPT_TABLEEND
+	};
+	
+
+#ifdef KANJI
+	pstrcpy(term_code, KANJI);
+#else /* KANJI */
+	*term_code = 0;
+#endif /* KANJI */
+
+	*query_host = 0;
+	*base_directory = 0;
+
+	setup_logging(argv[0],True);
+	mem_ctx = talloc_init("client.c/main");
+	if (!mem_ctx) {
+		d_printf("\nclient.c: Not enough memory\n");
+		exit(1);
+	}
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
+			argv[0], dyn_CONFIGFILE);
+	}
+	
+	pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 
+				POPT_CONTEXT_KEEP_FIRST);
+	poptSetOtherOptionHelp(pc, "service <password>");
+
+	in_client = True;   /* Make sure that we tell lp_load we are */
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		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; 
+			pstrcpy(desthost,poptGetOptArg(pc));
+			if( 0 == port ) port = 139;
+ 			message = True;
+ 			break;
+		case 'I':
+			{
+				dest_ip = *interpret_addr2(mem_ctx, poptGetOptArg(pc));
+				if (is_zero_ip(dest_ip))
+					exit(1);
+				have_ip = True;
+			}
+			break;
+		case 'E':
+			setup_logging("client", DEBUG_STDERR);
+			break;
+
+		case 'L':
+			remember_query_host(poptGetOptArg(pc), query_host);
+			break;
+		case 't':
+			pstrcpy(term_code, poptGetOptArg(pc));
+			break;
+		case 'm':
+			lp_set_cmdline("max protocol", poptGetOptArg(pc));
+			break;
+		case 'R':
+			lp_set_cmdline("name resolve order", poptGetOptArg(pc));
+			break;
+		case 'T':
+			if (!tar_parseargs(argc, argv, poptGetOptArg(pc), optind)) {
+				poptPrintUsage(pc, stderr, 0);
+				exit(1);
+			}
+			break;
+		case 'D':
+			fstrcpy(base_directory,poptGetOptArg(pc));
+			break;
+		case 'b':
+			io_bufsize = MAX(1, atoi(poptGetOptArg(pc)));
+			break;
+		}
+	}
+
+	poptGetArg(pc);
+	
+	load_interfaces();
+
+	if(poptPeekArg(pc)) {
+		pstrcpy(service,poptGetArg(pc));  
+		/* Convert any '/' characters in the service name to '\' characters */
+		string_replace(service, '/','\\');
+
+		if (count_chars(service,'\\') < 3) {
+			d_printf("\n%s: Not enough '\\' characters in service\n",service);
+			poptPrintUsage(pc, stderr, 0);
+			exit(1);
+		}
+	}
+
+	if (poptPeekArg(pc)) { 
+		cmdline_auth_info.got_pass = True;
+		pstrcpy(cmdline_auth_info.password,poptGetArg(pc));  
+	}
+
+	//init_names();
+
+	if (!tar_type && !*query_host && !*service && !message) {
+		poptPrintUsage(pc, stderr, 0);
+		exit(1);
+	}
+
+	poptFreeContext(pc);
+
+	pstrcpy(username, cmdline_auth_info.username);
+	pstrcpy(password, cmdline_auth_info.password);
+	use_kerberos = cmdline_auth_info.use_kerberos;
+	got_pass = cmdline_auth_info.got_pass;
+
+	DEBUG( 3, ( "Client started (version %s).\n", SAMBA_VERSION ) );
+
+	talloc_destroy(mem_ctx);
+	if (tar_type) {
+		if (cmdstr)
+			process_command_string(cmdstr);
+		return do_tar_op(base_directory);
+	}
+
+	if ((p=strchr_m(query_host,'#'))) {
+		*p = 0;
+		p++;
+		sscanf(p, "%x", &name_type);
+	}
+  
+	if (*query_host) {
+		return do_host_query(query_host);
+	}
+
+	if (message) {
+		return do_message_op();
+	}
+	
+	if (process(base_directory)) {
+		return 1;
+	}
+
+	return rc;
+}
diff --git a/source4/client/clitar.c b/source4/client/clitar.c
new file mode 100644
index 0000000000..78f44da8ca
--- /dev/null
+++ b/source4/client/clitar.c
@@ -0,0 +1,1856 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Tar Extensions
+   Copyright (C) Ricky Poulten 1995-1998
+   Copyright (C) Richard Sharpe 1998
+   
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+/* The following changes developed by Richard Sharpe for Canon Information
+   Systems Research Australia (CISRA)
+
+   1. Restore can now restore files with long file names
+   2. Save now saves directory information so that we can restore 
+      directory creation times
+   3. tar now accepts both UNIX path names and DOS path names. I prefer
+      those lovely /'s to those UGLY \'s :-)
+   4. the files to exclude can be specified as a regular expression by adding
+      an r flag to the other tar flags. Eg:
+
+         -TcrX file.tar "*.(obj|exe)"
+
+      will skip all .obj and .exe files
+*/
+
+
+#include "includes.h"
+#include "clitar.h"
+#include "../client/client_proto.h"
+
+static int clipfind(char **aret, int ret, char *tok);
+void dos_clean_name(char *s);
+
+typedef struct file_info_struct file_info2;
+
+struct file_info_struct
+{
+  SMB_BIG_UINT size;
+  uint16 mode;
+  uid_t uid;
+  gid_t gid;
+  /* These times are normally kept in GMT */
+  time_t mtime;
+  time_t atime;
+  time_t ctime;
+  char *name;     /* This is dynamically allocate */
+
+  file_info2 *next, *prev;  /* Used in the stack ... */
+
+};
+
+typedef struct
+{
+  file_info2 *top;
+  int items;
+
+} stack;
+
+#define SEPARATORS " \t\n\r"
+extern struct cli_state *cli;
+
+/* These defines are for the do_setrattr routine, to indicate
+ * setting and reseting of file attributes in the function call */
+#define ATTRSET 1
+#define ATTRRESET 0
+
+static uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+
+#ifndef CLIENT_TIMEOUT
+#define CLIENT_TIMEOUT (30*1000)
+#endif
+
+static char *tarbuf, *buffer_p;
+static int tp, ntarf, tbufsiz;
+static double ttarf;
+/* Incremental mode */
+static BOOL tar_inc=False;
+/* Reset archive bit */
+static BOOL tar_reset=False;
+/* Include / exclude mode (true=include, false=exclude) */
+static BOOL tar_excl=True;
+/* use regular expressions for search on file names */
+static BOOL tar_re_search=False;
+#ifdef HAVE_REGEX_H
+regex_t *preg;
+#endif
+/* Do not dump anything, just calculate sizes */
+static BOOL dry_run=False;
+/* Dump files with System attribute */
+static BOOL tar_system=True;
+/* Dump files with Hidden attribute */
+static BOOL tar_hidden=True;
+/* Be noisy - make a catalogue */
+static BOOL tar_noisy=True;
+static BOOL tar_real_noisy=False;  /* Don't want to be really noisy by default */
+
+char tar_type='\0';
+static char **cliplist=NULL;
+static int clipn=0;
+static BOOL must_free_cliplist = False;
+
+extern file_info def_finfo;
+extern BOOL lowercase;
+extern uint16 cnum;
+extern BOOL readbraw_supported;
+extern int max_xmit;
+extern pstring cur_dir;
+extern int get_total_time_ms;
+extern int get_total_size;
+
+static int blocksize=20;
+static int tarhandle;
+
+static void writetarheader(int f,  const char *aname, SMB_BIG_UINT size, time_t mtime,
+			   const char *amode, unsigned char ftype);
+static void do_atar(char *rname,char *lname,file_info *finfo1);
+static void do_tar(file_info *finfo);
+static void oct_it(SMB_BIG_UINT value, int ndgs, char *p);
+static void fixtarname(char *tptr, const char *fp, int l);
+static int dotarbuf(int f, char *b, int n);
+static void dozerobuf(int f, int n);
+static void dotareof(int f);
+static void initarbuf(void);
+
+/* restore functions */
+static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix);
+static long unoct(char *p, int ndgs);
+static void do_tarput(void);
+static void unfixtarname(char *tptr, char *fp, int l, BOOL first);
+
+/*
+ * tar specific utitlities
+ */
+
+/*******************************************************************
+Create  a string of size size+1 (for the null)
+*******************************************************************/
+static char *string_create_s(int size)
+{
+  char *tmp;
+
+  tmp = (char *)malloc(size+1);
+
+  if (tmp == NULL) {
+
+    DEBUG(0, ("Out of memory in string_create_s\n"));
+
+  }
+
+  return(tmp);
+
+}
+
+/****************************************************************************
+Write a tar header to buffer
+****************************************************************************/
+static void writetarheader(int f, const char *aname, SMB_BIG_UINT size, time_t mtime,
+			   const char *amode, unsigned char ftype)
+{
+  union hblock hb;
+  int i, chk, l;
+  char *jp;
+
+  DEBUG(5, ("WriteTarHdr, Type = %c, Size= %.0f, Name = %s\n", ftype, (double)size, aname));
+
+  memset(hb.dummy, 0, sizeof(hb.dummy));
+  
+  l=strlen(aname);
+  if (l >= NAMSIZ - 1) {
+	  /* write a GNU tar style long header */
+	  char *b;
+	  b = (char *)malloc(l+TBLOCK+100);
+	  if (!b) {
+		  DEBUG(0,("out of memory\n"));
+		  exit(1);
+	  }
+	  writetarheader(f, "/./@LongLink", l+2, 0, "     0 \0", 'L');
+	  memset(b, 0, l+TBLOCK+100);
+	  fixtarname(b, aname, l);
+	  i = strlen(b)+1;
+	  DEBUG(5, ("File name in tar file: %s, size=%d, \n", b, (int)strlen(b)));
+	  dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
+	  SAFE_FREE(b);
+  }
+
+  /* use l + 1 to do the null too */
+  fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
+
+  if (lowercase)
+    strlower(hb.dbuf.name);
+
+  /* write out a "standard" tar format header */
+
+  hb.dbuf.name[NAMSIZ-1]='\0';
+  safe_strcpy(hb.dbuf.mode, amode, strlen(amode));
+  oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.uid);
+  oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.gid);
+  oct_it((SMB_BIG_UINT) size, 13, hb.dbuf.size);
+  oct_it((SMB_BIG_UINT) mtime, 13, hb.dbuf.mtime);
+  memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
+  memset(hb.dbuf.linkname, 0, NAMSIZ);
+  hb.dbuf.linkflag=ftype;
+  
+  for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
+
+  oct_it((SMB_BIG_UINT) chk, 8, hb.dbuf.chksum);
+  hb.dbuf.chksum[6] = '\0';
+
+  (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
+}
+
+/****************************************************************************
+Read a tar header into a hblock structure, and validate
+***************************************************************************/
+static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix)
+{
+  long chk, fchk;
+  int i;
+  char *jp;
+
+  /*
+   * read in a "standard" tar format header - we're not that interested
+   * in that many fields, though
+   */
+
+  /* check the checksum */
+  for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;) chk+=(0xFF & *jp++);
+
+  if (chk == 0)
+    return chk;
+
+  /* compensate for blanks in chksum header */
+  for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
+    chk-=(0xFF & *jp++);
+
+  chk += ' ' * sizeof(hb->dbuf.chksum);
+
+  fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
+
+  DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
+	    chk, fchk, hb->dbuf.chksum));
+
+  if (fchk != chk)
+    {
+      DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
+      dump_data(5, (char *)hb - TBLOCK, TBLOCK *3);
+      return -1;
+    }
+
+  if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
+
+    DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
+    return(-1);
+
+  }
+
+  safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);
+
+  /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
+  unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
+	       strlen(hb->dbuf.name) + 1, True);
+
+  /* can't handle some links at present */
+  if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
+    if (hb->dbuf.linkflag == 0) {
+      DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
+		finfo->name));
+    } else { 
+      if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
+         /* Do nothing here at the moment. do_tarput will handle this
+            as long as the longlink gets back to it, as it has to advance 
+            the buffer pointer, etc */
+
+      } else {
+        DEBUG(0, ("this tar file appears to contain some kind of link other than a GNUtar Longlink - ignoring\n"));
+        return -2;
+      }
+    }
+  }
+    
+  if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR)
+    || (*(finfo->name+strlen(finfo->name)-1) == '\\'))
+    {
+      finfo->mode=FILE_ATTRIBUTE_DIRECTORY;
+    }
+  else
+    finfo->mode=0; /* we don't care about mode at the moment, we'll
+		    * just make it a regular file */
+  /*
+   * Bug fix by richard@sj.co.uk
+   *
+   * REC: restore times correctly (as does tar)
+   * We only get the modification time of the file; set the creation time
+   * from the mod. time, and the access time to current time
+   */
+  finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
+  finfo->atime = time(NULL);
+  finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
+
+  return True;
+}
+
+/****************************************************************************
+Write out the tar buffer to tape or wherever
+****************************************************************************/
+static int dotarbuf(int f, char *b, int n)
+{
+  int fail=1, writ=n;
+
+  if (dry_run) {
+    return writ;
+  }
+  /* This routine and the next one should be the only ones that do write()s */
+  if (tp + n >= tbufsiz)
+    {
+      int diff;
+
+      diff=tbufsiz-tp;
+      memcpy(tarbuf + tp, b, diff);
+      fail=fail && (1+write(f, tarbuf, tbufsiz));
+      n-=diff;
+      b+=diff;
+      tp=0;
+
+      while (n >= tbufsiz)
+	{
+	  fail=fail && (1 + write(f, b, tbufsiz));
+	  n-=tbufsiz;
+	  b+=tbufsiz;
+	}
+    }
+  if (n>0) {
+    memcpy(tarbuf+tp, b, n);
+    tp+=n;
+  }
+
+  return(fail ? writ : 0);
+}
+
+/****************************************************************************
+Write zeros to buffer / tape
+****************************************************************************/
+static void dozerobuf(int f, int n)
+{
+  /* short routine just to write out n zeros to buffer -
+   * used to round files to nearest block
+   * and to do tar EOFs */
+
+  if (dry_run)
+    return;
+  
+  if (n+tp >= tbufsiz)
+    {
+      memset(tarbuf+tp, 0, tbufsiz-tp);
+
+      write(f, tarbuf, tbufsiz);
+      memset(tarbuf, 0, (tp+=n-tbufsiz));
+    }
+  else
+    {
+      memset(tarbuf+tp, 0, n);
+      tp+=n;
+    }
+}
+
+/****************************************************************************
+Malloc tape buffer
+****************************************************************************/
+static void initarbuf(void)
+{
+  /* initialize tar buffer */
+  tbufsiz=blocksize*TBLOCK;
+  tarbuf=malloc(tbufsiz);      /* FIXME: We might not get the buffer */
+
+  /* reset tar buffer pointer and tar file counter and total dumped */
+  tp=0; ntarf=0; ttarf=0;
+}
+
+/****************************************************************************
+Write two zero blocks at end of file
+****************************************************************************/
+static void dotareof(int f)
+{
+  SMB_STRUCT_STAT stbuf;
+  /* Two zero blocks at end of file, write out full buffer */
+
+  if (dry_run)
+    return;
+
+  (void) dozerobuf(f, TBLOCK);
+  (void) dozerobuf(f, TBLOCK);
+
+  if (sys_fstat(f, &stbuf) == -1)
+    {
+      DEBUG(0, ("Couldn't stat file handle\n"));
+      return;
+    }
+
+  /* Could be a pipe, in which case S_ISREG should fail,
+   * and we should write out at full size */
+  if (tp > 0) write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
+}
+
+/****************************************************************************
+(Un)mangle DOS pathname, make nonabsolute
+****************************************************************************/
+static void fixtarname(char *tptr, const char *fp, int l)
+{
+	/* add a '.' to start of file name, convert from ugly dos \'s in path
+	 * to lovely unix /'s :-} */
+	*tptr++='.';
+
+	safe_strcpy(tptr, fp, l);
+	string_replace(tptr, '\\', '/');
+}
+
+/****************************************************************************
+Convert from decimal to octal string
+****************************************************************************/
+static void oct_it (SMB_BIG_UINT value, int ndgs, char *p)
+{
+  /* Converts long to octal string, pads with leading zeros */
+
+  /* skip final null, but do final space */
+  --ndgs;
+  p[--ndgs] = ' ';
+ 
+  /* Loop does at least one digit */
+  do {
+      p[--ndgs] = '0' + (char) (value & 7);
+      value >>= 3;
+    }
+  while (ndgs > 0 && value != 0);
+ 
+  /* Do leading zeros */
+  while (ndgs > 0)
+    p[--ndgs] = '0';
+}
+
+/****************************************************************************
+Convert from octal string to long
+***************************************************************************/
+static long unoct(char *p, int ndgs)
+{
+  long value=0;
+  /* Converts octal string to long, ignoring any non-digit */
+
+  while (--ndgs)
+    {
+      if (isdigit((int)*p))
+        value = (value << 3) | (long) (*p - '0');
+
+      p++;
+    }
+
+  return value;
+}
+
+/****************************************************************************
+Compare two strings in a slash insensitive way, allowing s1 to match s2 
+if s1 is an "initial" string (up to directory marker).  Thus, if s2 is 
+a file in any subdirectory of s1, declare a match.
+***************************************************************************/
+static int strslashcmp(char *s1, char *s2)
+{
+  char *s1_0=s1;
+
+  while(*s1 && *s2 &&
+	(*s1 == *s2
+	 || tolower(*s1) == tolower(*s2)
+	 || (*s1 == '\\' && *s2=='/')
+	 || (*s1 == '/' && *s2=='\\'))) {
+	  s1++; s2++;
+  }
+
+  /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" 
+     string of s2.
+   */
+  if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0;
+
+  /* ignore trailing slash on s1 */
+  if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0;
+
+  /* check for s1 is an "initial" string of s2 */
+  if ((*s2 == '/' || *s2 == '\\') && !*s1) return 0;
+
+  return *s1-*s2;
+}
+
+
+/****************************************************************************
+Ensure a remote path exists (make if necessary)
+***************************************************************************/
+static BOOL ensurepath(char *fname)
+{
+  /* *must* be called with buffer ready malloc'ed */
+  /* ensures path exists */
+
+  char *partpath, *ffname;
+  char *p=fname, *basehack;
+
+  DEBUG(5, ( "Ensurepath called with: %s\n", fname));
+
+  partpath = string_create_s(strlen(fname));
+  ffname = string_create_s(strlen(fname));
+
+  if ((partpath == NULL) || (ffname == NULL)){
+
+    DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
+    return(False);
+
+  }
+
+  *partpath = 0;
+
+  /* fname copied to ffname so can strtok */
+
+  safe_strcpy(ffname, fname, strlen(fname));
+
+  /* do a `basename' on ffname, so don't try and make file name directory */
+  if ((basehack=strrchr_m(ffname, '\\')) == NULL)
+    return True;
+  else
+    *basehack='\0';
+
+  p=strtok(ffname, "\\");
+
+  while (p)
+    {
+      safe_strcat(partpath, p, strlen(fname) + 1);
+
+      if (!cli_chkpath(cli, partpath)) {
+	if (!cli_mkdir(cli, partpath))
+	  {
+	    DEBUG(0, ("Error mkdirhiering\n"));
+	    return False;
+	  }
+	else
+	  DEBUG(3, ("mkdirhiering %s\n", partpath));
+
+      }
+
+      safe_strcat(partpath, "\\", strlen(fname) + 1);
+      p = strtok(NULL,"/\\");
+    }
+
+    return True;
+}
+
+static int padit(char *buf, int bufsize, int padsize)
+{
+	int berr= 0;
+	int bytestowrite;
+  
+	DEBUG(5, ("Padding with %d zeros\n", padsize));
+	memset(buf, 0, bufsize);
+	while( !berr && padsize > 0 ) {
+		bytestowrite= MIN(bufsize, padsize);
+		berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
+		padsize -= bytestowrite;
+	}
+  
+	return berr;
+}
+
+
+static void do_setrattr(char *name, uint16 attr, int set)
+{
+	uint16 oldattr;
+
+	if (!cli_getatr(cli, name, &oldattr, NULL, NULL)) return;
+
+	if (set == ATTRSET) {
+		attr |= oldattr;
+	} else {
+		attr = oldattr & ~attr;
+	}
+
+	if (!cli_setatr(cli, name, attr, 0)) {
+		DEBUG(1,("setatr failed: %s\n", cli_errstr(cli)));
+	}
+}
+
+
+/****************************************************************************
+append one remote file to the tar file
+***************************************************************************/
+static void do_atar(char *rname,char *lname,file_info *finfo1)
+{
+  int fnum;
+  SMB_BIG_UINT nread=0;
+  char ftype;
+  file_info2 finfo;
+  BOOL close_done = False;
+  BOOL shallitime=True;
+  char data[65520];
+  int read_size = 65520;
+  int datalen=0;
+
+  struct timeval tp_start;
+  GetTimeOfDay(&tp_start);
+
+  ftype = '0'; /* An ordinary file ... */
+
+  if (finfo1) {
+    finfo.size  = finfo1 -> size;
+    finfo.mode  = finfo1 -> mode;
+    finfo.uid   = finfo1 -> uid;
+    finfo.gid   = finfo1 -> gid;
+    finfo.mtime = finfo1 -> mtime;
+    finfo.atime = finfo1 -> atime;
+    finfo.ctime = finfo1 -> ctime;
+    finfo.name  = finfo1 -> name;
+  }
+  else {
+    finfo.size  = def_finfo.size;
+    finfo.mode  = def_finfo.mode;
+    finfo.uid   = def_finfo.uid;
+    finfo.gid   = def_finfo.gid;
+    finfo.mtime = def_finfo.mtime;
+    finfo.atime = def_finfo.atime;
+    finfo.ctime = def_finfo.ctime;
+    finfo.name  = def_finfo.name;
+  }
+
+  if (dry_run)
+    {
+      DEBUG(3,("skipping file %s of size %12.0f bytes\n",
+	       finfo.name,
+	       (double)finfo.size));
+      shallitime=0;
+      ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
+      ntarf++;
+      return;
+    }
+
+  fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE);
+
+  dos_clean_name(rname);
+
+  if (fnum == -1) {
+	  DEBUG(0,("%s opening remote file %s (%s)\n",
+		   cli_errstr(cli),rname, cur_dir));
+	  return;
+  }
+
+  finfo.name = string_create_s(strlen(rname));
+  if (finfo.name == NULL) {
+	  DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
+	  return;
+  }
+
+  safe_strcpy(finfo.name,rname, strlen(rname));
+  if (!finfo1) {
+	  size_t size;
+	  if (!cli_getattrE(cli, fnum, &finfo.mode, &size, NULL, &finfo.atime, &finfo.mtime)) {
+		  DEBUG(0, ("getattrE: %s\n", cli_errstr(cli)));
+		  return;
+	  }
+	  finfo.size = size;
+	  finfo.ctime = finfo.mtime;
+  }
+
+  DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
+
+  if (tar_inc && !(finfo.mode & FILE_ATTRIBUTE_ARCHIVE))
+    {
+      DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
+      shallitime=0;
+    }
+  else if (!tar_system && (finfo.mode & FILE_ATTRIBUTE_SYSTEM))
+    {
+      DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
+      shallitime=0;
+    }
+  else if (!tar_hidden && (finfo.mode & FILE_ATTRIBUTE_HIDDEN))
+    {
+      DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
+      shallitime=0;
+    }
+  else
+    {
+      DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s",
+	       finfo.name,
+	       (double)finfo.size,
+	       lname));
+      
+      /* write a tar header, don't bother with mode - just set to 100644 */
+      writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype);
+
+      while (nread < finfo.size && !close_done)	{
+	      
+	      DEBUG(3,("nread=%.0f\n",(double)nread));
+	      
+	      datalen = cli_read(cli, fnum, data, nread, read_size);
+	      
+	      if (datalen == -1) {
+		      DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
+		      break;
+	      }
+	      
+		  nread += datalen;
+
+		  /* if file size has increased since we made file size query, truncate
+			read so tar header for this file will be correct.
+		   */
+
+		  if (nread > finfo.size) {
+			datalen -= nread - finfo.size;
+			DEBUG(0,("File size change - truncating %s to %.0f bytes\n", finfo.name, (double)finfo.size));
+		  }
+
+	      /* add received bits of file to buffer - dotarbuf will
+	       * write out in 512 byte intervals */
+	      if (dotarbuf(tarhandle,data,datalen) != datalen) {
+		      DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
+		      break;
+	      }
+	      
+	      if (datalen == 0) {
+		      DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
+		      break;
+	      }
+
+	      datalen=0;
+      }
+
+      /* pad tar file with zero's if we couldn't get entire file */
+      if (nread < finfo.size) {
+	      DEBUG(0, ("Didn't get entire file. size=%.0f, nread=%d\n", (double)finfo.size, (int)nread));
+	      if (padit(data, sizeof(data), finfo.size - nread))
+		      DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
+      }
+
+      /* round tar file to nearest block */
+      if (finfo.size % TBLOCK)
+	dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
+      
+      ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
+      ntarf++;
+    }
+  
+  cli_close(cli, fnum);
+
+  if (shallitime)
+    {
+      struct timeval tp_end;
+      int this_time;
+
+      /* if shallitime is true then we didn't skip */
+      if (tar_reset && !dry_run)
+	(void) do_setrattr(finfo.name, FILE_ATTRIBUTE_ARCHIVE, ATTRRESET);
+      
+      GetTimeOfDay(&tp_end);
+      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 += finfo.size;
+
+      if (tar_noisy)
+	{
+	  DEBUG(0, ("%12.0f (%7.1f kb/s) %s\n",
+	       (double)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
+               finfo.name));
+	}
+
+      /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
+      DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
+	       finfo.size / MAX(0.001, (1.024*this_time)),
+	       get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
+    }
+}
+
+/****************************************************************************
+Append single file to tar file (or not)
+***************************************************************************/
+static void do_tar(file_info *finfo)
+{
+  pstring rname;
+
+  if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
+    return;
+
+  /* Is it on the exclude list ? */
+  if (!tar_excl && clipn) {
+    pstring exclaim;
+
+    DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(cur_dir)));
+
+    safe_strcpy(exclaim, cur_dir, sizeof(pstring));
+    *(exclaim+strlen(exclaim)-1)='\0';
+
+    safe_strcat(exclaim, "\\", sizeof(pstring));
+    safe_strcat(exclaim, finfo->name, sizeof(exclaim));
+
+    DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
+
+    if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
+#ifdef HAVE_REGEX_H
+	(tar_re_search && !regexec(preg, exclaim, 0, NULL, 0))) {
+#else
+        (tar_re_search && mask_match(cli, exclaim, cliplist[0], True))) {
+#endif
+      DEBUG(3,("Skipping file %s\n", exclaim));
+      return;
+    }
+  }
+
+  if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY)
+    {
+      pstring saved_curdir;
+      pstring mtar_mask;
+
+      safe_strcpy(saved_curdir, cur_dir, sizeof(saved_curdir));
+
+      DEBUG(5, ("Sizeof(cur_dir)=%d, strlen(cur_dir)=%d, strlen(finfo->name)=%d\nname=%s,cur_dir=%s\n", (int)sizeof(cur_dir), (int)strlen(cur_dir), (int)strlen(finfo->name), finfo->name, cur_dir));
+
+      safe_strcat(cur_dir,finfo->name, sizeof(cur_dir));
+      safe_strcat(cur_dir,"\\", sizeof(cur_dir));
+
+      DEBUG(5, ("Writing a dir, Name = %s\n", cur_dir));
+
+      /* write a tar directory, don't bother with mode - just set it to
+       * 40755 */
+      writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0", '5');
+      if (tar_noisy) {
+          DEBUG(0,("                directory %s\n", cur_dir));
+      }
+      ntarf++;  /* Make sure we have a file on there */
+      safe_strcpy(mtar_mask,cur_dir, sizeof(pstring));
+      safe_strcat(mtar_mask,"*", sizeof(pstring));
+      DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
+      do_list(mtar_mask, attribute, do_tar, False, True);
+      safe_strcpy(cur_dir,saved_curdir, sizeof(pstring));
+    }
+  else
+    {
+      safe_strcpy(rname,cur_dir, sizeof(pstring));
+      safe_strcat(rname,finfo->name, sizeof(pstring));
+      do_atar(rname,finfo->name,finfo);
+    }
+}
+
+/****************************************************************************
+Convert from UNIX to DOS file names
+***************************************************************************/
+static void unfixtarname(char *tptr, char *fp, int l, BOOL first)
+{
+	/* remove '.' from start of file name, convert from unix /'s to
+	 * dos \'s in path. Kill any absolute path names. But only if first!
+	 */
+
+	DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
+
+	if (first) {
+		if (*fp == '.') {
+			fp++;
+			l--;
+		}
+		if (*fp == '\\' || *fp == '/') {
+			fp++;
+			l--;
+		}
+	}
+
+	safe_strcpy(tptr, fp, l);
+	string_replace(tptr, '/', '\\');
+}
+
+
+/****************************************************************************
+Move to the next block in the buffer, which may mean read in another set of
+blocks. FIXME, we should allow more than one block to be skipped.
+****************************************************************************/
+static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
+{
+  int bufread, total = 0;
+
+  DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp));
+  *bufferp += TBLOCK;
+  total = TBLOCK;
+
+  if (*bufferp >= (ltarbuf + bufsiz)) {
+
+    DEBUG(5, ("Reading more data into ltarbuf ...\n"));
+
+    /*
+     * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>
+     * Fixes bug where read can return short if coming from
+     * a pipe.
+     */
+
+    bufread = read(tarhandle, ltarbuf, bufsiz);
+    total = bufread;
+
+    while (total < bufsiz) {
+      if (bufread < 0) { /* An error, return false */
+        return (total > 0 ? -2 : bufread);
+      }
+      if (bufread == 0) {
+        if (total <= 0) {
+            return -2;
+        }
+        break;
+      }
+      bufread = read(tarhandle, &ltarbuf[total], bufsiz - total);
+      total += bufread;
+    }
+
+    DEBUG(5, ("Total bytes read ... %i\n", total));
+
+    *bufferp = ltarbuf;
+
+  }
+
+  return(total);
+
+}
+
+/* Skip a file, even if it includes a long file name? */
+static int skip_file(int skipsize)
+{
+  int dsize = skipsize;
+
+  DEBUG(5, ("Skiping file. Size = %i\n", skipsize));
+
+  /* FIXME, we should skip more than one block at a time */
+
+  while (dsize > 0) {
+
+    if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
+
+	DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
+	return(False);
+
+    }
+
+    dsize -= TBLOCK;
+
+  }
+
+  return(True);
+}
+
+/*************************************************************
+ Get a file from the tar file and store it.
+ When this is called, tarbuf already contains the first
+ file block. This is a bit broken & needs fixing.
+**************************************************************/
+
+static int get_file(file_info2 finfo)
+{
+  int fnum = -1, pos = 0, dsize = 0, rsize = 0, bpos = 0;
+
+  DEBUG(5, ("get_file: file: %s, size %i\n", finfo.name, (int)finfo.size));
+
+  if (ensurepath(finfo.name) && 
+      (fnum=cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) == -1) {
+      DEBUG(0, ("abandoning restore\n"));
+      return(False);
+  }
+
+  /* read the blocks from the tar file and write to the remote file */
+
+  rsize = finfo.size;  /* This is how much to write */
+
+  while (rsize > 0) {
+
+    /* We can only write up to the end of the buffer */
+
+    dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */
+    dsize = MIN(dsize, rsize);  /* Should be only what is left */
+    DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));
+
+    if (cli_write(cli, fnum, 0, buffer_p + bpos, pos, dsize) != dsize) {
+	    DEBUG(0, ("Error writing remote file\n"));
+	    return 0;
+    }
+
+    rsize -= dsize;
+    pos += dsize;
+
+    /* Now figure out how much to move in the buffer */
+
+    /* FIXME, we should skip more than one block at a time */
+
+    /* First, skip any initial part of the part written that is left over */
+    /* from the end of the first TBLOCK                                   */
+
+    if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
+
+      dsize -= (TBLOCK - bpos);  /* Get rid of the end of the first block */
+      bpos = 0;
+
+      if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {  /* and skip the block */
+	DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
+	return False;
+
+      }
+
+    }
+
+    /*
+     * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>.
+     * If the file being extracted is an exact multiple of
+     * TBLOCK bytes then we don't want to extract the next
+     * block from the tarfile here, as it will be done in
+     * the caller of get_file().
+     */
+
+    while (((rsize != 0) && (dsize >= TBLOCK)) ||
+         ((rsize == 0) && (dsize > TBLOCK))) {
+
+      if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
+	DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
+	return False;
+      }
+
+      dsize -= TBLOCK;
+    }
+
+    bpos = dsize;
+
+  }
+
+  /* Now close the file ... */
+
+  if (!cli_close(cli, fnum)) {
+	  DEBUG(0, ("Error closing remote file\n"));
+	  return(False);
+  }
+
+  /* Now we update the creation date ... */
+
+  DEBUG(5, ("Updating creation date on %s\n", finfo.name));
+
+  if (!cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime)) {
+	  if (tar_real_noisy) {
+		  DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
+		  /*return(False); */ /* Ignore, as Win95 does not allow changes */
+	  }
+  }
+
+  ntarf++;
+
+  DEBUG(0, ("restore tar file %s of size %d bytes\n", finfo.name, (int)finfo.size));
+  
+  return(True);
+}
+
+/* Create a directory.  We just ensure that the path exists and return as there
+   is no file associated with a directory 
+*/
+static int get_dir(file_info2 finfo)
+{
+
+  DEBUG(0, ("restore directory %s\n", finfo.name));
+
+  if (!ensurepath(finfo.name)) {
+
+    DEBUG(0, ("Problems creating directory\n"));
+    return(False);
+
+  }
+
+  ntarf++;
+  return(True);
+
+}
+/* Get a file with a long file name ... first file has file name, next file 
+   has the data. We only want the long file name, as the loop in do_tarput
+   will deal with the rest.
+*/
+static char * get_longfilename(file_info2 finfo)
+{
+  int namesize = finfo.size + strlen(cur_dir) + 2;
+  char *longname = malloc(namesize);
+  int offset = 0, left = finfo.size;
+  BOOL first = True;
+
+  DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
+  DEBUG(5, ("Len = %d\n", (int)finfo.size));
+
+  if (longname == NULL) {
+
+    DEBUG(0, ("could not allocate buffer of size %d for longname\n", 
+	      (int)(finfo.size + strlen(cur_dir) + 2)));
+    return(NULL);
+  }
+
+  /* First, add cur_dir to the long file name */
+
+  if (strlen(cur_dir) > 0) {
+    strncpy(longname, cur_dir, namesize);
+    offset = strlen(cur_dir);
+  }
+
+  /* Loop through the blocks picking up the name */
+
+  while (left > 0) {
+
+    if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
+
+      DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
+      return(NULL);
+
+    }
+
+    unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--);
+    DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
+
+    offset += TBLOCK;
+    left -= TBLOCK;
+
+  }
+
+  return(longname);
+
+}
+
+static void do_tarput(void)
+{
+  file_info2 finfo;
+  struct timeval tp_start;
+  char *longfilename = NULL, linkflag;
+  int skip = False;
+
+  GetTimeOfDay(&tp_start);
+
+  DEBUG(5, ("RJS do_tarput called ...\n"));
+
+  buffer_p = tarbuf + tbufsiz;  /* init this to force first read */
+
+  /* Now read through those files ... */
+
+  while (True) {
+
+    /* Get us to the next block, or the first block first time around */
+
+    if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
+
+      DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
+
+      return;
+
+    }
+
+    DEBUG(5, ("Reading the next header ...\n"));
+
+    switch (readtarheader((union hblock *) buffer_p, &finfo, cur_dir)) {
+
+    case -2:    /* Hmm, not good, but not fatal */
+      DEBUG(0, ("Skipping %s...\n", finfo.name));
+      if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) &&
+          !skip_file(finfo.size)) {
+
+	DEBUG(0, ("Short file, bailing out...\n"));
+	return;
+
+      }
+
+      break;
+
+    case -1:
+      DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
+      return;
+
+    case 0: /* chksum is zero - looks like an EOF */
+      DEBUG(0, ("tar: restored %d files and directories\n", ntarf));
+      return;        /* Hmmm, bad here ... */
+
+    default: 
+      /* No action */
+
+      break;
+
+    }
+
+    /* Now, do we have a long file name? */
+
+    if (longfilename != NULL) {
+
+      SAFE_FREE(finfo.name);   /* Free the space already allocated */
+      finfo.name = longfilename;
+      longfilename = NULL;
+
+    }
+
+    /* Well, now we have a header, process the file ...            */
+
+    /* Should we skip the file? We have the long name as well here */
+
+    skip = clipn &&
+      ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl)
+#ifdef HAVE_REGEX_H
+      || (tar_re_search && !regexec(preg, finfo.name, 0, NULL, 0)));
+#else
+      || (tar_re_search && mask_match(cli, finfo.name, cliplist[0], True)));
+#endif
+
+  DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
+
+  if (skip) {
+
+    skip_file(finfo.size);
+    continue;
+
+  }
+
+    /* We only get this far if we should process the file */
+  linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag;
+
+    switch (linkflag) {
+
+    case '0':  /* Should use symbolic names--FIXME */
+
+      /* 
+       * Skip to the next block first, so we can get the file, FIXME, should
+       * be in get_file ...
+       * The 'finfo.size != 0' fix is from Bob Boehmer <boehmer@worldnet.att.net>
+       * Fixes bug where file size in tarfile is zero.
+       */
+
+      if ((finfo.size != 0) && next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
+	DEBUG(0, ("Short file, bailing out...\n"));
+	return;
+      }
+      if (!get_file(finfo)) {
+	DEBUG(0, ("Abandoning restore\n"));
+	return;
+
+      }
+      break;
+
+    case '5':
+      if (!get_dir(finfo)) {
+	DEBUG(0, ("Abandoning restore \n"));
+	return;
+      }
+      break;
+
+    case 'L':
+      longfilename = get_longfilename(finfo);
+      if (!longfilename) {
+	DEBUG(0, ("abandoning restore\n"));
+	return;
+
+      }
+      DEBUG(5, ("Long file name: %s\n", longfilename));
+      break;
+
+    default:
+      skip_file(finfo.size);  /* Don't handle these yet */
+      break;
+
+    }
+
+  }
+
+
+}
+
+
+/*
+ * samba interactive commands
+ */
+
+/****************************************************************************
+Blocksize command
+***************************************************************************/
+int cmd_block(void)
+{
+  fstring buf;
+  int block;
+
+  if (!next_token_nr(NULL,buf,NULL,sizeof(buf)))
+    {
+      DEBUG(0, ("blocksize <n>\n"));
+      return 1;
+    }
+
+  block=atoi(buf);
+  if (block < 0 || block > 65535)
+    {
+      DEBUG(0, ("blocksize out of range"));
+      return 1;
+    }
+
+  blocksize=block;
+  DEBUG(2,("blocksize is now %d\n", blocksize));
+
+  return 0;
+}
+
+/****************************************************************************
+command to set incremental / reset mode
+***************************************************************************/
+int cmd_tarmode(void)
+{
+  fstring buf;
+
+  while (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+    if (strequal(buf, "full"))
+      tar_inc=False;
+    else if (strequal(buf, "inc"))
+      tar_inc=True;
+    else if (strequal(buf, "reset"))
+      tar_reset=True;
+    else if (strequal(buf, "noreset"))
+      tar_reset=False;
+    else if (strequal(buf, "system"))
+      tar_system=True;
+    else if (strequal(buf, "nosystem"))
+      tar_system=False;
+    else if (strequal(buf, "hidden"))
+      tar_hidden=True;
+    else if (strequal(buf, "nohidden"))
+      tar_hidden=False;
+    else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
+      tar_noisy=True;
+    else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
+      tar_noisy=False;
+    else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
+  }
+
+  DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
+	    tar_inc ? "incremental" : "full",
+	    tar_system ? "system" : "nosystem",
+	    tar_hidden ? "hidden" : "nohidden",
+	    tar_reset ? "reset" : "noreset",
+	    tar_noisy ? "verbose" : "quiet"));
+
+  return 0;
+}
+
+/****************************************************************************
+Feeble attrib command
+***************************************************************************/
+int cmd_setmode(void)
+{
+  char *q;
+  fstring buf;
+  pstring fname;
+  uint16 attra[2];
+  int direct=1;
+
+  attra[0] = attra[1] = 0;
+
+  if (!next_token_nr(NULL,buf,NULL,sizeof(buf)))
+    {
+      DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
+      return 1;
+    }
+
+  safe_strcpy(fname, cur_dir, sizeof(pstring));
+  safe_strcat(fname, buf, sizeof(pstring));
+
+  while (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
+    q=buf;
+
+    while(*q)
+      switch (*q++) {
+      case '+': direct=1;
+	break;
+      case '-': direct=0;
+	break;
+      case 'r': attra[direct]|=FILE_ATTRIBUTE_READONLY;
+	break;
+      case 'h': attra[direct]|=FILE_ATTRIBUTE_HIDDEN;
+	break;
+      case 's': attra[direct]|=FILE_ATTRIBUTE_SYSTEM;
+	break;
+      case 'a': attra[direct]|=FILE_ATTRIBUTE_ARCHIVE;
+	break;
+      default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
+	return 1;
+      }
+  }
+
+  if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
+    {
+      DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
+      return 1;
+    }
+
+  DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
+  do_setrattr(fname, attra[ATTRSET], ATTRSET);
+  do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
+
+  return 0;
+}
+
+/****************************************************************************
+Principal command for creating / extracting
+***************************************************************************/
+int cmd_tar(void)
+{
+  fstring buf;
+  char **argl;
+  int argcl;
+
+  if (!next_token_nr(NULL,buf,NULL,sizeof(buf)))
+    {
+      DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
+      return 1;
+    }
+
+  argl=toktocliplist(&argcl, NULL);
+  if (!tar_parseargs(argcl, argl, buf, 0))
+    return 1;
+
+  process_tar();
+
+  SAFE_FREE(argl);
+
+  return 0;
+}
+
+/****************************************************************************
+Command line (option) version
+***************************************************************************/
+int process_tar(void)
+{
+  initarbuf();
+  switch(tar_type) {
+  case 'x':
+
+#if 0
+    do_tarput2();
+#else
+    do_tarput();
+#endif
+    SAFE_FREE(tarbuf);
+    close(tarhandle);
+    break;
+  case 'r':
+  case 'c':
+    if (clipn && tar_excl) {
+      int i;
+      pstring tarmac;
+
+      for (i=0; i<clipn; i++) {
+	DEBUG(5,("arg %d = %s\n", i, cliplist[i]));
+
+	if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
+	  *(cliplist[i]+strlen(cliplist[i])-1)='\0';
+	}
+	
+	if (strrchr_m(cliplist[i], '\\')) {
+	  pstring saved_dir;
+	  
+	  safe_strcpy(saved_dir, cur_dir, sizeof(pstring));
+	  
+	  if (*cliplist[i]=='\\') {
+	    safe_strcpy(tarmac, cliplist[i], sizeof(pstring));
+	  } else {
+	    safe_strcpy(tarmac, cur_dir, sizeof(pstring));
+	    safe_strcat(tarmac, cliplist[i], sizeof(pstring));
+	  }
+	  safe_strcpy(cur_dir, tarmac, sizeof(pstring));
+	  *(strrchr_m(cur_dir, '\\')+1)='\0';
+
+	  DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
+	  do_list(tarmac,attribute,do_tar, False, True);
+	  safe_strcpy(cur_dir,saved_dir, sizeof(pstring));
+	} else {
+	  safe_strcpy(tarmac, cur_dir, sizeof(pstring));
+	  safe_strcat(tarmac, cliplist[i], sizeof(pstring));
+	  DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
+	  do_list(tarmac,attribute,do_tar, False, True);
+	}
+      }
+    } else {
+      pstring mask;
+      safe_strcpy(mask,cur_dir, sizeof(pstring));
+      DEBUG(5, ("process_tar, do_list with mask: %s\n", mask));
+      safe_strcat(mask,"\\*", sizeof(pstring));
+      do_list(mask,attribute,do_tar,False, True);
+    }
+    
+    if (ntarf) dotareof(tarhandle);
+    close(tarhandle);
+    SAFE_FREE(tarbuf);
+    
+    DEBUG(0, ("tar: dumped %d files and directories\n", ntarf));
+    DEBUG(0, ("Total bytes written: %.0f\n", (double)ttarf));
+    break;
+  }
+
+  if (must_free_cliplist) {
+    int i;
+    for (i = 0; i < clipn; ++i) {
+      SAFE_FREE(cliplist[i]);
+    }
+    SAFE_FREE(cliplist);
+    cliplist = NULL;
+    clipn = 0;
+    must_free_cliplist = False;
+  }
+
+  return(0);
+}
+
+/****************************************************************************
+Find a token (filename) in a clip list
+***************************************************************************/
+static int clipfind(char **aret, int ret, char *tok)
+{
+  if (aret==NULL) return 0;
+
+  /* ignore leading slashes or dots in token */
+  while(strchr_m("/\\.", *tok)) tok++;
+
+  while(ret--) {
+    char *pkey=*aret++;
+
+    /* ignore leading slashes or dots in list */
+    while(strchr_m("/\\.", *pkey)) pkey++;
+
+    if (!strslashcmp(pkey, tok)) return 1;
+  }
+
+  return 0;
+}
+
+/****************************************************************************
+Read list of files to include from the file and initialize cliplist
+accordingly.
+***************************************************************************/
+static int read_inclusion_file(char *filename)
+{
+  XFILE *inclusion = NULL;
+  char buf[MAXPATHLEN + 1];
+  char *inclusion_buffer = NULL;
+  int inclusion_buffer_size = 0;
+  int inclusion_buffer_sofar = 0;
+  char *p;
+  char *tmpstr;
+  int i;
+  int error = 0;
+
+  clipn = 0;
+  buf[MAXPATHLEN] = '\0'; /* guarantee null-termination */
+  if ((inclusion = x_fopen(filename, O_RDONLY, 0)) == NULL) {
+    /* XXX It would be better to include a reason for failure, but without
+     * autoconf, it's hard to use strerror, sys_errlist, etc.
+     */
+    DEBUG(0,("Unable to open inclusion file %s\n", filename));
+    return 0;
+  }
+
+  while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) {
+    if (inclusion_buffer == NULL) {
+      inclusion_buffer_size = 1024;
+      if ((inclusion_buffer = malloc(inclusion_buffer_size)) == NULL) {
+	DEBUG(0,("failure allocating buffer to read inclusion file\n"));
+	error = 1;
+	break;
+      }
+    }
+    
+    if (buf[strlen(buf)-1] == '\n') {
+      buf[strlen(buf)-1] = '\0';
+    }
+    
+    if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
+      char *ib;
+      inclusion_buffer_size *= 2;
+      ib = Realloc(inclusion_buffer,inclusion_buffer_size);
+      if (! ib) {
+	DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
+		 inclusion_buffer_size));
+	error = 1;
+	break;
+      }
+      else inclusion_buffer = ib;
+    }
+    
+    safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
+    inclusion_buffer_sofar += strlen(buf) + 1;
+    clipn++;
+  }
+  x_fclose(inclusion);
+
+  if (! error) {
+    /* Allocate an array of clipn + 1 char*'s for cliplist */
+    cliplist = malloc((clipn + 1) * sizeof(char *));
+    if (cliplist == NULL) {
+      DEBUG(0,("failure allocating memory for cliplist\n"));
+      error = 1;
+    } else {
+      cliplist[clipn] = NULL;
+      p = inclusion_buffer;
+      for (i = 0; (! error) && (i < clipn); i++) {
+	/* set current item to NULL so array will be null-terminated even if
+	 * malloc fails below. */
+	cliplist[i] = NULL;
+	if ((tmpstr = (char *)malloc(strlen(p)+1)) == NULL) {
+	  DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
+	  error = 1;
+	} else {
+	  unfixtarname(tmpstr, p, strlen(p) + 1, True);
+	  cliplist[i] = tmpstr;
+	  if ((p = strchr_m(p, '\000')) == NULL) {
+	    DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
+	    abort();
+	  }
+	}
+	++p;
+      }
+      must_free_cliplist = True;
+    }
+  }
+
+  SAFE_FREE(inclusion_buffer);
+  if (error) {
+    if (cliplist) {
+      char **pp;
+      /* We know cliplist is always null-terminated */
+      for (pp = cliplist; *pp; ++pp) {
+        SAFE_FREE(*pp);
+      }
+      SAFE_FREE(cliplist);
+      cliplist = NULL;
+      must_free_cliplist = False;
+    }
+    return 0;
+  }
+  
+  /* cliplist and its elements are freed at the end of process_tar. */
+  return 1;
+}
+
+/****************************************************************************
+Parse tar arguments. Sets tar_type, tar_excl, etc.
+***************************************************************************/
+int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
+{
+  char tar_clipfl='\0';
+
+  /* Reset back to defaults - could be from interactive version 
+   * reset mode and archive mode left as they are though
+   */
+  tar_type='\0';
+  tar_excl=True;
+  dry_run=False;
+
+  while (*Optarg) 
+    switch(*Optarg++) {
+    case 'c':
+      tar_type='c';
+      break;
+    case 'x':
+      if (tar_type=='c') {
+	printf("Tar must be followed by only one of c or x.\n");
+	return 0;
+      }
+      tar_type='x';
+      break;
+    case 'b':
+      if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
+	DEBUG(0,("Option b must be followed by valid blocksize\n"));
+	return 0;
+      } else {
+	Optind++;
+      }
+      break;
+    case 'g':
+      tar_inc=True;
+      break;
+    case 'N':
+      if (Optind>=argc) {
+	DEBUG(0,("Option N must be followed by valid file name\n"));
+	return 0;
+      } else {
+	SMB_STRUCT_STAT stbuf;
+	extern time_t newer_than;
+	
+	if (sys_stat(argv[Optind], &stbuf) == 0) {
+	  newer_than = stbuf.st_mtime;
+	  DEBUG(1,("Getting files newer than %s",
+		   asctime(LocalTime(&newer_than))));
+	  Optind++;
+	} else {
+	  DEBUG(0,("Error setting newer-than time\n"));
+	  return 0;
+	}
+      }
+      break;
+    case 'a':
+      tar_reset=True;
+      break;
+    case 'q':
+      tar_noisy=False;
+      break;
+    case 'I':
+      if (tar_clipfl) {
+	DEBUG(0,("Only one of I,X,F must be specified\n"));
+	return 0;
+      }
+      tar_clipfl='I';
+      break;
+    case 'X':
+      if (tar_clipfl) {
+	DEBUG(0,("Only one of I,X,F must be specified\n"));
+	return 0;
+      }
+      tar_clipfl='X';
+      break;
+    case 'F':
+      if (tar_clipfl) {
+	DEBUG(0,("Only one of I,X,F must be specified\n"));
+	return 0;
+      }
+      tar_clipfl='F';
+      break;
+    case 'r':
+      DEBUG(0, ("tar_re_search set\n"));
+      tar_re_search = True;
+      break;
+    case 'n':
+      if (tar_type == 'c') {
+	DEBUG(0, ("dry_run set\n"));
+	dry_run = True;
+      } else {
+	DEBUG(0, ("n is only meaningful when creating a tar-file\n"));
+	return 0;
+      }
+      break;
+    default:
+      DEBUG(0,("Unknown tar option\n"));
+      return 0;
+    }
+
+  if (!tar_type) {
+    printf("Option T must be followed by one of c or x.\n");
+    return 0;
+  }
+
+  /* tar_excl is true if cliplist lists files to be included.
+   * Both 'I' and 'F' mean include. */
+  tar_excl=tar_clipfl!='X';
+
+  if (tar_clipfl=='F') {
+    if (argc-Optind-1 != 1) {
+      DEBUG(0,("Option F must be followed by exactly one filename.\n"));
+      return 0;
+    }
+    if (! read_inclusion_file(argv[Optind+1])) {
+      return 0;
+    }
+  } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
+    char *tmpstr;
+    char **tmplist;
+    int clipcount;
+
+    cliplist=argv+Optind+1;
+    clipn=argc-Optind-1;
+    clipcount = clipn;
+
+    if ((tmplist=malloc(clipn*sizeof(char *))) == NULL) {
+      DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", 
+               clipn)
+           );
+      return 0;
+    }
+
+    for (clipcount = 0; clipcount < clipn; clipcount++) {
+
+      DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
+
+      if ((tmpstr = (char *)malloc(strlen(cliplist[clipcount])+1)) == NULL) {
+        DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n",
+                 clipcount)
+             );
+        return 0;
+      }
+      unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
+      tmplist[clipcount] = tmpstr;
+      DEBUG(5, ("Processed an item, %s\n", tmpstr));
+
+      DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
+    }
+    cliplist = tmplist;
+    must_free_cliplist = True;
+  }
+
+  if (Optind+1<argc && tar_re_search) {  /* Doing regular expression seaches */
+#ifdef HAVE_REGEX_H
+    int errcode;
+
+    if ((preg = (regex_t *)malloc(65536)) == NULL) {
+
+      DEBUG(0, ("Could not allocate buffer for regular expression search\n"));
+      return;
+
+    }
+
+    if (errcode = regcomp(preg, argv[Optind + 1], REG_EXTENDED)) {
+      char errstr[1024];
+      size_t errlen;
+
+      errlen = regerror(errcode, preg, errstr, sizeof(errstr) - 1);
+      
+      DEBUG(0, ("Could not compile pattern buffer for re search: %s\n%s\n", argv[Optind + 1], errstr));
+      return;
+
+    }
+#endif
+
+    clipn=argc-Optind-1;
+    cliplist=argv+Optind+1;
+
+  }
+
+  if (Optind>=argc || !strcmp(argv[Optind], "-")) {
+    /* Sets tar handle to either 0 or 1, as appropriate */
+    tarhandle=(tar_type=='c');
+    /*
+     * Make sure that dbf points to stderr if we are using stdout for 
+     * tar output
+    */
+    if (tarhandle == 1) 
+	    setup_logging("clitar", DEBUG_STDERR);
+  } else {
+    if (tar_type=='c' && (dry_run || strcmp(argv[Optind], "/dev/null")==0))
+      {
+	if (!dry_run) {
+	  DEBUG(0,("Output is /dev/null, assuming dry_run\n"));
+	  dry_run = True;
+	}
+	tarhandle=-1;
+      } else
+    if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
+	|| (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0))
+      {
+	DEBUG(0,("Error opening local file %s - %s\n",
+		 argv[Optind], strerror(errno)));
+	return(0);
+      }
+  }
+
+  return 1;
+}
diff --git a/source4/client/mount.cifs.c b/source4/client/mount.cifs.c
new file mode 100644
index 0000000000..7167859d7b
--- /dev/null
+++ b/source4/client/mount.cifs.c
@@ -0,0 +1,557 @@
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <getopt.h>
+#include <errno.h>
+#include <netdb.h>
+#include <string.h>
+#include <mntent.h>
+
+#define MOUNT_CIFS_VERSION "1"
+
+extern char *getusername(void);
+
+char * thisprogram;
+int verboseflag = 0;
+static int got_password = 0;
+static int got_user = 0;
+static int got_domain = 0;
+static int got_ip = 0;
+static int got_unc = 0;
+static int got_uid = 0;
+static int got_gid = 0;
+static char * user_name = NULL;
+char * mountpassword = NULL;
+
+
+void mount_cifs_usage()
+{
+	printf("\nUsage:  %s remotetarget dir\n", thisprogram);
+	printf("\nMount the remotetarget, specified as either a UNC name or ");
+	printf(" CIFS URL, to the local directory, dir.\n");
+
+	exit(1);
+}
+
+/* caller frees username if necessary */
+char * getusername() {
+	char *username = NULL;
+	struct passwd *password = getpwuid(getuid());
+
+	if (password) {
+		username = password->pw_name;
+	}
+	return username;
+}
+
+char * parse_cifs_url(unc_name)
+{
+	printf("\ncifs url %s\n",unc_name);
+}
+
+int parse_options(char * options)
+{
+	char * data;
+	char * value = 0;
+
+	if (!options)
+		return 1;
+
+	while ((data = strsep(&options, ",")) != NULL) {
+		if (!*data)
+			continue;
+		if ((value = strchr(data, '=')) != NULL) {
+			*value++ = '\0';
+		}
+		if (strncmp(data, "user", 4) == 0) {
+			if (!value || !*value) {
+				printf("invalid or missing username\n");
+				return 1;	/* needs_arg; */
+			}
+			if (strnlen(value, 260) < 260) {
+				got_user=1;
+				/* BB add check for format user%pass */
+				/* if(strchr(username%passw) got_password = 1) */
+			} else {
+				printf("username too long\n");
+				return 1;
+			}
+	} else if (strncmp(data, "pass", 4) == 0) {
+		if (!value || !*value) {
+			if(got_password) {
+				printf("password specified twice, ignoring second\n");
+			} else
+				got_password = 1;
+		} else if (strnlen(value, 17) < 17) {
+			got_password = 1;
+		} else {
+			printf("password too long\n");
+			return 1;
+		}
+	} else if (strncmp(data, "ip", 2) == 0) {
+		if (!value || !*value) {
+			printf("target ip address argument missing");
+		} else if (strnlen(value, 35) < 35) {
+			got_ip = 1;
+		} else {
+			printf("ip address too long\n");
+			return 1;
+		}
+	} else if ((strncmp(data, "unc", 3) == 0)
+		   || (strncmp(data, "target", 6) == 0)
+		   || (strncmp(data, "path", 4) == 0)) {
+		if (!value || !*value) {
+			printf("invalid path to network resource\n");
+			return 1;  /* needs_arg; */
+		} else if(strnlen(value,5) < 5) {
+			printf("UNC name too short");
+		}
+
+		if (strnlen(value, 300) < 300) {
+			got_unc = 1;
+			if (strncmp(value, "//", 2) == 0) {
+				if(got_unc)
+					printf("unc name specified twice, ignoring second\n");
+				else
+					got_unc = 1;
+			} else if (strncmp(value, "\\\\", 2) != 0) {	                   
+				printf("UNC Path does not begin with // or \\\\ \n");
+				return 1;
+			} else {
+				if(got_unc)
+					printf("unc name specified twice, ignoring second\n");
+				else
+					got_unc = 1;
+			}
+		} else {
+			printf("CIFS: UNC name too long\n");
+			return 1;
+		}
+	} else if ((strncmp(data, "domain", 3) == 0)
+		   || (strncmp(data, "workgroup", 5) == 0)) {
+		if (!value || !*value) {
+			printf("CIFS: invalid domain name\n");
+			return 1;	/* needs_arg; */
+		}
+		if (strnlen(value, 65) < 65) {
+			got_domain = 1;
+		} else {
+			printf("domain name too long\n");
+			return 1;
+		}
+	} else if (strncmp(data, "uid", 3) == 0) {
+		if (value && *value) {
+			got_uid = 1;
+		}
+	} else if (strncmp(data, "gid", 3) == 0) {
+		if (value && *value) {
+			got_gid = 1;
+		}
+	} /* else if (strnicmp(data, "file_mode", 4) == 0) {
+		if (value && *value) {
+			vol->file_mode =
+				simple_strtoul(value, &value, 0);
+		}
+	} else if (strnicmp(data, "dir_mode", 3) == 0) {
+		if (value && *value) {
+			vol->dir_mode =
+				simple_strtoul(value, &value, 0);
+		}
+	} else if (strnicmp(data, "port", 4) == 0) {
+		if (value && *value) {
+			vol->port =
+				simple_strtoul(value, &value, 0);
+		}
+	} else if (strnicmp(data, "rsize", 5) == 0) {
+		if (value && *value) {
+			vol->rsize =
+				simple_strtoul(value, &value, 0);
+		}
+	} else if (strnicmp(data, "wsize", 5) == 0) {
+		if (value && *value) {
+			vol->wsize =
+				simple_strtoul(value, &value, 0);
+		}
+	} else if (strnicmp(data, "version", 3) == 0) {
+		
+	} else if (strnicmp(data, "rw", 2) == 0) {
+		
+	} else
+		printf("CIFS: Unknown mount option %s\n",data); */
+	}
+	return 0;
+}
+
+/* Note that caller frees the returned buffer if necessary */
+char * parse_server(char * unc_name)
+{
+	int length = strnlen(unc_name,1024);
+	char * share;
+	char * ipaddress_string = NULL;
+	struct hostent * host_entry;
+	struct in_addr server_ipaddr;
+	int rc,j;
+	char temp[64];
+
+	if(length > 1023) {
+		printf("mount error: UNC name too long");
+		return 0;
+	}
+	if (strncasecmp("cifs://",unc_name,7) == 0)
+		return parse_cifs_url(unc_name+7);
+	if (strncasecmp("smb://",unc_name,6) == 0) {
+		return parse_cifs_url(unc_name+6);
+	}
+
+	if(length < 3) {
+		/* BB add code to find DFS root here */
+		printf("\nMounting the DFS root for domain not implemented yet");
+		return 0;
+	} else {
+		/* BB add support for \\\\ not just // */
+		if(strncmp(unc_name,"//",2) && strncmp(unc_name,"\\\\",2)) {
+			printf("mount error: improperly formatted UNC name.");
+			printf(" %s does not begin with \\\\ or //\n",unc_name);
+			return 0;
+		} else {
+			unc_name[0] = '\\';
+			unc_name[1] = '\\';
+			unc_name += 2;
+			if ((share = strchr(unc_name, '/')) || 
+				(share = strchr(unc_name,'\\'))) {
+				*share = 0;  /* temporarily terminate the string */
+				share += 1;
+				host_entry = gethostbyname(unc_name);
+				*(share - 1) = '\\'; /* put the slash back */
+/*				rc = getipnodebyname(unc_name, AF_INET, AT_ADDRCONFIG ,&rc);*/
+				if(host_entry == NULL) {
+					printf("mount error: could not find target server. TCP name %s not found ", unc_name);
+					printf(" rc = %d\n",rc);
+					return 0;
+				}
+				else {
+					/* BB should we pass an alternate version of the share name as Unicode */
+					/* BB what about ipv6? BB */
+					/* BB add retries with alternate servers in list */
+
+					memcpy(&server_ipaddr.s_addr, host_entry->h_addr, 4);
+
+					ipaddress_string = inet_ntoa(server_ipaddr);                                                                                     
+					if(ipaddress_string == NULL) {
+						printf("mount error: could not get valid ip address for target server\n");
+						return 0;
+					}
+					return ipaddress_string; 
+				}
+			} else {
+				/* BB add code to find DFS root (send null path on get DFS Referral to specified server here */
+				printf("Mounting the DFS root for a particular server not implemented yet\n");
+				return 0;
+			}
+		}
+	}
+}
+
+static struct option longopts[] = {
+	{ "all", 0, 0, 'a' },
+	{ "help", 0, 0, 'h' },
+	{ "read-only", 0, 0, 'r' },
+	{ "ro", 0, 0, 'r' },
+	{ "verbose", 0, 0, 'v' },
+	{ "version", 0, 0, 'V' },
+	{ "read-write", 0, 0, 'w' },
+	{ "rw", 0, 0, 'w' },
+	{ "options", 1, 0, 'o' },
+	{ "types", 1, 0, 't' },
+	{ "replace", 0, 0, 129 },
+	{ "after", 0, 0, 130 },
+	{ "before", 0, 0, 131 },
+	{ "over", 0, 0, 132 },
+	{ "move", 0, 0, 133 },
+	{ "rsize",1, 0, 136 },
+	{ "wsize",1, 0, 137 },
+	{ "uid", 1, 0, 138},
+	{ "gid", 1, 0, 139},
+	{ "uuid",1,0,'U' },
+	{ "user",1,0,140},
+	{ "username",1,0,140},
+	{ "dom",1,0,141},
+	{ "domain",1,0,141},
+	{ "password",1,0,142},
+	{ NULL, 0, 0, 0 }
+};
+
+int main(int argc, char ** argv)
+{
+	int c;
+	int flags = MS_MANDLOCK | MS_MGC_VAL;
+	char * orgoptions = NULL;
+	char * share_name = NULL;
+	char * domain_name = NULL;
+	char * ipaddr = NULL;
+	char * uuid = NULL;
+	char * mountpoint;
+	char * options;
+	int rc,i;
+	int rsize = 0;
+	int wsize = 0;
+	int nomtab = 0;
+	int uid = 0;
+	int gid = 0;
+	int optlen = 0;
+	struct stat statbuf;
+	struct utsname sysinfo;
+	struct mntent mountent;
+	FILE * pmntfile;
+
+	/* setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE); */
+
+	if(argc && argv) {
+		thisprogram = argv[0];
+	}
+	if(thisprogram == NULL)
+		thisprogram = "mount.cifs";
+
+	uname(&sysinfo);
+	/* BB add workstation name and domain and pass down */
+/*#ifdef _GNU_SOURCE
+	printf(" node: %s machine: %s\n", sysinfo.nodename,sysinfo.machine);
+#endif*/
+	if(argc < 3)
+		mount_cifs_usage();
+	share_name = argv[1];
+	mountpoint = argv[2];
+	/* add sharename in opts string as unc= parm */
+
+	while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsU:vVwt:",
+			 longopts, NULL)) != -1) {
+		switch (c) {
+/*	case 'a':	       
+		++mount_all;
+		break;
+	case 'f':	       
+		++fake;
+		break;
+	case 'F':
+		++optfork;
+		break; */
+		case 'h':	 /* help */
+			mount_cifs_usage ();
+			break;
+/*	case 'i':
+		external_allowed = 0;
+		break;
+	case 'l':
+		list_with_volumelabel = 1;
+		break;
+	case 'L':
+		volumelabel = optarg;
+		break; */
+	case 'n':
+		++nomtab;
+		break;
+	case 'o':
+		if (orgoptions) {
+			orgoptions = strcat(orgoptions, ",");
+			orgoptions = strcat(orgoptions,optarg);
+		} else
+			orgoptions = strdup(optarg);
+		break;
+
+/*	case 'O':
+		if (test_opts)
+			test_opts = xstrconcat3(test_opts, ",", optarg);
+		else
+			test_opts = xstrdup(optarg);
+		break;*/
+		case 'r':  /* mount readonly */
+			flags |= MS_RDONLY;;
+			break;
+		case 'U':
+			uuid = optarg;
+			break;
+		case 'v':
+			++verboseflag;
+			break;
+/*	case 'V':	   
+		printf ("mount: %s\n", version);
+		exit (0);*/
+		case 'w':
+			flags &= ~MS_RDONLY;;
+			break;
+/*	case 0:
+		break;
+
+	case 128: 
+		mounttype = MS_BIND;
+		break;
+	case 129: 
+		mounttype = MS_REPLACE;
+		break;
+	case 130: 
+		mounttype = MS_AFTER;
+		break;
+	case 131: 
+		mounttype = MS_BEFORE;
+		break;
+	case 132: 
+		mounttype = MS_OVER;
+		break;
+	case 133: 
+		mounttype = MS_MOVE;
+		break;
+	case 135:
+		mounttype = (MS_BIND | MS_REC);
+		break; */
+		case 136:
+			rsize = atoi(optarg) ;
+			break;
+		case 137:
+			wsize = atoi(optarg);
+			break;
+		case 138:
+			uid = atoi(optarg);
+			break;
+		case 139:
+			gid = atoi(optarg);
+			break;
+		case 140:
+			got_user = 1;
+			user_name = optarg;
+			break;
+		case 141:
+			domain_name = optarg;
+			break;
+		case 142:
+			got_password = 1;
+			 mountpassword = optarg;
+			break;
+		case '?':
+		default:
+			mount_cifs_usage ();
+		}
+	}
+
+	/* canonicalize the path in argv[1]? */
+
+	if(stat (mountpoint, &statbuf)) {
+		printf("mount error: mount point %s does not exist\n",mountpoint);
+		return -1;
+	}
+	if (S_ISDIR(statbuf.st_mode) == 0) {
+		printf("mount error: mount point %s is not a directory\n",mountpoint);
+		return -1;
+	}
+
+	if(geteuid()) {
+		printf("mount error: permission denied, not superuser and cifs.mount not installed SUID\n"); 
+		return -1;
+	}
+
+	ipaddr = parse_server(share_name);
+/*	if(share_name == NULL)
+		return 1; */
+	if (parse_options(strdup(orgoptions)))
+		return 1;
+
+	if(got_user == 0)
+		user_name = getusername();
+       
+/*	check username for user%password format */
+
+	if(got_password == 0) {
+		if (getenv("PASSWD")) {
+			mountpassword = malloc(33);
+			if(mountpassword) {
+				strncpy(mountpassword,getenv("PASSWD"),32);
+				got_password = 1;
+			}
+/*		} else if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
+			get_password_file();
+			got_password = 1;*/ /* BB add missing function */
+		} else {
+			mountpassword = getpass("Password: "); /* BB obsolete */
+			got_password = 1;
+		}
+	}
+	/* FIXME launch daemon (handles dfs name resolution and credential change) 
+	   remember to clear parms and overwrite password field before launching */
+	if(orgoptions) {
+		optlen = strlen(orgoptions);
+	} else
+		optlen = 0;
+	if(share_name)
+		optlen += strlen(share_name) + 4;
+	if(user_name)
+		optlen += strlen(user_name) + 6;
+	if(ipaddr)
+		optlen += strlen(ipaddr) + 4;
+	if(mountpassword)
+		optlen += strlen(mountpassword) + 6;
+	options = malloc(optlen + 10);
+
+    options[0] = 0;
+	strncat(options,"unc=",4);
+	strcat(options,share_name);
+	if(ipaddr) {
+		strncat(options,",ip=",4);
+		strcat(options,ipaddr);
+	} 
+	if(user_name) {
+		strncat(options,",user=",6);
+		strcat(options,user_name);
+	} 
+	if(mountpassword) {
+		strncat(options,",pass=",6);
+		strcat(options,mountpassword);
+	}
+	strncat(options,",ver=",5);
+	strcat(options,MOUNT_CIFS_VERSION);
+
+	if(orgoptions) {
+		strcat(options,",");
+		strcat(options,orgoptions);
+	}
+	/* printf("\noptions %s \n",options);*/
+	if(mount(share_name, mountpoint, "cifs", flags, options)) {
+	/* remember to kill daemon on error */
+		switch (errno) {
+		case 0:
+			printf("mount failed but no error number set\n");
+			return 0;
+		case ENODEV:
+			printf("mount error: cifs filesystem not supported by the system\n");
+			break;
+		default:
+			printf("mount error %d = %s",errno,strerror(errno));
+		}
+		printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
+		return -1;
+	} else {
+		pmntfile = setmntent(MOUNTED, "a+");
+		if(pmntfile) {
+			mountent.mnt_fsname = share_name;
+			mountent.mnt_dir = mountpoint; 
+			mountent.mnt_type = "cifs"; 
+			mountent.mnt_opts = "";
+			mountent.mnt_freq = 0;
+			mountent.mnt_passno = 0;
+			rc = addmntent(pmntfile,&mountent);
+			endmntent(pmntfile);
+		} else {
+		    printf("could not update mount table\n");
+		}
+	}
+	return 0;
+}
+
diff --git a/source4/client/smbmnt.c b/source4/client/smbmnt.c
new file mode 100644
index 0000000000..ce406179cf
--- /dev/null
+++ b/source4/client/smbmnt.c
@@ -0,0 +1,306 @@
+/*
+ *  smbmnt.c
+ *
+ *  Copyright (C) 1995-1998 by Paal-Kr. Engstad and Volker Lendecke
+ *  extensively modified by Tridge
+ *
+ */
+
+#include "includes.h"
+
+#include <mntent.h>
+#include <sys/utsname.h>
+
+#include <asm/types.h>
+#include <asm/posix_types.h>
+#include <linux/smb.h>
+#include <linux/smb_mount.h>
+#include <asm/unistd.h>
+
+#ifndef	MS_MGC_VAL
+/* This may look strange but MS_MGC_VAL is what we are looking for and
+	is what we need from <linux/fs.h> under libc systems and is
+	provided in standard includes on glibc systems.  So...  We
+	switch on what we need...  */
+#include <linux/fs.h>
+#endif
+
+static uid_t mount_uid;
+static gid_t mount_gid;
+static int mount_ro;
+static unsigned mount_fmask;
+static unsigned mount_dmask;
+static int user_mount;
+static char *options;
+
+static void
+help(void)
+{
+        printf("\n");
+        printf("Usage: smbmnt mount-point [options]\n");
+	printf("Version %s\n\n",VERSION);
+        printf("-s share       share name on server\n"
+               "-r             mount read-only\n"
+               "-u uid         mount as uid\n"
+               "-g gid         mount as gid\n"
+               "-f mask        permission mask for files\n"
+               "-d mask        permission mask for directories\n"
+               "-o options     name=value, list of options\n"
+               "-h             print this help text\n");
+}
+
+static int
+parse_args(int argc, char *argv[], struct smb_mount_data *data, char **share)
+{
+        int opt;
+
+        while ((opt = getopt (argc, argv, "s:u:g:rf:d:o:")) != EOF)
+	{
+                switch (opt)
+		{
+                case 's':
+                        *share = optarg;
+                        break;
+                case 'u':
+			if (!user_mount) {
+				mount_uid = strtol(optarg, NULL, 0);
+			}
+                        break;
+                case 'g':
+			if (!user_mount) {
+				mount_gid = strtol(optarg, NULL, 0);
+			}
+                        break;
+                case 'r':
+                        mount_ro = 1;
+                        break;
+                case 'f':
+                        mount_fmask = strtol(optarg, NULL, 8);
+                        break;
+                case 'd':
+                        mount_dmask = strtol(optarg, NULL, 8);
+                        break;
+		case 'o':
+			options = optarg;
+			break;
+                default:
+                        return -1;
+                }
+        }
+        return 0;
+        
+}
+
+static char *
+fullpath(const char *p)
+{
+        char path[MAXPATHLEN];
+
+	if (strlen(p) > MAXPATHLEN-1) {
+		return NULL;
+	}
+
+        if (realpath(p, path) == NULL) {
+		fprintf(stderr,"Failed to find real path for mount point\n");
+		exit(1);
+	}
+	return strdup(path);
+}
+
+/* Check whether user is allowed to mount on the specified mount point. If it's
+   OK then we change into that directory - this prevents race conditions */
+static int mount_ok(char *mount_point)
+{
+	struct stat st;
+
+	if (chdir(mount_point) != 0) {
+		return -1;
+	}
+
+        if (stat(".", &st) != 0) {
+		return -1;
+        }
+
+        if (!S_ISDIR(st.st_mode)) {
+                errno = ENOTDIR;
+                return -1;
+        }
+
+        if ((getuid() != 0) && 
+	    ((getuid() != st.st_uid) || 
+	     ((st.st_mode & S_IRWXU) != S_IRWXU))) {
+                errno = EPERM;
+                return -1;
+        }
+
+        return 0;
+}
+
+/* Tries to mount using the appropriate format. For 2.2 the struct,
+   for 2.4 the ascii version. */
+static int
+do_mount(char *share_name, unsigned int flags, struct smb_mount_data *data)
+{
+	pstring opts;
+	struct utsname uts;
+	char *release, *major, *minor;
+	char *data1, *data2;
+
+	uname(&uts);
+	release = uts.release;
+	major = strtok(release, ".");
+	minor = strtok(NULL, ".");
+	if (major && minor && atoi(major) == 2 && atoi(minor) < 4) {
+		/* < 2.4, assume struct */
+		data1 = (char *) data;
+		data2 = opts;
+	} else {
+		/* >= 2.4, assume ascii but fall back on struct */
+		data1 = opts;
+		data2 = (char *) data;
+	}
+
+	slprintf(opts, sizeof(opts)-1,
+		 "version=7,uid=%d,gid=%d,file_mode=0%o,dir_mode=0%o,%s",
+		 data->uid, data->gid, data->file_mode, data->dir_mode,options);
+	if (mount(share_name, ".", "smbfs", flags, data1) == 0)
+		return 0;
+	return mount(share_name, ".", "smbfs", flags, data2);
+}
+
+ int main(int argc, char *argv[])
+{
+	char *mount_point, *share_name = NULL;
+	FILE *mtab;
+	int fd;
+	unsigned int flags;
+	struct smb_mount_data data;
+	struct mntent ment;
+
+	memset(&data, 0, sizeof(struct smb_mount_data));
+
+	if (argc < 2) {
+		help();
+		exit(1);
+	}
+
+	if (argv[1][0] == '-') {
+		help();
+		exit(1);
+	}
+
+	if (getuid() != 0) {
+		user_mount = 1;
+	}
+
+        if (geteuid() != 0) {
+                fprintf(stderr, "smbmnt must be installed suid root for direct user mounts (%d,%d)\n", getuid(), geteuid());
+                exit(1);
+        }
+
+	mount_uid = getuid();
+	mount_gid = getgid();
+	mount_fmask = umask(0);
+        umask(mount_fmask);
+	mount_fmask = ~mount_fmask;
+
+        mount_point = fullpath(argv[1]);
+
+        argv += 1;
+        argc -= 1;
+
+        if (mount_ok(mount_point) != 0) {
+                fprintf(stderr, "cannot mount on %s: %s\n",
+                        mount_point, strerror(errno));
+                exit(1);
+        }
+
+	data.version = SMB_MOUNT_VERSION;
+
+        /* getuid() gives us the real uid, who may umount the fs */
+        data.mounted_uid = getuid();
+
+        if (parse_args(argc, argv, &data, &share_name) != 0) {
+                help();
+                return -1;
+        }
+
+        data.uid = mount_uid;
+        data.gid = mount_gid;
+        data.file_mode = (S_IRWXU|S_IRWXG|S_IRWXO) & mount_fmask;
+        data.dir_mode  = (S_IRWXU|S_IRWXG|S_IRWXO) & mount_dmask;
+
+        if (mount_dmask == 0) {
+                data.dir_mode = data.file_mode;
+                if ((data.dir_mode & S_IRUSR) != 0)
+                        data.dir_mode |= S_IXUSR;
+                if ((data.dir_mode & S_IRGRP) != 0)
+                        data.dir_mode |= S_IXGRP;
+                if ((data.dir_mode & S_IROTH) != 0)
+                        data.dir_mode |= S_IXOTH;
+        }
+
+	flags = MS_MGC_VAL;
+
+	if (mount_ro) flags |= MS_RDONLY;
+
+	if (do_mount(share_name, flags, &data) < 0) {
+		switch (errno) {
+		case ENODEV:
+			fprintf(stderr, "ERROR: smbfs filesystem not supported by the kernel\n");
+			break;
+		default:
+			perror("mount error");
+		}
+		fprintf(stderr, "Please refer to the smbmnt(8) manual page\n");
+		return -1;
+	}
+
+        ment.mnt_fsname = share_name ? share_name : "none";
+        ment.mnt_dir = mount_point;
+        ment.mnt_type = "smbfs";
+        ment.mnt_opts = "";
+        ment.mnt_freq = 0;
+        ment.mnt_passno= 0;
+
+        mount_point = ment.mnt_dir;
+
+	if (mount_point == NULL)
+	{
+		fprintf(stderr, "Mount point too long\n");
+		return -1;
+	}
+	
+        if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1)
+        {
+                fprintf(stderr, "Can't get "MOUNTED"~ lock file");
+                return 1;
+        }
+        close(fd);
+	
+        if ((mtab = setmntent(MOUNTED, "a+")) == NULL)
+        {
+                fprintf(stderr, "Can't open " MOUNTED);
+                return 1;
+        }
+
+        if (addmntent(mtab, &ment) == 1)
+        {
+                fprintf(stderr, "Can't write mount entry");
+                return 1;
+        }
+        if (fchmod(fileno(mtab), 0644) == -1)
+        {
+                fprintf(stderr, "Can't set perms on "MOUNTED);
+                return 1;
+        }
+        endmntent(mtab);
+
+        if (unlink(MOUNTED"~") == -1)
+        {
+                fprintf(stderr, "Can't remove "MOUNTED"~");
+                return 1;
+        }
+
+	return 0;
+}	
diff --git a/source4/client/smbmount.c b/source4/client/smbmount.c
new file mode 100644
index 0000000000..da340144fc
--- /dev/null
+++ b/source4/client/smbmount.c
@@ -0,0 +1,930 @@
+/* 
+   Unix SMB/CIFS implementation.
+   SMBFS mount program
+   Copyright (C) Andrew Tridgell 1999
+   
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+#include <mntent.h>
+#include <asm/types.h>
+#include <linux/smb_fs.h>
+
+extern BOOL in_client;
+
+static pstring credentials;
+static pstring my_netbios_name;
+static pstring password;
+static pstring username;
+static pstring workgroup;
+static pstring mpoint;
+static pstring service;
+static pstring options;
+
+static struct in_addr dest_ip;
+static BOOL have_ip;
+static int smb_port = 0;
+static BOOL got_user;
+static BOOL got_pass;
+static uid_t mount_uid;
+static gid_t mount_gid;
+static int mount_ro;
+static unsigned mount_fmask;
+static unsigned mount_dmask;
+static BOOL use_kerberos;
+/* TODO: Add code to detect smbfs version in kernel */
+static BOOL status32_smbfs = False;
+
+static void usage(void);
+
+static void exit_parent(int sig)
+{
+	/* parent simply exits when child says go... */
+	exit(0);
+}
+
+static void daemonize(void)
+{
+	int j, status;
+	pid_t child_pid;
+
+	signal( SIGTERM, exit_parent );
+
+	if ((child_pid = sys_fork()) < 0) {
+		DEBUG(0,("could not fork\n"));
+	}
+
+	if (child_pid > 0) {
+		while( 1 ) {
+			j = waitpid( child_pid, &status, 0 );
+			if( j < 0 ) {
+				if( EINTR == errno ) {
+					continue;
+				}
+				status = errno;
+			}
+			break;
+		}
+
+		/* If we get here - the child exited with some error status */
+		if (WIFSIGNALED(status))
+			exit(128 + WTERMSIG(status));
+		else
+			exit(WEXITSTATUS(status));
+	}
+
+	signal( SIGTERM, SIG_DFL );
+	chdir("/");
+}
+
+static void close_our_files(int client_fd)
+{
+	int i;
+	struct rlimit limits;
+
+	getrlimit(RLIMIT_NOFILE,&limits);
+	for (i = 0; i< limits.rlim_max; i++) {
+		if (i == client_fd)
+			continue;
+		close(i);
+	}
+}
+
+static void usr1_handler(int x)
+{
+	return;
+}
+
+
+/***************************************************** 
+return a connection to a server
+*******************************************************/
+static struct cli_state *do_connection(char *the_service)
+{
+	struct cli_state *c;
+	struct nmb_name called, calling;
+	char *server_n;
+	struct in_addr ip;
+	pstring server;
+	char *share;
+
+	if (the_service[0] != '\\' || the_service[1] != '\\') {
+		usage();
+		exit(1);
+	}
+
+	pstrcpy(server, the_service+2);
+	share = strchr_m(server,'\\');
+	if (!share) {
+		usage();
+		exit(1);
+	}
+	*share = 0;
+	share++;
+
+	server_n = server;
+
+	make_nmb_name(&calling, my_netbios_name, 0x0);
+	make_nmb_name(&called , server, 0x20);
+
+ again:
+        zero_ip(&ip);
+	if (have_ip) ip = dest_ip;
+
+	/* have to open a new connection */
+	if (!(c=cli_initialise(NULL)) || (cli_set_port(c, smb_port) != smb_port) ||
+	    !cli_connect(c, server_n, &ip)) {
+		DEBUG(0,("%d: Connection to %s failed\n", sys_getpid(), server_n));
+		if (c) {
+			cli_shutdown(c);
+		}
+		return NULL;
+	}
+
+	/* SPNEGO doesn't work till we get NTSTATUS error support */
+	/* But it is REQUIRED for kerberos authentication */
+	if(!use_kerberos) c->use_spnego = False;
+
+	/* The kernel doesn't yet know how to sign it's packets */
+	c->sign_info.allow_smb_signing = False;
+
+	/* Use kerberos authentication if specified */
+	c->use_kerberos = use_kerberos;
+
+	if (!cli_session_request(c, &calling, &called)) {
+		char *p;
+		DEBUG(0,("%d: session request to %s failed (%s)\n", 
+			 sys_getpid(), called.name, cli_errstr(c)));
+		cli_shutdown(c);
+		if ((p=strchr_m(called.name, '.'))) {
+			*p = 0;
+			goto again;
+		}
+		if (strcmp(called.name, "*SMBSERVER")) {
+			make_nmb_name(&called , "*SMBSERVER", 0x20);
+			goto again;
+		}
+		return NULL;
+	}
+
+	DEBUG(4,("%d: session request ok\n", sys_getpid()));
+
+	if (!cli_negprot(c)) {
+		DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid()));
+		cli_shutdown(c);
+		return NULL;
+	}
+
+	if (!got_pass) {
+		char *pass = getpass("Password: ");
+		if (pass) {
+			pstrcpy(password, pass);
+		}
+	}
+
+	/* This should be right for current smbfs. Future versions will support
+	  large files as well as unicode and oplocks. */
+	if (status32_smbfs) {
+	    c->capabilities &= ~(CAP_UNICODE | CAP_LARGE_FILES | CAP_NT_SMBS |
+                                 CAP_NT_FIND | CAP_LEVEL_II_OPLOCKS);
+	}
+	else {
+	    c->capabilities &= ~(CAP_UNICODE | CAP_LARGE_FILES | CAP_NT_SMBS |
+				 CAP_NT_FIND | CAP_STATUS32 |
+				 CAP_LEVEL_II_OPLOCKS);
+	    c->force_dos_errors = True;
+	}
+
+	if (!cli_session_setup(c, username, 
+			       password, strlen(password),
+			       password, strlen(password),
+			       workgroup)) {
+		/* if a password was not supplied then try again with a
+			null username */
+		if (password[0] || !username[0] ||
+				!cli_session_setup(c, "", "", 0, "", 0, workgroup)) {
+			DEBUG(0,("%d: session setup failed: %s\n",
+				sys_getpid(), cli_errstr(c)));
+			cli_shutdown(c);
+			return NULL;
+		}
+		DEBUG(0,("Anonymous login successful\n"));
+	}
+
+	DEBUG(4,("%d: session setup ok\n", sys_getpid()));
+
+	if (!cli_send_tconX(c, share, "?????",
+			    password, strlen(password)+1)) {
+		DEBUG(0,("%d: tree connect failed: %s\n",
+			 sys_getpid(), cli_errstr(c)));
+		cli_shutdown(c);
+		return NULL;
+	}
+
+	DEBUG(4,("%d: tconx ok\n", sys_getpid()));
+
+	got_pass = True;
+
+	return c;
+}
+
+
+/****************************************************************************
+unmount smbfs  (this is a bailout routine to clean up if a reconnect fails)
+	Code blatently stolen from smbumount.c
+		-mhw-
+****************************************************************************/
+static void smb_umount(char *mount_point)
+{
+	int fd;
+        struct mntent *mnt;
+        FILE* mtab;
+        FILE* new_mtab;
+
+	/* Programmers Note:
+		This routine only gets called to the scene of a disaster
+		to shoot the survivors...  A connection that was working
+		has now apparently failed.  We have an active mount point
+		(presumably) that we need to dump.  If we get errors along
+		the way - make some noise, but we are already turning out
+		the lights to exit anyways...
+	*/
+        if (umount(mount_point) != 0) {
+                DEBUG(0,("%d: Could not umount %s: %s\n",
+			 sys_getpid(), mount_point, strerror(errno)));
+                return;
+        }
+
+        if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1) {
+                DEBUG(0,("%d: Can't get "MOUNTED"~ lock file", sys_getpid()));
+                return;
+        }
+
+        close(fd);
+	
+        if ((mtab = setmntent(MOUNTED, "r")) == NULL) {
+                DEBUG(0,("%d: Can't open " MOUNTED ": %s\n",
+			 sys_getpid(), strerror(errno)));
+                return;
+        }
+
+#define MOUNTED_TMP MOUNTED".tmp"
+
+        if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) {
+                DEBUG(0,("%d: Can't open " MOUNTED_TMP ": %s\n",
+			 sys_getpid(), strerror(errno)));
+                endmntent(mtab);
+                return;
+        }
+
+        while ((mnt = getmntent(mtab)) != NULL) {
+                if (strcmp(mnt->mnt_dir, mount_point) != 0) {
+                        addmntent(new_mtab, mnt);
+                }
+        }
+
+        endmntent(mtab);
+
+        if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
+                DEBUG(0,("%d: Error changing mode of %s: %s\n",
+			 sys_getpid(), MOUNTED_TMP, strerror(errno)));
+                return;
+        }
+
+        endmntent(new_mtab);
+
+        if (rename(MOUNTED_TMP, MOUNTED) < 0) {
+                DEBUG(0,("%d: Cannot rename %s to %s: %s\n",
+			 sys_getpid(), MOUNTED, MOUNTED_TMP, strerror(errno)));
+                return;
+        }
+
+        if (unlink(MOUNTED"~") == -1) {
+                DEBUG(0,("%d: Can't remove "MOUNTED"~", sys_getpid()));
+                return;
+        }
+}
+
+
+/*
+ * Call the smbfs ioctl to install a connection socket,
+ * then wait for a signal to reconnect. Note that we do
+ * not exit after open_sockets() or send_login() errors,
+ * as the smbfs mount would then have no way to recover.
+ */
+static void send_fs_socket(char *the_service, char *mount_point, struct cli_state *c)
+{
+	int fd, closed = 0, res = 1;
+	pid_t parentpid = getppid();
+	struct smb_conn_opt conn_options;
+
+	memset(&conn_options, 0, sizeof(conn_options));
+
+	while (1) {
+		if ((fd = open(mount_point, O_RDONLY)) < 0) {
+			DEBUG(0,("mount.smbfs[%d]: can't open %s\n",
+				 sys_getpid(), mount_point));
+			break;
+		}
+
+		conn_options.fd = c->fd;
+		conn_options.protocol = c->protocol;
+		conn_options.case_handling = SMB_CASE_DEFAULT;
+		conn_options.max_xmit = c->max_xmit;
+		conn_options.server_uid = c->vuid;
+		conn_options.tid = c->cnum;
+		conn_options.secmode = c->sec_mode;
+		conn_options.rawmode = 0;
+		conn_options.sesskey = c->sesskey;
+		conn_options.maxraw = 0;
+		conn_options.capabilities = c->capabilities;
+		conn_options.serverzone = c->serverzone/60;
+
+		res = ioctl(fd, SMB_IOC_NEWCONN, &conn_options);
+		if (res != 0) {
+			DEBUG(0,("mount.smbfs[%d]: ioctl failed, res=%d\n",
+				 sys_getpid(), res));
+			close(fd);
+			break;
+		}
+
+		if (parentpid) {
+			/* Ok...  We are going to kill the parent.  Now
+				is the time to break the process group... */
+			setsid();
+			/* Send a signal to the parent to terminate */
+			kill(parentpid, SIGTERM);
+			parentpid = 0;
+		}
+
+		close(fd);
+
+		/* This looks wierd but we are only closing the userspace
+		   side, the connection has already been passed to smbfs and 
+		   it has increased the usage count on the socket.
+
+		   If we don't do this we will "leak" sockets and memory on
+		   each reconnection we have to make. */
+		cli_shutdown(c);
+		c = NULL;
+
+		if (!closed) {
+			/* redirect stdout & stderr since we can't know that
+			   the library functions we use are using DEBUG. */
+			if ( (fd = open("/dev/null", O_WRONLY)) < 0)
+				DEBUG(2,("mount.smbfs: can't open /dev/null\n"));
+			close_our_files(fd);
+			if (fd >= 0) {
+				dup2(fd, STDOUT_FILENO);
+				dup2(fd, STDERR_FILENO);
+				close(fd);
+			}
+
+			/* here we are no longer interactive */
+			set_remote_machine_name("smbmount");	/* sneaky ... */
+			setup_logging("mount.smbfs", False);
+			reopen_logs();
+			DEBUG(0, ("mount.smbfs: entering daemon mode for service %s, pid=%d\n", the_service, sys_getpid()));
+
+			closed = 1;
+		}
+
+		/* Wait for a signal from smbfs ... but don't continue
+                   until we actually get a new connection. */
+		while (!c) {
+			CatchSignal(SIGUSR1, &usr1_handler);
+			pause();
+			DEBUG(2,("mount.smbfs[%d]: got signal, getting new socket\n", sys_getpid()));
+			c = do_connection(the_service);
+		}
+	}
+
+	smb_umount(mount_point);
+	DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid()));
+	exit(1);
+}
+
+
+/**
+ * Mount a smbfs
+ **/
+static void init_mount(void)
+{
+	char mount_point[MAXPATHLEN+1];
+	pstring tmp;
+	pstring svc2;
+	struct cli_state *c;
+	char *args[20];
+	int i, status;
+
+	if (realpath(mpoint, mount_point) == NULL) {
+		fprintf(stderr, "Could not resolve mount point %s\n", mpoint);
+		return;
+	}
+
+
+	c = do_connection(service);
+	if (!c) {
+		fprintf(stderr,"SMB connection failed\n");
+		exit(1);
+	}
+
+	/*
+		Set up to return as a daemon child and wait in the parent
+		until the child say it's ready...
+	*/
+	daemonize();
+
+	pstrcpy(svc2, service);
+	string_replace(svc2, '\\','/');
+	string_replace(svc2, ' ','_');
+
+	memset(args, 0, sizeof(args[0])*20);
+
+	i=0;
+	args[i++] = "smbmnt";
+
+	args[i++] = mount_point;
+	args[i++] = "-s";
+	args[i++] = svc2;
+
+	if (mount_ro) {
+		args[i++] = "-r";
+	}
+	if (mount_uid) {
+		slprintf(tmp, sizeof(tmp)-1, "%d", mount_uid);
+		args[i++] = "-u";
+		args[i++] = smb_xstrdup(tmp);
+	}
+	if (mount_gid) {
+		slprintf(tmp, sizeof(tmp)-1, "%d", mount_gid);
+		args[i++] = "-g";
+		args[i++] = smb_xstrdup(tmp);
+	}
+	if (mount_fmask) {
+		slprintf(tmp, sizeof(tmp)-1, "0%o", mount_fmask);
+		args[i++] = "-f";
+		args[i++] = smb_xstrdup(tmp);
+	}
+	if (mount_dmask) {
+		slprintf(tmp, sizeof(tmp)-1, "0%o", mount_dmask);
+		args[i++] = "-d";
+		args[i++] = smb_xstrdup(tmp);
+	}
+	if (options) {
+		args[i++] = "-o";
+		args[i++] = options;
+	}
+
+	if (sys_fork() == 0) {
+		char *smbmnt_path;
+
+		asprintf(&smbmnt_path, "%s/smbmnt", dyn_BINDIR);
+		
+		if (file_exist(smbmnt_path, NULL)) {
+			execv(smbmnt_path, args);
+			fprintf(stderr,
+				"smbfs/init_mount: execv of %s failed. Error was %s.",
+				smbmnt_path, strerror(errno));
+		} else {
+			execvp("smbmnt", args);
+			fprintf(stderr,
+				"smbfs/init_mount: execv of %s failed. Error was %s.",
+				"smbmnt", strerror(errno));
+		}
+		free(smbmnt_path);
+		exit(1);
+	}
+
+	if (waitpid(-1, &status, 0) == -1) {
+		fprintf(stderr,"waitpid failed: Error was %s", strerror(errno) );
+		/* FIXME: do some proper error handling */
+		exit(1);
+	}
+
+	if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
+		fprintf(stderr,"smbmnt failed: %d\n", WEXITSTATUS(status));
+		/* FIXME: do some proper error handling */
+		exit(1);
+	} else if (WIFSIGNALED(status)) {
+		fprintf(stderr, "smbmnt killed by signal %d\n", WTERMSIG(status));
+		exit(1);
+	}
+
+	/* Ok...  This is the rubicon for that mount point...  At any point
+	   after this, if the connections fail and can not be reconstructed
+	   for any reason, we will have to unmount the mount point.  There
+	   is no exit from the next call...
+	*/
+	send_fs_socket(service, mount_point, c);
+}
+
+
+/****************************************************************************
+get a password from a a file or file descriptor
+exit on failure (from smbclient, move to libsmb or shared .c file?)
+****************************************************************************/
+static void get_password_file(void)
+{
+	int fd = -1;
+	char *p;
+	BOOL close_it = False;
+	pstring spec;
+	char pass[128];
+
+	if ((p = getenv("PASSWD_FD")) != NULL) {
+		pstrcpy(spec, "descriptor ");
+		pstrcat(spec, p);
+		sscanf(p, "%d", &fd);
+		close_it = False;
+	} else if ((p = getenv("PASSWD_FILE")) != NULL) {
+		fd = sys_open(p, O_RDONLY, 0);
+		pstrcpy(spec, p);
+		if (fd < 0) {
+			fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",
+				spec, strerror(errno));
+			exit(1);
+		}
+		close_it = True;
+	}
+
+	for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */
+	    p && p - pass < sizeof(pass);) {
+		switch (read(fd, p, 1)) {
+		case 1:
+			if (*p != '\n' && *p != '\0') {
+				*++p = '\0'; /* advance p, and null-terminate pass */
+				break;
+			}
+		case 0:
+			if (p - pass) {
+				*p = '\0'; /* null-terminate it, just in case... */
+				p = NULL; /* then force the loop condition to become false */
+				break;
+			} else {
+				fprintf(stderr, "Error reading password from file %s: %s\n",
+					spec, "empty password\n");
+				exit(1);
+			}
+
+		default:
+			fprintf(stderr, "Error reading password from file %s: %s\n",
+				spec, strerror(errno));
+			exit(1);
+		}
+	}
+	pstrcpy(password, pass);
+	if (close_it)
+		close(fd);
+}
+
+/****************************************************************************
+get username and password from a credentials file
+exit on failure (from smbclient, move to libsmb or shared .c file?)
+****************************************************************************/
+static void read_credentials_file(char *filename)
+{
+	FILE *auth;
+	fstring buf;
+	uint16 len = 0;
+	char *ptr, *val, *param;
+
+	if ((auth=sys_fopen(filename, "r")) == NULL)
+	{
+		/* fail if we can't open the credentials file */
+		DEBUG(0,("ERROR: Unable to open credentials file!\n"));
+		exit (-1);
+	}
+
+	while (!feof(auth))
+	{
+		/* get a line from the file */
+		if (!fgets (buf, sizeof(buf), auth))
+			continue;
+		len = strlen(buf);
+
+		if ((len) && (buf[len-1]=='\n'))
+		{
+			buf[len-1] = '\0';
+			len--;
+		}
+		if (len == 0)
+			continue;
+
+		/* break up the line into parameter & value.
+		   will need to eat a little whitespace possibly */
+		param = buf;
+		if (!(ptr = strchr (buf, '=')))
+			continue;
+		val = ptr+1;
+		*ptr = '\0';
+
+		/* eat leading white space */
+		while ((*val!='\0') && ((*val==' ') || (*val=='\t')))
+			val++;
+
+		if (strwicmp("password", param) == 0)
+		{
+			pstrcpy(password, val);
+			got_pass = True;
+		}
+		else if (strwicmp("username", param) == 0) {
+			pstrcpy(username, val);
+		}
+
+		memset(buf, 0, sizeof(buf));
+	}
+	fclose(auth);
+}
+
+
+/****************************************************************************
+usage on the program
+****************************************************************************/
+static void usage(void)
+{
+	printf("Usage: mount.smbfs service mountpoint [-o options,...]\n");
+
+	printf("Version %s\n\n",VERSION);
+
+	printf(
+"Options:\n\
+      username=<arg>                  SMB username\n\
+      password=<arg>                  SMB password\n\
+      credentials=<filename>          file with username/password\n\
+      krb                             use kerberos (active directory)\n\
+      netbiosname=<arg>               source NetBIOS name\n\
+      uid=<arg>                       mount uid or username\n\
+      gid=<arg>                       mount gid or groupname\n\
+      port=<arg>                      remote SMB port number\n\
+      fmask=<arg>                     file umask\n\
+      dmask=<arg>                     directory umask\n\
+      debug=<arg>                     debug level\n\
+      ip=<arg>                        destination host or IP address\n\
+      workgroup=<arg>                 workgroup on destination\n\
+      sockopt=<arg>                   TCP socket options\n\
+      scope=<arg>                     NetBIOS scope\n\
+      iocharset=<arg>                 Linux charset (iso8859-1, utf8)\n\
+      codepage=<arg>                  server codepage (cp850)\n\
+      ttl=<arg>                       dircache time to live\n\
+      guest                           don't prompt for a password\n\
+      ro                              mount read-only\n\
+      rw                              mount read-write\n\
+\n\
+This command is designed to be run from within /bin/mount by giving\n\
+the option '-t smbfs'. For example:\n\
+  mount -t smbfs -o username=tridge,password=foobar //fjall/test /data/test\n\
+");
+}
+
+
+/****************************************************************************
+  Argument parsing for mount.smbfs interface
+  mount will call us like this:
+    mount.smbfs device mountpoint -o <options>
+  
+  <options> is never empty, containing at least rw or ro
+ ****************************************************************************/
+static void parse_mount_smb(int argc, char **argv)
+{
+	int opt;
+	char *opts;
+	char *opteq;
+	extern char *optarg;
+	int val;
+	char *p;
+
+	/* FIXME: This function can silently fail if the arguments are
+	 * not in the expected order.
+
+	> The arguments syntax of smbmount 2.2.3a (smbfs of Debian stable)
+	> requires that one gives "-o" before further options like username=...
+	> . Without -o, the username=.. setting is *silently* ignored. I've
+	> spent about an hour trying to find out why I couldn't log in now..
+
+	*/
+
+
+	if (argc < 2 || argv[1][0] == '-') {
+		usage();
+		exit(1);
+	}
+	
+	pstrcpy(service, argv[1]);
+	pstrcpy(mpoint, argv[2]);
+
+	/* Convert any '/' characters in the service name to
+	   '\' characters */
+	string_replace(service, '/','\\');
+	argc -= 2;
+	argv += 2;
+
+	opt = getopt(argc, argv, "o:");
+	if(opt != 'o') {
+		return;
+	}
+
+	options[0] = 0;
+	p = options;
+
+	/*
+	 * option parsing from nfsmount.c (util-linux-2.9u)
+	 */
+        for (opts = strtok(optarg, ","); opts; opts = strtok(NULL, ",")) {
+		DEBUG(3, ("opts: %s\n", opts));
+                if ((opteq = strchr_m(opts, '='))) {
+                        val = atoi(opteq + 1);
+                        *opteq = '\0';
+
+                        if (!strcmp(opts, "username") || 
+			    !strcmp(opts, "logon")) {
+				char *lp;
+				got_user = True;
+				pstrcpy(username,opteq+1);
+				if ((lp=strchr_m(username,'%'))) {
+					*lp = 0;
+					pstrcpy(password,lp+1);
+					got_pass = True;
+					memset(strchr_m(opteq+1,'%')+1,'X',strlen(password));
+				}
+				if ((lp=strchr_m(username,'/'))) {
+					*lp = 0;
+					pstrcpy(workgroup,lp+1);
+				}
+			} else if(!strcmp(opts, "passwd") ||
+				  !strcmp(opts, "password")) {
+				pstrcpy(password,opteq+1);
+				got_pass = True;
+				memset(opteq+1,'X',strlen(password));
+			} else if(!strcmp(opts, "credentials")) {
+				pstrcpy(credentials,opteq+1);
+			} else if(!strcmp(opts, "netbiosname")) {
+				pstrcpy(my_netbios_name,opteq+1);
+			} else if(!strcmp(opts, "uid")) {
+				mount_uid = nametouid(opteq+1);
+			} else if(!strcmp(opts, "gid")) {
+				mount_gid = nametogid(opteq+1);
+			} else if(!strcmp(opts, "port")) {
+				smb_port = val;
+			} else if(!strcmp(opts, "fmask")) {
+				mount_fmask = strtol(opteq+1, NULL, 8);
+			} else if(!strcmp(opts, "dmask")) {
+				mount_dmask = strtol(opteq+1, NULL, 8);
+			} else if(!strcmp(opts, "debug")) {
+				DEBUGLEVEL = val;
+			} else if(!strcmp(opts, "ip")) {
+				dest_ip = *interpret_addr2(opteq+1);
+				if (is_zero_ip(dest_ip)) {
+					fprintf(stderr,"Can't resolve address %s\n", opteq+1);
+					exit(1);
+				}
+				have_ip = True;
+			} else if(!strcmp(opts, "workgroup")) {
+				pstrcpy(workgroup,opteq+1);
+			} else if(!strcmp(opts, "sockopt")) {
+				lp_set_cmdline("socket options", opteq+1);
+			} else if(!strcmp(opts, "scope")) {
+				lp_set_cmdline("netbios scope", opteq+1);
+			} else {
+				slprintf(p, sizeof(pstring) - (p - options) - 1, "%s=%s,", opts, opteq+1);
+				p += strlen(p);
+			}
+		} else {
+			val = 1;
+			if(!strcmp(opts, "nocaps")) {
+				fprintf(stderr, "Unhandled option: %s\n", opteq+1);
+				exit(1);
+			} else if(!strcmp(opts, "guest")) {
+				*password = '\0';
+				got_pass = True;
+			} else if(!strcmp(opts, "krb")) {
+#ifdef HAVE_KRB5
+
+				use_kerberos = True;
+				if(!status32_smbfs)
+					fprintf(stderr, "Warning: kerberos support will only work for samba servers\n");
+#else
+				fprintf(stderr,"No kerberos support compiled in\n");
+				exit(1);
+#endif
+			} else if(!strcmp(opts, "rw")) {
+				mount_ro = 0;
+			} else if(!strcmp(opts, "ro")) {
+				mount_ro = 1;
+			} else {
+				strncpy(p, opts, sizeof(pstring) - (p - options) - 1);
+				p += strlen(opts);
+				*p++ = ',';
+				*p = 0;
+			}
+		}
+	}
+
+	if (!*service) {
+		usage();
+		exit(1);
+	}
+
+	if (p != options) {
+		*(p-1) = 0;	/* remove trailing , */
+		DEBUG(3,("passthrough options '%s'\n", options));
+	}
+}
+
+/****************************************************************************
+  main program
+****************************************************************************/
+ int main(int argc,char *argv[])
+{
+	extern char *optarg;
+	extern int optind;
+	char *p;
+
+	DEBUGLEVEL = 1;
+
+	/* here we are interactive, even if run from autofs */
+	setup_logging("mount.smbfs",True);
+
+#if 0 /* JRA - Urban says not needed ? */
+	/* CLI_FORCE_ASCII=false makes smbmount negotiate unicode. The default
+	   is to not announce any unicode capabilities as current smbfs does
+	   not support it. */
+	p = getenv("CLI_FORCE_ASCII");
+	if (p && !strcmp(p, "false"))
+		unsetenv("CLI_FORCE_ASCII");
+	else
+		setenv("CLI_FORCE_ASCII", "true", 1);
+#endif
+
+	in_client = True;   /* Make sure that we tell lp_load we are */
+
+	if (getenv("USER")) {
+		pstrcpy(username,getenv("USER"));
+
+		if ((p=strchr_m(username,'%'))) {
+			*p = 0;
+			pstrcpy(password,p+1);
+			got_pass = True;
+			memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password));
+		}
+		strupper(username);
+	}
+
+	if (getenv("PASSWD")) {
+		pstrcpy(password,getenv("PASSWD"));
+		got_pass = True;
+	}
+
+	if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
+		get_password_file();
+		got_pass = True;
+	}
+
+	if (*username == 0 && getenv("LOGNAME")) {
+		pstrcpy(username,getenv("LOGNAME"));
+	}
+
+	if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", 
+			dyn_CONFIGFILE);
+	}
+
+	parse_mount_smb(argc, argv);
+
+	if (use_kerberos && !got_user) {
+		got_pass = True;
+	}
+
+	if (*credentials != 0) {
+		read_credentials_file(credentials);
+	}
+
+	DEBUG(3,("mount.smbfs started (version %s)\n", VERSION));
+
+	if (*workgroup == 0) {
+		pstrcpy(workgroup,lp_workgroup());
+	}
+
+	load_interfaces();
+	if (!*my_netbios_name) {
+		pstrcpy(my_netbios_name, myhostname());
+	}
+	strupper(my_netbios_name);
+
+	init_mount();
+	return 0;
+}
diff --git a/source4/client/smbspool.c b/source4/client/smbspool.c
new file mode 100644
index 0000000000..43046bbad7
--- /dev/null
+++ b/source4/client/smbspool.c
@@ -0,0 +1,362 @@
+/* 
+   Unix SMB/CIFS implementation.
+   SMB backend for the Common UNIX Printing System ("CUPS")
+   Copyright 1999 by Easy Software Products
+   Copyright Andrew Tridgell 1994-1998
+   Copyright Andrew Bartlett 2002
+   
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+/*
+ * Globals...
+ */
+
+extern BOOL		in_client;	/* Boolean for client library */
+
+
+/*
+ * Local functions...
+ */
+
+static void		list_devices(void);
+static struct cli_state	*smb_connect(const char *, const char *, const char *, const char *, const char *);
+static int		smb_print(struct cli_state *, char *, FILE *);
+
+
+/*
+ * 'main()' - Main entry for SMB backend.
+ */
+
+ int				/* O - Exit status */
+ main(int  argc,			/* I - Number of command-line arguments */
+     char *argv[])		/* I - Command-line arguments */
+{
+  int		i;		/* Looping var */
+  int		copies;		/* Number of copies */
+  char		uri[1024],	/* URI */
+		*sep,		/* Pointer to separator */
+		*password;	/* Password */
+  const char	*username,	/* Username */
+		*server,	/* Server name */
+		*printer;	/* Printer name */
+  const char	*workgroup;	/* Workgroup */
+  FILE		*fp;		/* File to print */
+  int		status=0;		/* Status of LPD job */
+  struct cli_state *cli;	/* SMB interface */
+
+  /* we expect the URI in argv[0]. Detect the case where it is in argv[1] and cope */
+  if (argc > 2 && strncmp(argv[0],"smb://", 6) && !strncmp(argv[1],"smb://", 6)) {
+	  argv++;
+	  argc--;
+  }
+
+  if (argc == 1)
+  {
+   /*
+    * NEW!  In CUPS 1.1 the backends are run with no arguments to list the
+    *       available devices.  These can be devices served by this backend
+    *       or any other backends (i.e. you can have an SNMP backend that
+    *       is only used to enumerate the available network printers... :)
+    */
+
+    list_devices();
+    return (0);
+  }
+
+  if (argc < 6 || argc > 7)
+  {
+    fprintf(stderr, "Usage: %s [DEVICE_URI] job-id user title copies options [file]\n",
+            argv[0]);
+    fputs("       The DEVICE_URI environment variable can also contain the\n", stderr);
+    fputs("       destination printer:\n", stderr);
+    fputs("\n", stderr);
+    fputs("           smb://[username:password@][workgroup/]server/printer\n", stderr);
+    return (1);
+  }
+
+ /*
+  * If we have 7 arguments, print the file named on the command-line.
+  * Otherwise, print data from stdin...
+  */
+
+  if (argc == 6)
+  {
+   /*
+    * Print from Copy stdin to a temporary file...
+    */
+
+    fp     = stdin;
+    copies = 1;
+  }
+  else if ((fp = fopen(argv[6], "rb")) == NULL)
+  {
+    perror("ERROR: Unable to open print file");
+    return (1);
+  }
+  else
+    copies = atoi(argv[4]);
+
+ /*
+  * Find the URI...
+  */
+
+  if (strncmp(argv[0], "smb://", 6) == 0)
+    strncpy(uri, argv[0], sizeof(uri) - 1);
+  else if (getenv("DEVICE_URI") != NULL)
+    strncpy(uri, getenv("DEVICE_URI"), sizeof(uri) - 1);
+  else
+  {
+    fputs("ERROR: No device URI found in argv[0] or DEVICE_URI environment variable!\n", stderr);
+    return (1);
+  }
+
+  uri[sizeof(uri) - 1] = '\0';
+
+ /*
+  * Extract the destination from the URI...
+  */
+
+  if ((sep = strrchr_m(uri, '@')) != NULL)
+  {
+    username = uri + 6;
+    *sep++ = '\0';
+
+    server = sep;
+
+   /*
+    * Extract password as needed...
+    */
+
+    if ((password = strchr_m(username, ':')) != NULL)
+      *password++ = '\0';
+    else
+      password = "";
+  }
+  else
+  {
+    username = "";
+    password = "";
+    server   = uri + 6;
+  }
+
+  if ((sep = strchr_m(server, '/')) == NULL)
+  {
+    fputs("ERROR: Bad URI - need printer name!\n", stderr);
+    return (1);
+  }
+
+  *sep++ = '\0';
+  printer = sep;
+
+  if ((sep = strchr_m(printer, '/')) != NULL)
+  {
+   /*
+    * Convert to smb://[username:password@]workgroup/server/printer...
+    */
+
+    *sep++ = '\0';
+
+    workgroup = server;
+    server    = printer;
+    printer   = sep;
+  }
+  else
+    workgroup = NULL;
+
+ /*
+  * Setup the SAMBA server state...
+  */
+
+  setup_logging("smbspool", True);
+
+  in_client = True;   /* Make sure that we tell lp_load we are */
+
+  if (!lp_load(dyn_CONFIGFILE, True, False, False))
+  {
+    fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
+    return (1);
+  }
+
+  if (workgroup == NULL)
+    workgroup = lp_workgroup();
+
+  load_interfaces();
+
+  do
+  {
+    if ((cli = smb_connect(workgroup, server, printer, username, password)) == NULL)
+    {
+      if (getenv("CLASS") == NULL)
+      {
+        fprintf(stderr, "ERROR: Unable to connect to SAMBA host, will retry in 60 seconds...");
+        sleep (60);
+      }
+      else
+      {
+        fprintf(stderr, "ERROR: Unable to connect to SAMBA host, trying next printer...");
+        return (1);
+      }
+    }
+  }
+  while (cli == NULL);
+
+ /*
+  * Now that we are connected to the server, ignore SIGTERM so that we
+  * can finish out any page data the driver sends (e.g. to eject the
+  * current page...  Only ignore SIGTERM if we are printing data from
+  * stdin (otherwise you can't cancel raw jobs...)
+  */
+
+  if (argc < 7)
+    CatchSignal(SIGTERM, SIG_IGN);
+
+ /*
+  * Queue the job...
+  */
+
+  for (i = 0; i < copies; i ++)
+    if ((status = smb_print(cli, argv[3] /* title */, fp)) != 0)
+      break;
+
+  cli_shutdown(cli);
+
+ /*
+  * Return the queue status...
+  */
+
+  return (status);
+}
+
+
+/*
+ * 'list_devices()' - List the available printers seen on the network...
+ */
+
+static void
+list_devices(void)
+{
+ /*
+  * Eventually, search the local workgroup for available hosts and printers.
+  */
+
+  puts("network smb \"Unknown\" \"Windows Printer via SAMBA\"");
+}
+
+
+/*
+ * 'smb_connect()' - Return a connection to a server.
+ */
+
+static struct cli_state *		/* O - SMB connection */
+smb_connect(const char *workgroup,		/* I - Workgroup */
+            const char *server,		/* I - Server */
+            const char *share,		/* I - Printer */
+            const char *username,		/* I - Username */
+            const char *password)		/* I - Password */
+{
+  struct cli_state	*c;		/* New connection */
+  char *myname;		/* Client name */
+  NTSTATUS nt_status;
+
+ /*
+  * Get the names and addresses of the client and server...
+  */
+
+  myname = get_myname();  
+  	
+  nt_status = cli_full_connection(&c, myname, server, NULL, 0, share, "?????", 
+				  username, workgroup, password, 0, NULL);
+  
+  free(myname);
+  if (!NT_STATUS_IS_OK(nt_status)) {
+	  fprintf(stderr, "ERROR:  Connection failed with error %s\n", nt_errstr(nt_status));
+	  return NULL;
+  }
+
+  /*
+   * Return the new connection...
+   */
+  
+  return (c);
+}
+
+
+/*
+ * 'smb_print()' - Queue a job for printing using the SMB protocol.
+ */
+
+static int				/* O - 0 = success, non-0 = failure */
+smb_print(struct cli_state *cli,	/* I - SMB connection */
+          char             *title,	/* I - Title/job name */
+          FILE             *fp)		/* I - File to print */
+{
+  int	fnum;		/* File number */
+  int	nbytes,		/* Number of bytes read */
+	tbytes;		/* Total bytes read */
+  char	buffer[8192],	/* Buffer for copy */
+	*ptr;		/* Pointer into tile */
+
+
+ /*
+  * Sanitize the title...
+  */
+
+  for (ptr = title; *ptr; ptr ++)
+    if (!isalnum((int)*ptr) && !isspace((int)*ptr))
+      *ptr = '_';
+
+ /*
+  * Open the printer device...
+  */
+
+  if ((fnum = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE)) == -1)
+  {
+    fprintf(stderr, "ERROR: %s opening remote file %s\n",
+            cli_errstr(cli), title);
+    return (1);
+  }
+
+ /*
+  * Copy the file to the printer...
+  */
+
+  if (fp != stdin)
+    rewind(fp);
+
+  tbytes = 0;
+
+  while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
+  {
+    if (cli_write(cli, fnum, 0, buffer, tbytes, nbytes) != nbytes)
+    {
+      fprintf(stderr, "ERROR: Error writing file: %s\n", cli_errstr(cli));
+      break;
+    }
+
+    tbytes += nbytes;
+  } 
+
+  if (!cli_close(cli, fnum))
+  {
+    fprintf(stderr, "ERROR: %s closing remote file %s\n",
+            cli_errstr(cli), title);
+    return (1);
+  }
+  else
+    return (0);
+}
diff --git a/source4/client/smbumount.c b/source4/client/smbumount.c
new file mode 100644
index 0000000000..9ea3083a6f
--- /dev/null
+++ b/source4/client/smbumount.c
@@ -0,0 +1,186 @@
+/*
+ *  smbumount.c
+ *
+ *  Copyright (C) 1995-1998 by Volker Lendecke
+ *
+ */
+
+#include "includes.h"
+
+#include <mntent.h>
+
+#include <asm/types.h>
+#include <asm/posix_types.h>
+#include <linux/smb.h>
+#include <linux/smb_mount.h>
+#include <linux/smb_fs.h>
+
+/* This is a (hopefully) temporary hack due to the fact that
+	sizeof( uid_t ) != sizeof( __kernel_uid_t ) under glibc.
+	This may change in the future and smb.h may get fixed in the
+	future.  In the mean time, it's ugly hack time - get over it.
+*/
+#undef SMB_IOC_GETMOUNTUID
+#define	SMB_IOC_GETMOUNTUID		_IOR('u', 1, __kernel_uid_t)
+
+#ifndef O_NOFOLLOW
+#define O_NOFOLLOW     0400000
+#endif
+
+static void
+usage(void)
+{
+        printf("usage: smbumount mountpoint\n");
+}
+
+static int
+umount_ok(const char *mount_point)
+{
+	/* we set O_NOFOLLOW to prevent users playing games with symlinks to
+	   umount filesystems they don't own */
+        int fid = open(mount_point, O_RDONLY|O_NOFOLLOW, 0);
+        __kernel_uid_t mount_uid;
+	
+        if (fid == -1) {
+                fprintf(stderr, "Could not open %s: %s\n",
+                        mount_point, strerror(errno));
+                return -1;
+        }
+        
+        if (ioctl(fid, SMB_IOC_GETMOUNTUID, &mount_uid) != 0) {
+                fprintf(stderr, "%s probably not smb-filesystem\n",
+                        mount_point);
+                return -1;
+        }
+
+        if ((getuid() != 0)
+            && (mount_uid != getuid())) {
+                fprintf(stderr, "You are not allowed to umount %s\n",
+                        mount_point);
+                return -1;
+        }
+
+        close(fid);
+        return 0;
+}
+
+/* Make a canonical pathname from PATH.  Returns a freshly malloced string.
+   It is up the *caller* to ensure that the PATH is sensible.  i.e.
+   canonicalize ("/dev/fd0/.") returns "/dev/fd0" even though ``/dev/fd0/.''
+   is not a legal pathname for ``/dev/fd0''  Anything we cannot parse
+   we return unmodified.   */
+static char *
+canonicalize (char *path)
+{
+	char *canonical = malloc (PATH_MAX + 1);
+
+	if (!canonical) {
+		fprintf(stderr, "Error! Not enough memory!\n");
+		return NULL;
+	}
+
+	if (strlen(path) > PATH_MAX) {
+		fprintf(stderr, "Mount point string too long\n");
+		return NULL;
+	}
+
+	if (path == NULL)
+		return NULL;
+  
+	if (realpath (path, canonical))
+		return canonical;
+
+	strncpy (canonical, path, PATH_MAX);
+	canonical[PATH_MAX] = '\0';
+	return canonical;
+}
+
+
+int 
+main(int argc, char *argv[])
+{
+        int fd;
+        char* mount_point;
+        struct mntent *mnt;
+        FILE* mtab;
+        FILE* new_mtab;
+
+        if (argc != 2) {
+                usage();
+                exit(1);
+        }
+
+        if (geteuid() != 0) {
+                fprintf(stderr, "smbumount must be installed suid root\n");
+                exit(1);
+        }
+
+        mount_point = canonicalize(argv[1]);
+
+	if (mount_point == NULL)
+	{
+		exit(1);
+	}
+
+        if (umount_ok(mount_point) != 0) {
+                exit(1);
+        }
+
+        if (umount(mount_point) != 0) {
+                fprintf(stderr, "Could not umount %s: %s\n",
+                        mount_point, strerror(errno));
+                exit(1);
+        }
+
+        if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1)
+        {
+                fprintf(stderr, "Can't get "MOUNTED"~ lock file");
+                return 1;
+        }
+        close(fd);
+	
+        if ((mtab = setmntent(MOUNTED, "r")) == NULL) {
+                fprintf(stderr, "Can't open " MOUNTED ": %s\n",
+                        strerror(errno));
+                return 1;
+        }
+
+#define MOUNTED_TMP MOUNTED".tmp"
+
+        if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) {
+                fprintf(stderr, "Can't open " MOUNTED_TMP ": %s\n",
+                        strerror(errno));
+                endmntent(mtab);
+                return 1;
+        }
+
+        while ((mnt = getmntent(mtab)) != NULL) {
+                if (strcmp(mnt->mnt_dir, mount_point) != 0) {
+                        addmntent(new_mtab, mnt);
+                }
+        }
+
+        endmntent(mtab);
+
+        if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
+                fprintf(stderr, "Error changing mode of %s: %s\n",
+                        MOUNTED_TMP, strerror(errno));
+                exit(1);
+        }
+
+        endmntent(new_mtab);
+
+        if (rename(MOUNTED_TMP, MOUNTED) < 0) {
+                fprintf(stderr, "Cannot rename %s to %s: %s\n",
+                        MOUNTED, MOUNTED_TMP, strerror(errno));
+                exit(1);
+        }
+
+        if (unlink(MOUNTED"~") == -1)
+        {
+                fprintf(stderr, "Can't remove "MOUNTED"~");
+                return 1;
+        }
+
+	return 0;
+}	
diff --git a/source4/client/tree.c b/source4/client/tree.c
new file mode 100644
index 0000000000..94fd93c210
--- /dev/null
+++ b/source4/client/tree.c
@@ -0,0 +1,811 @@
+/* 
+   Unix SMB/CIFS implementation.
+   SMB client GTK+ tree-based application
+   Copyright (C) Andrew Tridgell 1998
+   Copyright (C) Richard Sharpe 2001
+   Copyright (C) John Terpstra 2001
+   
+   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 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* example-gtk+ application, ripped off from the gtk+ tree.c sample */
+
+#include <stdio.h>
+#include <errno.h>
+#include <gtk/gtk.h>
+#include "libsmbclient.h"
+
+static GtkWidget *clist;
+
+struct tree_data {
+
+  guint32 type;    /* Type of tree item, an SMBC_TYPE */
+  char name[256];  /* May need to change this later   */
+
+};
+
+void error_message(gchar *message) {
+
+  GtkWidget *dialog, *label, *okay_button;
+     
+  /* Create the widgets */
+     
+  dialog = gtk_dialog_new();
+  gtk_window_set_modal(GTK_WINDOW(dialog), True);
+  label = gtk_label_new (message);
+  okay_button = gtk_button_new_with_label("Okay");
+     
+  /* Ensure that the dialog box is destroyed when the user clicks ok. */
+     
+  gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
+			     GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
+  gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
+		     okay_button);
+
+  /* Add the label, and show everything we've added to the dialog. */
+
+  gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
+		     label);
+  gtk_widget_show_all (dialog);
+}
+
+/*
+ * We are given a widget, and we want to retrieve its URL so we 
+ * can do a directory listing.
+ *
+ * We walk back up the tree, picking up pieces until we hit a server or
+ * workgroup type and return a path from there
+ */
+
+static char path_string[1024];
+
+char *get_path(GtkWidget *item)
+{
+  GtkWidget *p = item;
+  struct tree_data *pd;
+  char *comps[1024];  /* We keep pointers to the components here */
+  int i = 0, j, level,type;
+
+  /* Walk back up the tree, getting the private data */
+
+  level = GTK_TREE(item->parent)->level;
+
+  /* Pick up this item's component info */
+
+  pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
+
+  comps[i++] = pd->name;
+  type = pd->type;
+
+  while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
+
+    /* Find the parent and extract the data etc ... */
+
+    p = GTK_WIDGET(p->parent);    
+    p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
+
+    pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
+
+    level = GTK_TREE(item->parent)->level;
+
+    comps[i++] = pd->name;
+    type = pd->type;
+
+  }
+
+  /* 
+   * Got a list of comps now, should check that we did not hit a workgroup
+   * when we got other things as well ... Later
+   *
+   * Now, build the path
+   */
+
+  snprintf(path_string, sizeof(path_string), "smb:/");
+
+  for (j = i - 1; j >= 0; j--) {
+
+    strncat(path_string, "/", sizeof(path_string) - strlen(path_string));
+    strncat(path_string, comps[j], sizeof(path_string) - strlen(path_string));
+
+  }
+  
+  fprintf(stdout, "Path string = %s\n", path_string);
+
+  return path_string;
+
+}
+
+struct tree_data *make_tree_data(guint32 type, const char *name)
+{
+  struct tree_data *p = (struct tree_data *)malloc(sizeof(struct tree_data));
+
+  if (p) {
+
+    p->type = type;
+    strncpy(p->name, name, sizeof(p->name));
+
+  }
+
+  return p;
+
+}
+
+/* Note that this is called every time the user clicks on an item,
+   whether it is already selected or not. */
+static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
+			     GtkWidget *subtree)
+{
+  gint dh, err, dirlen;
+  char dirbuf[512];
+  struct smbc_dirent *dirp;
+  struct stat st1;
+  char path[1024], path1[1024];
+
+  g_print ("select_child called for root tree %p, subtree %p, child %p\n",
+	   root_tree, subtree, child);
+
+  /* Now, figure out what it is, and display it in the clist ... */
+
+  gtk_clist_clear(GTK_CLIST(clist));  /* Clear the CLIST */
+
+  /* Now, get the private data for the subtree */
+
+  strncpy(path, get_path(child), 1024);
+
+  if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
+
+    g_print("cb_select_child: Could not open dir %s, %s\n", path,
+	    strerror(errno));
+
+    gtk_main_quit();
+
+    return;
+
+  }
+
+  while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
+			      sizeof(dirbuf))) != 0) {
+
+    if (err < 0) {
+
+      g_print("cb_select_child: Could not read dir %s, %s\n", path,
+	      strerror(errno));
+
+      gtk_main_quit();
+
+      return;
+
+    }
+
+    dirp = (struct smbc_dirent *)dirbuf;
+
+    while (err > 0) {
+      gchar col1[128], col2[128], col3[128], col4[128];
+      gchar *rowdata[4] = {col1, col2, col3, col4};
+
+      dirlen = dirp->dirlen;
+
+      /* Format each of the items ... */
+
+      strncpy(col1, dirp->name, 128);
+
+      col2[0] = col3[0] = col4[0] = (char)0;
+
+      switch (dirp->smbc_type) {
+
+      case SMBC_WORKGROUP:
+
+	break;
+
+      case SMBC_SERVER:
+
+	strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+
+	break;
+
+      case SMBC_FILE_SHARE:
+
+	strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+
+	break;
+
+      case SMBC_PRINTER_SHARE:
+
+	strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+	break;
+
+      case SMBC_COMMS_SHARE:
+
+	break;
+
+      case SMBC_IPC_SHARE:
+
+	break;
+
+      case SMBC_DIR:
+      case SMBC_FILE:
+
+	/* Get stats on the file/dir and see what we have */
+
+	if ((strcmp(dirp->name, ".") != 0) &&
+	    (strcmp(dirp->name, "..") != 0)) {
+
+	  strncpy(path1, path, sizeof(path1));
+	  strncat(path1, "/", sizeof(path) - strlen(path));
+	  strncat(path1, dirp->name, sizeof(path) - strlen(path));
+
+	  if (smbc_stat(path1, &st1) < 0) {
+	    
+	    if (errno != EBUSY) {
+	      
+	      g_print("cb_select_child: Could not stat file %s, %s\n", path1, 
+		      strerror(errno));
+	    
+	      gtk_main_quit();
+
+	      return;
+
+	    }
+	    else {
+
+	      strncpy(col2, "Device or resource busy", sizeof(col2));
+
+	    }
+	  }
+	  else {
+	    /* Now format each of the relevant things ... */
+
+	    snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)",
+		     (st1.st_mode&S_IRUSR?'r':'-'),
+		     (st1.st_mode&S_IWUSR?'w':'-'),
+		     (st1.st_mode&S_IXUSR?'x':'-'),
+		     (st1.st_mode&S_IRGRP?'r':'-'),
+		     (st1.st_mode&S_IWGRP?'w':'-'),
+		     (st1.st_mode&S_IXGRP?'x':'-'),
+		     (st1.st_mode&S_IROTH?'r':'-'),
+		     (st1.st_mode&S_IWOTH?'w':'-'),
+		     (st1.st_mode&S_IXOTH?'x':'-'),
+		     st1.st_mode); 
+	    snprintf(col3, sizeof(col3), "%u", st1.st_size);
+	    snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime));
+	  }
+	}
+
+	break;
+
+      default:
+
+	break;
+      }
+
+      gtk_clist_append(GTK_CLIST(clist), rowdata);
+
+      (char *)dirp += dirlen;
+      err -= dirlen;
+
+    }
+
+  }
+
+}
+
+/* Note that this is never called */
+static void cb_unselect_child( GtkWidget *root_tree,
+                               GtkWidget *child,
+                               GtkWidget *subtree )
+{
+  g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
+	   root_tree, subtree, child);
+}
+
+/* for all the GtkItem:: and GtkTreeItem:: signals */
+static void cb_itemsignal( GtkWidget *item,
+                           gchar     *signame )
+{
+  GtkWidget *real_tree, *aitem, *subtree;
+  gchar *name;
+  GtkLabel *label;
+  gint dh, err, dirlen, level;
+  char dirbuf[512];
+  struct smbc_dirent *dirp;
+  
+  label = GTK_LABEL (GTK_BIN (item)->child);
+  /* Get the text of the label */
+  gtk_label_get (label, &name);
+
+  level = GTK_TREE(item->parent)->level;
+
+  /* Get the level of the tree which the item is in */
+  g_print ("%s called for item %s->%p, level %d\n", signame, name,
+	   item, GTK_TREE (item->parent)->level);
+
+  real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
+
+  if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
+    char server[128];
+
+    if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
+      gchar errmsg[256];
+
+      g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item), 
+	      strerror(errno));
+
+      slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno));
+
+      error_message(errmsg);
+
+      /*      gtk_main_quit();*/
+
+      return;
+
+    }
+
+    while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
+				sizeof(dirbuf))) != 0) {
+
+      if (err < 0) { /* An error, report it */
+	gchar errmsg[256];
+
+	g_print("cb_itemsignal: Could not read dir smbc://, %s\n",
+		strerror(errno));
+
+	slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno));
+
+	error_message(errmsg);
+
+	/*	gtk_main_quit();*/
+
+	return;
+
+      }
+
+      dirp = (struct smbc_dirent *)dirbuf;
+
+      while (err > 0) {
+	struct tree_data *my_data;
+
+	dirlen = dirp->dirlen;
+
+	my_data = make_tree_data(dirp->smbc_type, dirp->name);
+
+	if (!my_data) {
+
+	  g_print("Could not allocate space for tree_data: %s\n",
+		  dirp->name);
+
+	  gtk_main_quit();
+	  return;
+
+	}
+
+	aitem = gtk_tree_item_new_with_label(dirp->name);
+
+	/* Connect all GtkItem:: and GtkTreeItem:: signals */
+	gtk_signal_connect (GTK_OBJECT(aitem), "select",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "select");
+	gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
+	gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
+	gtk_signal_connect (GTK_OBJECT(aitem), "expand",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
+	gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
+	/* Add it to the parent tree */
+	gtk_tree_append (GTK_TREE(real_tree), aitem);
+
+	gtk_widget_show (aitem);
+
+	gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
+
+	fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
+
+	if (dirp->smbc_type != SMBC_FILE &&
+	    dirp->smbc_type != SMBC_IPC_SHARE &&
+	    (strcmp(dirp->name, ".") != 0) && 
+	    (strcmp(dirp->name, "..") !=0)){
+	  
+	  subtree = gtk_tree_new();
+	  gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
+
+	  gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
+			     GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+	  gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
+			     GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+	}
+
+	(char *)dirp += dirlen;
+	err -= dirlen;
+
+      }
+
+    }
+
+    smbc_closedir(dh);   
+
+  }
+  else if (strncmp(signame, "collapse", 8) == 0) {
+    GtkWidget *subtree = gtk_tree_new();
+
+    gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
+
+    gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+    gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+			GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+    gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+			GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+  }
+
+}
+
+static void cb_selection_changed( GtkWidget *tree )
+{
+  GList *i;
+  
+  g_print ("selection_change called for tree %p\n", tree);
+  g_print ("selected objects are:\n");
+
+  i = GTK_TREE_SELECTION(tree);
+  while (i){
+    gchar *name;
+    GtkLabel *label;
+    GtkWidget *item;
+
+    /* Get a GtkWidget pointer from the list node */
+    item = GTK_WIDGET (i->data);
+    label = GTK_LABEL (GTK_BIN (item)->child);
+    gtk_label_get (label, &name);
+    g_print ("\t%s on level %d\n", name, GTK_TREE
+	     (item->parent)->level);
+    i = i->next;
+  }
+}
+
+/*
+ * Expand or collapse the whole network ...
+ */
+static void cb_wholenet(GtkWidget *item, gchar *signame)
+{
+  GtkWidget *real_tree, *aitem, *subtree;
+  gchar *name;
+  GtkLabel *label;
+  gint dh, err, dirlen;
+  char dirbuf[512];
+  struct smbc_dirent *dirp;
+  
+  label = GTK_LABEL (GTK_BIN (item)->child);
+  gtk_label_get (label, &name);
+  g_print ("%s called for item %s->%p, level %d\n", signame, name,
+	   item, GTK_TREE (item->parent)->level);
+
+  real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
+
+  if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
+
+    if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
+
+      g_print("cb_wholenet: Could not open dir smbc://, %s\n",
+	      strerror(errno));
+
+      gtk_main_quit();
+
+      return;
+
+    }
+
+    while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
+				sizeof(dirbuf))) != 0) {
+
+      if (err < 0) { /* An error, report it */
+
+	g_print("cb_wholenet: Could not read dir smbc://, %s\n",
+		strerror(errno));
+
+	gtk_main_quit();
+
+	return;
+
+      }
+
+      dirp = (struct smbc_dirent *)dirbuf;
+
+      while (err > 0) {
+	struct tree_data *my_data;
+
+	dirlen = dirp->dirlen;
+
+	my_data = make_tree_data(dirp->smbc_type, dirp->name);
+
+	aitem = gtk_tree_item_new_with_label(dirp->name);
+
+	/* Connect all GtkItem:: and GtkTreeItem:: signals */
+	gtk_signal_connect (GTK_OBJECT(aitem), "select",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "select");
+	gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
+	gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
+	gtk_signal_connect (GTK_OBJECT(aitem), "expand",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
+	gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
+			    GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
+
+	gtk_tree_append (GTK_TREE(real_tree), aitem);
+	/* Show it - this can be done at any time */
+	gtk_widget_show (aitem);
+
+	gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
+
+	fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
+
+	subtree = gtk_tree_new();
+
+	gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
+
+	gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
+			   GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+	gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
+			   GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+	(char *)dirp += dirlen;
+	err -= dirlen;
+
+      }
+
+    }
+
+    smbc_closedir(dh);   
+
+  }
+  else { /* Must be collapse ... FIXME ... */
+    GtkWidget *subtree = gtk_tree_new();
+
+    gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
+
+    gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+    gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+			GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+    gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+			GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+
+  }
+
+}
+
+/* Should put up a dialog box to ask the user for username and password */
+
+static void 
+auth_fn(const char *server, const char *share,
+	char *workgroup, int wgmaxlen, char *username, int unmaxlen,
+	char *password, int pwmaxlen)
+{
+
+   strncpy(username, "test", unmaxlen);
+   strncpy(password, "test", pwmaxlen);
+
+}
+
+static char *col_titles[] = {
+  "Name", "Attributes", "Size", "Modification Date",
+};
+
+int main( int   argc,
+          char *argv[] )
+{
+  GtkWidget *window, *scrolled_win, *scrolled_win2, *tree;
+  GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane;
+  gint err, dh;
+  gint i;
+  char dirbuf[512];
+  struct smbc_dirent *dirp;
+
+  gtk_init (&argc, &argv);
+
+  /* Init the smbclient library */
+
+  err = smbc_init(auth_fn, 10);
+
+  /* Print an error response ... */
+
+  if (err < 0) {
+
+    fprintf(stderr, "smbc_init returned %s (%i)\nDo you have a ~/.smb/smb.conf file?\n", strerror(errno), errno);
+    exit(1);
+
+  }
+
+  /* a generic toplevel window */
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_set_name(window, "main browser window");
+  gtk_signal_connect (GTK_OBJECT(window), "delete_event",
+		      GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
+  gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser");
+  gtk_widget_set_usize(GTK_WIDGET(window), 750, -1);
+  gtk_container_set_border_width (GTK_CONTAINER(window), 5);
+
+  gtk_widget_show (window);
+
+  /* A container for the two panes ... */
+
+  main_hbox = gtk_hbox_new(FALSE, 1);
+  gtk_container_border_width(GTK_CONTAINER(main_hbox), 1);
+  gtk_container_add(GTK_CONTAINER(window), main_hbox);
+
+  gtk_widget_show(main_hbox);
+
+  l_pane = gtk_hpaned_new();
+  gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
+  r_pane = gtk_hpaned_new();
+  gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size);
+  gtk_container_add(GTK_CONTAINER(main_hbox), l_pane);
+  gtk_widget_show(l_pane);
+
+  /* A generic scrolled window */
+  scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+				  GTK_POLICY_AUTOMATIC,
+				  GTK_POLICY_AUTOMATIC);
+  gtk_widget_set_usize (scrolled_win, 150, 200);
+  gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win);
+  gtk_widget_show (scrolled_win);
+
+  /* Another generic scrolled window */
+  scrolled_win2 = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2),
+				  GTK_POLICY_AUTOMATIC,
+				  GTK_POLICY_AUTOMATIC);
+  gtk_widget_set_usize (scrolled_win2, 150, 200);
+  gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2);
+  gtk_widget_show (scrolled_win2);
+  
+  /* Create the root tree */
+  tree = gtk_tree_new();
+  g_print ("root tree is %p\n", tree);
+  /* connect all GtkTree:: signals */
+  gtk_signal_connect (GTK_OBJECT(tree), "select_child",
+		      GTK_SIGNAL_FUNC(cb_select_child), tree);
+  gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
+		      GTK_SIGNAL_FUNC(cb_unselect_child), tree);
+  gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
+		      GTK_SIGNAL_FUNC(cb_selection_changed), tree);
+  /* Add it to the scrolled window */
+  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
+                                         tree);
+  /* Set the selection mode */
+  gtk_tree_set_selection_mode (GTK_TREE(tree),
+			       GTK_SELECTION_MULTIPLE);
+  /* Show it */
+  gtk_widget_show (tree);
+
+  /* Now, create a clist and attach it to the second pane */
+
+  clist = gtk_clist_new_with_titles(4, col_titles);
+
+  gtk_container_add (GTK_CONTAINER(scrolled_win2), clist);
+
+  gtk_widget_show(clist);
+
+  /* Now, build the top level display ... */
+
+  if ((dh = smbc_opendir("smb:///")) < 0) {
+
+    fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
+	    strerror(errno));
+
+    exit(1);
+
+  }
+
+  /* Create a tree item for Whole Network */
+
+  item = gtk_tree_item_new_with_label ("Whole Network");
+  /* Connect all GtkItem:: and GtkTreeItem:: signals */
+  gtk_signal_connect (GTK_OBJECT(item), "select",
+		      GTK_SIGNAL_FUNC(cb_itemsignal), "select");
+  gtk_signal_connect (GTK_OBJECT(item), "deselect",
+		      GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
+  gtk_signal_connect (GTK_OBJECT(item), "toggle",
+		      GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
+  gtk_signal_connect (GTK_OBJECT(item), "expand",
+		      GTK_SIGNAL_FUNC(cb_wholenet), "expand");
+  gtk_signal_connect (GTK_OBJECT(item), "collapse",
+		      GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
+  /* Add it to the parent tree */
+  gtk_tree_append (GTK_TREE(tree), item);
+  /* Show it - this can be done at any time */
+  gtk_widget_show (item);
+
+  subtree = gtk_tree_new();  /* A subtree for Whole Network */
+
+  gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+  gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+		      GTK_SIGNAL_FUNC(cb_select_child), tree);
+  gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+		      GTK_SIGNAL_FUNC(cb_unselect_child), tree);
+
+  /* Now, get the items in smb:/// and add them to the tree */
+
+  dirp = (struct smbc_dirent *)dirbuf;
+
+  while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
+			      sizeof(dirbuf))) != 0) {
+
+    if (err < 0) { /* Handle the error */
+
+      fprintf(stderr, "Could not read directory for smbc:///: %s\n",
+	      strerror(errno));
+
+      exit(1);
+
+    }
+
+    fprintf(stdout, "Dir len: %u\n", err);
+
+    while (err > 0) { /* Extract each entry and make a sub-tree */
+      struct tree_data *my_data;
+      int dirlen = dirp->dirlen;
+
+      my_data = make_tree_data(dirp->smbc_type, dirp->name);
+
+      item = gtk_tree_item_new_with_label(dirp->name);
+      /* Connect all GtkItem:: and GtkTreeItem:: signals */
+      gtk_signal_connect (GTK_OBJECT(item), "select",
+			  GTK_SIGNAL_FUNC(cb_itemsignal), "select");
+      gtk_signal_connect (GTK_OBJECT(item), "deselect",
+			  GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
+      gtk_signal_connect (GTK_OBJECT(item), "toggle",
+			  GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
+      gtk_signal_connect (GTK_OBJECT(item), "expand",
+			  GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
+      gtk_signal_connect (GTK_OBJECT(item), "collapse",
+			  GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
+      /* Add it to the parent tree */
+      gtk_tree_append (GTK_TREE(tree), item);
+      /* Show it - this can be done at any time */
+      gtk_widget_show (item);
+
+      gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data);
+
+      fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
+
+      subtree = gtk_tree_new();
+
+      gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+      gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+			  GTK_SIGNAL_FUNC(cb_select_child), tree);
+      gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+			  GTK_SIGNAL_FUNC(cb_unselect_child), tree);
+
+      (char *)dirp += dirlen;
+      err -= dirlen;
+
+    }
+
+  }
+
+  smbc_closedir(dh); /* FIXME, check for error :-) */
+
+  /* Show the window and loop endlessly */
+  gtk_main();
+  return 0;
+}
+/* example-end */