Add Socket Libraries.

[mirror_edk2.git] / StdLib / PosixLib / Glob / glob.c

/** @file\r
 * glob(3) -- a superset of the one defined in POSIX 1003.2.\r
 *\r
 * The [!...] convention to negate a range is supported (SysV, Posix, ksh).\r
 *\r
 * Optional extra services, controlled by flags not defined by POSIX:\r
 *\r
 * GLOB_MAGCHAR:\r
 *  Set in gl_flags if pattern contained a globbing character.\r
 * GLOB_NOMAGIC:\r
 *  Same as GLOB_NOCHECK, but it will only append pattern if it did\r
 *  not contain any magic characters.  [Used in csh style globbing]\r
 * GLOB_ALTDIRFUNC:\r
 *  Use alternately specified directory access functions.\r
 * GLOB_TILDE:\r
 *  expand ~user/foo to the /home/dir/of/user/foo\r
 * GLOB_BRACE:\r
 *  expand {1,2}{a,b} to 1a 1b 2a 2b\r
 * GLOB_PERIOD:\r
 *  allow metacharacters to match leading dots in filenames.\r
 * GLOB_NO_DOTDIRS:\r
 *  . and .. are hidden from wildcards, even if GLOB_PERIOD is set.\r
 * gl_matchc:\r
 *  Number of matches in the current invocation of glob.\r
 *\r
 * Copyright (c) 1989, 1993\r
 *  The Regents of the University of California.  All rights reserved.\r
 *\r
 * This code is derived from software contributed to Berkeley by\r
 * Guido van Rossum.\r
 *\r
 * Redistribution and use in source and binary forms, with or without\r
 * modification, are permitted provided that the following conditions\r
 * are met:\r
 * 1. Redistributions of source code must retain the above copyright\r
 *    notice, this list of conditions and the following disclaimer.\r
 * 2. Redistributions in binary form must reproduce the above copyright\r
 *    notice, this list of conditions and the following disclaimer in the\r
 *    documentation and/or other materials provided with the distribution.\r
 * 3. Neither the name of the University nor the names of its contributors\r
 *    may be used to endorse or promote products derived from this software\r
 *    without specific prior written permission.\r
 *\r
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
 * SUCH DAMAGE.\r
\r
    glob.c  8.3 (Berkeley) 10/13/93\r
    NetBSD: glob.c,v 1.23.4.1 2010/07/19 18:14:08 riz Exp\r
 */\r
#pragma warning ( disable : 4244 )\r
#pragma warning ( disable : 4018 )\r
\r
#include  <LibConfig.h>\r
\r
#include <sys/cdefs.h>\r
\r
#include <sys/param.h>\r
#include <sys/stat.h>\r
\r
#include <assert.h>\r
#include <ctype.h>\r
#include <dirent.h>\r
#include <errno.h>\r
#include <glob.h>\r
//#include <pwd.h>\r
#include <stdio.h>\r
#include <stddef.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <unistd.h>\r
#include <sys/fcntl.h>\r
#include "internal.h"\r
\r
#ifdef HAVE_NBTOOL_CONFIG_H\r
#define NO_GETPW_R\r
#endif\r
\r
#define GLOB_LIMIT_MALLOC     65536\r
#define GLOB_LIMIT_STAT         128\r
#define GLOB_LIMIT_READDIR    16384\r
\r
#define GLOB_INDEX_MALLOC         0\r
#define GLOB_INDEX_STAT           1\r
#define GLOB_INDEX_READDIR        2\r
\r
/*\r
 * XXX: For NetBSD 1.4.x compatibility. (kill me l8r)\r
 */\r
#ifndef _DIAGASSERT\r
#define _DIAGASSERT(a)\r
#endif\r
\r
#define DOLLAR        '$'\r
#define DOT           '.'\r
#define EOS           '\0'\r
#define LBRACKET      '['\r
#define NOT           '!'\r
#define QUESTION      '?'\r
#define QUOTE         '\\'\r
#define RANGE         '-'\r
#define RBRACKET      ']'\r
#define SEP           '/'\r
#define STAR          '*'\r
#define TILDE         '~'\r
#define UNDERSCORE    '_'\r
#define LBRACE        '{'\r
#define RBRACE        '}'\r
#define SLASH         '/'\r
#define COMMA         ','\r
\r
#ifndef USE_8BIT_CHARS\r
\r
#define M_QUOTE       0x8000\r
#define M_PROTECT     0x4000\r
#define M_MASK        0xffff\r
#define M_ASCII       0x00ff\r
\r
typedef u_short Char;\r
\r
#else\r
\r
#define M_QUOTE       (Char)0x80\r
#define M_PROTECT     (Char)0x40\r
#define M_MASK        (Char)0xff\r
#define M_ASCII       (Char)0x7f\r
\r
typedef char Char;\r
\r
#endif\r
\r
\r
#define CHAR(c)       ((Char)((c)&M_ASCII))\r
#define META(c)       ((Char)((c)|M_QUOTE))\r
#define M_ALL         META('*')\r
#define M_END         META(']')\r
#define M_NOT         META('!')\r
#define M_ONE         META('?')\r
#define M_RNG         META('-')\r
#define M_SET         META('[')\r
#define ismeta(c)     (((c)&M_QUOTE) != 0)\r
\r
static int            compare(const void *, const void *);\r
static int            g_Ctoc(const Char *, char *, size_t);\r
static int            g_lstat(Char *, __gl_stat_t  *, glob_t *);\r
static DIR           *g_opendir(Char *, glob_t *);\r
static Char          *g_strchr(const Char *, int);\r
static int            g_stat(Char *, __gl_stat_t *, glob_t *);\r
static int            glob0(const Char *, glob_t *, size_t *);\r
static int            glob1(Char *, glob_t *, size_t *);\r
static int            glob2(Char *, Char *, Char *, Char *, glob_t *, size_t *);\r
static int            glob3(Char *, Char *, Char *, Char *, Char *, glob_t *, size_t *);\r
static int            globextend(const Char *, glob_t *, size_t *);\r
static const Char    *globtilde(const Char *, Char *, size_t, glob_t *);\r
static int            globexp1(const Char *, glob_t *, size_t *);\r
static int            globexp2(const Char *, const Char *, glob_t *, int *, size_t *);\r
static int            match(Char *, Char *, Char *);\r
#ifdef DEBUG\r
static void           qprintf(const char *, Char *);\r
#endif\r
\r
int\r
glob(\r
  const char *pattern,\r
  int flags,\r
  int (*errfunc)(const char *, int),\r
  glob_t *pglob\r
)\r
{\r
  const u_char *patnext;\r
  int c;\r
  Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];\r
  /* 0 = malloc(), 1 = stat(), 2 = readdir() */\r
  size_t limit[] = { 0, 0, 0 };\r
\r
  _DIAGASSERT(pattern != NULL);\r
\r
  patnext = (const u_char *) pattern;\r
  if (!(flags & GLOB_APPEND)) {\r
    pglob->gl_pathc = 0;\r
    pglob->gl_pathv = NULL;\r
    if (!(flags & GLOB_DOOFFS))\r
      pglob->gl_offs = 0;\r
  }\r
  pglob->gl_flags = flags & ~GLOB_MAGCHAR;\r
  pglob->gl_errfunc = errfunc;\r
  pglob->gl_matchc = 0;\r
\r
  bufnext = patbuf;\r
  bufend = bufnext + MAXPATHLEN;\r
  if (flags & GLOB_NOESCAPE) {\r
    while (bufnext < bufend && (c = *patnext++) != EOS)\r
      *bufnext++ = c;\r
  } else {\r
    /* Protect the quoted characters. */\r
    while (bufnext < bufend && (c = *patnext++) != EOS)\r
      if (c == QUOTE) {\r
        if ((c = *patnext++) == EOS) {\r
          c = QUOTE;\r
          --patnext;\r
        }\r
        *bufnext++ = c | M_PROTECT;\r
      }\r
      else\r
        *bufnext++ = c;\r
  }\r
  *bufnext = EOS;\r
\r
  if (flags & GLOB_BRACE)\r
      return globexp1(patbuf, pglob, limit);\r
  else\r
      return glob0(patbuf, pglob, limit);\r
}\r
\r
/*\r
 * Expand recursively a glob {} pattern. When there is no more expansion\r
 * invoke the standard globbing routine to glob the rest of the magic\r
 * characters\r
 */\r
static int\r
globexp1(const Char *pattern, glob_t *pglob, size_t *limit)\r
{\r
  const Char* ptr = pattern;\r
  int rv;\r
\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  /* Protect a single {}, for find(1), like csh */\r
  if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)\r
    return glob0(pattern, pglob, limit);\r
\r
  while ((ptr = (const Char *) g_strchr(ptr, LBRACE)) != NULL)\r
    if (!globexp2(ptr, pattern, pglob, &rv, limit))\r
      return rv;\r
\r
  return glob0(pattern, pglob, limit);\r
}\r
\r
\r
/*\r
 * Recursive brace globbing helper. Tries to expand a single brace.\r
 * If it succeeds then it invokes globexp1 with the new pattern.\r
 * If it fails then it tries to glob the rest of the pattern and returns.\r
 */\r
static int\r
globexp2(const Char *ptr, const Char *pattern, glob_t *pglob, int *rv,\r
    size_t *limit)\r
{\r
  int     i;\r
  Char   *lm, *ls;\r
  const Char *pe, *pm, *pl;\r
  Char    patbuf[MAXPATHLEN + 1];\r
\r
  _DIAGASSERT(ptr != NULL);\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
  _DIAGASSERT(rv != NULL);\r
\r
  /* copy part up to the brace */\r
  for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)\r
    continue;\r
  ls = lm;\r
\r
  /* Find the balanced brace */\r
  for (i = 0, pe = ++ptr; *pe; pe++)\r
    if (*pe == LBRACKET) {\r
      /* Ignore everything between [] */\r
      for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)\r
        continue;\r
      if (*pe == EOS) {\r
        /*\r
         * We could not find a matching RBRACKET.\r
         * Ignore and just look for RBRACE\r
         */\r
        pe = pm;\r
      }\r
    }\r
    else if (*pe == LBRACE)\r
      i++;\r
    else if (*pe == RBRACE) {\r
      if (i == 0)\r
        break;\r
      i--;\r
    }\r
\r
  /* Non matching braces; just glob the pattern */\r
  if (i != 0 || *pe == EOS) {\r
    /*\r
     * we use `pattern', not `patbuf' here so that that\r
     * unbalanced braces are passed to the match\r
     */\r
    *rv = glob0(pattern, pglob, limit);\r
    return 0;\r
  }\r
\r
  for (i = 0, pl = pm = ptr; pm <= pe; pm++) {\r
    switch (*pm) {\r
    case LBRACKET:\r
      /* Ignore everything between [] */\r
      for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)\r
        continue;\r
      if (*pm == EOS) {\r
        /*\r
         * We could not find a matching RBRACKET.\r
         * Ignore and just look for RBRACE\r
         */\r
        pm = pl;\r
      }\r
      break;\r
\r
    case LBRACE:\r
      i++;\r
      break;\r
\r
    case RBRACE:\r
      if (i) {\r
        i--;\r
        break;\r
      }\r
      /* FALLTHROUGH */\r
    case COMMA:\r
      if (i && *pm == COMMA)\r
        break;\r
      else {\r
        /* Append the current string */\r
        for (lm = ls; (pl < pm); *lm++ = *pl++)\r
          continue;\r
        /*\r
         * Append the rest of the pattern after the\r
         * closing brace\r
         */\r
        for (pl = pe + 1; (*lm++ = *pl++) != EOS;)\r
          continue;\r
\r
        /* Expand the current pattern */\r
#ifdef DEBUG\r
        qprintf("globexp2:", patbuf);\r
#endif\r
        *rv = globexp1(patbuf, pglob, limit);\r
\r
        /* move after the comma, to the next string */\r
        pl = pm + 1;\r
      }\r
      break;\r
\r
    default:\r
      break;\r
    }\r
  }\r
  *rv = 0;\r
  return 0;\r
}\r
\r
\r
\r
/*\r
 * expand tilde from the passwd file.\r
 */\r
static const Char *\r
globtilde(const Char *pattern, Char *patbuf, size_t patsize, glob_t *pglob)\r
{\r
  const char *h;\r
  const Char *p;\r
  Char *b;\r
  char *d;\r
  Char *pend = &patbuf[patsize / sizeof(Char)];\r
\r
  pend--;\r
\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(patbuf != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))\r
    return pattern;\r
\r
  /* Copy up to the end of the string or / */\r
  for (p = pattern + 1, d = (char *)(void *)patbuf;\r
       d < (char *)(void *)pend && *p && *p != SLASH;\r
       *d++ = *p++)\r
    continue;\r
\r
  if (d == (char *)(void *)pend)\r
    return NULL;\r
\r
  *d = EOS;\r
  d = (char *)(void *)patbuf;\r
\r
  if (*d == EOS) {\r
    /*\r
     * handle a plain ~ or ~/ by expanding $HOME\r
     * first and then trying the password file\r
     */\r
    if ((h = getenv("HOME")) == NULL) {\r
      return pattern;\r
    }\r
  }\r
  else {\r
    /*\r
     * Expand a ~user\r
     */\r
    return pattern;\r
  }\r
\r
  /* Copy the home directory */\r
  for (b = patbuf; b < pend && *h; *b++ = *h++)\r
    continue;\r
\r
  if (b == pend)\r
    return NULL;\r
\r
  /* Append the rest of the pattern */\r
  while (b < pend && (*b++ = *p++) != EOS)\r
    continue;\r
\r
  if (b == pend)\r
    return NULL;\r
\r
  return patbuf;\r
}\r
\r
\r
/*\r
 * The main glob() routine: compiles the pattern (optionally processing\r
 * quotes), calls glob1() to do the real pattern matching, and finally\r
 * sorts the list (unless unsorted operation is requested).  Returns 0\r
 * if things went well, nonzero if errors occurred.  It is not an error\r
 * to find no matches.\r
 */\r
static int\r
glob0(const Char *pattern, glob_t *pglob, size_t *limit)\r
{\r
  const Char *qpatnext;\r
  int c, error;\r
  __gl_size_t oldpathc;\r
  Char *bufnext, patbuf[MAXPATHLEN+1];\r
\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if ((qpatnext = globtilde(pattern, patbuf, sizeof(patbuf),\r
      pglob)) == NULL)\r
    return GLOB_ABEND;\r
  oldpathc = pglob->gl_pathc;\r
  bufnext = patbuf;\r
\r
  /* We don't need to check for buffer overflow any more. */\r
  while ((c = *qpatnext++) != EOS) {\r
    switch (c) {\r
    case LBRACKET:\r
      c = *qpatnext;\r
      if (c == NOT)\r
        ++qpatnext;\r
      if (*qpatnext == EOS ||\r
          g_strchr(qpatnext+1, RBRACKET) == NULL) {\r
        *bufnext++ = LBRACKET;\r
        if (c == NOT)\r
          --qpatnext;\r
        break;\r
      }\r
      *bufnext++ = M_SET;\r
      if (c == NOT)\r
        *bufnext++ = M_NOT;\r
      c = *qpatnext++;\r
      do {\r
        *bufnext++ = CHAR(c);\r
        if (*qpatnext == RANGE &&\r
            (c = qpatnext[1]) != RBRACKET) {\r
          *bufnext++ = M_RNG;\r
          *bufnext++ = CHAR(c);\r
          qpatnext += 2;\r
        }\r
      } while ((c = *qpatnext++) != RBRACKET);\r
      pglob->gl_flags |= GLOB_MAGCHAR;\r
      *bufnext++ = M_END;\r
      break;\r
    case QUESTION:\r
      pglob->gl_flags |= GLOB_MAGCHAR;\r
      *bufnext++ = M_ONE;\r
      break;\r
    case STAR:\r
      pglob->gl_flags |= GLOB_MAGCHAR;\r
      /* collapse adjacent stars to one,\r
       * to avoid exponential behavior\r
       */\r
      if (bufnext == patbuf || bufnext[-1] != M_ALL)\r
        *bufnext++ = M_ALL;\r
      break;\r
    default:\r
      *bufnext++ = CHAR(c);\r
      break;\r
    }\r
  }\r
  *bufnext = EOS;\r
#ifdef DEBUG\r
  qprintf("glob0:", patbuf);\r
#endif\r
\r
  if ((error = glob1(patbuf, pglob, limit)) != 0)\r
    return error;\r
\r
  if (pglob->gl_pathc == oldpathc) {\r
    /*\r
     * If there was no match we are going to append the pattern\r
     * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was\r
     * specified and the pattern did not contain any magic\r
     * characters GLOB_NOMAGIC is there just for compatibility\r
     * with csh.\r
     */\r
    if ((pglob->gl_flags & GLOB_NOCHECK) ||\r
        ((pglob->gl_flags & (GLOB_NOMAGIC|GLOB_MAGCHAR))\r
         == GLOB_NOMAGIC)) {\r
      return globextend(pattern, pglob, limit);\r
    } else {\r
      return GLOB_NOMATCH;\r
    }\r
  } else if (!(pglob->gl_flags & GLOB_NOSORT)) {\r
    qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,\r
        (size_t)pglob->gl_pathc - oldpathc, sizeof(char *),\r
        compare);\r
  }\r
\r
  return 0;\r
}\r
\r
static int\r
compare(const void *p, const void *q)\r
{\r
\r
  _DIAGASSERT(p != NULL);\r
  _DIAGASSERT(q != NULL);\r
\r
  return strcoll(*(const char * const *)p, *(const char * const *)q);\r
}\r
\r
static int\r
glob1(Char *pattern, glob_t *pglob, size_t *limit)\r
{\r
  Char pathbuf[MAXPATHLEN+1];\r
\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */\r
  if (*pattern == EOS)\r
    return 0;\r
  /*\r
   * we save one character so that we can use ptr >= limit,\r
   * in the general case when we are appending non nul chars only.\r
   */\r
  return glob2(pathbuf, pathbuf,\r
      pathbuf + (sizeof(pathbuf) / sizeof(*pathbuf)) - 1, pattern,\r
      pglob, limit);\r
}\r
\r
/*\r
 * The functions glob2 and glob3 are mutually recursive; there is one level\r
 * of recursion for each segment in the pattern that contains one or more\r
 * meta characters.\r
 */\r
static int\r
glob2(Char *pathbuf, Char *pathend, Char *pathlim, Char *pattern, glob_t *pglob,\r
    size_t *limit)\r
{\r
  __gl_stat_t sb;\r
  Char *p, *q;\r
  int anymeta;\r
  Char *pend;\r
  ptrdiff_t diff;\r
\r
  _DIAGASSERT(pathbuf != NULL);\r
  _DIAGASSERT(pathend != NULL);\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  /*\r
   * Loop over pattern segments until end of pattern or until\r
   * segment with meta character found.\r
   */\r
  for (anymeta = 0;;) {\r
    if (*pattern == EOS) {    /* End of pattern? */\r
      *pathend = EOS;\r
      if (g_lstat(pathbuf, &sb, pglob))\r
        return 0;\r
\r
      if ((pglob->gl_flags & GLOB_LIMIT) &&\r
          limit[GLOB_INDEX_STAT]++ >= GLOB_LIMIT_STAT) {\r
        errno = 0;\r
        *pathend++ = SEP;\r
        *pathend = EOS;\r
        return GLOB_NOSPACE;\r
      }\r
      if (((pglob->gl_flags & GLOB_MARK) &&\r
          pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||\r
//          (S_ISLNK(sb.st_mode) &&\r
          (0 &&\r
          (g_stat(pathbuf, &sb, pglob) == 0) &&\r
          S_ISDIR(sb.st_mode)))) {\r
        if (pathend >= pathlim)\r
          return GLOB_ABORTED;\r
        *pathend++ = SEP;\r
        *pathend = EOS;\r
      }\r
      ++pglob->gl_matchc;\r
      return globextend(pathbuf, pglob, limit);\r
    }\r
\r
    /* Find end of next segment, copy tentatively to pathend. */\r
    q = pathend;\r
    p = pattern;\r
    while (*p != EOS && *p != SEP) {\r
      if (ismeta(*p))\r
        anymeta = 1;\r
      if (q >= pathlim)\r
        return GLOB_ABORTED;\r
      *q++ = *p++;\r
    }\r
\r
                /*\r
     * No expansion, or path ends in slash-dot shash-dot-dot,\r
     * do next segment.\r
     */\r
    if (pglob->gl_flags & GLOB_PERIOD) {\r
      for (pend = pathend; pend > pathbuf && pend[-1] == '/';\r
          pend--)\r
        continue;\r
      diff = pend - pathbuf;\r
    } else {\r
      /* XXX: GCC */\r
      diff = 0;\r
      pend = pathend;\r
    }\r
\r
                if ((!anymeta) ||\r
        ((pglob->gl_flags & GLOB_PERIOD) &&\r
         (diff >= 1 && pend[-1] == DOT) &&\r
         (diff >= 2 && (pend[-2] == SLASH || pend[-2] == DOT)) &&\r
         (diff < 3 || pend[-3] == SLASH))) {\r
      pathend = q;\r
      pattern = p;\r
      while (*pattern == SEP) {\r
        if (pathend >= pathlim)\r
          return GLOB_ABORTED;\r
        *pathend++ = *pattern++;\r
      }\r
    } else      /* Need expansion, recurse. */\r
      return glob3(pathbuf, pathend, pathlim, pattern, p,\r
          pglob, limit);\r
  }\r
  /* NOTREACHED */\r
}\r
\r
static int\r
glob3(Char *pathbuf, Char *pathend, Char *pathlim, Char *pattern,\r
    Char *restpattern, glob_t *pglob, size_t *limit)\r
{\r
  struct dirent *dp;\r
  DIR *dirp;\r
  int error;\r
  char buf[MAXPATHLEN];\r
\r
  /*\r
   * The readdirfunc declaration can't be prototyped, because it is\r
   * assigned, below, to two functions which are prototyped in glob.h\r
   * and dirent.h as taking pointers to differently typed opaque\r
   * structures.\r
   */\r
  struct dirent *(*readdirfunc)(void *);\r
\r
  _DIAGASSERT(pathbuf != NULL);\r
  _DIAGASSERT(pathend != NULL);\r
  _DIAGASSERT(pattern != NULL);\r
  _DIAGASSERT(restpattern != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  *pathend = EOS;\r
  errno = 0;\r
\r
  if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {\r
    if (pglob->gl_errfunc) {\r
      if (g_Ctoc(pathbuf, buf, sizeof(buf)))\r
        return GLOB_ABORTED;\r
      if (pglob->gl_errfunc(buf, errno) ||\r
          pglob->gl_flags & GLOB_ERR)\r
        return GLOB_ABORTED;\r
    }\r
    /*\r
     * Posix/XOpen: glob should return when it encounters a\r
     * directory that it cannot open or read\r
     * XXX: Should we ignore ENOTDIR and ENOENT though?\r
     * I think that Posix had in mind EPERM...\r
     */\r
    if (pglob->gl_flags & GLOB_ERR)\r
      return GLOB_ABORTED;\r
\r
    return 0;\r
  }\r
\r
  error = 0;\r
\r
  /* Search directory for matching names. */\r
  if (pglob->gl_flags & GLOB_ALTDIRFUNC)\r
    readdirfunc = pglob->gl_readdir;\r
  else\r
    readdirfunc = (struct dirent *(*)(void *)) readdir;\r
  while ((dp = (*readdirfunc)(dirp)) != NULL) {\r
    u_char *sc;\r
    Char *dc;\r
\r
    if ((pglob->gl_flags & GLOB_LIMIT) &&\r
        limit[GLOB_INDEX_READDIR]++ >= GLOB_LIMIT_READDIR) {\r
      errno = 0;\r
      *pathend++ = SEP;\r
      *pathend = EOS;\r
      return GLOB_NOSPACE;\r
    }\r
\r
    /*\r
     * Initial DOT must be matched literally, unless we have\r
     * GLOB_PERIOD set.\r
     */\r
    if ((pglob->gl_flags & GLOB_PERIOD) == 0)\r
      if (dp->FileName[0] == DOT && *pattern != DOT)\r
        continue;\r
    /*\r
     * If GLOB_NO_DOTDIRS is set, . and .. vanish.\r
     */\r
    if ((pglob->gl_flags & GLOB_NO_DOTDIRS) &&\r
        (dp->FileName[0] == DOT) &&\r
        ((dp->FileName[1] == EOS) ||\r
         ((dp->FileName[1] == DOT) && (dp->FileName[2] == EOS))))\r
      continue;\r
    /*\r
     * The resulting string contains EOS, so we can\r
     * use the pathlim character, if it is the nul\r
     */\r
    for (sc = (u_char *) dp->FileName, dc = pathend;\r
         dc <= pathlim && (*dc++ = *sc++) != EOS;)\r
      continue;\r
\r
    /*\r
     * Have we filled the buffer without seeing EOS?\r
     */\r
    if (dc > pathlim && *pathlim != EOS) {\r
      /*\r
       * Abort when requested by caller, otherwise\r
       * reset pathend back to last SEP and continue\r
       * with next dir entry.\r
       */\r
      if (pglob->gl_flags & GLOB_ERR) {\r
        error = GLOB_ABORTED;\r
        break;\r
      }\r
      else {\r
        *pathend = EOS;\r
        continue;\r
      }\r
    }\r
\r
    if (!match(pathend, pattern, restpattern)) {\r
      *pathend = EOS;\r
      continue;\r
    }\r
    error = glob2(pathbuf, --dc, pathlim, restpattern, pglob,\r
        limit);\r
    if (error)\r
      break;\r
  }\r
\r
  if (pglob->gl_flags & GLOB_ALTDIRFUNC)\r
    (*pglob->gl_closedir)(dirp);\r
  else\r
    closedir(dirp);\r
\r
  /*\r
   * Again Posix X/Open issue with regards to error handling.\r
   */\r
  if ((error || errno) && (pglob->gl_flags & GLOB_ERR))\r
    return GLOB_ABORTED;\r
\r
  return error;\r
}\r
\r
\r
/*\r
 * Extend the gl_pathv member of a glob_t structure to accommodate a new item,\r
 * add the new item, and update gl_pathc.\r
 *\r
 * This assumes the BSD realloc, which only copies the block when its size\r
 * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic\r
 * behavior.\r
 *\r
 * Return 0 if new item added, error code if memory couldn't be allocated.\r
 *\r
 * Invariant of the glob_t structure:\r
 *  Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and\r
 *  gl_pathv points to (gl_offs + gl_pathc + 1) items.\r
 */\r
static int\r
globextend(const Char *path, glob_t *pglob, size_t *limit)\r
{\r
  char **pathv;\r
  size_t i, newsize, len;\r
  char *copy;\r
  const Char *p;\r
\r
  _DIAGASSERT(path != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);\r
  pathv = pglob->gl_pathv ? realloc(pglob->gl_pathv, newsize) :\r
      malloc(newsize);\r
  if (pathv == NULL)\r
    return GLOB_NOSPACE;\r
\r
  if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {\r
    /* first time around -- clear initial gl_offs items */\r
    pathv += pglob->gl_offs;\r
    for (i = pglob->gl_offs + 1; --i > 0; )\r
      *--pathv = NULL;\r
  }\r
  pglob->gl_pathv = pathv;\r
\r
  for (p = path; *p++;)\r
    continue;\r
  len = (size_t)(p - path);\r
  limit[GLOB_INDEX_MALLOC] += len;\r
  if ((copy = malloc(len)) != NULL) {\r
    if (g_Ctoc(path, copy, len)) {\r
      free(copy);\r
      return GLOB_ABORTED;\r
    }\r
    pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;\r
  }\r
  pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;\r
\r
  if ((pglob->gl_flags & GLOB_LIMIT) &&\r
      (newsize + limit[GLOB_INDEX_MALLOC]) >= GLOB_LIMIT_MALLOC) {\r
    errno = 0;\r
    return GLOB_NOSPACE;\r
  }\r
\r
  return copy == NULL ? GLOB_NOSPACE : 0;\r
}\r
\r
\r
/*\r
 * pattern matching function for filenames.  Each occurrence of the *\r
 * pattern causes a recursion level.\r
 */\r
static int\r
match(Char *name, Char *pat, Char *patend)\r
{\r
  int ok, negate_range;\r
  Char c, k;\r
\r
  _DIAGASSERT(name != NULL);\r
  _DIAGASSERT(pat != NULL);\r
  _DIAGASSERT(patend != NULL);\r
\r
  while (pat < patend) {\r
    c = *pat++;\r
    switch (c & M_MASK) {\r
    case M_ALL:\r
      if (pat == patend)\r
        return 1;\r
      do\r
          if (match(name, pat, patend))\r
            return 1;\r
      while (*name++ != EOS);\r
      return 0;\r
    case M_ONE:\r
      if (*name++ == EOS)\r
        return 0;\r
      break;\r
    case M_SET:\r
      ok = 0;\r
      if ((k = *name++) == EOS)\r
        return 0;\r
      if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)\r
        ++pat;\r
      while (((c = *pat++) & M_MASK) != M_END)\r
        if ((*pat & M_MASK) == M_RNG) {\r
          if (c <= k && k <= pat[1])\r
            ok = 1;\r
          pat += 2;\r
        } else if (c == k)\r
          ok = 1;\r
      if (ok == negate_range)\r
        return 0;\r
      break;\r
    default:\r
      if (*name++ != c)\r
        return 0;\r
      break;\r
    }\r
  }\r
  return *name == EOS;\r
}\r
\r
/* Free allocated data belonging to a glob_t structure. */\r
void\r
globfree(glob_t *pglob)\r
{\r
  size_t i;\r
  char **pp;\r
\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if (pglob->gl_pathv != NULL) {\r
    pp = pglob->gl_pathv + pglob->gl_offs;\r
    for (i = pglob->gl_pathc; i--; ++pp)\r
      if (*pp)\r
        free(*pp);\r
    free(pglob->gl_pathv);\r
    pglob->gl_pathv = NULL;\r
    pglob->gl_pathc = 0;\r
  }\r
}\r
\r
static DIR *\r
g_opendir(Char *str, glob_t *pglob)\r
{\r
  char buf[MAXPATHLEN];\r
\r
  _DIAGASSERT(str != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if (!*str)\r
    (void)strlcpy(buf, ".", sizeof(buf));\r
  else {\r
    if (g_Ctoc(str, buf, sizeof(buf)))\r
      return NULL;\r
  }\r
\r
  if (pglob->gl_flags & GLOB_ALTDIRFUNC)\r
    return (*pglob->gl_opendir)(buf);\r
\r
  return opendir(buf);\r
}\r
\r
static int\r
g_lstat(Char *fn, __gl_stat_t *sb, glob_t *pglob)\r
{\r
  char buf[MAXPATHLEN];\r
\r
  _DIAGASSERT(fn != NULL);\r
  _DIAGASSERT(sb != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if (g_Ctoc(fn, buf, sizeof(buf)))\r
    return -1;\r
  if (pglob->gl_flags & GLOB_ALTDIRFUNC)\r
    return (*pglob->gl_lstat)(buf, sb);\r
  return lstat(buf, sb);\r
}\r
\r
static int\r
g_stat(Char *fn, __gl_stat_t *sb, glob_t *pglob)\r
{\r
  char buf[MAXPATHLEN];\r
\r
  _DIAGASSERT(fn != NULL);\r
  _DIAGASSERT(sb != NULL);\r
  _DIAGASSERT(pglob != NULL);\r
\r
  if (g_Ctoc(fn, buf, sizeof(buf)))\r
    return -1;\r
  if (pglob->gl_flags & GLOB_ALTDIRFUNC)\r
    return (*pglob->gl_stat)(buf, sb);\r
  return stat(buf, sb);\r
}\r
\r
static Char *\r
g_strchr(const Char *str, int ch)\r
{\r
\r
  _DIAGASSERT(str != NULL);\r
\r
  do {\r
    if (*str == ch)\r
      return __UNCONST(str);\r
  } while (*str++);\r
  return NULL;\r
}\r
\r
static int\r
g_Ctoc(const Char *str, char *buf, size_t len)\r
{\r
  char *dc;\r
\r
  _DIAGASSERT(str != NULL);\r
  _DIAGASSERT(buf != NULL);\r
\r
  if (len == 0)\r
    return 1;\r
\r
  for (dc = buf; len && (*dc++ = *str++) != EOS; len--)\r
    continue;\r
\r
  return len == 0;\r
}\r
\r
#ifdef DEBUG\r
static void\r
qprintf(const char *str, Char *s)\r
{\r
  Char *p;\r
\r
  _DIAGASSERT(str != NULL);\r
  _DIAGASSERT(s != NULL);\r
\r
  (void)printf("%s:\n", str);\r
  for (p = s; *p; p++)\r
    (void)printf("%c", CHAR(*p));\r
  (void)printf("\n");\r
  for (p = s; *p; p++)\r
    (void)printf("%c", *p & M_PROTECT ? '"' : ' ');\r
  (void)printf("\n");\r
  for (p = s; *p; p++)\r
    (void)printf("%c", ismeta(*p) ? '_' : ' ');\r
  (void)printf("\n");\r
}\r
#endif\r