r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[tprouty/samba.git] / source / client / smbmount.c
index 51c1ee6310a947752053ba34c3815bb265cac625..b68dbfe346299365c0541f4f8432587e90bbc528 100644 (file)
@@ -1,12 +1,11 @@
 /* 
-   Unix SMB/Netbios implementation.
-   Version 1.9.
-   SMB client
-   Copyright (C) Andrew Tridgell 1994-1998
+   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
+   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,
    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.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifdef SYSLOG
-#undef SYSLOG
-#endif
-
-#include <linux/version.h>
-#define LVERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
-#if LINUX_VERSION_CODE < LVERSION(2,1,70)
-#error this code will only compile on versions of linux after 2.1.70
-#endif
-
 #include "includes.h"
-#include <linux/smb_fs.h>
-static struct smb_conn_opt conn_options;
-
-#ifndef REGISTER
-#define REGISTER 0
-#endif
 
-/* Uncomment this to allow debug the smbmount daemon */
-#define SMBFS_DEBUG 1
-
-pstring cur_dir = "\\";
-pstring cd_path = "";
-extern pstring service;
-extern pstring desthost;
-extern pstring global_myname;
-extern pstring myhostname;
-extern pstring password;
-extern pstring username;
-extern pstring workgroup;
-char *cmdstr="";
-extern BOOL got_pass;
-extern BOOL connect_as_printer;
-extern BOOL connect_as_ipc;
-extern struct in_addr ipzero;
-
-extern BOOL doencrypt;
+#include <mntent.h>
+#include <asm/types.h>
+#include <linux/smb_fs.h>
 
+extern BOOL in_client;
 extern pstring user_socket_options;
+extern char *optarg;
+extern int optind;
+
+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 BOOL smbfs_has_unicode = False;
+static BOOL smbfs_has_lfs = False;
+
+static void usage(void);
+
+static void exit_parent(int sig)
+{
+       /* parent simply exits when child says go... */
+       exit(0);
+}
 
-/* 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)
-
-extern int name_type;
-
-extern int max_protocol;
-int port = SMB_PORT;
+static void daemonize(void)
+{
+       int j, status;
+       pid_t child_pid;
 
+       signal( SIGTERM, exit_parent );
 
-time_t newer_than = 0;
-int archive_level = 0;
+       if ((child_pid = sys_fork()) < 0) {
+               DEBUG(0,("could not fork\n"));
+       }
 
-extern pstring debugf;
-extern int DEBUGLEVEL;
+       if (child_pid > 0) {
+               while( 1 ) {
+                       j = waitpid( child_pid, &status, 0 );
+                       if( j < 0 ) {
+                               if( EINTR == errno ) {
+                                       continue;
+                               }
+                               status = errno;
+                       }
+                       break;
+               }
 
-BOOL translation = False;
+               /* If we get here - the child exited with some error status */
+               if (WIFSIGNALED(status))
+                       exit(128 + WTERMSIG(status));
+               else
+                       exit(WEXITSTATUS(status));
+       }
 
-extern int cnum;
-extern int mid;
-extern int pid;
-extern int tid;
-extern int gid;
-extern int uid;
+       signal( SIGTERM, SIG_DFL );
+       chdir("/");
+}
 
-extern BOOL have_ip;
-extern int max_xmit;
+static void close_our_files(int client_fd)
+{
+       int i;
+       struct rlimit limits;
 
-/* clitar bits insert */
-extern int blocksize;
-extern BOOL tar_inc;
-extern BOOL tar_reset;
-/* clitar bits end */
+       getrlimit(RLIMIT_NOFILE,&limits);
+       for (i = 0; i< limits.rlim_max; i++) {
+               if (i == client_fd)
+                       continue;
+               close(i);
+       }
+}
 
-int myumask = 0755;
+static void usr1_handler(int x)
+{
+       return;
+}
 
-extern pstring scope;
 
-BOOL prompt = True;
+/***************************************************** 
+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);
+       }
 
-int printmode = 1;
+       pstrcpy(server, the_service+2);
+       share = strchr_m(server,'\\');
+       if (!share) {
+               usage();
+               exit(1);
+       }
+       *share = 0;
+       share++;
 
-BOOL recurse = False;
-BOOL lowercase = False;
+       server_n = server;
 
-struct in_addr dest_ip;
+       make_nmb_name(&calling, my_netbios_name, 0x0);
+       make_nmb_name(&called , server, 0x20);
 
-#define SEPARATORS " \t\n\r"
+ again:
+        zero_ip(&ip);
+       if (have_ip) ip = dest_ip;
 
-BOOL abort_mget = True;
+       /* have to open a new connection */
+       if (!(c=cli_initialise()) || (cli_set_port(c, smb_port) != smb_port) ||
+           !NT_STATUS_IS_OK(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;
+       }
 
-extern int Protocol;
+       /* SPNEGO doesn't work till we get NTSTATUS error support */
+       /* But it is REQUIRED for kerberos authentication */
+       if(!use_kerberos) c->use_spnego = False;
 
-extern BOOL readbraw_supported ;
-extern BOOL writebraw_supported;
+       /* The kernel doesn't yet know how to sign it's packets */
+       c->sign_info.allow_smb_signing = False;
 
-pstring fileselection = "";
+       /* Use kerberos authentication if specified */
+       c->use_kerberos = use_kerberos;
 
-extern file_info def_finfo;
+       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;
+       }
 
-/* timing globals */
-int get_total_size = 0;
-int get_total_time_ms = 0;
-int put_total_size = 0;
-int put_total_time_ms = 0;
+       DEBUG(4,("%d: session request ok\n", sys_getpid()));
 
-/* totals globals */
-int dir_total = 0;
+       if (!cli_negprot(c)) {
+               DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid()));
+               cli_shutdown(c);
+               return NULL;
+       }
 
-extern int Client;
+       if (!got_pass) {
+               char *pass = getpass("Password: ");
+               if (pass) {
+                       pstrcpy(password, pass);
+               }
+       }
 
-#define USENMB
+       /* This should be right for current smbfs. Future versions will support
+         large files as well as unicode and oplocks. */
+       c->capabilities &= ~(CAP_NT_SMBS | CAP_NT_FIND | CAP_LEVEL_II_OPLOCKS);
+       if (!smbfs_has_lfs)
+               c->capabilities &= ~CAP_LARGE_FILES;
+       if (!smbfs_has_unicode)
+               c->capabilities &= ~CAP_UNICODE;
+       if (!status32_smbfs) {
+               c->capabilities &= ~CAP_STATUS32;
+               c->force_dos_errors = True;
+       }
 
-#define CNV_LANG(s) dos_to_unix(s,False)
-#define CNV_INPUT(s) unix_to_dos(s,True)
+       if (!NT_STATUS_IS_OK(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] ||
+                   !NT_STATUS_IS_OK(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"));
+       }
 
-/****************************************************************************
-check for existance of a dir
-****************************************************************************/
-static BOOL chkpath(char *path,BOOL report)
-{
-  fstring path2;
-  pstring inbuf,outbuf;
-  char *p;
-
-  strcpy(path2,path);
-  trim_string(path2,NULL,"\\");
-  if (!*path2) *path2 = '\\';
-
-  bzero(outbuf,smb_size);
-  set_message(outbuf,0,4 + strlen(path2),True);
-  SCVAL(outbuf,smb_com,SMBchkpth);
-  SSVAL(outbuf,smb_tid,cnum);
-  cli_setup_pkt(outbuf);
-
-  p = smb_buf(outbuf);
-  *p++ = 4;
-  strcpy(p,path2);
-
-#if 0
-  {
-         /* this little bit of code can be used to extract NT error codes.
-            Just feed a bunch of "cd foo" commands to smbclient then watch
-            in netmon (tridge) */
-         static int code=0;
-         SIVAL(outbuf, smb_rcls, code | 0xC0000000);
-         SSVAL(outbuf, smb_flg2, SVAL(outbuf, smb_flg2) | (1<<14));
-         code++;
-  }
-#endif
+       DEBUG(4,("%d: session setup ok\n", sys_getpid()));
 
-  send_smb(Client,outbuf);
-  client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+       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;
+       }
 
-  if (report && CVAL(inbuf,smb_rcls) != 0)
-    DEBUG(2,("chkpath: %s\n",smb_errstr(inbuf)));
+       DEBUG(4,("%d: tconx ok\n", sys_getpid()));
 
-  return(CVAL(inbuf,smb_rcls) == 0);
-}
+       got_pass = True;
 
-static void
-daemonize(void)
-{
-       int i;
-       if ((i = fork()) < 0)
-       {
-               DEBUG(0, ("could not fork\n"));
-       }
-       if (i > 0)
-       {
-               /* parent simply exits */
-               exit(0);
-       }
-       setsid();
-       chdir("/");
+       return c;
 }
 
-static void
-close_our_files(void)
-{
-       int i;
-       for (i = 0; i < NR_OPEN; i++) {
-               if (i == Client) {
-                       continue;
-               }
-               close(i);
-       }
-}
 
-static void
-usr1_handler(int x)
+/****************************************************************************
+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)
 {
-       return;
+       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;
+        }
 }
 
-/*
- * Send a login and store the connection options. This is a separate
- * function to keep clientutil.c independent of linux kernel changes.
- */
-static BOOL mount_send_login(char *inbuf, char *outbuf)
-{
-  struct connection_options opt;
-  int res = cli_send_login(inbuf, outbuf, True, True, &opt);
-
-  if (!res)
-    return res;
-
-  conn_options.protocol = opt.protocol;
-  conn_options.case_handling = CASE_LOWER;
-  conn_options.max_xmit = opt.max_xmit;
-  conn_options.server_uid = opt.server_uid;
-  conn_options.tid = opt.tid;
-  conn_options.secmode = opt.sec_mode;
-  conn_options.maxmux = opt.max_mux;
-  conn_options.maxvcs = opt.max_vcs;
-  conn_options.rawmode = opt.rawmode;
-  conn_options.sesskey = opt.sesskey;
-  conn_options.maxraw = opt.maxraw;
-  conn_options.capabilities = opt.capabilities;
-  conn_options.serverzone = opt.serverzone;
-
-  return True;
-}
 
 /*
  * Call the smbfs ioctl to install a connection socket,
@@ -253,416 +329,535 @@ static BOOL mount_send_login(char *inbuf, char *outbuf)
  * 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 *mount_point, char *inbuf, char *outbuf)
+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;
 
-       while (1)
-       {
-               if ((fd = open(mount_point, O_RDONLY)) < 0)
-               {
-                       DEBUG(0, ("smbmount: can't open %s\n", mount_point));
+       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;
-               }               
-
-               /*
-                * Call the ioctl even if we couldn't get a socket ...
-                * there's no point in making smbfs wait for a timeout.
-                */
-               conn_options.fd = -1;
-               if (res)
-                       conn_options.fd = Client;
+               }
+
+               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, ("smbmount: ioctl failed, res=%d\n", res));
+               if (res != 0) {
+                       DEBUG(0,("mount.smbfs[%d]: ioctl failed, res=%d\n",
+                                sys_getpid(), res));
+                       close(fd);
+                       break;
                }
 
-               close_sockets();
-               close(fd);
-               /*
-                * Close all open files if we haven't done so yet.
-                */
-#ifndef SMBFS_DEBUG
-               if (!closed)
-               {
-                       closed = 1;
-                       close_our_files();
+               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;
                }
-#endif
 
-               /*
-                * Wait for a signal from smbfs ...
-                */
-               signal(SIGUSR1, &usr1_handler);
-               pause();
-               DEBUG(0, ("smbmount: got signal, getting new socket\n"));
+               close(fd);
 
-               res = cli_open_sockets(port);
-               if (!res)
-               {
-                       DEBUG(0, ("smbmount: can't open sockets\n"));
-                       continue;
+               /* 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. */
+               c->smb_rw_error = DO_NOT_DO_TDIS;
+               cli_shutdown(c);
+               c = NULL;
+
+               if (!closed) {
+                       /* close the name cache so that close_our_files() doesn't steal its FD */
+                       namecache_shutdown();
+
+                       /* 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", False);     /* 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;
                }
 
-               res = mount_send_login(inbuf, outbuf);
-               if (!res)
-               {
-                       DEBUG(0, ("smbmount: login failed\n"));
+               /* 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);
                }
        }
-       DEBUG(0, ("smbmount: exit\n"));
+
+       smb_umount(mount_point);
+       DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid()));
        exit(1);
 }
 
-/****************************************************************************
-mount smbfs
-****************************************************************************/
-static void cmd_mount(char *inbuf,char *outbuf)
-{
-       pstring mpoint;
-       pstring share_name;
-       pstring mount_command;
-       fstring buf;
-       int retval;
-       char mount_point[MAXPATHLEN+1];
 
-       if (!next_token(NULL, mpoint, NULL))
-       {
-               DEBUG(0,("You must supply a mount point\n"));
+/**
+ * Mount a smbfs
+ **/
+static void init_mount(void)
+{
+       char mount_point[PATH_MAX+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;
        }
 
-       memset(mount_point, 0, sizeof(mount_point));
 
-       if (realpath(mpoint, mount_point) == NULL)
-       {
-               DEBUG(0, ("Could not resolve mount point\n"));
-               return;
+       c = do_connection(service);
+       if (!c) {
+               fprintf(stderr,"SMB connection failed\n");
+               exit(1);
        }
 
        /*
-        * Build the service name to report on the Unix side,
-        * converting '\' to '/' and ' ' to '_'.
-        */
-       strcpy(share_name, service);  
-       string_replace(share_name, '\\', '/');
-       string_replace(share_name, ' ', '_');
+               Set up to return as a daemon child and wait in the parent
+               until the child say it's ready...
+       */
+       daemonize();
 
-       slprintf(mount_command, sizeof(mount_command)-1,"smbmnt %s -s %s", mount_point, share_name);
+       pstrcpy(svc2, service);
+       string_replace(svc2, '\\','/');
+       string_replace(svc2, ' ','_');
 
-       while(next_token(NULL, buf, NULL))
-       {
-               strcat(mount_command, " ");
-               strcat(mount_command, buf);
-       }
+       memset(args, 0, sizeof(args[0])*20);
 
-       DEBUG(3, ("mount command: %s\n", mount_command));
+       i=0;
+       args[i++] = "smbmnt";
 
-       /*
-        * Create the background process before trying the mount.
-        * (We delay closing files to allow diagnostic messages.)
-        */
-       daemonize();
+       args[i++] = mount_point;
+       args[i++] = "-s";
+       args[i++] = svc2;
 
-       /* The parent has exited here, the child handles the connection: */
-       if ((retval = system(mount_command)) != 0)
-       {
-               DEBUG(0,("mount failed\n"));
-               exit(1);
+       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;
        }
-       send_fs_socket(mount_point, inbuf, outbuf);
-}      
-
-
-/* This defines the commands supported by this client */
-struct
-{
-  char *name;
-  void (*fn)();
-  char *description;
-} commands[] = 
-{
-  {"mount", cmd_mount, "<mount-point options> mount an smbfs file system"},
-  {"",NULL,NULL}
-};
 
+       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);
+       }
 
-/*******************************************************************
-  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;
+       if (waitpid(-1, &status, 0) == -1) {
+               fprintf(stderr,"waitpid failed: Error was %s", strerror(errno) );
+               /* FIXME: do some proper error handling */
+               exit(1);
        }
-      else if (strnequal(commands[i].name, tok, tok_len))
-       {
-         matches++;
-         cmd = i;
+
+       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);
        }
-      i++;
-    }
-  
-  if (matches == 0)
-    return(-1);
-  else if (matches == 1)
-    return(cmd);
-  else
-    return(-2);
+
+       /* 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);
 }
 
+
 /****************************************************************************
-help
+get a password from a a file or file descriptor
+exit on failure (from smbclient, move to libsmb or shared .c file?)
 ****************************************************************************/
-void cmd_help(void)
+static void get_password_file(void)
 {
-  int i=0,j;
-  fstring buf;
-
-  if (next_token(NULL,buf,NULL))
-    {
-      if ((i = process_tok(buf)) >= 0)
-       DEBUG(0,("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++) {
-         DEBUG(0,("%-15s",commands[i].name));
-         i++;
-       }
-       DEBUG(0,("\n"));
-      }
+       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);
 }
 
 /****************************************************************************
-wait for keyboard activity, swallowing network packets
+get username and password from a credentials file
+exit on failure (from smbclient, move to libsmb or shared .c file?)
 ****************************************************************************/
-#ifdef CLIX
-static char wait_keyboard(char *buffer)
-#else
-static void wait_keyboard(char *buffer)
-#endif
+static void read_credentials_file(char *filename)
 {
-  fd_set fds;
-  int selrtn;
-  struct timeval timeout;
-  
-#ifdef CLIX
-  int delay = 0;
-#endif
-  
-  while (1) 
-    {
-      extern int Client;
-      FD_ZERO(&fds);
-      FD_SET(Client,&fds);
-#ifndef CLIX
-      FD_SET(fileno(stdin),&fds);
-#endif
+       FILE *auth;
+       fstring buf;
+       uint16 len = 0;
+       char *ptr, *val, *param;
 
-      timeout.tv_sec = 20;
-      timeout.tv_usec = 0;
-#ifdef CLIX
-      timeout.tv_sec = 0;
-#endif
-      selrtn = sys_select(&fds,&timeout);
-      
-#ifndef CLIX
-      if (FD_ISSET(fileno(stdin),&fds))
-       return;
-#else
-      {
-       char ch;
-       int readret;
-
-    set_blocking(fileno(stdin), False);        
-       readret = read_data( fileno(stdin), &ch, 1);
-       set_blocking(fileno(stdin), True);
-       if (readret == -1)
-         {
-           if (errno != EAGAIN)
-             {
-               /* should crash here */
-               DEBUG(1,("readchar stdin failed\n"));
-             }
-         }
-       else if (readret != 0)
-         {
-           return ch;
-         }
-      }
-#endif
+       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);
+       }
 
-      /* We deliberately use receive_smb instead of
-         client_receive_smb as we want to receive
-         session keepalives and then drop them here.
-       */
-      if (FD_ISSET(Client,&fds))
-       receive_smb(Client,buffer,0);
-      
-#ifdef CLIX
-      delay++;
-      if (delay > 100000)
+       while (!feof(auth))
        {
-         delay = 0;
-         chkpath("\\",False);
+               /* 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));
        }
-#else
-      chkpath("\\",False);
-#endif
-    }  
+       fclose(auth);
 }
 
 
 /****************************************************************************
-  process commands from the client
+usage on the program
 ****************************************************************************/
-static BOOL process(char *base_directory)
+static void usage(void)
 {
-  extern FILE *dbf;
-  pstring line;
-  char *cmd;
+       printf("Usage: mount.smbfs service mountpoint [-o options,...]\n");
+
+       printf("Version %s\n\n",SAMBA_VERSION_STRING);
+
+       printf("Please be aware that smbfs is deprecated in favor of "
+              "cifs\n\n");
+
+       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\
+      unicode                         use unicode when communicating with server\n\
+      lfs                             large file system support\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\
+");
+}
 
-  char *InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
-  char *OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 
-  if ((InBuffer == NULL) || (OutBuffer == NULL)) 
-    return(False);
+/****************************************************************************
+  Argument parsing for mount.smbfs interface
+  mount will call us like this:
+    mount.smbfs device mountpoint -o <options>
   
-  bzero(OutBuffer,smb_size);
+  <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;
+       int val;
+       char *p;
 
-  if (!mount_send_login(InBuffer,OutBuffer))
-    return(False);
+       /* FIXME: This function can silently fail if the arguments are
+        * not in the expected order.
 
-  cmd = cmdstr;
-  if (cmd[0] != '\0') while (cmd[0] != '\0')
-    {
-      char *p;
-      fstring tok;
-      int i;
+       > 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 ((p = strchr(cmd, ';')) == 0)
-       {
-         strncpy(line, cmd, 999);
-         line[1000] = '\0';
-         cmd += strlen(cmd);
+       */
+
+
+       if (argc < 2 || argv[1][0] == '-') {
+               usage();
+               exit(1);
        }
-      else
-       {
-         if (p - cmd > 999) p = cmd + 999;
-         strncpy(line, cmd, p - cmd);
-         line[p - cmd] = '\0';
-         cmd = p + 1;
-       }
-
-      /* input language code to internal one */
-      CNV_INPUT (line);
-      
-      /* and get the first part of the command */
-      {
-       char *ptr = line;
-       if (!next_token(&ptr,tok,NULL)) continue;
-      }
-
-      if ((i = process_tok(tok)) >= 0)
-       commands[i].fn(InBuffer,OutBuffer);
-      else if (i == -2)
-       DEBUG(0,("%s: command abbreviation ambiguous\n",CNV_LANG(tok)));
-      else
-       DEBUG(0,("%s: command not found\n",CNV_LANG(tok)));
-    }
-  else while (!feof(stdin))
-    {
-      fstring tok;
-      int i;
-
-      bzero(OutBuffer,smb_size);
-
-      /* display a prompt */
-      DEBUG(0,("smb: %s> ", CNV_LANG(cur_dir)));
-      fflush(dbf);
-
-#ifdef CLIX
-      line[0] = wait_keyboard(InBuffer);
-      /* this might not be such a good idea... */
-      if ( line[0] == EOF)
-       break;
-#else
-      wait_keyboard(InBuffer);
-#endif
-  
-      /* and get a response */
-#ifdef CLIX
-      fgets( &line[1],999, stdin);
+       
+       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")) {
+                               pstrcpy(user_socket_options,opteq+1);
+                       } else if(!strcmp(opts, "scope")) {
+                               set_global_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
-      if (!fgets(line,1000,stdin))
-       break;
+                               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 if(!strcmp(opts, "unicode")) {
+                               smbfs_has_unicode = True;
+                       } else if(!strcmp(opts, "lfs")) {
+                               smbfs_has_lfs = True;
+                       } else {
+                               strncpy(p, opts, sizeof(pstring) - (p - options) - 1);
+                               p += strlen(opts);
+                               *p++ = ',';
+                               *p = 0;
+                       }
+               }
+       }
 
-      /* input language code to internal one */
-      CNV_INPUT (line);
-
-      /* special case - first char is ! */
-      if (*line == '!')
-       {
-         system(line + 1);
-         continue;
-       }
-      
-      /* and get the first part of the command */
-      {
-       char *ptr = line;
-       if (!next_token(&ptr,tok,NULL)) continue;
-      }
-
-      if ((i = process_tok(tok)) >= 0)
-       commands[i].fn(InBuffer,OutBuffer);
-      else if (i == -2)
-       DEBUG(0,("%s: command abbreviation ambiguous\n",CNV_LANG(tok)));
-      else
-       DEBUG(0,("%s: command not found\n",CNV_LANG(tok)));
-    }
-  
-  cli_send_logout();
-  return(True);
-}
+       if (!*service) {
+               usage();
+               exit(1);
+       }
 
-/****************************************************************************
-usage on the program
-****************************************************************************/
-static void usage(char *pname)
-{
-  DEBUG(0,("Usage: %s service <password> [-p port] [-d debuglevel] [-l log] ",
-          pname));
-
-  DEBUG(0,("\nVersion %s\n",VERSION));
-  DEBUG(0,("\t-p port               connect to the specified port\n"));
-  DEBUG(0,("\t-d debuglevel         set the debuglevel\n"));
-  DEBUG(0,("\t-l log basename.      Basename for log/debug files\n"));
-  DEBUG(0,("\t-n netbios name.      Use this name as my netbios name\n"));
-  DEBUG(0,("\t-N                    don't ask for a password\n"));
-  DEBUG(0,("\t-m max protocol       set the max protocol level\n"));
-  DEBUG(0,("\t-I dest IP            use this IP to connect to\n"));
-  DEBUG(0,("\t-E                    write messages to stderr instead of stdout\n"));
-  DEBUG(0,("\t-U username           set the network username\n"));
-  DEBUG(0,("\t-W workgroup          set the workgroup name\n"));
-  DEBUG(0,("\t-c command string     execute semicolon separated commands\n"));
-  DEBUG(0,("\t-t terminal code      terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"));
-  DEBUG(0,("\t-D directory          start from directory\n"));
-  DEBUG(0,("\n"));
+       if (p != options) {
+               *(p-1) = 0;     /* remove trailing , */
+               DEBUG(3,("passthrough options '%s'\n", options));
+       }
 }
 
 /****************************************************************************
@@ -670,230 +865,81 @@ static void usage(char *pname)
 ****************************************************************************/
  int main(int argc,char *argv[])
 {
-  fstring base_directory;
-  char *pname = argv[0];
-  int opt;
-  extern FILE *dbf;
-  extern char *optarg;
-  extern int optind;
-  pstring query_host;
-  BOOL nt_domain_logon = False;
-  static pstring servicesf = CONFIGFILE;
-  pstring term_code;
-  char *p;
-
-#ifdef KANJI
-  strcpy(term_code, KANJI);
-#else /* KANJI */
-  *term_code = 0;
-#endif /* KANJI */
-
-  *query_host = 0;
-  *base_directory = 0;
-
-  DEBUGLEVEL = 2;
-
-  setup_logging(pname,True);
-
-  TimeInit();
-  charset_initialise();
-
-  pid = getpid();
-  uid = getuid();
-  gid = getgid();
-  mid = pid + 100;
-  myumask = umask(0);
-  umask(myumask);
-
-  if (getenv("USER"))
-  {
-    strcpy(username,getenv("USER"));
-
-    /* modification to support userid%passwd syntax in the USER var
-       25.Aug.97, jdblair@uab.edu */
-
-    if ((p=strchr(username,'%')))
-    {
-      *p = 0;
-      strcpy(password,p+1);
-      got_pass = True;
-      memset(strchr(getenv("USER"),'%')+1,'X',strlen(password));
-    }
-    strupper(username);
-  }
-
- /* modification to support PASSWD environmental var
-  25.Aug.97, jdblair@uab.edu */
-
-  if (getenv("PASSWD"))
-    strcpy(password,getenv("PASSWD"));
-
-  if (*username == 0 && getenv("LOGNAME"))
-    {
-      strcpy(username,getenv("LOGNAME"));
-      strupper(username);
-    }
-
-  if (argc < 2)
-    {
-      usage(pname);
-      exit(1);
-    }
-  
-  if (*argv[1] != '-')
-    {
+       char *p;
 
-      strcpy(service, argv[1]);  
-      /* Convert any '/' characters in the service name to '\' characters */
-      string_replace( service, '/','\\');
-      argc--;
-      argv++;
+       DEBUGLEVEL = 1;
 
-      if (count_chars(service,'\\') < 3)
-       {
-         usage(pname);
-         printf("\n%s: Not enough '\\' characters in service\n",service);
-         exit(1);
-       }
+       load_case_tables();
 
-      if (argc > 1 && (*argv[1] != '-'))
-       {
-         got_pass = True;
-         strcpy(password,argv[1]);  
-         memset(argv[1],'X',strlen(argv[1]));
-         argc--;
-         argv++;
-       }
-    }
-
-  while ((opt = 
-         getopt(argc, argv,"s:B:O:M:S:i:Nn:d:Pp:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
-    switch (opt)
-      {
-      case 'm':
-       max_protocol = interpret_protocol(optarg,max_protocol);
-       break;
-      case 'O':
-       strcpy(user_socket_options,optarg);
-       break;  
-      case 'S':
-       strcpy(desthost,optarg);
-       strupper(desthost);
-       nt_domain_logon = True;
-       break;
-      case 'B':
-       iface_set_default(NULL,optarg,NULL);
-       break;
-      case 'D':
-       strcpy(base_directory,optarg);
-       break;
-      case 'i':
-       strcpy(scope,optarg);
-       break;
-      case 'U':
-       {
-         char *lp;
-       strcpy(username,optarg);
-       if ((lp=strchr(username,'%')))
-         {
-           *lp = 0;
-           strcpy(password,lp+1);
-           got_pass = True;
-           memset(strchr(optarg,'%')+1,'X',strlen(password));
-         }
-       }
-           
-       break;
-      case 'W':
-       strcpy(workgroup,optarg);
-       break;
-      case 'E':
-       dbf = stderr;
-       break;
-      case 'I':
-       {
-         dest_ip = *interpret_addr2(optarg);
-         if (zero_ip(dest_ip)) exit(1);
-         have_ip = True;
-       }
-       break;
-      case 'n':
-       strcpy(global_myname,optarg);
-       break;
-      case 'N':
-       got_pass = True;
-       break;
-      case 'd':
-       if (*optarg == 'A')
-         DEBUGLEVEL = 10000;
+       /* 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
-         DEBUGLEVEL = atoi(optarg);
-       break;
-      case 'l':
-       slprintf(debugf,sizeof(debugf)-1,"%s.client",optarg);
-       break;
-      case 'p':
-       port = atoi(optarg);
-       break;
-      case 'c':
-       cmdstr = optarg;
-       got_pass = True;
-       break;
-      case 'h':
-       usage(pname);
-       exit(0);
-       break;
-      case 's':
-       strcpy(servicesf, optarg);
-       break;
-      case 't':
-        strcpy(term_code, optarg);
-       break;
-      default:
-       usage(pname);
-       exit(1);
-      }
+               setenv("CLI_FORCE_ASCII", "true", 1);
+#endif
 
-  if (!*query_host && !*service)
-    {
-      usage(pname);
-      exit(1);
-    }
+       in_client = True;   /* Make sure that we tell lp_load we are */
 
+       if (getenv("USER")) {
+               pstrcpy(username,getenv("USER"));
 
-  DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION));
+               if ((p=strchr_m(username,'%'))) {
+                       *p = 0;
+                       pstrcpy(password,p+1);
+                       got_pass = True;
+                       memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password));
+               }
+               strupper_m(username);
+       }
 
-  if(!get_myname(myhostname,NULL))
-  {
-    DEBUG(0,("Failed to get my hostname.\n"));
-  }
+       if (getenv("PASSWD")) {
+               pstrcpy(password,getenv("PASSWD"));
+               got_pass = True;
+       }
 
-  if (!lp_load(servicesf,True,False,False)) {
-    fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
-  }
+       if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
+               get_password_file();
+               got_pass = True;
+       }
 
-  codepage_initialise(lp_client_code_page());
+       if (*username == 0 && getenv("LOGNAME")) {
+               pstrcpy(username,getenv("LOGNAME"));
+       }
 
-  interpret_coding_system(term_code);
+       if (!lp_load(dyn_CONFIGFILE,True,False,False,True)) {
+               fprintf(stderr, "Can't load %s - run testparm to debug it\n", 
+                       dyn_CONFIGFILE);
+       }
 
-  if (*workgroup == 0)
-    strcpy(workgroup,lp_workgroup());
+       parse_mount_smb(argc, argv);
 
-  load_interfaces();
-  get_myname((*global_myname)?NULL:global_myname,NULL);  
-  strupper(global_myname);
+       if (use_kerberos && !got_user) {
+               got_pass = True;
+       }
 
-  if (cli_open_sockets(port))
-    {
-      if (!process(base_directory))
-       {
-         close_sockets();
-         return(1);
+       if (*credentials != 0) {
+               read_credentials_file(credentials);
+       }
+
+       DEBUG(3,("mount.smbfs started (version %s)\n", SAMBA_VERSION_STRING));
+
+       if (*workgroup == 0) {
+               pstrcpy(workgroup,lp_workgroup());
+       }
+
+       load_interfaces();
+       if (!*my_netbios_name) {
+               pstrcpy(my_netbios_name, myhostname());
        }
-      close_sockets();
-    }
-  else
-    return(1);
+       strupper_m(my_netbios_name);
 
-  return(0);
+       init_mount();
+       return 0;
 }