BSD 4_3_Net_2 release

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

diff --git a/usr/src/sbin/umount/umount.c b/usr/src/sbin/umount/umount.c
index 16cc42b..750cb43 100644 (file)
--- a/usr/src/sbin/umount/umount.c
+++ b/usr/src/sbin/umount/umount.c
@@ -1,113 +1,427 @@
-static char *sccsid = "@(#)umount.c    4.5 (Berkeley) %G%";
+/*-
+ * 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[] =
+"@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)umount.c   5.16 (Berkeley) 6/3/91";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+
+#ifdef NFS
+#include <sys/time.h>
+#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>
+#endif

 
 

-#include <stdio.h>

 #include <fstab.h>
 #include <fstab.h>

+#include <stdio.h>
+#include <string.h>

 
 

-/*
- * umount
- */
+#ifdef NFS
+int xdr_dir();
+char *nfshost;
+#endif

 
 

-#define        NMOUNT  16
-#define        NAMSIZ  32
+int    vflag, all, errs, fake;
+int    fflag = MNT_NOFORCE;
+char   *getmntname();

 
 

-struct mtab {
-       char    file[NAMSIZ];
-       char    spec[NAMSIZ];
-} mtab[NMOUNT];
+#define        MNTON   1
+#define        MNTFROM 2
+#define        MNTTYPE 3

 
 

-char   *rindex();
-int    vflag, all, errs;
+int *typelist, *maketypelist();

 
 main(argc, argv)
        int argc;
        char **argv;
 {
 
 main(argc, argv)
        int argc;
        char **argv;
 {

-       register struct mtab *mp;
-       register char *p1, *p2;
-       int mf;
+       extern char *optarg;
+       extern int optind;
+       int ch;

 
 

-       argc--, argv++;

        sync();
        sync();

-       mf = open("/etc/mtab", 0);
-       read(mf, (char *)mtab, sizeof (mtab));
-again:
-       if (!strcmp(*argv, "-v")) {
-               vflag++;
-               argc--, argv++;
-               goto again;
-       }
-       if (!strcmp(*argv, "-a")) {
-               all++;
-               argc--, argv++;
-               goto again;
-       }
-       if (argc == 0 && !all) {
-               fprintf(stderr, "Usage: umount [ -a ] [ -v ] [ dev ... ]\n");
-               exit(1);
-       }
+       while ((ch = getopt(argc, argv, "afFh:t:v")) != EOF)
+               switch((char)ch) {
+               case 'v':
+                       vflag++;
+                       break;
+               case 'f':
+                       fflag = MNT_FORCE;
+                       break;
+               case 'F':
+                       fake++;
+                       break;
+               case 'a':
+                       all++;
+                       break;
+               case 't':
+                       typelist = maketypelist(optarg);
+                       break;
+#ifdef NFS
+               case 'h':
+                       /* -h flag implies -a, and "-t nfs" if no -t flag */
+                       nfshost = optarg;
+                       all++;
+                       if (typelist == NULL)
+                               typelist = maketypelist("nfs");
+                       break;
+#endif /* NFS */
+               case '?':
+               default:
+                       usage();
+                       /* NOTREACHED */
+               }
+       argc -= optind;
+       argv += optind;
+
+       if (argc == 0 && !all)
+               usage();

        if (all) {
        if (all) {

+               if (argc > 0)
+                       usage();

                if (setfsent() == 0)
                        perror(FSTAB), exit(1);
                if (setfsent() == 0)
                        perror(FSTAB), exit(1);

-               umountall();
+               umountall(typelist);

                exit(0);
                exit(0);

-       }
+       } else
+               setfsent();

        while (argc > 0) {
        while (argc > 0) {

-               if (umountfs(*argv++) == 0)
+               if (umountfs(*argv++, 0) == 0)

                        errs++;
                argc--;
        }
        exit(errs);
 }
 
                        errs++;
                argc--;
        }
        exit(errs);
 }
 

-umountall()
+usage()

 {
 {

-       struct fstab fs, *fsp;
+       fprintf(stderr,
+               "%s\n%s\n",
+               "Usage: umount [-fv] special | node",
+#ifndef        NFS
+               "    or umount -a[fv] [-t fstypelist]"
+#else
+               "    or umount -a[fv] [-h host] [-t fstypelist]"
+#endif
+             );
+       exit(1);
+}

 
 

-       if ((fsp = getfsent()) == 0)
-               return;
-       fs = *fsp;      /* save info locally; it is static from getfsent() */
-       umountall();
-       if (strcmp(fs.fs_file, "/") == 0)
+umountall(typelist)
+       char **typelist;
+{
+       register struct fstab *fs;
+       struct fstab *allocfsent();
+
+       if ((fs = getfsent()) == (struct fstab *)0)

                return;
                return;

-       if (strcmp(fs.fs_type, FSTAB_RW) && strcmp(fs.fs_type, FSTAB_RO))
+       fs = allocfsent(fs);
+       umountall(typelist);
+       if (strcmp(fs->fs_file, "/") == 0) {
+               freefsent(fs);

                return;
                return;

-       if (umountfs(fs.fs_spec) < 0) {
-               perror(fs.fs_spec);
+       }
+       if (strcmp(fs->fs_type, FSTAB_RW) &&
+           strcmp(fs->fs_type, FSTAB_RO) &&
+           strcmp(fs->fs_type, FSTAB_RQ)) {
+               freefsent(fs);

                return;
        }
                return;
        }

+       (void) umountfs(fs->fs_file, typelist);
+       freefsent(fs);
+}
+
+struct fstab *
+allocfsent(fs)
+       register struct fstab *fs;
+{
+       register struct fstab *new;
+       register char *cp;
+
+       new = (struct fstab *)malloc((unsigned)sizeof (*fs));
+       cp = (char *)malloc((unsigned)strlen(fs->fs_file) + 1);
+       strcpy(cp, fs->fs_file);
+       new->fs_file = cp;
+       cp = (char *)malloc((unsigned)strlen(fs->fs_type) + 1);
+       strcpy(cp, fs->fs_type);
+       new->fs_type = cp;
+       cp = (char *)malloc((unsigned)strlen(fs->fs_spec) + 1);
+       strcpy(cp, fs->fs_spec);
+       new->fs_spec = cp;
+       new->fs_passno = fs->fs_passno;
+       new->fs_freq = fs->fs_freq;
+       return (new);

 }
 
 }
 

-struct mtab zeromtab;
+freefsent(fs)
+       register struct fstab *fs;
+{

 
 

-umountfs(name)
+       if (fs->fs_file)
+               free(fs->fs_file);
+       if (fs->fs_spec)
+               free(fs->fs_spec);
+       if (fs->fs_type)
+               free(fs->fs_type);
+       free((char *)fs);
+}
+
+umountfs(name, typelist)

        char *name;
        char *name;

+       int *typelist;

 {
 {

-       register char *p1, *p2;
-       register struct mtab *mp;
-       int mf;
+       char *mntpt;
+       struct stat stbuf;
+       int type;
+#ifdef NFS
+       register CLIENT *clp;
+       struct hostent *hp = 0;
+       struct sockaddr_in saddr;
+       struct timeval pertry, try;
+       enum clnt_stat clnt_stat;
+       int so = RPC_ANYSOCK;
+       char *hostp, *delimp;
+#endif /* NFS */
+
+       if (stat(name, &stbuf) < 0) {
+               if (getmntname(name, MNTFROM, &type) != 0)
+                       mntpt = name;
+               else if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
+                       fprintf(stderr, "%s: not currently mounted\n", name);
+                       return (0);
+               }
+       } else if ((stbuf.st_mode & S_IFMT) == S_IFBLK) {
+               if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
+                       fprintf(stderr, "%s: not currently mounted\n", name);
+                       return (0);
+               }
+       } else if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
+               mntpt = name;
+               if (getmntname(mntpt, MNTFROM, &type) == 0) {
+                       fprintf(stderr, "%s: not currently mounted\n", name);
+                       return (0);
+               }
+       } else {
+               fprintf(stderr, "%s: not a directory or special device\n",
+                       name);
+               return (0);
+       }
+
+       if (badtype(type, typelist))
+               return(1);
+#ifdef NFS
+       if ((delimp = index(name, '@')) != NULL) {
+               hostp = delimp + 1;
+               *delimp = '\0';
+               hp = gethostbyname(hostp);
+               *delimp = '@';
+       } else if ((delimp = index(name, ':')) != NULL) {
+               *delimp = '\0';
+               hostp = name;
+               hp = gethostbyname(hostp);
+               name = delimp+1;
+               *delimp = ':';
+       }

 
 

-       if (unmount(name) < 0) {
-               perror(name);
+       if (!namematch(hp, nfshost))
+               return(1);
+#endif /* NFS */
+       if (!fake && unmount(mntpt, fflag) < 0) {
+               perror(mntpt);

                return (0);
        }
        if (vflag)
                return (0);
        }
        if (vflag)

-               fprintf(stderr, "%s: Unmounted\n", name);
-       while ((p1 = rindex(name, '/')) && p1[1] == 0)
-               *p1 = 0;
-       if (p1)
-               name = p1 + 1;
-       for (mp = mtab; mp < &mtab[NMOUNT]; mp++) {
-               if (strncmp(mp->spec, name, sizeof (mp->spec)))
-                       continue;
-               *mp = zeromtab;
-               for (mp = &mtab[NMOUNT]; mp >= mtab; mp--)
-                       if (mp->file[0])
-                               break;
-               mp++;
-               mf = creat("/etc/mtab", 0644);
-               write(mf, (char *)mtab, (mp-mtab) * sizeof (struct mtab));
-               return (1);
+               fprintf(stderr, "%s: Unmounted from %s\n", name, mntpt);
+
+#ifdef NFS
+       if (!fake && hp != NULL && (fflag & MNT_FORCE) == 0) {
+               *delimp = '\0';
+               bcopy(hp->h_addr,(caddr_t)&saddr.sin_addr,hp->h_length);
+               saddr.sin_family = AF_INET;
+               saddr.sin_port = 0;
+               pertry.tv_sec = 3;
+               pertry.tv_usec = 0;
+               if ((clp = clntudp_create(&saddr, RPCPROG_MNT, RPCMNT_VER1,
+                   pertry, &so)) == NULL) {
+                       clnt_pcreateerror("Cannot MNT PRC");
+                       return (1);
+               }
+               clp->cl_auth = authunix_create_default();
+               try.tv_sec = 20;
+               try.tv_usec = 0;
+               clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, xdr_dir, name,
+                       xdr_void, (caddr_t)0, try);
+               if (clnt_stat != RPC_SUCCESS) {
+                       clnt_perror(clp, "Bad MNT RPC");
+                       return (1);
+               }
+               auth_destroy(clp->cl_auth);
+               clnt_destroy(clp);
+       }
+#endif /* NFS */
+       return (1);
+}
+
+char *
+getmntname(name, what, type)
+       char *name;
+       int what;
+       int *type;
+{
+       int mntsize, i;
+       struct statfs *mntbuf;
+
+       if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
+               perror("umount");
+               return (0);
+       }
+       for (i = 0; i < mntsize; i++) {
+               if (what == MNTON && !strcmp(mntbuf[i].f_mntfromname, name)) {
+                       if (type)
+                               *type = mntbuf[i].f_type;
+                       return (mntbuf[i].f_mntonname);
+               }
+               if (what == MNTFROM && !strcmp(mntbuf[i].f_mntonname, name)) {
+                       if (type)
+                               *type = mntbuf[i].f_type;
+                       return (mntbuf[i].f_mntfromname);
+               }

        }
        }

-       fprintf(stderr, "%s: Not mounted\n", name);

        return (0);
 }
        return (0);
 }

+
+static int skipvfs;
+
+badtype(type, typelist)
+       int type;
+       int *typelist;
+{
+       if (typelist == 0)
+               return(0);
+       while (*typelist) {
+               if (type == *typelist)
+                       return(skipvfs);
+               typelist++;
+       }
+       return(!skipvfs);
+}
+
+int *
+maketypelist(fslist)
+       char *fslist;
+{
+       register char *nextcp;
+       register int *av, i;
+
+       if (fslist == NULL)
+               return(NULL);
+       if (fslist[0] == 'n' && fslist[1] == 'o') {
+               fslist += 2;
+               skipvfs = 1;
+       } else
+               skipvfs = 0;
+       for (i = 0, nextcp = fslist; *nextcp; nextcp++)
+               if (*nextcp == ',')
+                       i++;
+       av = (int *)malloc((i+2) * sizeof(int));
+       if (av == NULL)
+               return(NULL);
+       for (i = 0; fslist; fslist = nextcp) {
+               if (nextcp = index(fslist, ','))
+                       *nextcp++ = '\0';
+               if (strcmp(fslist, "ufs") == 0)
+                       av[i++] = MOUNT_UFS;
+               else if (strcmp(fslist, "nfs") == 0)
+                       av[i++] = MOUNT_NFS;
+               else if (strcmp(fslist, "mfs") == 0)
+                       av[i++] = MOUNT_MFS;
+               else if (strcmp(fslist, "pc") == 0)
+                       av[i++] = MOUNT_PC;
+       }
+       av[i++] = 0;
+       return(av);
+}
+
+#ifdef NFS
+namematch(hp, nfshost)
+       struct hostent *hp;
+       char *nfshost;
+{
+       register char *cp;
+       register char **np;
+
+       if (hp == NULL || nfshost == NULL)
+               return(1);
+       if (strcasecmp(nfshost, hp->h_name) == 0)
+               return(1);
+       if (cp = index(hp->h_name, '.')) {
+               *cp = '\0';
+               if (strcasecmp(nfshost, hp->h_name) == 0)
+                       return(1);
+       }
+       for (np = hp->h_aliases; *np; np++) {
+               if (strcasecmp(nfshost, *np) == 0)
+                       return(1);
+               if (cp = index(*np, '.')) {
+                       *cp = '\0';
+                       if (strcasecmp(nfshost, *np) == 0)
+                               return(1);
+               }
+       }
+       return(0);
+}
+
+/*
+ * xdr routines for mount rpc's
+ */
+xdr_dir(xdrsp, dirp)
+       XDR *xdrsp;
+       char *dirp;
+{
+       return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
+}
+#endif /* NFS */