BSD 4_3_Net_2 release

[unix-history] / usr / src / sbin / mount / mount.c

diff --git a/usr/src/sbin/mount/mount.c b/usr/src/sbin/mount/mount.c
index 45fa096..9c561b2 100644 (file)
--- a/usr/src/sbin/mount/mount.c
+++ b/usr/src/sbin/mount/mount.c
@@ -1,31 +1,52 @@
 /*
 /*

- * Copyright (c) 1980 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * 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.

  */
 
 #ifndef lint
 char copyright[] =
  */
 
 #ifndef lint
 char copyright[] =

-"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+"@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\

  All rights reserved.\n";
  All rights reserved.\n";

-#endif not lint
+#endif /* not lint */

 
 #ifndef lint
 
 #ifndef lint

-static char sccsid[] = "@(#)mount.c    5.14 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)mount.c    5.44 (Berkeley) 2/26/91";
+#endif /* not lint */

 
 

-#include "pathnames.h"

 #include <sys/param.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <sys/param.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/wait.h>

-#include <fstab.h>
-#include <errno.h>
-#include <stdio.h>
-#include <strings.h>
-#include <sys/dir.h>
-#include <sys/uio.h>
-#include <sys/namei.h>
+#include <sys/errno.h>
+#include <sys/signal.h>

 #include <sys/mount.h>
 #ifdef NFS
 #include <sys/socket.h>
 #include <sys/mount.h>
 #ifdef NFS
 #include <sys/socket.h>


@@ -38,6 +59,13 @@ static char sccsid[] = "@(#)mount.c  5.14 (Berkeley) %G%";
 #include <nfs/nfsv2.h>
 #include <nfs/nfs.h>
 #endif
 #include <nfs/nfsv2.h>
 #include <nfs/nfs.h>
 #endif

+#include <fstab.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "pathnames.h"
+
+#define DEFAULT_ROOTUID        -2

 
 #define        BADTYPE(type) \
        (strcmp(type, FSTAB_RO) && strcmp(type, FSTAB_RW) && \
 
 #define        BADTYPE(type) \
        (strcmp(type, FSTAB_RO) && strcmp(type, FSTAB_RW) && \


@@ -45,14 +73,18 @@ static char sccsid[] = "@(#)mount.c 5.14 (Berkeley) %G%";
 #define        SETTYPE(type) \
        (!strcmp(type, FSTAB_RW) || !strcmp(type, FSTAB_RQ))
 
 #define        SETTYPE(type) \
        (!strcmp(type, FSTAB_RW) || !strcmp(type, FSTAB_RQ))
 

-static int fake, verbose, mnttype;
-char **envp;
+int fake, verbose, updateflg, mnttype;
+char *mntname, **envp;
+char **vfslist, **makevfslist();
+static void prmount();

 
 #ifdef NFS
 int xdr_dir(), xdr_fh();
 char *getnfsargs();
 
 #ifdef NFS
 int xdr_dir(), xdr_fh();
 char *getnfsargs();

-struct nfs_args nfsargs = {
-       (struct sockaddr_in *)0,
+struct nfs_args nfsdefargs = {
+       (struct sockaddr *)0,
+       SOCK_DGRAM,
+       0,

        (nfsv2fh_t *)0,
        0,
        NFS_WSIZE,
        (nfsv2fh_t *)0,
        0,
        NFS_WSIZE,


@@ -66,7 +98,8 @@ struct nfhret {
        u_long  stat;
        nfsv2fh_t nfh;
 };
        u_long  stat;
        nfsv2fh_t nfh;
 };

-int retrycnt = 10000;
+#define        DEF_RETRY       10000
+int retrycnt;

 #define        BGRND   1
 #define        ISBGRND 2
 int opflags = 0;
 #define        BGRND   1
 #define        ISBGRND 2
 int opflags = 0;


@@ -80,17 +113,18 @@ main(argc, argv, arge)
        extern char *optarg;
        extern int optind;
        register struct fstab *fs;
        extern char *optarg;
        extern int optind;
        register struct fstab *fs;

-       register int cnt;
-       int all, ch, rval, sfake, i;
+       int all, ch, rval, flags, ret, pid, i;

        long mntsize;
        long mntsize;

-       struct statfs *mntbuf;
+       struct statfs *mntbuf, *getmntpt();

        char *type, *options = NULL;
        char *type, *options = NULL;

+       FILE *pidfile;

 
        envp = arge;
        all = 0;
        type = NULL;
        mnttype = MOUNT_UFS;
 
        envp = arge;
        all = 0;
        type = NULL;
        mnttype = MOUNT_UFS;

-       while ((ch = getopt(argc, argv, "afrwvt:o:")) != EOF)
+       mntname = "ufs";
+       while ((ch = getopt(argc, argv, "afrwuvt:o:")) != EOF)

                switch((char)ch) {
                case 'a':
                        all = 1;
                switch((char)ch) {
                case 'a':
                        all = 1;


@@ -101,6 +135,9 @@ main(argc, argv, arge)
                case 'r':
                        type = FSTAB_RO;
                        break;
                case 'r':
                        type = FSTAB_RO;
                        break;

+               case 'u':
+                       updateflg = MNT_UPDATE;
+                       break;

                case 'v':
                        verbose = 1;
                        break;
                case 'v':
                        verbose = 1;
                        break;


@@ -111,9 +148,9 @@ main(argc, argv, arge)
                        options = optarg;
                        break;
                case 't':
                        options = optarg;
                        break;
                case 't':

-                       if (mnttype = getmnttype(optarg))
-                               break;
-                       /* fall through */
+                       vfslist = makevfslist(optarg);
+                       mnttype = getmnttype(optarg);
+                       break;

                case '?':
                default:
                        usage();
                case '?':
                default:
                        usage();


@@ -126,20 +163,19 @@ main(argc, argv, arge)
 
        if (all) {
                rval = 0;
 
        if (all) {
                rval = 0;

-               for (sfake = fake; fs = getfsent(); fake = sfake) {
+               while (fs = getfsent()) {

                        if (BADTYPE(fs->fs_type))
                                continue;
                        if (BADTYPE(fs->fs_type))
                                continue;

+                       if (badvfsname(fs->fs_vfstype, vfslist))
+                               continue;

                        /* `/' is special, it's always mounted */
                        if (!strcmp(fs->fs_file, "/"))
                        /* `/' is special, it's always mounted */
                        if (!strcmp(fs->fs_file, "/"))

-                               fake = 1;
-                       if ((mnttype = getmnttype(fs->fs_vfstype)) == 0) {
-                               fprintf(stderr,
-                                   "%s %s type of file system is unknown.\n",
-                                   "mount:", fs->fs_vfstype);
-                               continue;
-                       }
-                       rval |= mountfs(fs->fs_spec, fs->fs_file,
-                           type ? type : fs->fs_type, options, fs->fs_mntops);
+                               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(rval);
        }
                }
                exit(rval);
        }


@@ -147,137 +183,181 @@ main(argc, argv, arge)
        if (argc == 0) {
                if (verbose || fake || type)
                        usage();
        if (argc == 0) {
                if (verbose || fake || type)
                        usage();

-               if ((mntsize = getmntinfo(&mntbuf)) == 0) {
-                       fprintf(stderr,
+               if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
+                       (void) fprintf(stderr,

                                "mount: cannot get mount information\n");
                        exit(1);
                }
                                "mount: cannot get mount information\n");
                        exit(1);
                }

-               for (i = 0; i < mntsize; i++)
+               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);
                        prmount(mntbuf[i].f_mntfromname, mntbuf[i].f_mntonname,
                                mntbuf[i].f_flags);

+               }

                exit(0);
        }
 
                exit(0);
        }
 

-       if (argc == 1) {
+       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))) {
                if (!(fs = getfsfile(*argv)) && !(fs = getfsspec(*argv))) {

-                       fprintf(stderr,
+                       (void) fprintf(stderr,

                            "mount: unknown special file or file system %s.\n",
                            *argv);
                        exit(1);
                }
                if (BADTYPE(fs->fs_type)) {
                            "mount: unknown special file or file system %s.\n",
                            *argv);
                        exit(1);
                }
                if (BADTYPE(fs->fs_type)) {

-                       fprintf(stderr,
+                       (void) fprintf(stderr,

                            "mount: %s has unknown file system type.\n", *argv);
                        exit(1);
                }
                            "mount: %s has unknown file system type.\n", *argv);
                        exit(1);
                }

-               if ((mnttype = getmnttype(fs->fs_vfstype)) == 0) {
-                       fprintf(stderr,
-                           "mount: %s type of file system is unknown.\n",
-                           fs->fs_vfstype);
-                       exit(1);
-               }
-               exit(mountfs(fs->fs_spec, fs->fs_file,
-                   type ? type : fs->fs_type, options, fs->fs_mntops));
-       }
-
-       if (argc != 2)
+               mnttype = getmnttype(fs->fs_vfstype);
+               ret = mountfs(fs->fs_spec, fs->fs_file, updateflg,
+                   type, options, fs->fs_mntops);
+       } else if (argc != 2) {

                usage();
                usage();

-
-       exit(mountfs(argv[0], argv[1], type ? type : "rw", options, NULL));
+               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, type, options, mntopts)
+mountfs(spec, name, flags, type, options, mntopts)

        char *spec, *name, *type, *options, *mntopts;
        char *spec, *name, *type, *options, *mntopts;

+       int flags;

 {
 {

-       extern int errno;
-       register int cnt;
-       int flags, argc, status, i;
+       union wait status;
+       pid_t pid;
+       int argc, i;

        struct ufs_args args;
        struct ufs_args args;

+       struct nfs_args nfsargs;

        char *argp, *argv[50];
        char *argp, *argv[50];

+       char execname[MAXPATHLEN + 1], flagval[12];

 
 

-       flags = 0;
-       if (!strcmp(type, FSTAB_RO))
-               flags |= M_RDONLY;
-       if (options)
-               getstdopts(options, &flags);
+       nfsargs = nfsdefargs;

        if (mntopts)
                getstdopts(mntopts, &flags);
        if (mntopts)
                getstdopts(mntopts, &flags);

+       if (options)
+               getstdopts(options, &flags);
+       if (type)
+               getstdopts(type, &flags);

        switch (mnttype) {
        case MOUNT_UFS:
        switch (mnttype) {
        case MOUNT_UFS:

-               if (options)
-                       getufsopts(options, &flags);

                if (mntopts)
                        getufsopts(mntopts, &flags);
                if (mntopts)
                        getufsopts(mntopts, &flags);

+               if (options)
+                       getufsopts(options, &flags);

                args.fspec = spec;
                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:
                argp = (caddr_t)&args;
                break;
 
 #ifdef NFS
        case MOUNT_NFS:

-               if (options)
-                       getnfsopts(options, &nfsargs, &opflags,
-                               &retrycnt);
+               retrycnt = DEF_RETRY;

                if (mntopts)
                if (mntopts)

-                       getnfsopts(mntopts, &nfsargs, &opflags,
-                               &retrycnt);
-               if (argp = getnfsargs(spec, name, type))
+                       getnfsopts(mntopts, &nfsargs, &opflags, &retrycnt);
+               if (options)
+                       getnfsopts(options, &nfsargs, &opflags, &retrycnt);
+               if (argp = getnfsargs(spec, &nfsargs))

                        break;
                return (1);
 #endif /* NFS */
 
                        break;
                return (1);
 #endif /* NFS */
 

-#ifdef MFS

        case MOUNT_MFS:
        case MOUNT_MFS:

-               argv[0] = "memfs";
+       default:
+               argv[0] = mntname;

                argc = 1;
                argc = 1;

-               if (options)
-                       argc += getmfsopts(options, &argv[argc]);
+               if (flags) {
+                       argv[argc++] = "-F";
+                       sprintf(flagval, "%d", flags);
+                       argv[argc++] = flagval;
+               }

                if (mntopts)
                if (mntopts)

-                       argc += getmfsopts(mntopts, &argv[argc]);
+                       argc += getexecopts(mntopts, &argv[argc]);
+               if (options)
+                       argc += getexecopts(options, &argv[argc]);

                argv[argc++] = spec;
                argv[argc++] = name;
                argv[argc++] = spec;
                argv[argc++] = name;

+               argv[argc++] = NULL;
+               sprintf(execname, "%s/mount_%s", _PATH_EXECDIR, mntname);

                if (verbose) {
                if (verbose) {

-                       printf("exec:");
-                       for (i = 0; i < argc; i++)
-                               printf(" %s", argv[i]);
-                       printf("\n");
+                       (void)printf("exec: %s", execname);
+                       for (i = 1; i < argc - 1; i++)
+                               (void)printf(" %s", argv[i]);
+                       (void)printf("\n");

                }
                if (fake)
                        break;
                }
                if (fake)
                        break;

-               if (i = vfork()) {
-                       if (i == -1) {
-                               perror("mount: vfork for memfs");
+               if (pid = vfork()) {
+                       if (pid == -1) {
+                               perror("mount: vfork starting file system");

                                return (1);
                        }
                                return (1);
                        }

-                       if (waitpid(i, &status, 0) != -1 &&
+                       if (waitpid(pid, (int *)&status, 0) != -1 &&

                            WIFEXITED(status) &&
                            WEXITSTATUS(status) != 0)
                                return (WEXITSTATUS(status));
                            WIFEXITED(status) &&
                            WEXITSTATUS(status) != 0)
                                return (WEXITSTATUS(status));

-                       spec = "memfs";
+                       spec = mntname;

                        goto out;
                }
                        goto out;
                }

-               execve(_PATH_MEMFS, argv, envp);
-               perror(_PATH_MEMFS);
+               execve(execname, argv, envp);
+               (void) fprintf(stderr, "mount: cannot exec %s for %s: ",
+                       execname, name);
+               perror((char *)NULL);

                exit (1);
                exit (1);

-#endif /* MFS */
-
-       default:
-               if (opflags & ISBGRND)
-                       exit(1);
-               fprintf(stderr, "%d: unknown mount type\n", mnttype);
-               exit(1);

                /* NOTREACHED */
 
        }
        if (!fake && mount(mnttype, name, flags, argp)) {
                if (opflags & ISBGRND)
                        exit(1);
                /* NOTREACHED */
 
        }
        if (!fake && mount(mnttype, name, flags, argp)) {
                if (opflags & ISBGRND)
                        exit(1);

-               fprintf(stderr, "%s on %s: ", spec, name);
+               (void) fprintf(stderr, "%s on %s: ", spec, name);

                switch (errno) {
                case EMFILE:
                switch (errno) {
                case EMFILE:

-                       fprintf(stderr, "Mount table full\n");
+                       (void) fprintf(stderr, "Mount table full\n");

                        break;
                case EINVAL:
                        break;
                case EINVAL:

-                       fprintf(stderr, "Bogus super block\n");
+                       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;
                default:
                        perror((char *)NULL);


@@ -291,46 +371,53 @@ out:
                prmount(spec, name, flags);
 
        if (opflags & ISBGRND)
                prmount(spec, name, flags);
 
        if (opflags & ISBGRND)

-               exit();
-       else
-               return(0);
+               exit(1);
+       return(0);

 }
 
 }
 

-static
+static void

 prmount(spec, name, flags)
        char *spec, *name;
 prmount(spec, name, flags)
        char *spec, *name;

-       long flags;
+       register short flags;

 {
 {

-       register char *root;
+       register int first;

 
        if (opflags & ISBGRND)
                return;
 
        if (opflags & ISBGRND)
                return;

-       /*
-        * trim trailing /'s and find last component of name
-        */
-       for (root = index(spec, '\0'); *--root == '/';)
-               /* void */;
-       *++root = '\0';
-       if (root = rindex(spec, '/'))
-               spec = root + 1;
-       printf("%s on %s", spec, name);
-       if (flags & M_RDONLY)
-               printf(" (read-only)");
-       if (flags & M_NOEXEC)
-               printf(" (noexec)");
-       if (flags & M_NOSUID)
-               printf(" (nosuid)");
-       if (flags & M_NODEV)
-               printf(" (nodev)");
-       if (flags & M_SYNCHRONOUS)
-               printf(" (synchronous)");
-       printf("\n");
+       (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;
 {
 
 }
 
 getmnttype(fstype)
        char *fstype;
 {
 

+       mntname = fstype;

        if (!strcmp(fstype, "ufs"))
                return (MOUNT_UFS);
        if (!strcmp(fstype, "nfs"))
        if (!strcmp(fstype, "ufs"))
                return (MOUNT_UFS);
        if (!strcmp(fstype, "nfs"))


@@ -342,67 +429,87 @@ getmnttype(fstype)
 
 usage()
 {
 
 usage()
 {

-       fprintf(stderr, "usage: mount [-afrw]\nor mount [-frw] special | node\nor mount [-frw] special node\n");
+
+       (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;
        exit(1);
 }
 
 getstdopts(options, flagp)
        char *options;

-       long *flagp;
+       int *flagp;

 {
        register char *opt;
        int negative;
 {
        register char *opt;
        int negative;

-       char *optbuf[BUFSIZ], *strtok();
+       char optbuf[BUFSIZ];

 
 

-       strcpy(optbuf, options);
-       for (opt = strtok(optbuf, ","); opt; opt = strtok(NULL, ",")) {
+       (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 (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)
                if (!strcasecmp(opt, "exec")) {
                        if (negative)

-                               *flagp |= M_NOEXEC;
+                               *flagp |= MNT_NOEXEC;
+                       else
+                               *flagp &= ~MNT_NOEXEC;

                        continue;
                }
                if (!strcasecmp(opt, "suid")) {
                        if (negative)
                        continue;
                }
                if (!strcasecmp(opt, "suid")) {
                        if (negative)

-                               *flagp |= M_NOSUID;
+                               *flagp |= MNT_NOSUID;
+                       else
+                               *flagp &= ~MNT_NOSUID;

                        continue;
                }
                if (!strcasecmp(opt, "dev")) {
                        if (negative)
                        continue;
                }
                if (!strcasecmp(opt, "dev")) {
                        if (negative)

-                               *flagp |= M_NODEV;
+                               *flagp |= MNT_NODEV;
+                       else
+                               *flagp &= ~MNT_NODEV;

                        continue;
                }
                if (!strcasecmp(opt, "synchronous")) {
                        if (!negative)
                        continue;
                }
                if (!strcasecmp(opt, "synchronous")) {
                        if (!negative)

-                               *flagp |= M_SYNCHRONOUS;
+                               *flagp |= MNT_SYNCHRONOUS;
+                       else
+                               *flagp &= ~MNT_SYNCHRONOUS;

                        continue;
                }
        }
 }
 
                        continue;
                }
        }
 }
 

+/* ARGSUSED */

 getufsopts(options, flagp)
        char *options;
 getufsopts(options, flagp)
        char *options;

-       long *flagp;
+       int *flagp;

 {
 {

-

        return;
 }
 
        return;
 }
 

-#ifdef MFS
-getmfsopts(options, argv)
+getexecopts(options, argv)

        char *options;
        char **argv;
 {
        register int argc = 0;
        register char *opt;
        char *options;
        char **argv;
 {
        register int argc = 0;
        register char *opt;

-       char *strtok();

 
 

-       for (opt = strtok(options, ","); opt; opt = strtok(NULL, ",")) {
+       for (opt = strtok(options, ","); opt; opt = strtok((char *)NULL, ",")) {

                if (opt[0] != '-')
                        continue;
                argv[argc++] = opt;
                if (opt[0] != '-')
                        continue;
                argv[argc++] = opt;


@@ -413,16 +520,103 @@ getmfsopts(options, argv)
        }
        return (argc);
 }
        }
        return (argc);
 }

-#endif /* MFS */
+
+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);
+}
+
+static int skipvfs;
+
+badvfstype(vfstype, vfslist)
+       short vfstype;
+       char **vfslist;
+{
+
+       if (vfslist == 0)
+               return(0);
+       while (*vfslist) {
+               if (vfstype == getmnttype(*vfslist))
+                       return(skipvfs);
+               vfslist++;
+       }
+       return (!skipvfs);
+}
+
+badvfsname(vfsname, vfslist)
+       char *vfsname;
+       char **vfslist;
+{
+
+       if (vfslist == 0)
+               return(0);
+       while (*vfslist) {
+               if (strcmp(vfsname, *vfslist) == 0)
+                       return(skipvfs);
+               vfslist++;
+       }
+       return (!skipvfs);
+}
+
+char **
+makevfslist(fslist)
+       char *fslist;
+{
+       register char **av, *nextcp;
+       register int i;
+
+       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
 
 #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;
 /*
  * Handle the getoption arg.
  * Essentially update "opflags", "retrycnt" and "nfsargs"
  */
 getnfsopts(optarg, nfsargsp, opflagsp, retrycntp)
        char *optarg;

-       struct nfs_args *nfsargsp;
+       register struct nfs_args *nfsargsp;

        int *opflagsp;
        int *retrycntp;
 {
        int *opflagsp;
        int *retrycntp;
 {


@@ -430,8 +624,7 @@ getnfsopts(optarg, nfsargsp, opflagsp, retrycntp)
        int num;
        char *nump;
 
        int num;
        char *nump;
 

-       cp = optarg;
-       while (cp != NULL && *cp != '\0') {
+       for (cp = optarg; cp != NULL && *cp != '\0'; cp = nextcp) {

                if ((nextcp = index(cp, ',')) != NULL)
                        *nextcp++ = '\0';
                if ((nump = index(cp, '=')) != NULL) {
                if ((nextcp = index(cp, ',')) != NULL)
                        *nextcp++ = '\0';
                if ((nump = index(cp, '=')) != NULL) {


@@ -445,9 +638,21 @@ getnfsopts(optarg, nfsargsp, opflagsp, retrycntp)
                if (!strcmp(cp, "bg")) {
                        *opflagsp |= BGRND;
                } else if (!strcmp(cp, "soft")) {
                if (!strcmp(cp, "bg")) {
                        *opflagsp |= BGRND;
                } else if (!strcmp(cp, "soft")) {

+                       if (nfsargsp->flags & NFSMNT_SPONGY)
+                               exclusive("soft, spongy");

                        nfsargsp->flags |= NFSMNT_SOFT;
                        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, "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) {
                } else if (!strcmp(cp, "retry") && num > 0) {
                        *retrycntp = num;
                } else if (!strcmp(cp, "rsize") && num > 0) {


@@ -463,44 +668,54 @@ getnfsopts(optarg, nfsargsp, opflagsp, retrycntp)
                        nfsargsp->retrans = num;
                        nfsargsp->flags |= NFSMNT_RETRANS;
                }
                        nfsargsp->retrans = num;
                        nfsargsp->flags |= NFSMNT_RETRANS;
                }

-               cp = nextcp;
+       }
+       if (nfsargsp->sotype == SOCK_DGRAM) {
+               if (nfsargsp->rsize > NFS_MAXDGRAMDATA)
+                       nfsargsp->rsize = NFS_MAXDGRAMDATA;
+               if (nfsargsp->wsize > NFS_MAXDGRAMDATA)
+                       nfsargsp->wsize = NFS_MAXDGRAMDATA;

        }
 }
 
 char *
        }
 }
 
 char *

-getnfsargs(spec)
+getnfsargs(spec, nfsargsp)

        char *spec;
        char *spec;

+       struct nfs_args *nfsargsp;

 {
        register CLIENT *clp;
        struct hostent *hp;
 {
        register CLIENT *clp;
        struct hostent *hp;

-       struct sockaddr_in saddr;
+       static struct sockaddr_in saddr;

        struct timeval pertry, try;
        enum clnt_stat clnt_stat;
        int so = RPC_ANYSOCK;
        struct timeval pertry, try;
        enum clnt_stat clnt_stat;
        int so = RPC_ANYSOCK;

-       char *hostp, *delimp;
+       char *fsp, *hostp, *delimp;

        u_short tport;
        u_short tport;

-       struct nfhret nfhret;
-       char nam[MNAMELEN + 1];
+       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';
        strncpy(nam, spec, MNAMELEN);
        nam[MNAMELEN] = '\0';

-       if ((delimp = index(spec, '@')) != NULL) {
+       if ((delimp = index(buf, '@')) != NULL) {

                hostp = delimp + 1;
                hostp = delimp + 1;

-       } else if ((delimp = index(spec, ':')) != NULL) {
-               hostp = spec;
-               spec = delimp + 1;
+               fsp = buf;
+       } else if ((delimp = index(buf, ':')) != NULL) {
+               hostp = buf;
+               fsp = delimp + 1;

        } else {
        } else {

-               fprintf(stderr,
-                   "No <host>:<dirpath> or <dirpath>@<host> spec\n");
+               (void) fprintf(stderr,
+                   "mount: No <host>:<dirpath> or <dirpath>@<host> spec\n");

                return (0);
        }
        *delimp = '\0';
        if ((hp = gethostbyname(hostp)) == NULL) {
                return (0);
        }
        *delimp = '\0';
        if ((hp = gethostbyname(hostp)) == NULL) {

-               fprintf(stderr, "Can't get net id for host\n");
+               (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);
                return (0);
        }
        bcopy(hp->h_addr, (caddr_t)&saddr.sin_addr, hp->h_length);

-       nfhret.stat = EACCES;   /* Mark not yet successful */
+       nfhret.stat = ETIMEDOUT;        /* Mark not yet successful */

        while (retrycnt > 0) {
                saddr.sin_family = AF_INET;
                saddr.sin_port = htons(PMAPPORT);
        while (retrycnt > 0) {
                saddr.sin_family = AF_INET;
                saddr.sin_port = htons(PMAPPORT);


@@ -521,7 +736,7 @@ getnfsargs(spec)
                                try.tv_sec = 10;
                                try.tv_usec = 0;
                                clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
                                try.tv_sec = 10;
                                try.tv_usec = 0;
                                clnt_stat = clnt_call(clp, RPCMNT_MOUNT,

-                                   xdr_dir, spec, xdr_fh, &nfhret, try);
+                                   xdr_dir, fsp, xdr_fh, &nfhret, try);

                                if (clnt_stat != RPC_SUCCESS) {
                                        if ((opflags & ISBGRND) == 0)
                                                clnt_perror(clp, "Bad MNT RPC");
                                if (clnt_stat != RPC_SUCCESS) {
                                        if ((opflags & ISBGRND) == 0)
                                                clnt_perror(clp, "Bad MNT RPC");


@@ -546,15 +761,16 @@ getnfsargs(spec)
        if (nfhret.stat) {
                if (opflags & ISBGRND)
                        exit(1);
        if (nfhret.stat) {
                if (opflags & ISBGRND)
                        exit(1);

-               fprintf(stderr, "Can't access %s, errno=%d\n", spec,
-                   nfhret.stat);
+               (void) fprintf(stderr, "Mount RPC error on %s: ", spec);
+               errno = nfhret.stat;
+               perror((char *)NULL);

                return (0);
        }
        saddr.sin_port = htons(tport);
                return (0);
        }
        saddr.sin_port = htons(tport);

-       nfsargs.addr = &saddr;
-       nfsargs.fh = &nfhret.nfh;
-       nfsargs.hostname = nam;
-       return ((caddr_t)&nfsargs);
+       nfsargsp->addr = (struct sockaddr *) &saddr;
+       nfsargsp->fh = &nfhret.nfh;
+       nfsargsp->hostname = nam;
+       return ((caddr_t)nfsargsp);

 }
 
 /*
 }
 
 /*