2.11BSD#431 - /usr/src/lib/libc/gen/fstab.c

   1: /*
   2:  * Copyright (c) 1980, 1988, 1993
   3:  *	The Regents of the University of California.  All rights reserved.
   4:  *
   5:  * Redistribution and use in source and binary forms, with or without
   6:  * modification, are permitted provided that the following conditions
   7:  * are met:
   8:  * 1. Redistributions of source code must retain the above copyright
   9:  *    notice, this list of conditions and the following disclaimer.
  10:  * 2. Redistributions in binary form must reproduce the above copyright
  11:  *    notice, this list of conditions and the following disclaimer in the
  12:  *    documentation and/or other materials provided with the distribution.
  13:  * 3. All advertising materials mentioning features or use of this software
  14:  *    must display the following acknowledgement:
  15:  *	This product includes software developed by the University of
  16:  *	California, Berkeley and its contributors.
  17:  * 4. Neither the name of the University nor the names of its contributors
  18:  *    may be used to endorse or promote products derived from this software
  19:  *    without specific prior written permission.
  20:  *
  21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31:  * SUCH DAMAGE.
  32:  */
  33: 
  34: #if defined(LIBC_SCCS) && !defined(lint)
  35: static char sccsid[] = "@(#)fstab.c	8.1.1 (2.11BSD) 1996/1/15";
  36: #endif /* LIBC_SCCS and not lint */
  37: 
  38: #include <errno.h>
  39: #include <fstab.h>
  40: #include <stdio.h>
  41: #include <stdlib.h>
  42: #include <string.h>
  43: #include <unistd.h>
  44: #include <sys/uio.h>
  45: 
  46: extern  char    *__progname;
  47: static FILE *_fs_fp;
  48: static struct fstab _fs_fstab;
  49: 
  50: static void error();
  51: static int fstabscan();
  52: 
  53: static int
  54: fstabscan()
  55: {
  56:     char *cp;
  57:     register char *bp;
  58: #define MAXLINELENGTH   256
  59:     static char line[MAXLINELENGTH];
  60:     char subline[MAXLINELENGTH], *colon = ":";
  61:     int typexx;
  62: 
  63:     for (;;) {
  64:         if (!fgets(line, sizeof(line), _fs_fp))
  65:             return(0);
  66:         bp = index(line, '\n');
  67:         if (!bp)
  68:             return(0);
  69:         *bp = '\0';
  70:         cp = line;
  71: /* OLD_STYLE_FSTAB */
  72:         if (!strpbrk(cp, " \t")) {
  73:             _fs_fstab.fs_spec = strsep(&cp, colon);
  74:             _fs_fstab.fs_file = strsep(&cp, colon);
  75:             _fs_fstab.fs_type = strsep(&cp, colon);
  76:             if (_fs_fstab.fs_type) {
  77:                 if (!strcmp(_fs_fstab.fs_type, FSTAB_XX))
  78:                     continue;
  79:                 _fs_fstab.fs_mntops = _fs_fstab.fs_type;
  80:                 _fs_fstab.fs_vfstype =
  81:                     strcmp(_fs_fstab.fs_type, FSTAB_SW) ?
  82:                     "ufs" : "swap";
  83:                 if (bp = strsep(&cp, colon)) {
  84:                     _fs_fstab.fs_freq = atoi(bp);
  85:                     if (bp = strsep(&cp, colon)) {
  86:                         _fs_fstab.fs_passno = atoi(bp);
  87:                         return(1);
  88:                     }
  89:                 }
  90:             }
  91:             goto bad;
  92:         }
  93: /* OLD_STYLE_FSTAB */
  94:         _fs_fstab.fs_spec = strtok(cp, " \t");
  95:         if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#')
  96:             continue;
  97:         _fs_fstab.fs_file = strtok((char *)NULL, " \t");
  98:         _fs_fstab.fs_vfstype = strtok((char *)NULL, " \t");
  99:         _fs_fstab.fs_mntops = strtok((char *)NULL, " \t");
 100:         if (_fs_fstab.fs_mntops == NULL)
 101:             goto bad;
 102:         _fs_fstab.fs_freq = 0;
 103:         _fs_fstab.fs_passno = 0;
 104:         if ((cp = strtok((char *)NULL, " \t")) != NULL) {
 105:             _fs_fstab.fs_freq = atoi(cp);
 106:             if ((cp = strtok((char *)NULL, " \t")) != NULL)
 107:                 _fs_fstab.fs_passno = atoi(cp);
 108:         }
 109:         strcpy(subline, _fs_fstab.fs_mntops);
 110:         for (typexx = 0, cp = strtok(subline, ","); cp;
 111:              cp = strtok((char *)NULL, ",")) {
 112:             if (strlen(cp) != 2)
 113:                 continue;
 114:             if (!strcmp(cp, FSTAB_RW)) {
 115:                 _fs_fstab.fs_type = FSTAB_RW;
 116:                 break;
 117:             }
 118:             if (!strcmp(cp, FSTAB_RQ)) {
 119:                 _fs_fstab.fs_type = FSTAB_RQ;
 120:                 break;
 121:             }
 122:             if (!strcmp(cp, FSTAB_RO)) {
 123:                 _fs_fstab.fs_type = FSTAB_RO;
 124:                 break;
 125:             }
 126:             if (!strcmp(cp, FSTAB_SW)) {
 127:                 _fs_fstab.fs_type = FSTAB_SW;
 128:                 break;
 129:             }
 130:             if (!strcmp(cp, FSTAB_XX)) {
 131:                 _fs_fstab.fs_type = FSTAB_XX;
 132:                 typexx++;
 133:                 break;
 134:             }
 135:         }
 136:         if (typexx)
 137:             continue;
 138:         if (cp != NULL)
 139:             return(1);
 140: 
 141: bad:        /* no way to distinguish between EOF and syntax error */
 142:         error(EFTYPE);
 143:     }
 144:     /* NOTREACHED */
 145: }
 146: 
 147: struct fstab *
 148: getfsent()
 149: {
 150:     if (!_fs_fp && !setfsent() || !fstabscan())
 151:         return((struct fstab *)NULL);
 152:     return(&_fs_fstab);
 153: }
 154: 
 155: struct fstab *
 156: getfsspec(name)
 157:     register char *name;
 158: {
 159:     if (setfsent())
 160:         while (fstabscan())
 161:             if (!strcmp(_fs_fstab.fs_spec, name))
 162:                 return(&_fs_fstab);
 163:     return((struct fstab *)NULL);
 164: }
 165: 
 166: struct fstab *
 167: getfsfile(name)
 168:     register char *name;
 169: {
 170:     if (setfsent())
 171:         while (fstabscan())
 172:             if (!strcmp(_fs_fstab.fs_file, name))
 173:                 return(&_fs_fstab);
 174:     return((struct fstab *)NULL);
 175: }
 176: 
 177: setfsent()
 178: {
 179:     if (_fs_fp) {
 180:         rewind(_fs_fp);
 181:         return(1);
 182:     }
 183:     if (_fs_fp = fopen(_PATH_FSTAB, "r"))
 184:         return(1);
 185:     error(errno);
 186:     return(0);
 187: }
 188: 
 189: void
 190: endfsent()
 191: {
 192:     if (_fs_fp) {
 193:         (void)fclose(_fs_fp);
 194:         _fs_fp = NULL;
 195:     }
 196: }
 197: 
 198: static void
 199: error(err)
 200:     int err;
 201: {
 202:     register int saverrno;
 203: 
 204:     saverrno = errno;
 205:     errno = err;
 206:     warn("%s", _PATH_FSTAB);
 207:     errno = saverrno;
 208: }

Defined functions

Defined variables

Defined macros