make error messages a little better, use constants in unistd.h

[unix-history] / usr / src / lib / libc / gen / fstab.c

/*
* Copyright (c) 1980, 1988 Regents of the University of California.
* All rights reserved.
*
* %sccs.include.redist.c%
*/

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)fstab.c     5.13 (Berkeley) %G%";
#endif /* LIBC_SCCS and not lint */

#include <sys/errno.h>
#include <fstab.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

static FILE *_fs_fp;
static struct fstab _fs_fstab;

static
fstabscan()
{
       register char *cp;
#define MAXLINELENGTH   1024
       static char line[MAXLINELENGTH];
       char subline[MAXLINELENGTH];
       char *fgets(), *strtok();
       int typexx;

       for (;;) {
               if (!(cp = fgets(line, sizeof(line), _fs_fp)))
                       return(0);
/* OLD_STYLE_FSTAB */
               if (!strpbrk(cp, " \t")) {
                       _fs_fstab.fs_spec = strtok(cp, ":\n");
                       _fs_fstab.fs_file = strtok((char *)NULL, ":\n");
                       _fs_fstab.fs_type = strtok((char *)NULL, ":\n");
                       if (_fs_fstab.fs_type) {
                               if (!strcmp(_fs_fstab.fs_type, FSTAB_XX))
                                       continue;
                               _fs_fstab.fs_mntops = _fs_fstab.fs_type;
                               _fs_fstab.fs_vfstype =
                                   strcmp(_fs_fstab.fs_type, FSTAB_SW) ?
                                   "ufs" : "swap";
                               if (cp = strtok((char *)NULL, ":\n")) {
                                       _fs_fstab.fs_freq = atoi(cp);
                                       if (cp = strtok((char *)NULL, ":\n")) {
                                               _fs_fstab.fs_passno = atoi(cp);
                                               return(1);
                                       }
                               }
                       }
                       goto bad;
               }
/* OLD_STYLE_FSTAB */
               _fs_fstab.fs_spec = strtok(cp, " \t\n");
               if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#')
                       continue;
               _fs_fstab.fs_file = strtok((char *)NULL, " \t\n");
               _fs_fstab.fs_vfstype = strtok((char *)NULL, " \t\n");
               _fs_fstab.fs_mntops = strtok((char *)NULL, " \t\n");
               if (_fs_fstab.fs_mntops == NULL)
                       goto bad;
               _fs_fstab.fs_freq = 0;
               _fs_fstab.fs_passno = 0;
               if ((cp = strtok((char *)NULL, " \t\n")) != NULL) {
                       _fs_fstab.fs_freq = atoi(cp);
                       if ((cp = strtok((char *)NULL, " \t\n")) != NULL)
                               _fs_fstab.fs_passno = atoi(cp);
               }
               strcpy(subline, _fs_fstab.fs_mntops);
               for (typexx = 0, cp = strtok(subline, ","); cp;
                    cp = strtok((char *)NULL, ",")) {
                       if (strlen(cp) != 2)
                               continue;
                       if (!strcmp(cp, FSTAB_RW)) {
                               _fs_fstab.fs_type = FSTAB_RW;
                               break;
                       }
                       if (!strcmp(cp, FSTAB_RQ)) {
                               _fs_fstab.fs_type = FSTAB_RQ;
                               break;
                       }
                       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;
                       }
               }
               if (typexx)
                       continue;
               if (cp != NULL)
                       return(1);

bad:            /* no way to distinguish between EOF and syntax error */
               write(EBADFORMAT);
       }
       /* NOTREACHED */
}

struct fstab *
getfsent()
{
       if (!_fs_fp && !setfsent() || !fstabscan())
               return((struct fstab *)NULL);
       return(&_fs_fstab);
}

struct fstab *
getfsspec(name)
       register char *name;
{
       if (setfsent())
               while (fstabscan())
                       if (!strcmp(_fs_fstab.fs_spec, name))
                               return(&_fs_fstab);
       return((struct fstab *)NULL);
}

struct fstab *
getfsfile(name)
       register char *name;
{
       if (setfsent())
               while (fstabscan())
                       if (!strcmp(_fs_fstab.fs_file, name))
                               return(&_fs_fstab);
       return((struct fstab *)NULL);
}

setfsent()
{
       if (_fs_fp) {
               rewind(_fs_fp);
               return(1);
       }
       if (_fs_fp = fopen(_PATH_FSTAB, "r"))
               return(1);
       error(errno);
       return(0);
}

void
endfsent()
{
       if (_fs_fp) {
               (void)fclose(_fs_fp);
               _fs_fp = NULL;
       }
}

static
error(err)
       int err;
{
       char *p;

       (void)write(STDERR_FILENO, "fstab: ", 7);
       (void)write(STDERR_FILENO, _PATH_FSTAB, sizeof(_PATH_FSTAB) - 1);
       p = strerror(err);
       (void)write(STDERR_FILENO, p, strlen(p));
       (void)write(STDERR_FILENO, "\n", 1);
}