Revert to 3.4.7...for now?

git-svn-id: svn://svn.debian.org/svn/pkg-samba/trunk/samba@3416 fc4039ab-9d04-0410-8cac-899223bdd6b0

8 files changed, 2006 insertions, 44 deletions

diff --git a/source4/client/client.c b/source4/client/client.c
index 3fa819c8e7..018be29761 100644
--- a/source4/client/client.c
+++ b/source4/client/client.c
@@ -1221,14 +1221,10 @@ static int cmd_put(struct smbclient_context *ctx, const char **args)
 
 	lname = talloc_strdup(ctx, args[1]);
   
-	if (args[2]) {
-		if (args[2][0]=='\\')
-			rname = talloc_strdup(ctx, args[2]);
-		else
-			rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[2]);
-	} else {
+	if (args[2])
+		rname = talloc_strdup(ctx, args[2]);
+	else
 		rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, lname);
-	}
 	
 	dos_clean_name(rname);
 
@@ -3294,18 +3290,15 @@ static int do_message_op(const char *netbios_name, const char *desthost,
 			lp_gensec_settings(ctx, cmdline_lp_ctx)))
 		return 1;
 
-	if (base_directory) {
+	if (base_directory) 
 		do_cd(ctx, base_directory);
-		free(base_directory);
-	}
 	
 	if (cmdstr) {
 		rc = process_command_string(ctx, cmdstr);
 	} else {
 		rc = process_stdin(ctx);
 	}
-
-	free(desthost);
+  
 	talloc_free(mem_ctx);
 
 	return rc;
diff --git a/source4/client/config.m4 b/source4/client/config.m4
deleted file mode 100644
index 800320d7d5..0000000000
--- a/source4/client/config.m4
+++ /dev/null
@@ -1,13 +0,0 @@
-case "$host_os" in
-  *linux*)
-  	SMB_ENABLE(mount.cifs, YES)
-  	SMB_ENABLE(umount.cifs, YES)
-  	SMB_ENABLE(cifs.upcall, NO) # Disabled for now
-	;;
-   *)
-  	SMB_ENABLE(mount.cifs, NO)
-  	SMB_ENABLE(umount.cifs, NO)
-  	SMB_ENABLE(cifs.upcall, NO)
-	;;
-esac
-
diff --git a/source4/client/config.mk b/source4/client/config.mk
index dee42d016a..877544a09a 100644
--- a/source4/client/config.mk
+++ b/source4/client/config.mk
@@ -20,22 +20,6 @@ PRIVATE_DEPENDENCIES = \
 
 smbclient_OBJ_FILES = $(clientsrcdir)/client.o
 
-[BINARY::mount.cifs]
-INSTALLDIR = BINDIR
-
-mount.cifs_OBJ_FILES = ../client/mount.cifs.o \
-					   ../client/mtab.o
-
-[BINARY::umount.cifs]
-INSTALLDIR = BINDIR
-
-umount.cifs_OBJ_FILES = ../client/umount.cifs.o \
-					   ../client/mtab.o
-
-#[BINARY::cifs.upcall]
-#INSTALLDIR = BINDIR
-#cifs.upcall_OBJ_FILES = ../client/cifs.upcall.o
-
 #################################
 # Start BINARY cifsdd
 [BINARY::cifsdd]
diff --git a/source4/client/mount.cifs.c b/source4/client/mount.cifs.c
new file mode 100644
index 0000000000..899c90cefd
--- /dev/null
+++ b/source4/client/mount.cifs.c
@@ -0,0 +1,559 @@
+#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, "");
+#if defined(LOCALEDIR)
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE); */
+#endif
+
+	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..0d619a88fe
--- /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 uint_t mount_fmask;
+static uint_t 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, uint_t 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;
+	uint_t 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..c219a42f3a
--- /dev/null
+++ b/source4/client/smbmount.c
@@ -0,0 +1,942 @@
+/* 
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "system/passwd.h"
+
+#include <mntent.h>
+#include <asm/types.h>
+#include <linux/smb_fs.h>
+
+#define pstrcpy(d,s) safe_strcpy((d),(s),sizeof(pstring)-1)
+#define pstrcat(d,s) safe_strcat((d),(s),sizeof(pstring)-1)
+
+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 uint_t mount_fmask;
+static uint_t 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 smbcli_state *do_connection(const char *the_service, bool unicode, int maxprotocol,
+					  struct smbcli_session_options session_options)
+{
+	struct smbcli_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);
+	choose_called_name(&called, server, 0x20);
+
+ again:
+        zero_ip(&ip);
+	if (have_ip) ip = dest_ip;
+
+	/* have to open a new connection */
+	if (!(c=smbcli_initialise(NULL)) || (smbcli_set_port(c, smb_port) != smb_port) ||
+	    !smbcli_connect(c, server_n, &ip)) {
+		DEBUG(0,("%d: Connection to %s failed\n", sys_getpid(), server_n));
+		if (c) {
+			talloc_free(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 (!smbcli_session_request(c, &calling, &called)) {
+		char *p;
+		DEBUG(0,("%d: session request to %s failed (%s)\n", 
+			 sys_getpid(), called.name, smbcli_errstr(c)));
+		talloc_free(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 (!smbcli_negprot(c, unicode, maxprotocol)) {
+		DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid()));
+		talloc_free(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 (!smbcli_session_setup(c, username, 
+			       password, strlen(password),
+			       password, strlen(password),
+			       workgroup, session_options)) {
+		/* if a password was not supplied then try again with a
+			null username */
+		if (password[0] || !username[0] ||
+				!smbcli_session_setup(c, "", "", 0, "", 0, workgroup, 
+						      session_options)) {
+			DEBUG(0,("%d: session setup failed: %s\n",
+				sys_getpid(), smbcli_errstr(c)));
+			talloc_free(c);
+			return NULL;
+		}
+		DEBUG(0,("Anonymous login successful\n"));
+	}
+
+	DEBUG(4,("%d: session setup ok\n", sys_getpid()));
+
+	if (!smbcli_tconX(c, share, "?????", password, strlen(password)+1)) {
+		DEBUG(0,("%d: tree connect failed: %s\n",
+			 sys_getpid(), smbcli_errstr(c)));
+		talloc_free(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(const 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(struct loadparm_context *lp_ctx,
+			   const char *the_service, const char *mount_point, struct smbcli_state *c)
+{
+	int fd, closed = 0, res = 1;
+	pid_t parentpid = getppid();
+	struct smb_conn_opt conn_options;
+	struct smbcli_session_options session_options;
+
+	lp_smbcli_session_options(lp_ctx, &session_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. */
+		talloc_free(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", DEBUG_STDERR);
+			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, 
+					  lp_unicode(lp_ctx), 
+					  lp_cli_maxprotocol(lp_ctx),
+					  session_options);
+		}
+	}
+
+	smb_umount(mount_point);
+	DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid()));
+	exit(1);
+}
+
+
+/**
+ * Mount a smbfs
+ **/
+static void init_mount(struct loadparm_context *lp_ctx)
+{
+	char mount_point[MAXPATHLEN+1];
+	pstring tmp;
+	pstring svc2;
+	struct smbcli_state *c;
+	char *args[20];
+	int i, status;
+	struct smbcli_session_options session_options;
+
+	if (realpath(mpoint, mount_point) == NULL) {
+		fprintf(stderr, "Could not resolve mount point %s\n", mpoint);
+		return;
+	}
+
+	lp_smbcli_session_options(lp_ctx, &session_options);
+
+	c = do_connection(service, lp_unicode(lp_ctx), lp_cli_maxprotocol(lp_ctx),
+			  session_options);
+	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)) {
+			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(lp_ctx, 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 = 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_t 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_v4(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;
+	struct loadparm_context *lp_ctx;
+
+	DEBUGLEVEL = 1;
+
+	/* here we are interactive, even if run from autofs */
+	setup_logging("mount.smbfs",DEBUG_STDERR);
+
+#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
+
+	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"));
+	}
+
+	lp_ctx = loadparm_init(talloc_autofree_context());
+
+	if (!lp_load(lp_ctx, dyn_CONFIGFILE)) {
+		fprintf(stderr, "Can't load %s - run testparm to debug it\n", 
+			lp_config_file());
+	}
+
+	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());
+	}
+
+	if (!*my_netbios_name) {
+		pstrcpy(my_netbios_name, myhostname());
+	}
+	strupper(my_netbios_name);
+
+	init_mount(lp_ctx);
+	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/tests/test_smbclient.sh b/source4/client/tests/test_smbclient.sh
index 2fd5b56ca0..7775422e33 100755
--- a/source4/client/tests/test_smbclient.sh
+++ b/source4/client/tests/test_smbclient.sh
@@ -43,8 +43,13 @@ testit "share and server list" $VALGRIND $smbclient -L $SERVER $CONFIGURATION  -
 
 testit "share and server list anonymously" $VALGRIND $smbclient -N -L $SERVER $CONFIGURATION $@ || failed=`expr $failed + 1`
 
-# Use the smbclient binary as our test file
-cat $smbclient >tmpfile
+# Generate random file
+cat >tmpfile<<EOF
+foo
+bar
+bloe
+blah
+EOF
 
 # put that file
 runcmd "MPutting file" 'mput tmpfile' || failed=`expr $failed + 1`
@@ -112,7 +117,7 @@ runcmd "Removing file" 'rm tmpfilex'|| failed=`expr $failed + 1`
 
 runcmd "Lookup name" "lookup $DOMAIN\\$USERNAME" || failed=`expr $failed + 1`
 
-#Fails unless there are privileges
+#Fails unless there are privilages
 #runcmd "Lookup privs of name" "privileges $DOMAIN\\$USERNAME" || failed=`expr $failed + 1`
 
 # do some simple operations using old protocol versions