gen/fstab.c

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