[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.15 and 1.22.4.1

version 1.15, 1998/10/11 19:42:29 version 1.22.4.1, 2001/10/27 19:19:14
Line 44  __RCSID("$NetBSD$");
Line 44  __RCSID("$NetBSD$");
   
 #include "namespace.h"  #include "namespace.h"
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/uio.h>  
   #include <assert.h>
 #include <err.h>  #include <err.h>
 #include <errno.h>  #include <errno.h>
 #include <fstab.h>  #include <fstab.h>
Line 54  __RCSID("$NetBSD$");
Line 55  __RCSID("$NetBSD$");
 #include <unistd.h>  #include <unistd.h>
   
 #ifdef __weak_alias  #ifdef __weak_alias
 __weak_alias(endfsent,_endfsent);  __weak_alias(endfsent,_endfsent)
 __weak_alias(getfsent,_getfsent);  __weak_alias(getfsent,_getfsent)
 __weak_alias(getfsfile,_getfsfile);  __weak_alias(getfsfile,_getfsfile)
 __weak_alias(getfsspec,_getfsspec);  __weak_alias(getfsspec,_getfsspec)
 __weak_alias(setfsent,_setfsent);  __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;
   
           _DIAGASSERT(str != NULL);
           _DIAGASSERT(sep != NULL);
   
           while ((ret = strsep(str, sep)) != NULL && *ret == '\0')
                   continue;
           return ret;
   }
   
   
 static int  static int
 fstabscan()  fstabscan()
 {  {
         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 sep[] = ":\n";
         static const char ws[] = " \t\n";          static const char ws[] = " \t\n";
           static char *fstab_type[] = {
               FSTAB_RW, FSTAB_RQ, FSTAB_RO, FSTAB_SW, FSTAB_DP, FSTAB_XX, NULL
           };
   
           (void)memset(&_fs_fstab, 0, sizeof(_fs_fstab));
         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, sep);                          _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(NULL, sep);                          _fs_fstab.fs_file = nextfld(&lp, sep);
                         _fs_fstab.fs_type = strtok(NULL, sep);                          _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;
Line 95  fstabscan()
Line 120  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(NULL, sep)) != NULL) {                                  if ((cp = nextfld(&lp, sep)) != NULL) {
                                         _fs_fstab.fs_freq = atoi(cp);                                          _fs_fstab.fs_freq = atoi(cp);
                                         if ((cp = strtok(NULL, sep)) != NULL) {                                          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, ws);                  _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(NULL, ws);                  _fs_fstab.fs_file = nextfld(&lp, ws);
                 _fs_fstab.fs_vfstype = strtok(NULL, ws);                  _fs_fstab.fs_vfstype = nextfld(&lp, ws);
                 _fs_fstab.fs_mntops = strtok(NULL, ws);                  _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(NULL, ws)) != NULL) {                  if ((cp = nextfld(&lp, ws)) != NULL) {
                         _fs_fstab.fs_freq = atoi(cp);                          _fs_fstab.fs_freq = atoi(cp);
                         if ((cp = strtok(NULL, ws)) != NULL)                          if ((cp = nextfld(&lp, ws)) != NULL)
                                 _fs_fstab.fs_passno = atoi(cp);                                  _fs_fstab.fs_passno = atoi(cp);
                 }                  }
                 (void)strncpy(subline, _fs_fstab.fs_mntops, sizeof(subline)-1);                  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 (_fs_fstab.fs_type == NULL)
                           goto bad;
                   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 163  struct fstab *
Line 178  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)
         const char *name;          const char *name;
 {  {
   
           _DIAGASSERT(name != NULL);
   
         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)
         const char *name;          const char *name;
 {  {
   
           _DIAGASSERT(name != NULL);
   
         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)          if ((_fs_fp = fopen(_PATH_FSTAB, "r")) == NULL) {
                 return(1);                  warn("Cannot open `%s'", _PATH_FSTAB);
         error(errno);                  return 0;
         return(0);          }
           return 1;
 }  }
   
 void  void
Line 210  endfsent()
Line 233  endfsent()
                 _fs_fp = NULL;                  _fs_fp = NULL;
         }          }
 }  }
   
 static void  
 error(err)  
         int err;  
 {  
   
         errno = err;  
         warn(_PATH_FSTAB);  
 }  

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.22.4.1

CVSweb <webmaster@jp.NetBSD.org>