BSD 4_3_Net_2 release
[unix-history] / usr / src / sbin / mount / mount.c
index a88a8ea..9c561b2 100644 (file)
-#ifndef lint
-static char *sccsid = "@(#)mount.c     4.11 (Berkeley) %G%";
-#endif
-
 /*
 /*
- * mount
+ * Copyright (c) 1980, 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  */
  */
-#include <sys/param.h>
 
 
-#include <stdio.h>
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)mount.c    5.44 (Berkeley) 2/26/91";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/file.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/errno.h>
+#include <sys/signal.h>
+#include <sys/mount.h>
+#ifdef NFS
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <netdb.h>
+#include <rpc/rpc.h>
+#include <rpc/pmap_clnt.h>
+#include <rpc/pmap_prot.h>
+#include <nfs/rpcv2.h>
+#include <nfs/nfsv2.h>
+#include <nfs/nfs.h>
+#endif
 #include <fstab.h>
 #include <fstab.h>
-#include <mtab.h>
-#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "pathnames.h"
+
+#define DEFAULT_ROOTUID        -2
 
 
-#define        DNMAX   (sizeof (mtab[0].m_dname) - 1)
-#define        PNMAX   (sizeof (mtab[0].m_path) - 1)
+#define        BADTYPE(type) \
+       (strcmp(type, FSTAB_RO) && strcmp(type, FSTAB_RW) && \
+           strcmp(type, FSTAB_RQ))
+#define        SETTYPE(type) \
+       (!strcmp(type, FSTAB_RW) || !strcmp(type, FSTAB_RQ))
 
 
-struct mtab mtab[NMOUNT];
+int fake, verbose, updateflg, mnttype;
+char *mntname, **envp;
+char **vfslist, **makevfslist();
+static void prmount();
 
 
-int    all;
-int    ro;
-int    fake;
-int    verbose;
-char   *index(), *rindex();
+#ifdef NFS
+int xdr_dir(), xdr_fh();
+char *getnfsargs();
+struct nfs_args nfsdefargs = {
+       (struct sockaddr *)0,
+       SOCK_DGRAM,
+       0,
+       (nfsv2fh_t *)0,
+       0,
+       NFS_WSIZE,
+       NFS_RSIZE,
+       NFS_TIMEO,
+       NFS_RETRANS,
+       (char *)0,
+};
 
 
-main(argc, argv)
+struct nfhret {
+       u_long  stat;
+       nfsv2fh_t nfh;
+};
+#define        DEF_RETRY       10000
+int retrycnt;
+#define        BGRND   1
+#define        ISBGRND 2
+int opflags = 0;
+#endif
+
+main(argc, argv, arge)
        int argc;
        char **argv;
        int argc;
        char **argv;
+       char **arge;
 {
 {
-       register struct mtab *mp;
-       register char *np;
-       int mf;
-       char *type = FSTAB_RW;
-
-       mf = open("/etc/mtab", 0);
-       read(mf, (char *)mtab, sizeof (mtab));
-       if (argc == 1) {
-               for (mp = mtab; mp < &mtab[NMOUNT]; mp++)
-                       if (mp->m_path[0] != '\0')
-                               prmtab(mp);
-               exit(0);
-       }
-top:
-       if (argc > 1) {
-               if (!strcmp(argv[1], "-a")) {
-                       all++;
-                       argc--, argv++;
-                       goto top;
-               }
-               if (!strcmp(argv[1], "-r")) {
+       extern char *optarg;
+       extern int optind;
+       register struct fstab *fs;
+       int all, ch, rval, flags, ret, pid, i;
+       long mntsize;
+       struct statfs *mntbuf, *getmntpt();
+       char *type, *options = NULL;
+       FILE *pidfile;
+
+       envp = arge;
+       all = 0;
+       type = NULL;
+       mnttype = MOUNT_UFS;
+       mntname = "ufs";
+       while ((ch = getopt(argc, argv, "afrwuvt:o:")) != EOF)
+               switch((char)ch) {
+               case 'a':
+                       all = 1;
+                       break;
+               case 'f':
+                       fake = 1;
+                       break;
+               case 'r':
                        type = FSTAB_RO;
                        type = FSTAB_RO;
-                       argc--, argv++;
-                       goto top;
-               }
-               if (!strcmp(argv[1], "-f")) {
-                       fake++;
-                       argc--, argv++;
-                       goto top;
-               }
-               if (!strcmp(argv[1], "-v")) {
-                       verbose++;
-                       argc--, argv++;
-                       goto top;
+                       break;
+               case 'u':
+                       updateflg = MNT_UPDATE;
+                       break;
+               case 'v':
+                       verbose = 1;
+                       break;
+               case 'w':
+                       type = FSTAB_RW;
+                       break;
+               case 'o':
+                       options = optarg;
+                       break;
+               case 't':
+                       vfslist = makevfslist(optarg);
+                       mnttype = getmnttype(optarg);
+                       break;
+               case '?':
+               default:
+                       usage();
+                       /* NOTREACHED */
                }
                }
-       }
+       argc -= optind;
+       argv += optind;
+
+       /* NOSTRICT */
+
        if (all) {
        if (all) {
-               struct fstab *fsp;
-
-               if (argc > 1)
-                       goto argcnt;
-               close(2); dup(1);
-               if (setfsent() == 0)
-                       perror(FSTAB), exit(1);
-               while ((fsp = getfsent()) != 0) {
-                       if (strcmp(fsp->fs_file, "/") == 0)
+               rval = 0;
+               while (fs = getfsent()) {
+                       if (BADTYPE(fs->fs_type))
                                continue;
                                continue;
-                       if (strcmp(fsp->fs_type, FSTAB_RO) &&
-                           strcmp(fsp->fs_type, FSTAB_RW) &&
-                           strcmp(fsp->fs_type, FSTAB_RQ))
+                       if (badvfsname(fs->fs_vfstype, vfslist))
                                continue;
                                continue;
-                       mountfs(fsp->fs_spec, fsp->fs_file, fsp->fs_type);
+                       /* `/' is special, it's always mounted */
+                       if (!strcmp(fs->fs_file, "/"))
+                               flags = MNT_UPDATE;
+                       else
+                               flags = updateflg;
+                       mnttype = getmnttype(fs->fs_vfstype);
+                       rval |= mountfs(fs->fs_spec, fs->fs_file, flags,
+                           type, options, fs->fs_mntops);
                }
                }
-               exit(0);
+               exit(rval);
        }
        }
-       if (argc == 2) {
-               struct fstab *fs;
 
 
-               if (setfsent() == 0)
-                       perror(FSTAB), exit(1);
-               fs = getfsfile(argv[1]);
-               if (fs == NULL)
-                       goto argcnt;
-               mountfs(fs->fs_spec, fs->fs_file, type);
+       if (argc == 0) {
+               if (verbose || fake || type)
+                       usage();
+               if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
+                       (void) fprintf(stderr,
+                               "mount: cannot get mount information\n");
+                       exit(1);
+               }
+               for (i = 0; i < mntsize; i++) {
+                       if (badvfstype(mntbuf[i].f_type, vfslist))
+                               continue;
+                       prmount(mntbuf[i].f_mntfromname, mntbuf[i].f_mntonname,
+                               mntbuf[i].f_flags);
+               }
                exit(0);
        }
                exit(0);
        }
-       if (argc != 3) {
-argcnt:
-               fprintf(stderr,
-    "usage: mount [ -a ] [ -r ] [ -f ] [ -v ] [ special dir ] [ dir ]\n");
+
+       if (argc == 1 && updateflg) {
+               if ((mntbuf = getmntpt(*argv)) == NULL) {
+                       (void) fprintf(stderr,
+                           "mount: unknown special file or file system %s.\n",
+                           *argv);
+                       exit(1);
+               }
+               mnttype = mntbuf->f_type;
+               if (!strcmp(mntbuf->f_mntfromname, "root_device")) {
+                       fs = getfsfile("/");
+                       strcpy(mntbuf->f_mntfromname, fs->fs_spec);
+               }
+               ret = mountfs(mntbuf->f_mntfromname, mntbuf->f_mntonname,
+                   updateflg, type, options, (char *)NULL);
+       } else if (argc == 1) {
+               if (!(fs = getfsfile(*argv)) && !(fs = getfsspec(*argv))) {
+                       (void) fprintf(stderr,
+                           "mount: unknown special file or file system %s.\n",
+                           *argv);
+                       exit(1);
+               }
+               if (BADTYPE(fs->fs_type)) {
+                       (void) fprintf(stderr,
+                           "mount: %s has unknown file system type.\n", *argv);
+                       exit(1);
+               }
+               mnttype = getmnttype(fs->fs_vfstype);
+               ret = mountfs(fs->fs_spec, fs->fs_file, updateflg,
+                   type, options, fs->fs_mntops);
+       } else if (argc != 2) {
+               usage();
+               ret = 1;
+       } else {
+               /*
+                * If -t flag has not been specified, and spec
+                * contains either a ':' or a '@' then assume that
+                * an NFS filesystem is being specified ala Sun.
+                */
+               if (vfslist == (char **)0 &&
+                   (index(argv[0], ':') || index(argv[0], '@')))
+                       mnttype = MOUNT_NFS;
+               ret = mountfs(argv[0], argv[1], updateflg, type, options,
+                   (char *)NULL);
+       }
+       if ((pidfile = fopen(_PATH_MOUNTDPID, "r")) != NULL) {
+               pid = 0;
+               fscanf(pidfile, "%d", &pid);
+               fclose(pidfile);
+               if (pid > 0)
+                       kill(pid, SIGHUP);
+       }
+       exit (ret);
+}
+
+mountfs(spec, name, flags, type, options, mntopts)
+       char *spec, *name, *type, *options, *mntopts;
+       int flags;
+{
+       union wait status;
+       pid_t pid;
+       int argc, i;
+       struct ufs_args args;
+       struct nfs_args nfsargs;
+       char *argp, *argv[50];
+       char execname[MAXPATHLEN + 1], flagval[12];
+
+       nfsargs = nfsdefargs;
+       if (mntopts)
+               getstdopts(mntopts, &flags);
+       if (options)
+               getstdopts(options, &flags);
+       if (type)
+               getstdopts(type, &flags);
+       switch (mnttype) {
+       case MOUNT_UFS:
+               if (mntopts)
+                       getufsopts(mntopts, &flags);
+               if (options)
+                       getufsopts(options, &flags);
+               args.fspec = spec;
+               args.exroot = DEFAULT_ROOTUID;
+               if (flags & MNT_RDONLY)
+                       args.exflags = MNT_EXRDONLY;
+               else
+                       args.exflags = 0;
+               argp = (caddr_t)&args;
+               break;
+
+#ifdef NFS
+       case MOUNT_NFS:
+               retrycnt = DEF_RETRY;
+               if (mntopts)
+                       getnfsopts(mntopts, &nfsargs, &opflags, &retrycnt);
+               if (options)
+                       getnfsopts(options, &nfsargs, &opflags, &retrycnt);
+               if (argp = getnfsargs(spec, &nfsargs))
+                       break;
+               return (1);
+#endif /* NFS */
+
+       case MOUNT_MFS:
+       default:
+               argv[0] = mntname;
+               argc = 1;
+               if (flags) {
+                       argv[argc++] = "-F";
+                       sprintf(flagval, "%d", flags);
+                       argv[argc++] = flagval;
+               }
+               if (mntopts)
+                       argc += getexecopts(mntopts, &argv[argc]);
+               if (options)
+                       argc += getexecopts(options, &argv[argc]);
+               argv[argc++] = spec;
+               argv[argc++] = name;
+               argv[argc++] = NULL;
+               sprintf(execname, "%s/mount_%s", _PATH_EXECDIR, mntname);
+               if (verbose) {
+                       (void)printf("exec: %s", execname);
+                       for (i = 1; i < argc - 1; i++)
+                               (void)printf(" %s", argv[i]);
+                       (void)printf("\n");
+               }
+               if (fake)
+                       break;
+               if (pid = vfork()) {
+                       if (pid == -1) {
+                               perror("mount: vfork starting file system");
+                               return (1);
+                       }
+                       if (waitpid(pid, (int *)&status, 0) != -1 &&
+                           WIFEXITED(status) &&
+                           WEXITSTATUS(status) != 0)
+                               return (WEXITSTATUS(status));
+                       spec = mntname;
+                       goto out;
+               }
+               execve(execname, argv, envp);
+               (void) fprintf(stderr, "mount: cannot exec %s for %s: ",
+                       execname, name);
+               perror((char *)NULL);
+               exit (1);
+               /* NOTREACHED */
+
+       }
+       if (!fake && mount(mnttype, name, flags, argp)) {
+               if (opflags & ISBGRND)
+                       exit(1);
+               (void) fprintf(stderr, "%s on %s: ", spec, name);
+               switch (errno) {
+               case EMFILE:
+                       (void) fprintf(stderr, "Mount table full\n");
+                       break;
+               case EINVAL:
+                       if (flags & MNT_UPDATE)
+                               (void) fprintf(stderr, "Specified device %s\n",
+                                       "does not match mounted device");
+                       else if (mnttype == MOUNT_UFS)
+                               (void) fprintf(stderr, "Bogus super block\n");
+                       else
+                               perror((char *)NULL);
+                       break;
+               default:
+                       perror((char *)NULL);
+                       break;
+               }
+               return(1);
+       }
+
+out:
+       if (verbose)
+               prmount(spec, name, flags);
+
+       if (opflags & ISBGRND)
                exit(1);
                exit(1);
+       return(0);
+}
+
+static void
+prmount(spec, name, flags)
+       char *spec, *name;
+       register short flags;
+{
+       register int first;
+
+       if (opflags & ISBGRND)
+               return;
+       (void)printf("%s on %s", spec, name);
+       if (!(flags & MNT_VISFLAGMASK)) {
+               (void)printf("\n");
+               return;
+       }
+       first = 0;
+#define        PR(msg) (void)printf("%s%s", !first++ ? " (" : ", ", msg)
+       if (flags & MNT_RDONLY)
+               PR("read-only");
+       if (flags & MNT_NOEXEC)
+               PR("noexec");
+       if (flags & MNT_NOSUID)
+               PR("nosuid");
+       if (flags & MNT_NODEV)
+               PR("nodev");
+       if (flags & MNT_SYNCHRONOUS)
+               PR("synchronous");
+       if (flags & MNT_QUOTA)
+               PR("with quotas");
+       if (flags & MNT_LOCAL)
+               PR("local");
+       if (flags & MNT_EXPORTED)
+               if (flags & MNT_EXRDONLY)
+                       PR("NFS exported read-only");
+               else
+                       PR("NFS exported");
+       (void)printf(")\n");
+}
+
+getmnttype(fstype)
+       char *fstype;
+{
+
+       mntname = fstype;
+       if (!strcmp(fstype, "ufs"))
+               return (MOUNT_UFS);
+       if (!strcmp(fstype, "nfs"))
+               return (MOUNT_NFS);
+       if (!strcmp(fstype, "mfs"))
+               return (MOUNT_MFS);
+       return (0);
+}
+
+usage()
+{
+
+       (void) fprintf(stderr,
+               "usage:\n  mount %s %s\n  mount %s\n  mount %s\n",
+               "[ -frwu ] [ -t nfs | ufs | external_type ]",
+               "[ -o options ] special node",
+               "[ -afrwu ] [ -t nfs | ufs | external_type ]",
+               "[ -frwu ] special | node");
+       exit(1);
+}
+
+getstdopts(options, flagp)
+       char *options;
+       int *flagp;
+{
+       register char *opt;
+       int negative;
+       char optbuf[BUFSIZ];
+
+       (void)strcpy(optbuf, options);
+       for (opt = strtok(optbuf, ","); opt; opt = strtok((char *)NULL, ",")) {
+               if (opt[0] == 'n' && opt[1] == 'o') {
+                       negative++;
+                       opt += 2;
+               } else {
+                       negative = 0;
+               }
+               if (!negative && !strcasecmp(opt, FSTAB_RO)) {
+                       *flagp |= MNT_RDONLY;
+                       continue;
+               }
+               if (!negative && !strcasecmp(opt, FSTAB_RW)) {
+                       *flagp &= ~MNT_RDONLY;
+                       continue;
+               }
+               if (!strcasecmp(opt, "exec")) {
+                       if (negative)
+                               *flagp |= MNT_NOEXEC;
+                       else
+                               *flagp &= ~MNT_NOEXEC;
+                       continue;
+               }
+               if (!strcasecmp(opt, "suid")) {
+                       if (negative)
+                               *flagp |= MNT_NOSUID;
+                       else
+                               *flagp &= ~MNT_NOSUID;
+                       continue;
+               }
+               if (!strcasecmp(opt, "dev")) {
+                       if (negative)
+                               *flagp |= MNT_NODEV;
+                       else
+                               *flagp &= ~MNT_NODEV;
+                       continue;
+               }
+               if (!strcasecmp(opt, "synchronous")) {
+                       if (!negative)
+                               *flagp |= MNT_SYNCHRONOUS;
+                       else
+                               *flagp &= ~MNT_SYNCHRONOUS;
+                       continue;
+               }
        }
        }
-       mountfs(argv[1], argv[2], type);
 }
 
 }
 
-prmtab(mp)
-       register struct mtab *mp;
+/* ARGSUSED */
+getufsopts(options, flagp)
+       char *options;
+       int *flagp;
+{
+       return;
+}
+
+getexecopts(options, argv)
+       char *options;
+       char **argv;
 {
 {
+       register int argc = 0;
+       register char *opt;
 
 
-       printf("%s on %s", mp->m_dname, mp->m_path);
-       if (strcmp(mp->m_type, FSTAB_RO) == 0)
-               printf("\t(read-only)");
-       if (strcmp(mp->m_type, FSTAB_RQ) == 0)
-               printf("\t(with quotas)");
-       putchar('\n');
+       for (opt = strtok(options, ","); opt; opt = strtok((char *)NULL, ",")) {
+               if (opt[0] != '-')
+                       continue;
+               argv[argc++] = opt;
+               if (opt[2] == '\0' || opt[2] != '=')
+                       continue;
+               opt[2] = '\0';
+               argv[argc++] = &opt[3];
+       }
+       return (argc);
+}
+
+struct statfs *
+getmntpt(name)
+       char *name;
+{
+       long mntsize;
+       register long i;
+       struct statfs *mntbuf;
+
+       mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
+       for (i = 0; i < mntsize; i++) {
+               if (!strcmp(mntbuf[i].f_mntfromname, name) ||
+                   !strcmp(mntbuf[i].f_mntonname, name))
+                       return (&mntbuf[i]);
+       }
+       return ((struct statfs *)0);
 }
 
 }
 
-mountfs(spec, name, type)
-       char *spec, *name, *type;
+static int skipvfs;
+
+badvfstype(vfstype, vfslist)
+       short vfstype;
+       char **vfslist;
 {
 {
-       register char *np;
-       register struct mtab *mp;
-       int mf;
 
 
-       if (!fake) {
-               if (mount(spec, name, strcmp(type, FSTAB_RO) == 0) < 0) {
-                       extern int errno;
-                       char *cp;
+       if (vfslist == 0)
+               return(0);
+       while (*vfslist) {
+               if (vfstype == getmnttype(*vfslist))
+                       return(skipvfs);
+               vfslist++;
+       }
+       return (!skipvfs);
+}
 
 
-                       fprintf(stderr, "%s on ", spec);
-                       switch (errno) {
+badvfsname(vfsname, vfslist)
+       char *vfsname;
+       char **vfslist;
+{
 
 
-                       case EMFILE:
-                               cp = "Mount table full";
-                               break;
+       if (vfslist == 0)
+               return(0);
+       while (*vfslist) {
+               if (strcmp(vfsname, *vfslist) == 0)
+                       return(skipvfs);
+               vfslist++;
+       }
+       return (!skipvfs);
+}
 
 
-                       case EINVAL:
-                               cp = "Bogus super block";
-                               break;
+char **
+makevfslist(fslist)
+       char *fslist;
+{
+       register char **av, *nextcp;
+       register int i;
 
 
-                       default:
-                               perror(name);
-                               return;
+       if (fslist == NULL)
+               return (NULL);
+       if (fslist[0] == 'n' && fslist[1] == 'o') {
+               fslist += 2;
+               skipvfs = 1;
+       }
+       for (i = 0, nextcp = fslist; *nextcp; nextcp++)
+               if (*nextcp == ',')
+                       i++;
+       av = (char **)malloc((size_t)(i+2) * sizeof(char *));
+       if (av == NULL)
+               return (NULL);
+       nextcp = fslist;
+       i = 0;
+       av[i++] = nextcp;
+       while (nextcp = index(nextcp, ',')) {
+               *nextcp++ = '\0';
+               av[i++] = nextcp;
+       }
+       av[i++] = 0;
+       return (av);
+}
+
+#ifdef NFS
+exclusive(a, b)
+       char *a, *b;
+{
+
+       (void) fprintf(stderr, "mount: Options %s, %s mutually exclusive\n",
+           a, b);
+       exit(1);
+}
+
+/*
+ * Handle the getoption arg.
+ * Essentially update "opflags", "retrycnt" and "nfsargs"
+ */
+getnfsopts(optarg, nfsargsp, opflagsp, retrycntp)
+       char *optarg;
+       register struct nfs_args *nfsargsp;
+       int *opflagsp;
+       int *retrycntp;
+{
+       register char *cp, *nextcp;
+       int num;
+       char *nump;
+
+       for (cp = optarg; cp != NULL && *cp != '\0'; cp = nextcp) {
+               if ((nextcp = index(cp, ',')) != NULL)
+                       *nextcp++ = '\0';
+               if ((nump = index(cp, '=')) != NULL) {
+                       *nump++ = '\0';
+                       num = atoi(nump);
+               } else
+                       num = -1;
+               /*
+                * Just test for a string match and do it
+                */
+               if (!strcmp(cp, "bg")) {
+                       *opflagsp |= BGRND;
+               } else if (!strcmp(cp, "soft")) {
+                       if (nfsargsp->flags & NFSMNT_SPONGY)
+                               exclusive("soft, spongy");
+                       nfsargsp->flags |= NFSMNT_SOFT;
+               } else if (!strcmp(cp, "spongy")) {
+                       if (nfsargsp->flags & NFSMNT_SOFT)
+                               exclusive("soft, spongy");
+                       nfsargsp->flags |= NFSMNT_SPONGY;
+               } else if (!strcmp(cp, "compress")) {
+                       nfsargsp->flags |= NFSMNT_COMPRESS;
+               } else if (!strcmp(cp, "intr")) {
+                       nfsargsp->flags |= NFSMNT_INT;
+               } else if (!strcmp(cp, "tcp")) {
+                       nfsargsp->sotype = SOCK_STREAM;
+               } else if (!strcmp(cp, "noconn")) {
+                       nfsargsp->flags |= NFSMNT_NOCONN;
+               } else if (!strcmp(cp, "retry") && num > 0) {
+                       *retrycntp = num;
+               } else if (!strcmp(cp, "rsize") && num > 0) {
+                       nfsargsp->rsize = num;
+                       nfsargsp->flags |= NFSMNT_RSIZE;
+               } else if (!strcmp(cp, "wsize") && num > 0) {
+                       nfsargsp->wsize = num;
+                       nfsargsp->flags |= NFSMNT_WSIZE;
+               } else if (!strcmp(cp, "timeo") && num > 0) {
+                       nfsargsp->timeo = num;
+                       nfsargsp->flags |= NFSMNT_TIMEO;
+               } else if (!strcmp(cp, "retrans") && num > 0) {
+                       nfsargsp->retrans = num;
+                       nfsargsp->flags |= NFSMNT_RETRANS;
+               }
+       }
+       if (nfsargsp->sotype == SOCK_DGRAM) {
+               if (nfsargsp->rsize > NFS_MAXDGRAMDATA)
+                       nfsargsp->rsize = NFS_MAXDGRAMDATA;
+               if (nfsargsp->wsize > NFS_MAXDGRAMDATA)
+                       nfsargsp->wsize = NFS_MAXDGRAMDATA;
+       }
+}
+
+char *
+getnfsargs(spec, nfsargsp)
+       char *spec;
+       struct nfs_args *nfsargsp;
+{
+       register CLIENT *clp;
+       struct hostent *hp;
+       static struct sockaddr_in saddr;
+       struct timeval pertry, try;
+       enum clnt_stat clnt_stat;
+       int so = RPC_ANYSOCK;
+       char *fsp, *hostp, *delimp;
+       u_short tport;
+       static struct nfhret nfhret;
+       static char nam[MNAMELEN + 1];
+       char buf[MAXPATHLEN + 1];
+
+       strncpy(buf, spec, MAXPATHLEN);
+       buf[MAXPATHLEN] = '\0';
+       strncpy(nam, spec, MNAMELEN);
+       nam[MNAMELEN] = '\0';
+       if ((delimp = index(buf, '@')) != NULL) {
+               hostp = delimp + 1;
+               fsp = buf;
+       } else if ((delimp = index(buf, ':')) != NULL) {
+               hostp = buf;
+               fsp = delimp + 1;
+       } else {
+               (void) fprintf(stderr,
+                   "mount: No <host>:<dirpath> or <dirpath>@<host> spec\n");
+               return (0);
+       }
+       *delimp = '\0';
+       if ((hp = gethostbyname(hostp)) == NULL) {
+               (void) fprintf(stderr, "mount: Can't get net id for host\n");
+               return (0);
+       }
+       bcopy(hp->h_addr, (caddr_t)&saddr.sin_addr, hp->h_length);
+       nfhret.stat = ETIMEDOUT;        /* Mark not yet successful */
+       while (retrycnt > 0) {
+               saddr.sin_family = AF_INET;
+               saddr.sin_port = htons(PMAPPORT);
+               if ((tport = pmap_getport(&saddr, RPCPROG_NFS,
+                   NFS_VER2, IPPROTO_UDP)) == 0) {
+                       if ((opflags & ISBGRND) == 0)
+                               clnt_pcreateerror("NFS Portmap");
+               } else {
+                       saddr.sin_port = 0;
+                       pertry.tv_sec = 10;
+                       pertry.tv_usec = 0;
+                       if ((clp = clntudp_create(&saddr, RPCPROG_MNT,
+                           RPCMNT_VER1, pertry, &so)) == NULL) {
+                               if ((opflags & ISBGRND) == 0)
+                                       clnt_pcreateerror("Cannot MNT PRC");
+                       } else {
+                               clp->cl_auth = authunix_create_default();
+                               try.tv_sec = 10;
+                               try.tv_usec = 0;
+                               clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
+                                   xdr_dir, fsp, xdr_fh, &nfhret, try);
+                               if (clnt_stat != RPC_SUCCESS) {
+                                       if ((opflags & ISBGRND) == 0)
+                                               clnt_perror(clp, "Bad MNT RPC");
+                               } else {
+                                       auth_destroy(clp->cl_auth);
+                                       clnt_destroy(clp);
+                                       retrycnt = 0;
+                               }
                        }
                        }
-                       fprintf(stderr, "%s: %s\n", name, cp);
-                       return;
                }
                }
-               /* we don't do quotas.... */
-               if (strcmp(type, FSTAB_RQ) == 0)
-                       type = FSTAB_RW;
+               if (--retrycnt > 0) {
+                       if (opflags & BGRND) {
+                               opflags &= ~BGRND;
+                               if (fork())
+                                       return (0);
+                               else
+                                       opflags |= ISBGRND;
+                       } 
+                       sleep(10);
+               }
        }
        }
-       np = index(spec, '\0');
-       while (*--np == '/')
-               *np = '\0';
-       np = rindex(spec, '/');
-       if (np) {
-               *np++ = '\0';
-               spec = np;
-       }
-       for (mp = mtab; mp < &mtab[NMOUNT]; mp++)
-               if (strcmp(mp->m_dname, spec) == 0)
-                       goto replace;
-       for (mp = mtab; mp < &mtab[NMOUNT]; mp++)
-               if (mp->m_path[0] == '\0')
-                       goto replace;
-       return;
-replace:
-       strncpy(mp->m_dname, spec, DNMAX);
-       mp->m_dname[DNMAX] = '\0';
-       strncpy(mp->m_path, name, PNMAX);
-       mp->m_path[PNMAX] = '\0';
-       strcpy(mp->m_type, type);
-       if (verbose)
-               prmtab(mp);
-       mp = mtab + NMOUNT - 1;
-       while (mp > mtab && mp->m_path[0] == '\0')
-               --mp;
-       mf = creat("/etc/mtab", 0644);
-       write(mf, (char *)mtab, (mp - mtab + 1) * sizeof (struct mtab));
-       close(mf);
-       return;
+       if (nfhret.stat) {
+               if (opflags & ISBGRND)
+                       exit(1);
+               (void) fprintf(stderr, "Mount RPC error on %s: ", spec);
+               errno = nfhret.stat;
+               perror((char *)NULL);
+               return (0);
+       }
+       saddr.sin_port = htons(tport);
+       nfsargsp->addr = (struct sockaddr *) &saddr;
+       nfsargsp->fh = &nfhret.nfh;
+       nfsargsp->hostname = nam;
+       return ((caddr_t)nfsargsp);
+}
+
+/*
+ * xdr routines for mount rpc's
+ */
+xdr_dir(xdrsp, dirp)
+       XDR *xdrsp;
+       char *dirp;
+{
+       return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
+}
+
+xdr_fh(xdrsp, np)
+       XDR *xdrsp;
+       struct nfhret *np;
+{
+       if (!xdr_u_long(xdrsp, &(np->stat)))
+               return (0);
+       if (np->stat)
+               return (1);
+       return (xdr_opaque(xdrsp, (caddr_t)&(np->nfh), NFSX_FH));
 }
 }
+#endif /* NFS */