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