[BACK]Return to fstab.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / gen

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libc/gen/fstab.c between version 1.2 and 1.14

version 1.2, 1993/07/30 08:22:14 version 1.14, 1998/07/26 13:51:27
Line 1 
Line 1 
   /*      $NetBSD$        */
   
 /*  /*
  * Copyright (c) 1980, 1988 Regents of the University of California.   * Copyright (c) 1980, 1988, 1993
  * All rights reserved.   *      The Regents of the University of California.  All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions   * modification, are permitted provided that the following conditions
Line 31 
Line 33 
  * SUCH DAMAGE.   * SUCH DAMAGE.
  */   */
   
   #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)  #if defined(LIBC_SCCS) && !defined(lint)
 /*static char sccsid[] = "from: @(#)fstab.c     5.15 (Berkeley) 2/23/91";*/  #if 0
 static char rcsid[] = "$Id$";  static char sccsid[] = "@(#)fstab.c     8.1 (Berkeley) 6/4/93";
   #else
   __RCSID("$NetBSD$");
   #endif
 #endif /* LIBC_SCCS and not lint */  #endif /* LIBC_SCCS and not lint */
   
 #include <sys/errno.h>  #include <sys/types.h>
   #include <sys/uio.h>
   #include <err.h>
   #include <errno.h>
 #include <fstab.h>  #include <fstab.h>
 #include <unistd.h>  
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <unistd.h>
   
   #ifdef __weak_alias
   __weak_alias(endfsent,_endfsent);
   __weak_alias(getfsent,_getfsent);
   __weak_alias(getfsfile,_getfsfile);
   __weak_alias(getfsspec,_getfsspec);
   __weak_alias(setfsent,_setfsent);
   #endif
   
 static FILE *_fs_fp;  static FILE *_fs_fp;
 static struct fstab _fs_fstab;  static struct fstab _fs_fstab;
 static error();  
   
 static  static void error __P((int));
   static int fstabscan __P((void));
   
   static int
 fstabscan()  fstabscan()
 {  {
         register char *cp;          char *cp;
 #define MAXLINELENGTH   1024  #define MAXLINELENGTH   1024
         static char line[MAXLINELENGTH];          static char line[MAXLINELENGTH];
         char subline[MAXLINELENGTH];          char subline[MAXLINELENGTH];
         int typexx;          int typexx;
           static const char sep[] = ":\n";
           static const char ws[] = " \t\n";
   
         for (;;) {          for (;;) {
                 if (!(cp = fgets(line, sizeof(line), _fs_fp)))                  if (!(cp = fgets(line, sizeof(line), _fs_fp)))
                         return(0);                          return(0);
 /* OLD_STYLE_FSTAB */  /* OLD_STYLE_FSTAB */
                 if (!strpbrk(cp, " \t")) {                  if (!strpbrk(cp, " \t")) {
                         _fs_fstab.fs_spec = strtok(cp, ":\n");                          _fs_fstab.fs_spec = strtok(cp, sep);
                         _fs_fstab.fs_file = strtok((char *)NULL, ":\n");                          if (!_fs_fstab.fs_spec || *_fs_fstab.fs_spec == '#')
                         _fs_fstab.fs_type = strtok((char *)NULL, ":\n");                                  continue;
                           _fs_fstab.fs_file = strtok(NULL, sep);
                           _fs_fstab.fs_type = strtok(NULL, 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;
Line 71  fstabscan()
Line 94  fstabscan()
                                 _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 = strtok(NULL, sep)) != NULL) {
                                         _fs_fstab.fs_freq = atoi(cp);                                          _fs_fstab.fs_freq = atoi(cp);
                                         if (cp = strtok((char *)NULL, ":\n")) {                                          if ((cp = strtok(NULL, sep)) != NULL) {
                                                 _fs_fstab.fs_passno = atoi(cp);                                                  _fs_fstab.fs_passno = atoi(cp);
                                                 return(1);                                                  return(1);
                                         }                                          }
Line 82  fstabscan()
Line 105  fstabscan()
                         goto bad;                          goto bad;
                 }                  }
 /* OLD_STYLE_FSTAB */  /* OLD_STYLE_FSTAB */
                 _fs_fstab.fs_spec = strtok(cp, " \t\n");                  _fs_fstab.fs_spec = strtok(cp, 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 = strtok(NULL, ws);
                 _fs_fstab.fs_vfstype = strtok((char *)NULL, " \t\n");                  _fs_fstab.fs_vfstype = strtok(NULL, ws);
                 _fs_fstab.fs_mntops = strtok((char *)NULL, " \t\n");                  _fs_fstab.fs_mntops = strtok(NULL, 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 = strtok(NULL, ws)) != NULL) {
                         _fs_fstab.fs_freq = atoi(cp);                          _fs_fstab.fs_freq = atoi(cp);
                         if ((cp = strtok((char *)NULL, " \t\n")) != NULL)                          if ((cp = strtok(NULL, ws)) != NULL)
                                 _fs_fstab.fs_passno = atoi(cp);                                  _fs_fstab.fs_passno = atoi(cp);
                 }                  }
                 strcpy(subline, _fs_fstab.fs_mntops);                  (void)strncpy(subline, _fs_fstab.fs_mntops, sizeof(subline)-1);
                 for (typexx = 0, cp = strtok(subline, ","); cp;                  for (typexx = 0, cp = strtok(subline, ","); cp;
                      cp = strtok((char *)NULL, ",")) {                       cp = strtok((char *)NULL, ",")) {
                         if (strlen(cp) != 2)                          if (strlen(cp) != 2)
Line 138  bad:  /* no way to distinguish between E
Line 161  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((struct fstab *)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())
Line 156  getfsspec(name)
Line 179  getfsspec(name)
   
 struct fstab *  struct fstab *
 getfsfile(name)  getfsfile(name)
         register const char *name;          const char *name;
 {  {
         if (setfsent())          if (setfsent())
                 while (fstabscan())                  while (fstabscan())
Line 165  getfsfile(name)
Line 188  getfsfile(name)
         return((struct fstab *)NULL);          return((struct fstab *)NULL);
 }  }
   
   int
 setfsent()  setfsent()
 {  {
         if (_fs_fp) {          if (_fs_fp) {
                 rewind(_fs_fp);                  rewind(_fs_fp);
                 return(1);                  return(1);
         }          }
         if (_fs_fp = fopen(_PATH_FSTAB, "r"))          if ((_fs_fp = fopen(_PATH_FSTAB, "r")) != NULL)
                 return(1);                  return(1);
         error(errno);          error(errno);
         return(0);          return(0);
Line 186  endfsent()
Line 210  endfsent()
         }          }
 }  }
   
 static  static void
 error(err)  error(err)
         int err;          int err;
 {  {
         char *p;  
   
         (void)write(STDERR_FILENO, "fstab: ", 7);          errno = err;
         (void)write(STDERR_FILENO, _PATH_FSTAB, sizeof(_PATH_FSTAB) - 1);          warn(_PATH_FSTAB);
         p = strerror(err);  
         (void)write(STDERR_FILENO, p, strlen(p));  
         (void)write(STDERR_FILENO, "\n", 1);  
 }  }
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.14
CVSweb <webmaster@jp.NetBSD.org>