[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.20 and 1.31

version 1.20, 1999/09/16 11:44:56 version 1.31, 2012/03/13 21:13:34
Line 12 
Line 12 
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. Neither the name of the University nor the names of its contributors
  *    must display the following acknowledgement:  
  *      This product includes software developed by the University of  
  *      California, Berkeley and its contributors.  
  * 4. Neither the name of the University nor the names of its contributors  
  *    may be used to endorse or promote products derived from this software   *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.   *    without specific prior written permission.
  *   *
Line 55  __RCSID("$NetBSD$");
Line 51  __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;
Line 67  static size_t _fs_lineno = 0;
Line 63  static size_t _fs_lineno = 0;
 static const char *_fs_file = _PATH_FSTAB;  static const char *_fs_file = _PATH_FSTAB;
 static struct fstab _fs_fstab;  static struct fstab _fs_fstab;
   
 static int fstabscan __P((void));  static char *nextfld(char **, const char *);
   static int fstabscan(void);
   
 static __inline char *nextfld __P((char **, const char *));  
   
   static char *
 static __inline char *  nextfld(char **str, const char *sep)
 nextfld(str, sep)  
         char **str;  
         const char *sep;  
 {  {
         char *ret;          char *ret;
   
         _DIAGASSERT(str != NULL);          _DIAGASSERT(str != NULL);
         _DIAGASSERT(sep != NULL);          _DIAGASSERT(sep != NULL);
   
         while ((ret = strsep(str, sep)) != NULL && *ret == '\0')          while ((ret = stresep(str, sep, '\\')) != NULL && *ret == '\0')
                 continue;                  continue;
         return ret;          return ret;
 }  }
   
   
 static int  static int
 fstabscan()  fstabscan(void)
 {  {
         char *cp, *lp, *sp;          char *cp, *lp, *sp;
 #define MAXLINELENGTH   1024  #define MAXLINELENGTH   1024
Line 97  fstabscan()
Line 90  fstabscan()
         char subline[MAXLINELENGTH];          char subline[MAXLINELENGTH];
         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[] = {          static const char *fstab_type[] = {
             FSTAB_RW, FSTAB_RQ, FSTAB_RO, FSTAB_SW, FSTAB_DP, FSTAB_XX, NULL              FSTAB_RW, FSTAB_RQ, FSTAB_RO, FSTAB_SW, FSTAB_DP, FSTAB_XX, NULL
         };          };
   
           (void)memset(&_fs_fstab, 0, sizeof(_fs_fstab));
         for (;;) {          for (;;) {
                 if (!(lp = fgets(line, sizeof(line), _fs_fp)))                  if (!(lp = fgets(line, (int)sizeof(line), _fs_fp)))
                         return 0;                          return 0;
                 _fs_lineno++;                  _fs_lineno++;
 /* OLD_STYLE_FSTAB */  /* OLD_STYLE_FSTAB */
Line 117  fstabscan()
Line 111  fstabscan()
                                         continue;                                          continue;
                                 _fs_fstab.fs_mntops = _fs_fstab.fs_type;                                  _fs_fstab.fs_mntops = _fs_fstab.fs_type;
                                 _fs_fstab.fs_vfstype =                                  _fs_fstab.fs_vfstype =
                                       __UNCONST(
                                     strcmp(_fs_fstab.fs_type, FSTAB_SW) ?                                      strcmp(_fs_fstab.fs_type, FSTAB_SW) ?
                                     "ufs" : "swap";                                      "ufs" : "swap");
                                 if ((cp = nextfld(&lp, sep)) != NULL) {                                  if ((cp = nextfld(&lp, sep)) != NULL) {
                                         _fs_fstab.fs_freq = atoi(cp);                                          _fs_fstab.fs_freq = atoi(cp);
                                         if ((cp = nextfld(&lp, sep)) != NULL) {                                          if ((cp = nextfld(&lp, sep)) != NULL) {
Line 145  fstabscan()
Line 140  fstabscan()
                         if ((cp = nextfld(&lp, ws)) != NULL)                          if ((cp = nextfld(&lp, ws)) != NULL)
                                 _fs_fstab.fs_passno = atoi(cp);                                  _fs_fstab.fs_passno = atoi(cp);
                 }                  }
                 sp = strncpy(subline, _fs_fstab.fs_mntops, sizeof(subline)-1);  
                   /* subline truncated iff line truncated */
                   (void)strlcpy(subline, _fs_fstab.fs_mntops, sizeof(subline));
                   sp = subline;
   
                 while ((cp = nextfld(&sp, ",")) != NULL) {                  while ((cp = nextfld(&sp, ",")) != NULL) {
                         char **tp;                          const char **tp;
   
                         if (strlen(cp) != 2)                          if (strlen(cp) != 2)
                                 continue;                                  continue;
   
                         for (tp = fstab_type; *tp; tp++)                          for (tp = fstab_type; *tp; tp++)
                                 if (strcmp(cp, *tp) == 0) {                                  if (strcmp(cp, *tp) == 0) {
                                         _fs_fstab.fs_type = *tp;                                          _fs_fstab.fs_type = __UNCONST(*tp);
                                         break;                                          break;
                                 }                                  }
                         if (*tp)                          if (*tp)
                                 break;                                  break;
                 }                  }
                   if (_fs_fstab.fs_type == NULL)
                           goto bad;
                 if (strcmp(_fs_fstab.fs_type, FSTAB_XX) == 0)                  if (strcmp(_fs_fstab.fs_type, FSTAB_XX) == 0)
                         continue;                          continue;
                 if (cp != NULL)                  if (cp != NULL)
Line 172  bad:
Line 173  bad:
 }  }
   
 struct fstab *  struct fstab *
 getfsent()  getfsent(void)
 {  {
         if ((!_fs_fp && !setfsent()) || !fstabscan())          if ((!_fs_fp && !setfsent()) || !fstabscan())
                 return NULL;                  return NULL;
Line 180  getfsent()
Line 181  getfsent()
 }  }
   
 struct fstab *  struct fstab *
 getfsspec(name)  getfsspec(const char *name)
         const char *name;  
 {  {
   
         _DIAGASSERT(name != NULL);          _DIAGASSERT(name != NULL);
 #ifdef _DIAGNOSTIC  
         if (name == NULL)  
                 return NULL;  
 #endif  
   
         if (setfsent())          if (setfsent())
                 while (fstabscan())                  while (fstabscan())
Line 198  getfsspec(name)
Line 194  getfsspec(name)
 }  }
   
 struct fstab *  struct fstab *
 getfsfile(name)  getfsfile(const char *name)
         const char *name;  
 {  {
   
         _DIAGASSERT(name != NULL);          _DIAGASSERT(name != NULL);
 #ifdef _DIAGNOSTIC  
         if (name == NULL)  
                 return NULL;  
 #endif  
   
         if (setfsent())          if (setfsent())
                 while (fstabscan())                  while (fstabscan())
Line 216  getfsfile(name)
Line 207  getfsfile(name)
 }  }
   
 int  int
 setfsent()  setfsent(void)
 {  {
         _fs_lineno = 0;          _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, "re")) == NULL) {
                 warn("Cannot open `%s'", _PATH_FSTAB);                  warn("Cannot open `%s'", _PATH_FSTAB);
                 return 0;                  return 0;
         }          }
Line 231  setfsent()
Line 222  setfsent()
 }  }
   
 void  void
 endfsent()  endfsent(void)
 {  {
         if (_fs_fp) {          if (_fs_fp) {
                 (void)fclose(_fs_fp);                  (void)fclose(_fs_fp);

Legend:
Removed from v.1.20  
changed lines
  Added in v.1.31

CVSweb <webmaster@jp.NetBSD.org>