version 1.8.2.1, 1996/09/19 20:02:35 |
version 1.18, 1999/01/26 02:23:34 |
|
|
* SUCH DAMAGE. |
* SUCH DAMAGE. |
*/ |
*/ |
|
|
|
#include <sys/cdefs.h> |
#if defined(LIBC_SCCS) && !defined(lint) |
#if defined(LIBC_SCCS) && !defined(lint) |
#if 0 |
#if 0 |
static char sccsid[] = "@(#)fstab.c 8.1 (Berkeley) 6/4/93"; |
static char sccsid[] = "@(#)fstab.c 8.1 (Berkeley) 6/4/93"; |
#else |
#else |
static char rcsid[] = "$NetBSD$"; |
__RCSID("$NetBSD$"); |
#endif |
#endif |
#endif /* LIBC_SCCS and not lint */ |
#endif /* LIBC_SCCS and not lint */ |
|
|
#include "namespace.h" |
#include "namespace.h" |
#include <sys/types.h> |
#include <sys/types.h> |
#include <sys/uio.h> |
#include <err.h> |
#include <errno.h> |
#include <errno.h> |
#include <fstab.h> |
#include <fstab.h> |
#include <stdio.h> |
#include <stdio.h> |
Line 60 __weak_alias(setfsent,_setfsent); |
|
Line 61 __weak_alias(setfsent,_setfsent); |
|
#endif |
#endif |
|
|
static FILE *_fs_fp; |
static FILE *_fs_fp; |
|
static size_t _fs_lineno = 0; |
|
static const char *_fs_file = _PATH_FSTAB; |
static struct fstab _fs_fstab; |
static struct fstab _fs_fstab; |
|
|
static void error __P((int)); |
|
static int fstabscan __P((void)); |
static int fstabscan __P((void)); |
|
|
|
static __inline char *nextfld __P((char **, const char *)); |
|
|
|
|
|
static __inline char * |
|
nextfld(str, sep) |
|
char **str; |
|
const char *sep; |
|
{ |
|
char *ret; |
|
while ((ret = strsep(str, sep)) != NULL && *ret == '\0') |
|
continue; |
|
return ret; |
|
} |
|
|
|
|
static int |
static int |
fstabscan() |
fstabscan() |
{ |
{ |
register char *cp; |
char *cp, *lp, *sp; |
#define MAXLINELENGTH 1024 |
#define MAXLINELENGTH 1024 |
static char line[MAXLINELENGTH]; |
static char line[MAXLINELENGTH]; |
char subline[MAXLINELENGTH]; |
char subline[MAXLINELENGTH]; |
int typexx; |
static const char sep[] = ":\n"; |
|
static const char ws[] = " \t\n"; |
|
static char *fstab_type[] = { |
|
FSTAB_RW, FSTAB_RQ, FSTAB_RO, FSTAB_SW, FSTAB_XX, NULL |
|
}; |
|
|
for (;;) { |
for (;;) { |
if (!(cp = fgets(line, sizeof(line), _fs_fp))) |
if (!(lp = fgets(line, sizeof(line), _fs_fp))) |
return(0); |
return 0; |
|
_fs_lineno++; |
/* OLD_STYLE_FSTAB */ |
/* OLD_STYLE_FSTAB */ |
if (!strpbrk(cp, " \t")) { |
if (!strpbrk(lp, " \t")) { |
_fs_fstab.fs_spec = strtok(cp, ":\n"); |
_fs_fstab.fs_spec = nextfld(&lp, sep); |
if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#') |
if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#') |
continue; |
continue; |
_fs_fstab.fs_file = strtok((char *)NULL, ":\n"); |
_fs_fstab.fs_file = nextfld(&lp, sep); |
_fs_fstab.fs_type = strtok((char *)NULL, ":\n"); |
_fs_fstab.fs_type = nextfld(&lp, sep); |
if (_fs_fstab.fs_type) { |
if (_fs_fstab.fs_type) { |
if (!strcmp(_fs_fstab.fs_type, FSTAB_XX)) |
if (!strcmp(_fs_fstab.fs_type, FSTAB_XX)) |
continue; |
continue; |
|
|
_fs_fstab.fs_vfstype = |
_fs_fstab.fs_vfstype = |
strcmp(_fs_fstab.fs_type, FSTAB_SW) ? |
strcmp(_fs_fstab.fs_type, FSTAB_SW) ? |
"ufs" : "swap"; |
"ufs" : "swap"; |
if (cp = strtok((char *)NULL, ":\n")) { |
if ((cp = nextfld(&lp, sep)) != NULL) { |
_fs_fstab.fs_freq = atoi(cp); |
_fs_fstab.fs_freq = atoi(cp); |
if (cp = strtok((char *)NULL, ":\n")) { |
if ((cp = nextfld(&lp, sep)) != NULL) { |
_fs_fstab.fs_passno = atoi(cp); |
_fs_fstab.fs_passno = atoi(cp); |
return(1); |
return 1; |
} |
} |
} |
} |
} |
} |
goto bad; |
goto bad; |
} |
} |
/* OLD_STYLE_FSTAB */ |
/* OLD_STYLE_FSTAB */ |
_fs_fstab.fs_spec = strtok(cp, " \t\n"); |
_fs_fstab.fs_spec = nextfld(&lp, ws); |
if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#') |
if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#') |
continue; |
continue; |
_fs_fstab.fs_file = strtok((char *)NULL, " \t\n"); |
_fs_fstab.fs_file = nextfld(&lp, ws); |
_fs_fstab.fs_vfstype = strtok((char *)NULL, " \t\n"); |
_fs_fstab.fs_vfstype = nextfld(&lp, ws); |
_fs_fstab.fs_mntops = strtok((char *)NULL, " \t\n"); |
_fs_fstab.fs_mntops = nextfld(&lp, ws); |
if (_fs_fstab.fs_mntops == NULL) |
if (_fs_fstab.fs_mntops == NULL) |
goto bad; |
goto bad; |
_fs_fstab.fs_freq = 0; |
_fs_fstab.fs_freq = 0; |
_fs_fstab.fs_passno = 0; |
_fs_fstab.fs_passno = 0; |
if ((cp = strtok((char *)NULL, " \t\n")) != NULL) { |
if ((cp = nextfld(&lp, ws)) != NULL) { |
_fs_fstab.fs_freq = atoi(cp); |
_fs_fstab.fs_freq = atoi(cp); |
if ((cp = strtok((char *)NULL, " \t\n")) != NULL) |
if ((cp = nextfld(&lp, ws)) != NULL) |
_fs_fstab.fs_passno = atoi(cp); |
_fs_fstab.fs_passno = atoi(cp); |
} |
} |
strcpy(subline, _fs_fstab.fs_mntops); |
sp = strncpy(subline, _fs_fstab.fs_mntops, sizeof(subline)-1); |
for (typexx = 0, cp = strtok(subline, ","); cp; |
while ((cp = nextfld(&sp, ",")) != NULL) { |
cp = strtok((char *)NULL, ",")) { |
char **tp; |
|
|
if (strlen(cp) != 2) |
if (strlen(cp) != 2) |
continue; |
continue; |
if (!strcmp(cp, FSTAB_RW)) { |
|
_fs_fstab.fs_type = FSTAB_RW; |
for (tp = fstab_type; *tp; tp++) |
break; |
if (strcmp(cp, *tp) == 0) { |
} |
_fs_fstab.fs_type = *tp; |
if (!strcmp(cp, FSTAB_RQ)) { |
break; |
_fs_fstab.fs_type = FSTAB_RQ; |
} |
break; |
if (*tp) |
} |
|
if (!strcmp(cp, FSTAB_RO)) { |
|
_fs_fstab.fs_type = FSTAB_RO; |
|
break; |
|
} |
|
if (!strcmp(cp, FSTAB_SW)) { |
|
_fs_fstab.fs_type = FSTAB_SW; |
|
break; |
|
} |
|
if (!strcmp(cp, FSTAB_XX)) { |
|
_fs_fstab.fs_type = FSTAB_XX; |
|
typexx++; |
|
break; |
break; |
} |
|
} |
} |
if (typexx) |
if (strcmp(_fs_fstab.fs_type, FSTAB_XX) == 0) |
continue; |
continue; |
if (cp != NULL) |
if (cp != NULL) |
return(1); |
return 1; |
|
|
bad: /* no way to distinguish between EOF and syntax error */ |
bad: |
error(EFTYPE); |
warnx("%s, %lu: Missing fields", _fs_file, (u_long)_fs_lineno); |
} |
} |
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
Line 158 bad: /* no way to distinguish between E |
|
Line 168 bad: /* no way to distinguish between E |
|
struct fstab * |
struct fstab * |
getfsent() |
getfsent() |
{ |
{ |
if (!_fs_fp && !setfsent() || !fstabscan()) |
if ((!_fs_fp && !setfsent()) || !fstabscan()) |
return((struct fstab *)NULL); |
return NULL; |
return(&_fs_fstab); |
return &_fs_fstab; |
} |
} |
|
|
struct fstab * |
struct fstab * |
getfsspec(name) |
getfsspec(name) |
register const char *name; |
const char *name; |
{ |
{ |
if (setfsent()) |
if (setfsent()) |
while (fstabscan()) |
while (fstabscan()) |
if (!strcmp(_fs_fstab.fs_spec, name)) |
if (!strcmp(_fs_fstab.fs_spec, name)) |
return(&_fs_fstab); |
return &_fs_fstab; |
return((struct fstab *)NULL); |
return NULL; |
} |
} |
|
|
struct fstab * |
struct fstab * |
getfsfile(name) |
getfsfile(name) |
register const char *name; |
const char *name; |
{ |
{ |
if (setfsent()) |
if (setfsent()) |
while (fstabscan()) |
while (fstabscan()) |
if (!strcmp(_fs_fstab.fs_file, name)) |
if (!strcmp(_fs_fstab.fs_file, name)) |
return(&_fs_fstab); |
return &_fs_fstab; |
return((struct fstab *)NULL); |
return NULL; |
} |
} |
|
|
int |
int |
setfsent() |
setfsent() |
{ |
{ |
|
_fs_lineno = 0; |
if (_fs_fp) { |
if (_fs_fp) { |
rewind(_fs_fp); |
rewind(_fs_fp); |
return(1); |
return 1; |
|
} |
|
if ((_fs_fp = fopen(_PATH_FSTAB, "r")) == NULL) { |
|
warn("Cannot open `%s'", _PATH_FSTAB); |
|
return 0; |
} |
} |
if (_fs_fp = fopen(_PATH_FSTAB, "r")) |
return 1; |
return(1); |
|
error(errno); |
|
return(0); |
|
} |
} |
|
|
void |
void |
|
|
_fs_fp = NULL; |
_fs_fp = NULL; |
} |
} |
} |
} |
|
|
static void |
|
error(err) |
|
int err; |
|
{ |
|
struct iovec iov[5]; |
|
|
|
iov[0].iov_base = "fstab: "; |
|
iov[0].iov_len = 7; |
|
iov[1].iov_base = _PATH_FSTAB; |
|
iov[1].iov_len = sizeof(_PATH_FSTAB) - 1; |
|
iov[2].iov_base = ": "; |
|
iov[2].iov_len = 2; |
|
iov[3].iov_base = strerror(err); |
|
iov[3].iov_len = strlen(iov[3].iov_base); |
|
iov[4].iov_base = "\n"; |
|
iov[4].iov_len = 1; |
|
(void)writev(STDERR_FILENO, iov, 5); |
|
} |
|