[BACK]Return to glob.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/glob.c between version 1.4 and 1.14

version 1.4, 1993/11/06 01:10:18 version 1.14, 2005/11/29 03:11:59
Line 1 
Line 1 
   /*      $NetBSD$        */
   
 /*  /*
  * Copyright (c) 1989, 1993   * Copyright (c) 1989, 1993
  *      The Regents of the University of California.  All rights reserved.   *      The Regents of the University of California.  All rights reserved.
Line 13 
Line 15 
  * 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 34 
Line 32 
  * SUCH DAMAGE.   * SUCH DAMAGE.
  */   */
   
   #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)  #if defined(LIBC_SCCS) && !defined(lint)
 /* from: static char sccsid[] = "@(#)glob.c     8.3 (Berkeley) 10/13/93"; */  #if 0
 static char *rcsid = "$Id$";  static char sccsid[] = "@(#)glob.c      8.3 (Berkeley) 10/13/93";
   #else
   __RCSID("$NetBSD$");
   #endif
 #endif /* LIBC_SCCS and not lint */  #endif /* LIBC_SCCS and not lint */
   
 /*  /*
Line 46  static char *rcsid = "$Id$";
Line 48  static char *rcsid = "$Id$";
  *   *
  * Optional extra services, controlled by flags not defined by POSIX:   * Optional extra services, controlled by flags not defined by POSIX:
  *   *
  * GLOB_QUOTE:  
  *      Escaping convention: \ inhibits any special meaning the following  
  *      character might have (except \ at end of string is retained).  
  * GLOB_MAGCHAR:   * GLOB_MAGCHAR:
  *      Set in gl_flags if pattern contained a globbing character.   *      Set in gl_flags if pattern contained a globbing character.
  * GLOB_NOMAGIC:   * GLOB_NOMAGIC:
Line 64  static char *rcsid = "$Id$";
Line 63  static char *rcsid = "$Id$";
  *      Number of matches in the current invocation of glob.   *      Number of matches in the current invocation of glob.
  */   */
   
   #include "namespace.h"
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/stat.h>  #include <sys/stat.h>
   
   #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <dirent.h>  #include <dirent.h>
 #include <errno.h>  #include <errno.h>
Line 77  static char *rcsid = "$Id$";
Line 78  static char *rcsid = "$Id$";
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   #ifdef HAVE_NBTOOL_CONFIG_H
   #define NO_GETPW_R
   #endif
   
   /*
    * XXX: For NetBSD 1.4.x compatibility. (kill me l8r)
    */
   #ifndef _DIAGASSERT
   #define _DIAGASSERT(a)
   #endif
   
 #define DOLLAR          '$'  #define DOLLAR          '$'
 #define DOT             '.'  #define DOT             '.'
 #define EOS             '\0'  #define EOS             '\0'
Line 128  typedef char Char;
Line 140  typedef char Char;
   
   
 static int       compare __P((const void *, const void *));  static int       compare __P((const void *, const void *));
 static void      g_Ctoc __P((const Char *, char *));  static int       g_Ctoc __P((const Char *, char *, size_t));
 static int       g_lstat __P((Char *, struct stat *, glob_t *));  static int       g_lstat __P((Char *, __gl_stat_t  *, glob_t *));
 static DIR      *g_opendir __P((Char *, glob_t *));  static DIR      *g_opendir __P((Char *, glob_t *));
 static Char     *g_strchr __P((Char *, int));  static Char     *g_strchr __P((const Char *, int));
 #ifdef notdef  static int       g_stat __P((Char *, __gl_stat_t *, glob_t *));
 static Char     *g_strcat __P((Char *, const Char *));  
 #endif  
 static int       g_stat __P((Char *, struct stat *, glob_t *));  
 static int       glob0 __P((const Char *, glob_t *));  static int       glob0 __P((const Char *, glob_t *));
 static int       glob1 __P((Char *, glob_t *));  static int       glob1 __P((Char *, glob_t *, size_t *));
 static int       glob2 __P((Char *, Char *, Char *, glob_t *));  static int       glob2 __P((Char *, Char *, Char *, Char *, glob_t *,
 static int       glob3 __P((Char *, Char *, Char *, Char *, glob_t *));      size_t *));
 static int       globextend __P((const Char *, glob_t *));  static int       glob3 __P((Char *, Char *, Char *, Char *, Char *, glob_t *,
 static const Char *      globtilde __P((const Char *, Char *, glob_t *));      size_t *));
   static int       globextend __P((const Char *, glob_t *, size_t *));
   static const Char *globtilde __P((const Char *, Char *, size_t, glob_t *));
 static int       globexp1 __P((const Char *, glob_t *));  static int       globexp1 __P((const Char *, glob_t *));
 static int       globexp2 __P((const Char *, const Char *, glob_t *, int *));  static int       globexp2 __P((const Char *, const Char *, glob_t *, int *));
 static int       match __P((Char *, Char *, Char *));  static int       match __P((Char *, Char *, Char *));
Line 159  glob(pattern, flags, errfunc, pglob)
Line 170  glob(pattern, flags, errfunc, pglob)
         int c;          int c;
         Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];          Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];
   
         patnext = (u_char *) pattern;          _DIAGASSERT(pattern != NULL);
   
           patnext = (const u_char *) pattern;
         if (!(flags & GLOB_APPEND)) {          if (!(flags & GLOB_APPEND)) {
                 pglob->gl_pathc = 0;                  pglob->gl_pathc = 0;
                 pglob->gl_pathv = NULL;                  pglob->gl_pathv = NULL;
Line 172  glob(pattern, flags, errfunc, pglob)
Line 185  glob(pattern, flags, errfunc, pglob)
   
         bufnext = patbuf;          bufnext = patbuf;
         bufend = bufnext + MAXPATHLEN;          bufend = bufnext + MAXPATHLEN;
         if (flags & GLOB_QUOTE) {          if (flags & GLOB_NOESCAPE) {
                   while (bufnext < bufend && (c = *patnext++) != EOS)
                           *bufnext++ = c;
           } else {
                 /* Protect the quoted characters. */                  /* Protect the quoted characters. */
                 while (bufnext < bufend && (c = *patnext++) != EOS)                  while (bufnext < bufend && (c = *patnext++) != EOS)
                         if (c == QUOTE) {                          if (c == QUOTE) {
Line 185  glob(pattern, flags, errfunc, pglob)
Line 201  glob(pattern, flags, errfunc, pglob)
                         else                          else
                                 *bufnext++ = c;                                  *bufnext++ = c;
         }          }
         else  
             while (bufnext < bufend && (c = *patnext++) != EOS)  
                     *bufnext++ = c;  
         *bufnext = EOS;          *bufnext = EOS;
   
         if (flags & GLOB_BRACE)          if (flags & GLOB_BRACE)
Line 201  glob(pattern, flags, errfunc, pglob)
Line 214  glob(pattern, flags, errfunc, pglob)
  * invoke the standard globbing routine to glob the rest of the magic   * invoke the standard globbing routine to glob the rest of the magic
  * characters   * characters
  */   */
 static int globexp1(pattern, pglob)  static int
   globexp1(pattern, pglob)
         const Char *pattern;          const Char *pattern;
         glob_t *pglob;          glob_t *pglob;
 {  {
         const Char* ptr = pattern;          const Char* ptr = pattern;
         int rv;          int rv;
   
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(pglob != NULL);
   
         /* Protect a single {}, for find(1), like csh */          /* Protect a single {}, for find(1), like csh */
         if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)          if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
                 return glob0(pattern, pglob);                  return glob0(pattern, pglob);
   
         while ((ptr = (const Char *) g_strchr((Char *) ptr, LBRACE)) != NULL)          while ((ptr = (const Char *) g_strchr(ptr, LBRACE)) != NULL)
                 if (!globexp2(ptr, pattern, pglob, &rv))                  if (!globexp2(ptr, pattern, pglob, &rv))
                         return rv;                          return rv;
   
Line 225  static int globexp1(pattern, pglob)
Line 242  static int globexp1(pattern, pglob)
  * If it succeeds then it invokes globexp1 with the new pattern.   * If it succeeds then it invokes globexp1 with the new pattern.
  * If it fails then it tries to glob the rest of the pattern and returns.   * If it fails then it tries to glob the rest of the pattern and returns.
  */   */
 static int globexp2(ptr, pattern, pglob, rv)  static int
   globexp2(ptr, pattern, pglob, rv)
         const Char *ptr, *pattern;          const Char *ptr, *pattern;
         glob_t *pglob;          glob_t *pglob;
         int *rv;          int *rv;
Line 235  static int globexp2(ptr, pattern, pglob,
Line 253  static int globexp2(ptr, pattern, pglob,
         const Char *pe, *pm, *pl;          const Char *pe, *pm, *pl;
         Char    patbuf[MAXPATHLEN + 1];          Char    patbuf[MAXPATHLEN + 1];
   
           _DIAGASSERT(ptr != NULL);
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(pglob != NULL);
           _DIAGASSERT(rv != NULL);
   
         /* copy part up to the brace */          /* copy part up to the brace */
         for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)          for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
                 continue;                  continue;
Line 264  static int globexp2(ptr, pattern, pglob,
Line 287  static int globexp2(ptr, pattern, pglob,
   
         /* Non matching braces; just glob the pattern */          /* Non matching braces; just glob the pattern */
         if (i != 0 || *pe == EOS) {          if (i != 0 || *pe == EOS) {
                 *rv = glob0(patbuf, pglob);                  /*
                    * we use `pattern', not `patbuf' here so that that
                    * unbalanced braces are passed to the match
                    */
                   *rv = glob0(pattern, pglob);
                 return 0;                  return 0;
         }          }
   
         for (i = 0, pl = pm = ptr; pm <= pe; pm++)          for (i = 0, pl = pm = ptr; pm <= pe; pm++) {
                 switch (*pm) {                  switch (*pm) {
                 case LBRACKET:                  case LBRACKET:
                         /* Ignore everything between [] */                          /* Ignore everything between [] */
Line 289  static int globexp2(ptr, pattern, pglob,
Line 316  static int globexp2(ptr, pattern, pglob,
   
                 case RBRACE:                  case RBRACE:
                         if (i) {                          if (i) {
                             i--;                                  i--;
                             break;                                  break;
                         }                          }
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case COMMA:                  case COMMA:
Line 321  static int globexp2(ptr, pattern, pglob,
Line 348  static int globexp2(ptr, pattern, pglob,
                 default:                  default:
                         break;                          break;
                 }                  }
           }
         *rv = 0;          *rv = 0;
         return 0;          return 0;
 }  }
Line 331  static int globexp2(ptr, pattern, pglob,
Line 359  static int globexp2(ptr, pattern, pglob,
  * expand tilde from the passwd file.   * expand tilde from the passwd file.
  */   */
 static const Char *  static const Char *
 globtilde(pattern, patbuf, pglob)  globtilde(pattern, patbuf, patsize, pglob)
         const Char *pattern;          const Char *pattern;
         Char *patbuf;          Char *patbuf;
           size_t patsize;
         glob_t *pglob;          glob_t *pglob;
 {  {
         struct passwd *pwd;          struct passwd *pwd;
         char *h;          const char *h;
         const Char *p;          const Char *p;
         Char *b;          Char *b;
           char *d;
           Char *pend = &patbuf[patsize / sizeof(Char)];
   #ifndef NO_GETPW_R
           struct passwd pwres;
           char pwbuf[1024];
   #endif
   
           pend--;
   
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(patbuf != NULL);
           _DIAGASSERT(pglob != NULL);
   
         if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))          if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
                 return pattern;                  return pattern;
   
         /* Copy up to the end of the string or / */          /* Copy up to the end of the string or / */
         for (p = pattern + 1, h = (char *) patbuf; *p && *p != SLASH;          for (p = pattern + 1, d = (char *)(void *)patbuf;
              *h++ = *p++)               d < (char *)(void *)pend && *p && *p != SLASH;
                *d++ = *p++)
                 continue;                  continue;
   
         *h = EOS;          if (d == (char *)(void *)pend)
                   return NULL;
   
           *d = EOS;
           d = (char *)(void *)patbuf;
   
         if (((char *) patbuf)[0] == EOS) {          if (*d == EOS) {
                 /*                  /*
                  * handle a plain ~ or ~/ by expanding $HOME                   * handle a plain ~ or ~/ by expanding $HOME
                  * first and then trying the password file                   * first and then trying the password file
                  */                   */
                 if ((h = getenv("HOME")) == NULL) {                  if ((h = getenv("HOME")) == NULL) {
   #ifdef NO_GETPW_R
                         if ((pwd = getpwuid(getuid())) == NULL)                          if ((pwd = getpwuid(getuid())) == NULL)
   #else
                           if (getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf),
                               &pwd) != 0 || pwd == NULL)
   #endif
                                 return pattern;                                  return pattern;
                         else                          else
                                 h = pwd->pw_dir;                                  h = pwd->pw_dir;
Line 367  globtilde(pattern, patbuf, pglob)
Line 418  globtilde(pattern, patbuf, pglob)
                 /*                  /*
                  * Expand a ~user                   * Expand a ~user
                  */                   */
                 if ((pwd = getpwnam((char*) patbuf)) == NULL)  #ifdef NO_GETPW_R
                   if ((pwd = getpwnam(d)) == NULL)
   #else
                   if (getpwnam_r(d, &pwres, pwbuf, sizeof(pwbuf), &pwd) != 0 ||
                       pwd == NULL)
   #endif
                         return pattern;                          return pattern;
                 else                  else
                         h = pwd->pw_dir;                          h = pwd->pw_dir;
         }          }
   
         /* Copy the home directory */          /* Copy the home directory */
         for (b = patbuf; *h; *b++ = *h++)          for (b = patbuf; b < pend && *h; *b++ = *h++)
                 continue;                  continue;
   
           if (b == pend)
                   return NULL;
   
         /* Append the rest of the pattern */          /* Append the rest of the pattern */
         while ((*b++ = *p++) != EOS)          while (b < pend && (*b++ = *p++) != EOS)
                 continue;                  continue;
   
           if (b == pend)
                   return NULL;
   
         return patbuf;          return patbuf;
 }  }
   
Line 398  glob0(pattern, pglob)
Line 460  glob0(pattern, pglob)
         glob_t *pglob;          glob_t *pglob;
 {  {
         const Char *qpatnext;          const Char *qpatnext;
         int c, err, oldpathc;          int c, error, oldpathc;
         Char *bufnext, patbuf[MAXPATHLEN+1];          Char *bufnext, patbuf[MAXPATHLEN+1];
           size_t limit = 0;
   
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(pglob != NULL);
   
         qpatnext = globtilde(pattern, patbuf, pglob);          if ((qpatnext = globtilde(pattern, patbuf, sizeof(patbuf),
               pglob)) == NULL)
                   return GLOB_ABEND;
         oldpathc = pglob->gl_pathc;          oldpathc = pglob->gl_pathc;
         bufnext = patbuf;          bufnext = patbuf;
   
Line 413  glob0(pattern, pglob)
Line 481  glob0(pattern, pglob)
                         if (c == NOT)                          if (c == NOT)
                                 ++qpatnext;                                  ++qpatnext;
                         if (*qpatnext == EOS ||                          if (*qpatnext == EOS ||
                             g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {                              g_strchr(qpatnext+1, RBRACKET) == NULL) {
                                 *bufnext++ = LBRACKET;                                  *bufnext++ = LBRACKET;
                                 if (c == NOT)                                  if (c == NOT)
                                         --qpatnext;                                          --qpatnext;
Line 445  glob0(pattern, pglob)
Line 513  glob0(pattern, pglob)
                          * to avoid exponential behavior                           * to avoid exponential behavior
                          */                           */
                         if (bufnext == patbuf || bufnext[-1] != M_ALL)                          if (bufnext == patbuf || bufnext[-1] != M_ALL)
                             *bufnext++ = M_ALL;                                  *bufnext++ = M_ALL;
                         break;                          break;
                 default:                  default:
                         *bufnext++ = CHAR(c);                          *bufnext++ = CHAR(c);
Line 457  glob0(pattern, pglob)
Line 525  glob0(pattern, pglob)
         qprintf("glob0:", patbuf);          qprintf("glob0:", patbuf);
 #endif  #endif
   
         if ((err = glob1(patbuf, pglob)) != 0)          if ((error = glob1(patbuf, pglob, &limit)) != 0)
                 return(err);                  return(error);
   
         /*          if (pglob->gl_pathc == oldpathc) {
          * If there was no match we are going to append the pattern                  /*
          * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified                   * If there was no match we are going to append the pattern
          * and the pattern did not contain any magic characters                   * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was
          * GLOB_NOMAGIC is there just for compatibility with csh.                   * specified and the pattern did not contain any magic
          */                   * characters GLOB_NOMAGIC is there just for compatibility
         if (pglob->gl_pathc == oldpathc &&                   * with csh.
             ((pglob->gl_flags & GLOB_NOCHECK) ||                   */
               ((pglob->gl_flags & GLOB_NOMAGIC) &&                  if ((pglob->gl_flags & GLOB_NOCHECK) ||
                !(pglob->gl_flags & GLOB_MAGCHAR))))                      ((pglob->gl_flags & (GLOB_NOMAGIC|GLOB_MAGCHAR))
                 return(globextend(pattern, pglob));                       == GLOB_NOMAGIC)) {
         else if (!(pglob->gl_flags & GLOB_NOSORT))                          return globextend(pattern, pglob, &limit);
                   } else {
                           return (GLOB_NOMATCH);
                   }
           } else if (!(pglob->gl_flags & GLOB_NOSORT)) {
                 qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,                  qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
                     pglob->gl_pathc - oldpathc, sizeof(char *), compare);                      (size_t)pglob->gl_pathc - oldpathc, sizeof(char *),
                       compare);
           }
   
         return(0);          return(0);
 }  }
   
Line 481  static int
Line 556  static int
 compare(p, q)  compare(p, q)
         const void *p, *q;          const void *p, *q;
 {  {
         return(strcmp(*(char **)p, *(char **)q));  
           _DIAGASSERT(p != NULL);
           _DIAGASSERT(q != NULL);
   
           return(strcoll(*(const char * const *)p, *(const char * const *)q));
 }  }
   
 static int  static int
 glob1(pattern, pglob)  glob1(pattern, pglob, limit)
         Char *pattern;          Char *pattern;
         glob_t *pglob;          glob_t *pglob;
           size_t *limit;
 {  {
         Char pathbuf[MAXPATHLEN+1];          Char pathbuf[MAXPATHLEN+1];
   
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(pglob != NULL);
   
         /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */          /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
         if (*pattern == EOS)          if (*pattern == EOS)
                 return(0);                  return(0);
         return(glob2(pathbuf, pathbuf, pattern, pglob));          /*
            * we save one character so that we can use ptr >= limit,
            * in the general case when we are appending non nul chars only.
            */
           return(glob2(pathbuf, pathbuf,
                        pathbuf + (sizeof(pathbuf) / sizeof(*pathbuf)) - 1,
                        pattern,
               pglob, limit));
 }  }
   
 /*  /*
Line 503  glob1(pattern, pglob)
Line 593  glob1(pattern, pglob)
  * meta characters.   * meta characters.
  */   */
 static int  static int
 glob2(pathbuf, pathend, pattern, pglob)  glob2(pathbuf, pathend, pathlim, pattern, pglob, limit)
         Char *pathbuf, *pathend, *pattern;          Char *pathbuf, *pathend, *pathlim, *pattern;
         glob_t *pglob;          glob_t *pglob;
           size_t *limit;
 {  {
         struct stat sb;          __gl_stat_t sb;
         Char *p, *q;          Char *p, *q;
         int anymeta;          int anymeta;
   
           _DIAGASSERT(pathbuf != NULL);
           _DIAGASSERT(pathend != NULL);
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(pglob != NULL);
   
         /*          /*
          * Loop over pattern segments until end of pattern or until           * Loop over pattern segments until end of pattern or until
          * segment with meta character found.           * segment with meta character found.
Line 522  glob2(pathbuf, pathend, pattern, pglob)
Line 618  glob2(pathbuf, pathend, pattern, pglob)
                                 return(0);                                  return(0);
   
                         if (((pglob->gl_flags & GLOB_MARK) &&                          if (((pglob->gl_flags & GLOB_MARK) &&
                             pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)                              pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
                             || (S_ISLNK(sb.st_mode) &&                              (S_ISLNK(sb.st_mode) &&
                             (g_stat(pathbuf, &sb, pglob) == 0) &&                              (g_stat(pathbuf, &sb, pglob) == 0) &&
                             S_ISDIR(sb.st_mode)))) {                              S_ISDIR(sb.st_mode)))) {
                                   if (pathend >= pathlim)
                                           return (GLOB_ABORTED);
                                 *pathend++ = SEP;                                  *pathend++ = SEP;
                                 *pathend = EOS;                                  *pathend = EOS;
                         }                          }
                         ++pglob->gl_matchc;                          ++pglob->gl_matchc;
                         return(globextend(pathbuf, pglob));                          return(globextend(pathbuf, pglob, limit));
                 }                  }
   
                 /* Find end of next segment, copy tentatively to pathend. */                  /* Find end of next segment, copy tentatively to pathend. */
Line 539  glob2(pathbuf, pathend, pattern, pglob)
Line 637  glob2(pathbuf, pathend, pattern, pglob)
                 while (*p != EOS && *p != SEP) {                  while (*p != EOS && *p != SEP) {
                         if (ismeta(*p))                          if (ismeta(*p))
                                 anymeta = 1;                                  anymeta = 1;
                           if (q >= pathlim)
                                   return GLOB_ABORTED;
                         *q++ = *p++;                          *q++ = *p++;
                 }                  }
   
                 if (!anymeta) {         /* No expansion, do next segment. */                  if (!anymeta) {         /* No expansion, do next segment. */
                         pathend = q;                          pathend = q;
                         pattern = p;                          pattern = p;
                         while (*pattern == SEP)                          while (*pattern == SEP) {
                                   if (pathend >= pathlim)
                                           return GLOB_ABORTED;
                                 *pathend++ = *pattern++;                                  *pathend++ = *pattern++;
                           }
                 } else                  /* Need expansion, recurse. */                  } else                  /* Need expansion, recurse. */
                         return(glob3(pathbuf, pathend, pattern, p, pglob));                          return(glob3(pathbuf, pathend, pathlim, pattern, p,
                               pglob, limit));
         }          }
         /* NOTREACHED */          /* NOTREACHED */
 }  }
   
 static int  static int
 glob3(pathbuf, pathend, pattern, restpattern, pglob)  glob3(pathbuf, pathend, pathlim, pattern, restpattern, pglob, limit)
         Char *pathbuf, *pathend, *pattern, *restpattern;          Char *pathbuf, *pathend, *pathlim, *pattern, *restpattern;
         glob_t *pglob;          glob_t *pglob;
           size_t *limit;
 {  {
         register struct dirent *dp;          struct dirent *dp;
         DIR *dirp;          DIR *dirp;
         int err;          int error;
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         /*          /*
Line 569  glob3(pathbuf, pathend, pattern, restpat
Line 674  glob3(pathbuf, pathend, pattern, restpat
          * and dirent.h as taking pointers to differently typed opaque           * and dirent.h as taking pointers to differently typed opaque
          * structures.           * structures.
          */           */
         struct dirent *(*readdirfunc)();          struct dirent *(*readdirfunc) __P((void *));
   
           _DIAGASSERT(pathbuf != NULL);
           _DIAGASSERT(pathend != NULL);
           _DIAGASSERT(pattern != NULL);
           _DIAGASSERT(restpattern != NULL);
           _DIAGASSERT(pglob != NULL);
   
         *pathend = EOS;          *pathend = EOS;
         errno = 0;          errno = 0;
   
         if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {          if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
                 /* TODO: don't call for ENOENT or ENOTDIR? */  
                 if (pglob->gl_errfunc) {                  if (pglob->gl_errfunc) {
                         g_Ctoc(pathbuf, buf);                          if (g_Ctoc(pathbuf, buf, sizeof(buf)))
                                   return (GLOB_ABORTED);
                         if (pglob->gl_errfunc(buf, errno) ||                          if (pglob->gl_errfunc(buf, errno) ||
                             pglob->gl_flags & GLOB_ERR)                              pglob->gl_flags & GLOB_ERR)
                                 return (GLOB_ABEND);                                  return (GLOB_ABORTED);
                 }                  }
                   /*
                    * Posix/XOpen: glob should return when it encounters a
                    * directory that it cannot open or read
                    * XXX: Should we ignore ENOTDIR and ENOENT though?
                    * I think that Posix had in mind EPERM...
                    */
                   if (pglob->gl_flags & GLOB_ERR)
                           return (GLOB_ABORTED);
   
                 return(0);                  return(0);
         }          }
   
         err = 0;          error = 0;
   
         /* Search directory for matching names. */          /* Search directory for matching names. */
         if (pglob->gl_flags & GLOB_ALTDIRFUNC)          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                 readdirfunc = pglob->gl_readdir;                  readdirfunc = pglob->gl_readdir;
         else          else
                 readdirfunc = readdir;                  readdirfunc = (struct dirent *(*)__P((void *))) readdir;
         while ((dp = (*readdirfunc)(dirp))) {          while ((dp = (*readdirfunc)(dirp)) != NULL) {
                 register u_char *sc;                  u_char *sc;
                 register Char *dc;                  Char *dc;
   
                 /* Initial DOT must be matched literally. */                  /* Initial DOT must be matched literally. */
                 if (dp->d_name[0] == DOT && *pattern != DOT)                  if (dp->d_name[0] == DOT && *pattern != DOT)
                         continue;                          continue;
                   /*
                    * The resulting string contains EOS, so we can
                    * use the pathlim character, if it is the nul
                    */
                 for (sc = (u_char *) dp->d_name, dc = pathend;                  for (sc = (u_char *) dp->d_name, dc = pathend;
                      (*dc++ = *sc++) != EOS;)                       dc <= pathlim && (*dc++ = *sc++) != EOS;)
                         continue;                          continue;
   
                   /*
                    * Have we filled the buffer without seeing EOS?
                    */
                   if (dc > pathlim && *pathlim != EOS) {
                           /*
                            * Abort when requested by caller, otherwise
                            * reset pathend back to last SEP and continue
                            * with next dir entry.
                            */
                           if (pglob->gl_flags & GLOB_ERR) {
                                   error = GLOB_ABORTED;
                                   break;
                           }
                           else {
                                   *pathend = EOS;
                                   continue;
                           }
                   }
   
                 if (!match(pathend, pattern, restpattern)) {                  if (!match(pathend, pattern, restpattern)) {
                         *pathend = EOS;                          *pathend = EOS;
                         continue;                          continue;
                 }                  }
                 err = glob2(pathbuf, --dc, restpattern, pglob);                  error = glob2(pathbuf, --dc, pathlim, restpattern, pglob, limit);
                 if (err)                  if (error)
                         break;                          break;
         }          }
   
Line 615  glob3(pathbuf, pathend, pattern, restpat
Line 759  glob3(pathbuf, pathend, pattern, restpat
                 (*pglob->gl_closedir)(dirp);                  (*pglob->gl_closedir)(dirp);
         else          else
                 closedir(dirp);                  closedir(dirp);
         return(err);  
           /*
            * Again Posix X/Open issue with regards to error handling.
            */
           if ((error || errno) && (pglob->gl_flags & GLOB_ERR))
                   return (GLOB_ABORTED);
   
           return(error);
 }  }
   
   
Line 634  glob3(pathbuf, pathend, pattern, restpat
Line 785  glob3(pathbuf, pathend, pattern, restpat
  *      gl_pathv points to (gl_offs + gl_pathc + 1) items.   *      gl_pathv points to (gl_offs + gl_pathc + 1) items.
  */   */
 static int  static int
 globextend(path, pglob)  globextend(path, pglob, limit)
         const Char *path;          const Char *path;
         glob_t *pglob;          glob_t *pglob;
           size_t *limit;
 {  {
         register char **pathv;          char **pathv;
         register int i;          int i;
         u_int newsize;          size_t newsize, len;
         char *copy;          char *copy;
         const Char *p;          const Char *p;
   
           _DIAGASSERT(path != NULL);
           _DIAGASSERT(pglob != NULL);
   
         newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);          newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
         pathv = pglob->gl_pathv ?          pathv = pglob->gl_pathv ? realloc(pglob->gl_pathv, newsize) :
                     realloc((char *)pglob->gl_pathv, newsize) :              malloc(newsize);
                     malloc(newsize);  
         if (pathv == NULL)          if (pathv == NULL)
                 return(GLOB_NOSPACE);                  return(GLOB_NOSPACE);
   
Line 661  globextend(path, pglob)
Line 815  globextend(path, pglob)
   
         for (p = path; *p++;)          for (p = path; *p++;)
                 continue;                  continue;
         if ((copy = malloc(p - path)) != NULL) {          len = (size_t)(p - path);
                 g_Ctoc(path, copy);          *limit += len;
           if ((copy = malloc(len)) != NULL) {
                   if (g_Ctoc(path, copy, len)) {
                           free(copy);
                           return(GLOB_ABORTED);
                   }
                 pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;                  pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
         }          }
         pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;          pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
   
           if ((pglob->gl_flags & GLOB_LIMIT) && (newsize + *limit) >= ARG_MAX) {
                   errno = 0;
                   return(GLOB_NOSPACE);
           }
   
         return(copy == NULL ? GLOB_NOSPACE : 0);          return(copy == NULL ? GLOB_NOSPACE : 0);
 }  }
   
Line 676  globextend(path, pglob)
Line 841  globextend(path, pglob)
  */   */
 static int  static int
 match(name, pat, patend)  match(name, pat, patend)
         register Char *name, *pat, *patend;          Char *name, *pat, *patend;
 {  {
         int ok, negate_range;          int ok, negate_range;
         Char c, k;          Char c, k;
   
           _DIAGASSERT(name != NULL);
           _DIAGASSERT(pat != NULL);
           _DIAGASSERT(patend != NULL);
   
         while (pat < patend) {          while (pat < patend) {
                 c = *pat++;                  c = *pat++;
                 switch (c & M_MASK) {                  switch (c & M_MASK) {
Line 726  void
Line 895  void
 globfree(pglob)  globfree(pglob)
         glob_t *pglob;          glob_t *pglob;
 {  {
         register int i;          int i;
         register char **pp;          char **pp;
   
           _DIAGASSERT(pglob != NULL);
   
         if (pglob->gl_pathv != NULL) {          if (pglob->gl_pathv != NULL) {
                 pp = pglob->gl_pathv + pglob->gl_offs;                  pp = pglob->gl_pathv + pglob->gl_offs;
Line 735  globfree(pglob)
Line 906  globfree(pglob)
                         if (*pp)                          if (*pp)
                                 free(*pp);                                  free(*pp);
                 free(pglob->gl_pathv);                  free(pglob->gl_pathv);
                   pglob->gl_pathv = NULL;
                   pglob->gl_pathc = 0;
         }          }
 }  }
   
 static DIR *  static DIR *
 g_opendir(str, pglob)  g_opendir(str, pglob)
         register Char *str;          Char *str;
         glob_t *pglob;          glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
           _DIAGASSERT(str != NULL);
           _DIAGASSERT(pglob != NULL);
   
         if (!*str)          if (!*str)
                 strcpy(buf, ".");                  (void)strlcpy(buf, ".", sizeof(buf));
         else          else {
                 g_Ctoc(str, buf);                  if (g_Ctoc(str, buf, sizeof(buf)))
                           return NULL;
           }
   
         if (pglob->gl_flags & GLOB_ALTDIRFUNC)          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                 return((*pglob->gl_opendir)(buf));                  return((*pglob->gl_opendir)(buf));
Line 758  g_opendir(str, pglob)
Line 936  g_opendir(str, pglob)
   
 static int  static int
 g_lstat(fn, sb, pglob)  g_lstat(fn, sb, pglob)
         register Char *fn;          Char *fn;
         struct stat *sb;          __gl_stat_t *sb;
         glob_t *pglob;          glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         g_Ctoc(fn, buf);          _DIAGASSERT(fn != NULL);
           _DIAGASSERT(sb != NULL);
           _DIAGASSERT(pglob != NULL);
   
           if (g_Ctoc(fn, buf, sizeof(buf)))
                   return -1;
         if (pglob->gl_flags & GLOB_ALTDIRFUNC)          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                 return((*pglob->gl_lstat)(buf, sb));                  return((*pglob->gl_lstat)(buf, sb));
         return(lstat(buf, sb));          return(lstat(buf, sb));
Line 772  g_lstat(fn, sb, pglob)
Line 955  g_lstat(fn, sb, pglob)
   
 static int  static int
 g_stat(fn, sb, pglob)  g_stat(fn, sb, pglob)
         register Char *fn;          Char *fn;
         struct stat *sb;          __gl_stat_t *sb;
         glob_t *pglob;          glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         g_Ctoc(fn, buf);          _DIAGASSERT(fn != NULL);
           _DIAGASSERT(sb != NULL);
           _DIAGASSERT(pglob != NULL);
   
           if (g_Ctoc(fn, buf, sizeof(buf)))
                   return -1;
         if (pglob->gl_flags & GLOB_ALTDIRFUNC)          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                 return((*pglob->gl_stat)(buf, sb));                  return((*pglob->gl_stat)(buf, sb));
         return(stat(buf, sb));          return(stat(buf, sb));
Line 786  g_stat(fn, sb, pglob)
Line 974  g_stat(fn, sb, pglob)
   
 static Char *  static Char *
 g_strchr(str, ch)  g_strchr(str, ch)
         Char *str;          const Char *str;
         int ch;          int ch;
 {  {
   
           _DIAGASSERT(str != NULL);
   
         do {          do {
                 if (*str == ch)                  if (*str == ch)
                         return (str);                          return __UNCONST(str);
         } while (*str++);          } while (*str++);
         return (NULL);          return NULL;
 }  }
   
 #ifdef notdef  static int
 static Char *  g_Ctoc(str, buf, len)
 g_strcat(dst, src)          const Char *str;
         Char *dst;          char *buf;
         const Char* src;          size_t len;
 {  {
         Char *sdst = dst;          char *dc;
   
         while (*dst++)  
                 continue;  
         --dst;  
         while((*dst++ = *src++) != EOS)  
             continue;  
   
         return (sdst);          _DIAGASSERT(str != NULL);
 }          _DIAGASSERT(buf != NULL);
 #endif  
   
 static void          if (len == 0)
 g_Ctoc(str, buf)                  return 1;
         register const Char *str;  
         char *buf;  
 {  
         register char *dc;  
   
         for (dc = buf; (*dc++ = *str++) != EOS;)          for (dc = buf; len && (*dc++ = *str++) != EOS; len--)
                 continue;                  continue;
   
           return len == 0;
 }  }
   
 #ifdef DEBUG  #ifdef DEBUG
 static void  static void
 qprintf(str, s)  qprintf(str, s)
         const char *str;          const char *str;
         register Char *s;          Char *s;
 {  {
         register Char *p;          Char *p;
   
           _DIAGASSERT(str != NULL);
           _DIAGASSERT(s != NULL);
   
         (void)printf("%s:\n", str);          (void)printf("%s:\n", str);
         for (p = s; *p; p++)          for (p = s; *p; p++)

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.14

CVSweb <webmaster@jp.NetBSD.org>