开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
glob.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：26k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

glob.c：源码内容
  1. /* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public License as
  5.    published by the Free Software Foundation; either version 2 of the
  6.    License, or (at your option) any later version.
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; see the file COPYING.LIB.  If not,
  15.    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16.    Boston, MA 02111-1307, USA.  */
  18. /* AIX requires this to be the first thing in the file.  */
  19. #if defined _AIX && !defined __GNUC__
  20.  #pragma alloca
  21. #endif
  23. /* Enable GNU extensions in glob.h.  */
  24. #ifndef _GNU_SOURCE
  25. # define _GNU_SOURCE 1
  26. #endif
  28. /* Required to tell conf.h not to include the standard ProFTPD
  29.  * header files
  30.  */
  32. #define __PROFTPD_SUPPORT_LIBRARY
  34. #include <conf.h>
  36. #include <errno.h>
  37. #include <sys/types.h>
  38. #include <sys/stat.h>
  40. #include <assert.h>
  41. #include <stdio.h> /* Needed on stupid SunOS for assert. */
  43. #include <libsupp.h>
  45. #undef _LIBC
  46. #undef __GNU_LIBRARY__
  48. #ifndef HAVE_GLOB
  50. /* Comment out all this code if we are using the GNU C Library, and are not
  51.    actually compiling the library itself.  This code is part of the GNU C
  52.    Library, but also included in many other GNU distributions.  Compiling
  53.    and linking in this code is a waste when using the GNU C library
  54.    (especially if it is a shared library).  Rather than having every GNU
  55.    program understand `configure --with-gnu-libc' and omit the object files,
  56.    it is simpler to just do this in the source for each such file.  */
  58. #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
  59. # include <stddef.h>
  60. #endif
  62. #if defined(HAVE_UNISTD_H) || defined(_LIBC)
  63. # include <unistd.h>
  64. # ifndef POSIX
  65. #  ifdef _POSIX_VERSION
  66. #   define POSIX
  67. #  endif
  68. # endif
  69. #endif
  71. #if !defined(_AMIGA) && !defined(VMS) && !defined(WINDOWS32)
  72. # include <pwd.h>
  73. #endif
  75. #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
  76. extern int errno;
  77. #endif
  78. #ifndef __set_errno
  79. # define __set_errno(val) errno = (val)
  80. #endif
  82. #ifndef NULL
  83. # define NULL  0
  84. #endif
  86. #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
  87. # include <dirent.h>
  88. # define NAMLEN(dirent) strlen((dirent)->d_name)
  89. #else 
  90. # define dirent direct
  91. # define NAMLEN(dirent) (dirent)->d_namlen
  92. # ifdef HAVE_SYS_NDIR_H
  93. #  include <sys/ndir.h>
  94. # endif
  95. # ifdef HAVE_SYS_DIR_H
  96. #  include <sys/dir.h>
  97. # endif
  98. # ifdef HAVE_NDIR_H
  99. #  include <ndir.h>
  100. # endif
  101. # ifdef HAVE_VMSDIR_H
  102. #  include "vmsdir.h"  
  103. # endif /* HAVE_VMSDIR_H */
  104. #endif
  106. /* In GNU systems, <dirent.h> defines this macro for us.  */
  107. #ifdef _D_NAMLEN   
  108. # undef NAMLEN
  109. # define NAMLEN(d) _D_NAMLEN(d)
  110. #endif
  112. #ifdef _DIRENT_HAVE_D_TYPE
  113. # define HAVE_D_TYPE 1
  114. #endif
  116. #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
  117. /* Posix does not require that the d_ino field be present, and some
  118.    systems do not provide it. */
  119. # define REAL_DIR_ENTRY(dp) 1
  120. #else
  121. # define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
  122. #endif /* POSIX */
  124. #if defined STDC_HEADERS || defined __GNU_LIBRARY__
  125. # include <stdlib.h>
  126. # include <string.h>
  127. # define        ANSI_STRING
  128. #else   /* No standard headers.  */
  130. extern char *getenv ();
  132. # ifdef HAVE_STRING_H
  133. #  include <string.h>
  134. #  define ANSI_STRING
  135. # else
  136. #  include <strings.h>
  137. # endif
  138. # ifdef HAVE_MEMORY_H
  139. #  include <memory.h>
  140. # endif
  142. #ifndef __osf__
  143. extern char *malloc (), *realloc ();
  144. extern void free (); 
  146. extern void qsort ();
  147. extern void abort (), exit ();
  148. #endif /* __osf__ */
  150. #endif  /* Standard headers.  */
  152. #ifndef ANSI_STRING
  154. # ifndef bzero
  155. extern void bzero ();
  156. # endif
  157. # ifndef bcopy
  158. extern void bcopy ();
  159. # endif
  161. # undef memcpy
  162. # define memcpy(d, s, n)        bcopy ((s), (d), (n))
  163. # undef strrchr
  164. # define strrchr        rindex
  165. /* memset is only used for zero here, but let's be paranoid.  */
  166. # undef memset
  167. # define memset(s, better_be_zero, n) 
  168.   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
  169. #endif  /* Not ANSI_STRING.  */
  171. #if !defined HAVE_STRCOLL && !defined _LIBC
  172. # define strcoll        strcmp
  173. #endif
  175. #if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
  176. # define HAVE_MEMPCPY   1
  177. # define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
  178. #endif
  180. #ifndef __GNU_LIBRARY__
  181. # ifdef __GNUC__
  182. __inline
  183. # endif
  184. # ifndef __SASC
  185. #  ifdef WINDOWS32
  186. static void *
  187. #  else
  188. static char *
  189. # endif
  190. my_realloc (p, n)
  191.      char *p;
  192.      unsigned int n;
  193. {
  194.   /* These casts are the for sake of the broken Ultrix compiler,
  195.      which warns of illegal pointer combinations otherwise.  */
  196.   if (p == NULL)
  197.     return (char *) malloc (n);
  198.   return (char *) realloc (p, n);
  199. }
  200. # define realloc my_realloc
  201. # endif /* __SASC */
  202. #endif /* __GNU_LIBRARY__ */
  205. #if !defined __alloca && !defined __GNU_LIBRARY__
  207. # ifdef __GNUC__
  208. #  undef alloca
  209. #  define alloca(n) __builtin_alloca (n)
  210. # else /* Not GCC.  */
  211. #  ifdef HAVE_ALLOCA_H
  212. #   include <alloca.h>
  213. #  else /* Not HAVE_ALLOCA_H.  */
  214. #   ifndef _AIX
  215. #    ifdef WINDOWS32
  216. #     include <malloc.h>
  217. #    else
  218. extern char *alloca ();
  219. #    endif /* WINDOWS32 */
  220. #   endif /* Not _AIX.  */
  221. #  endif /* sparc or HAVE_ALLOCA_H.  */
  222. # endif /* GCC.  */
  224. # define __alloca alloca
  226. #endif
  228. #ifndef __GNU_LIBRARY__
  229. # define __stat stat
  230. # ifdef STAT_MACROS_BROKEN
  231. #  undef S_ISDIR
  232. # endif
  233. # ifndef S_ISDIR
  234. #  define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
  235. # endif
  236. #endif
  238. #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
  239. # undef size_t
  240. # define size_t unsigned int
  241. #endif
  243. /* Some system header files erroneously define these.
  244.    We want our own definitions from <glob.h> to take precedence.  */
  245. #undef GLOB_ERR
  246. #undef GLOB_MARK
  247. #undef GLOB_NOSORT
  248. #undef GLOB_DOOFFS
  249. #undef GLOB_NOCHECK
  250. #undef GLOB_APPEND
  251. #undef GLOB_NOESCAPE
  252. #undef GLOB_PERIOD
  253. #include "glob.h"
  255. static
  256. #if __GNUC__ - 0 >= 2
  257. inline
  258. #endif
  259. const char *next_brace_sub __P ((const char *begin));
  260. static int glob_in_dir __P ((const char *pattern, const char *directory,
  261.      int flags,
  262.      int (*errfunc) __P ((const char *, int)),
  263.      glob_t *pglob));
  264. static int prefix_array __P ((const char *prefix, char **array, size_t n));
  265. static int collated_compare __P ((const __ptr_t, const __ptr_t));
  268. /* Find the end of the sub-pattern in a brace expression.  We define
  269.    this as an inline function if the compiler permits.  */
  270. static
  271. #if __GNUC__ - 0 >= 2
  272. inline
  273. #endif
  274. const char *
  275. next_brace_sub (begin)
  276.      const char *begin;
  277. {
  278.   unsigned int depth = 0;
  279.   const char *cp = begin;
  281.   while (1)
  282.     {
  283.       if (depth == 0)
  284. {
  285.   if (*cp != ',' && *cp != '}' && *cp != '')
  286.     {
  287.       if (*cp == '{')
  288. ++depth;
  289.       ++cp;
  290.       continue;
  291.     }
  292. }
  293.       else
  294. {
  295.   while (*cp != '' && (*cp != '}' || depth > 0))
  296.     {
  297.       if (*cp == '}')
  298. --depth;
  299.       ++cp;
  300.     }
  301.   if (*cp == '')
  302.     /* An incorrectly terminated brace expression.  */
  303.     return NULL;
  305.   continue;
  306. }
  307.       break;
  308.     }
  310.   return cp;
  311. }
  313. /* Do glob searching for PATTERN, placing results in PGLOB.
  314.    The bits defined above may be set in FLAGS.
  315.    If a directory cannot be opened or read and ERRFUNC is not nil,
  316.    it is called with the pathname that caused the error, and the
  317.    `errno' value from the failing call; if it returns non-zero
  318.    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
  319.    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
  320.    Otherwise, `glob' returns zero.  */
  321. int
  322. glob (pattern, flags, errfunc, pglob)
  323.      const char *pattern;
  324.      int flags;
  325.      int (*errfunc) __P ((const char *, int));
  326.      glob_t *pglob;
  327. {
  328.   const char *filename;
  329.   char *dirname;
  330.   size_t dirlen;
  331.   int status;
  332.   int oldcount;
  334.   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
  335.     {
  336.       __set_errno (EINVAL);
  337.       return -1;
  338.     }
  340.   if (flags & GLOB_BRACE)
  341.     {
  342.       const char *begin = strchr (pattern, '{');
  343.       if (begin != NULL)
  344. {
  345.   /* Allocate working buffer large enough for our work.  Note that
  346.     we have at least an opening and closing brace.  */
  347.   int firstc;
  348.   char *alt_start;
  349.   const char *p;
  350.   const char *next;
  351.   const char *rest;
  352.   size_t rest_len;
  353. #ifdef __GNUC__
  354.   char onealt[strlen (pattern) - 1];
  355. #else
  356.   char *onealt = (char *) malloc (strlen (pattern) - 1);
  357.   if (onealt == NULL)
  358.     {
  359.       if (!(flags & GLOB_APPEND))
  360. globfree (pglob);
  361.       return GLOB_NOSPACE;
  362.     }
  363. #endif
  365.   /* We know the prefix for all sub-patterns.  */
  366. #ifdef HAVE_MEMPCPY
  367.   alt_start = mempcpy (onealt, pattern, begin - pattern);
  368. #else
  369.   memcpy (onealt, pattern, begin - pattern);
  370.   alt_start = &onealt[begin - pattern];
  371. #endif
  373.   /* Find the first sub-pattern and at the same time find the
  374.      rest after the closing brace.  */
  375.   next = next_brace_sub (begin + 1);
  376.   if (next == NULL)
  377.     {
  378.       /* It is an illegal expression.  */
  379. #ifndef __GNUC__
  380.       free (onealt);
  381. #endif
  382.       return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
  383.     }
  385.   /* Now find the end of the whole brace expression.  */
  386.   rest = next;
  387.   while (*rest != '}')
  388.     {
  389.       rest = next_brace_sub (rest + 1);
  390.       if (rest == NULL)
  391. {
  392.   /* It is an illegal expression.  */
  393. #ifndef __GNUC__
  394.   free (onealt);
  395. #endif
  396.   return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
  397. }
  398.     }
  399.   /* Please note that we now can be sure the brace expression
  400.      is well-formed.  */
  401.   rest_len = strlen (++rest) + 1;
  403.   /* We have a brace expression.  BEGIN points to the opening {,
  404.      NEXT points past the terminator of the first element, and END
  405.      points past the final }.  We will accumulate result names from
  406.      recursive runs for each brace alternative in the buffer using
  407.      GLOB_APPEND.  */
  409.   if (!(flags & GLOB_APPEND))
  410.     {
  411.       /* This call is to set a new vector, so clear out the
  412.  vector so we can append to it.  */
  413.       pglob->gl_pathc = 0;
  414.       pglob->gl_pathv = NULL;
  415.     }
  416.   firstc = pglob->gl_pathc;
  418.   p = begin + 1;
  419.   while (1)
  420.     {
  421.       int result;
  423.       /* Construct the new glob expression.  */
  424. #ifdef HAVE_MEMPCPY
  425.       mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
  426. #else
  427.       memcpy (alt_start, p, next - p);
  428.       memcpy (&alt_start[next - p], rest, rest_len);
  429. #endif
  431.       result = glob (onealt,
  432.      ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
  433.       | GLOB_APPEND), errfunc, pglob);
  435.       /* If we got an error, return it.  */
  436.       if (result && result != GLOB_NOMATCH)
  437. {
  438. #ifndef __GNUC__
  439.   free (onealt);
  440. #endif
  441.   if (!(flags & GLOB_APPEND))
  442.     globfree (pglob);
  443.   return result;
  444. }
  446.       if (*next == '}')
  447. /* We saw the last entry.  */
  448. break;
  450.       p = next + 1;
  451.       next = next_brace_sub (p);
  452.       assert (next != NULL);
  453.     }
  455. #ifndef __GNUC__
  456.   free (onealt);
  457. #endif
  459.   if (pglob->gl_pathc != firstc)
  460.     /* We found some entries.  */
  461.     return 0;
  462.   else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
  463.     return GLOB_NOMATCH;
  464. }
  465.     }
  467.   /* Find the filename.  */
  468.   filename = strrchr (pattern, '/');
  469.   if (filename == NULL)
  470.     {
  471.       filename = pattern;
  472. #ifdef _AMIGA
  473.       dirname = (char *) "";
  474. #else
  475.       dirname = (char *) ".";
  476. #endif
  477.       dirlen = 0;
  478.     }
  479.   else if (filename == pattern)
  480.     {
  481.       /* "/pattern".  */
  482.       dirname = (char *) "/";
  483.       dirlen = 1;
  484.       ++filename;
  485.     }
  486.   else
  487.     {
  488.       dirlen = filename - pattern;
  489.       dirname = (char *) __alloca (dirlen + 1);
  490. #ifdef HAVE_MEMPCPY
  491.       *((char *) mempcpy (dirname, pattern, dirlen)) = '';
  492. #else
  493.       memcpy (dirname, pattern, dirlen);
  494.       dirname[dirlen] = '';
  495. #endif
  496.       ++filename;
  497.     }
  499.   if (filename[0] == '' && dirlen > 1)
  500.     /* "pattern/".  Expand "pattern", appending slashes.  */
  501.     {
  502.       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
  503.       if (val == 0)
  504. pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
  505.       return val;
  506.     }
  508.   if (!(flags & GLOB_APPEND))
  509.     {
  510.       pglob->gl_pathc = 0;
  511.       pglob->gl_pathv = NULL;
  512.     }
  514.   oldcount = pglob->gl_pathc;
  516. #ifndef VMS
  517.   if ((flags & GLOB_TILDE) && dirname[0] == '~')
  518.     {
  519.       if (dirname[1] == '' || dirname[1] == '/')
  520. {
  521.   /* Look up home directory.  */
  522.   char *home_dir = getenv ("HOME");
  523. # ifdef _AMIGA
  524.   if (home_dir == NULL || home_dir[0] == '')
  525.     home_dir = "SYS:";
  526. # else
  527. #  ifdef WINDOWS32
  528.   if (home_dir == NULL || home_dir[0] == '')
  529.             home_dir = "c:/users/default"; /* poor default */
  530. #  else
  531.   if (home_dir == NULL || home_dir[0] == '')
  532.     {
  533.       int success;
  534. #   if defined HAVE_GETLOGIN_R || defined _LIBC
  535.       extern int getlogin_r __P ((char *, size_t));
  536.       size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
  537.       char *name;
  539.       if (buflen == 0)
  540. /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
  541.    a moderate value.  */
  542. buflen = 16;
  543.       name = (char *) __alloca (buflen);
  545.       success = getlogin_r (name, buflen) >= 0;
  546. #   else
  547.       extern char *getlogin __P ((void));
  548.       char *name;
  550.       success = (name = getlogin ()) != NULL;
  551. #   endif
  552.       if (success)
  553. {
  554. #   if defined HAVE_GETPWNAM_R || defined _LIBC
  555.   size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
  556.   char *pwtmpbuf;
  557.   struct passwd pwbuf, *p;
  559.   pwtmpbuf = (char *) __alloca (pwbuflen);
  561.   success = (__getpwnam_r (name, &pwbuf, pwtmpbuf,
  562.    pwbuflen, &p) >= 0);
  563. #   else
  564.   struct passwd *p = getpwnam (name);
  565.   success = p != NULL;
  566. #   endif
  567.   if (success)
  568.     home_dir = p->pw_dir;
  569. }
  570.     }
  571.   if (home_dir == NULL || home_dir[0] == '')
  572.     home_dir = (char *) "~"; /* No luck.  */
  573. #  endif /* WINDOWS32 */
  574. # endif
  575.   /* Now construct the full directory.  */
  576.   if (dirname[1] == '')
  577.     dirname = home_dir;
  578.   else
  579.     {
  580.       char *newp;
  581.       size_t home_len = strlen (home_dir);
  582.       newp = (char *) __alloca (home_len + dirlen);
  583. # ifdef HAVE_MEMPCPY
  584.       mempcpy (mempcpy (newp, home_dir, home_len),
  585.        &dirname[1], dirlen);
  586. # else
  587.       memcpy (newp, home_dir, home_len);
  588.       memcpy (&newp[home_len], &dirname[1], dirlen);
  589. # endif
  590.       dirname = newp;
  591.     }
  592. }
  593. # if !defined _AMIGA && !defined WINDOWS32
  594.       else
  595. {
  596.   char *end_name = strchr (dirname, '/');
  597.   char *user_name;
  598.   char *home_dir;
  600.   if (end_name == NULL)
  601.     user_name = dirname + 1;
  602.   else
  603.     {
  604.       user_name = (char *) __alloca (end_name - dirname);
  605. # ifdef HAVE_MEMPCPY
  606.       *((char *) mempcpy (user_name, dirname + 1, end_name - dirname))
  607. = '';
  608. # else
  609.       memcpy (user_name, dirname + 1, end_name - dirname);
  610.       user_name[end_name - dirname - 1] = '';
  611. # endif
  612.     }
  614.   /* Look up specific user's home directory.  */
  615.   {
  616. #  if defined HAVE_GETPWNAM_R || defined _LIBC
  617.     size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
  618.     char *pwtmpbuf = (char *) __alloca (buflen);
  619.     struct passwd pwbuf, *p;
  620.     if (__getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) >= 0)
  621.       home_dir = p->pw_dir;
  622.     else
  623.       home_dir = NULL;
  624. #  else
  625.     struct passwd *p = getpwnam (user_name);
  626.     if (p != NULL)
  627.       home_dir = p->pw_dir;
  628.     else
  629.       home_dir = NULL;
  630. #  endif
  631.   }
  632.   /* If we found a home directory use this.  */
  633.   if (home_dir != NULL)
  634.     {
  635.       char *newp;
  636.       size_t home_len = strlen (home_dir);
  637.       size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
  638.       newp = (char *) __alloca (home_len + rest_len + 1);
  639. #  ifdef HAVE_MEMPCPY
  640.       *((char *) mempcpy (mempcpy (newp, home_dir, home_len),
  641.   end_name, rest_len)) = '';
  642. #  else
  643.       memcpy (newp, home_dir, home_len);
  644.       memcpy (&newp[home_len], end_name, rest_len);
  645.       newp[home_len + rest_len] = '';
  646. #  endif
  647.       dirname = newp;
  648.     }
  649. }
  650. # endif /* Not Amiga && not WINDOWS32.  */
  651.     }
  652. #endif /* Not VMS.  */
  654.   if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
  655.     {
  656.       /* The directory name contains metacharacters, so we
  657.  have to glob for the directory, and then glob for
  658.  the pattern in each directory found.  */
  659.       glob_t dirs;
  660.       register int i;
  662.       status = glob (dirname,
  663.      ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE))
  664.       | GLOB_NOSORT | GLOB_ONLYDIR),
  665.      errfunc, &dirs);
  666.       if (status != 0)
  667. return status;
  669.       /* We have successfully globbed the preceding directory name.
  670.  For each name we found, call glob_in_dir on it and FILENAME,
  671.  appending the results to PGLOB.  */
  672.       for (i = 0; i < dirs.gl_pathc; ++i)
  673. {
  674.   int oldcount;
  676. #ifdef SHELL
  677.   {
  678.     /* Make globbing interruptible in the bash shell. */
  679.     extern int interrupt_state;
  681.     if (interrupt_state)
  682.       {
  683. globfree (&dirs);
  684. globfree (&files);
  685. return GLOB_ABORTED;
  686.       }
  687.   }
  688. #endif /* SHELL.  */
  690.   oldcount = pglob->gl_pathc;
  691.   status = glob_in_dir (filename, dirs.gl_pathv[i],
  692. ((flags | GLOB_APPEND)
  693.  & ~(GLOB_NOCHECK | GLOB_ERR)),
  694. errfunc, pglob);
  695.   if (status == GLOB_NOMATCH)
  696.     /* No matches in this directory.  Try the next.  */
  697.     continue;
  699.   if (status != 0)
  700.     {
  701.       globfree (&dirs);
  702.       globfree (pglob);
  703.       return status;
  704.     }
  706.   /* Stick the directory on the front of each name.  */
  707.   if (prefix_array (dirs.gl_pathv[i],
  708.     &pglob->gl_pathv[oldcount],
  709.     pglob->gl_pathc - oldcount))
  710.     {
  711.       globfree (&dirs);
  712.       globfree (pglob);
  713.       return GLOB_NOSPACE;
  714.     }
  715. }
  717.       flags |= GLOB_MAGCHAR;
  719.       if (pglob->gl_pathc == oldcount)
  720.         {
  721. /* No matches.  */
  722. if (flags & GLOB_NOCHECK)
  723.   {
  724.     size_t len = strlen (pattern) + 1;
  725.     char *patcopy = (char *) malloc (len);
  726.     if (patcopy == NULL)
  727.       return GLOB_NOSPACE;
  728.     memcpy (patcopy, pattern, len);
  730.     pglob->gl_pathv
  731.       = (char **) realloc (pglob->gl_pathv,
  732.    (pglob->gl_pathc +
  733.     ((flags & GLOB_DOOFFS) ?
  734.      pglob->gl_offs : 0) +
  735.     1 + 1) *
  736.    sizeof (char *));
  737.     if (pglob->gl_pathv == NULL)
  738.       {
  739. free (patcopy);
  740. return GLOB_NOSPACE;
  741.       }
  743.     if (flags & GLOB_DOOFFS)
  744.       while (pglob->gl_pathc < pglob->gl_offs)
  745. pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  747.     pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
  748.     pglob->gl_pathv[pglob->gl_pathc] = NULL;
  749.     pglob->gl_flags = flags;
  750.   }
  751. else {
  752.   return GLOB_NOMATCH;
  753.         }
  754.       }
  755.     }
  756.   else
  757.     {
  758.       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
  759.       if (status != 0)
  760. return status;
  762.       if (dirlen > 0)
  763. {
  764.   /* Stick the directory on the front of each name.  */
  765.   if (prefix_array (dirname,
  766.     &pglob->gl_pathv[oldcount],
  767.     pglob->gl_pathc - oldcount))
  768.     {
  769.       globfree (pglob);
  770.       return GLOB_NOSPACE;
  771.     }
  772. }
  773.     }
  775.   if (flags & GLOB_MARK)
  776.     {
  777.       /* Append slashes to directory names.  */
  778.       int i;
  779.       struct stat st;
  780.       for (i = oldcount; i < pglob->gl_pathc; ++i)
  781. if (((flags & GLOB_ALTDIRFUNC) ?
  782.      (*pglob->gl_stat) (pglob->gl_pathv[i], &st) :
  783.      __stat (pglob->gl_pathv[i], &st)) == 0 &&
  784.     S_ISDIR (st.st_mode))
  785.   {
  786.       size_t len = strlen (pglob->gl_pathv[i]) + 2;
  787.     char *new = realloc (pglob->gl_pathv[i], len);
  788.       if (new == NULL)
  789.       {
  790. globfree (pglob);
  791. return GLOB_NOSPACE;
  792.       }
  793.     strncpy (&new[len - 2], "/", 2);
  794.     pglob->gl_pathv[i] = new;
  795.   }
  796.     }
  798.   if (!(flags & GLOB_NOSORT))
  799.     /* Sort the vector.  */
  800.     qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
  801.    pglob->gl_pathc - oldcount,
  802.    sizeof (char *), collated_compare);
  804.   return 0;
  805. }
  808. /* Free storage allocated in PGLOB by a previous `glob' call.  */
  809. void
  810. globfree (pglob)
  811.      register glob_t *pglob;
  812. {
  813.   if (pglob->gl_pathv != NULL)
  814.     {
  815.       register int i;
  816.       for (i = 0; i < pglob->gl_pathc; ++i)
  817. if (pglob->gl_pathv[i] != NULL)
  818.   free ((__ptr_t) pglob->gl_pathv[i]);
  819.       free ((__ptr_t) pglob->gl_pathv);
  820.     }
  821. }
  824. /* Do a collated comparison of A and B.  */
  825. static int
  826. collated_compare (a, b)
  827.      const __ptr_t a;
  828.      const __ptr_t b;
  829. {
  830.   const char *const s1 = *(const char *const * const) a;
  831.   const char *const s2 = *(const char *const * const) b;
  833.   if (s1 == s2)
  834.     return 0;
  835.   if (s1 == NULL)
  836.     return 1;
  837.   if (s2 == NULL)
  838.     return -1;
  839.   return strcoll (s1, s2);
  840. }
  843. /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
  844.    elements in place.  Return nonzero if out of memory, zero if successful.
  845.    A slash is inserted between DIRNAME and each elt of ARRAY,
  846.    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
  847. static int
  848. prefix_array (dirname, array, n)
  849.      const char *dirname;
  850.      char **array;
  851.      size_t n;
  852. {
  853.   register size_t i;
  854.   size_t dirlen = strlen (dirname);
  856.   if (dirlen == 1 && dirname[0] == '/')
  857.     /* DIRNAME is just "/", so normal prepending would get us "//foo".
  858.        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
  859.     dirlen = 0;
  861.   for (i = 0; i < n; ++i)
  862.     {
  863.       size_t eltlen = strlen (array[i]) + 1;
  864.       char *new = (char *) malloc (dirlen + 1 + eltlen);
  865.       if (new == NULL)
  866. {
  867.   while (i > 0)
  868.     free ((__ptr_t) array[--i]);
  869.   return 1;
  870. }
  872. #ifdef HAVE_MEMPCPY
  873.       {
  874. char *endp = (char *) mempcpy (new, dirname, dirlen);
  875. *endp++ = '/';
  876. mempcpy (endp, array[i], eltlen);
  877.       }
  878. #else
  879.       memcpy (new, dirname, dirlen);
  880.       new[dirlen] = '/';
  881.       memcpy (&new[dirlen + 1], array[i], eltlen);
  882. #endif
  883.       free ((__ptr_t) array[i]);
  884.       array[i] = new;
  885.     }
  887.   return 0;
  888. }
  891. /* Return nonzero if PATTERN contains any metacharacters.
  892.    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
  893. int
  894. __glob_pattern_p (pattern, quote)
  895.      const char *pattern;
  896.      int quote;
  897. {
  898.   register const char *p;
  899.   int open = 0;
  901.   for (p = pattern; *p != ''; ++p)
  902.     switch (*p)
  903.       {
  904.       case '?':
  905.       case '*':
  906. return 1;
  908.       case '\':
  909. if (quote && p[1] != '')
  910.   ++p;
  911. break;
  913.       case '[':
  914. open = 1;
  915. break;
  917.       case ']':
  918. if (open)
  919.   return 1;
  920. break;
  921.       }
  923.   return 0;
  924. }
  925. #ifdef _LIBC
  926. weak_alias (__glob_pattern_p, glob_pattern_p)
  927. #endif
  930. /* Like `glob', but PATTERN is a final pathname component,
  931.    and matches are searched for in DIRECTORY.
  932.    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
  933.    The GLOB_APPEND flag is assumed to be set (always appends).  */
  934. static int
  935. glob_in_dir (pattern, directory, flags, errfunc, pglob)
  936.      const char *pattern;
  937.      const char *directory;
  938.      int flags;
  939.      int (*errfunc) __P ((const char *, int));
  940.      glob_t *pglob;
  941. {
  942.   __ptr_t stream;
  944.   struct globlink
  945.     {
  946.       struct globlink *next;
  947.       char *name;
  948.     };
  949.   struct globlink *names = NULL;
  950.   size_t nfound;
  951.   int meta;
  952.   int save;
  954.   stream = ((flags & GLOB_ALTDIRFUNC) ?
  955.       (*pglob->gl_opendir) (directory) :
  956.     (__ptr_t) opendir (directory));
  957.   if (stream == NULL)
  958.     {
  959.       if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
  960.   (flags & GLOB_ERR))
  961. return GLOB_ABORTED;
  962.       nfound = 0;
  963.       meta = 0;
  964.     }
  965.   else if (pattern[0] == '')
  966.     {
  967.       /* This is a special case for matching directories like in
  968.  "*a/".  */
  969.       names = (struct globlink *) __alloca (sizeof (struct globlink));
  970.       names->name = (char *) malloc (1);
  971.       if (names->name == NULL)
  972. goto memory_error;
  973.       names->name[0] = '';
  974.       names->next = NULL;
  975.       nfound = 1;
  976.       meta = 0;
  977.     }
  978.   else
  979.     {
  980.       nfound = 0;
  981.       meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
  982.       if(meta)
  983. flags |= GLOB_MAGCHAR;
  985.       while (1)
  986. {
  987.   const char *name;
  988.   size_t len;
  989.   struct dirent *d = ((flags & GLOB_ALTDIRFUNC) ?
  990.       (*pglob->gl_readdir) (stream) :
  991.       readdir ((DIR *) stream));
  992.   if (d == NULL)
  993.     break;
  994.   if (! REAL_DIR_ENTRY (d))
  995.     continue;
  997. #ifdef HAVE_D_TYPE
  998.   /* If we shall match only directories use the information
  999.      provided by the dirent call if possible.  */
  1000.   if ((flags & GLOB_ONLYDIR)
  1001.       && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR)
  1002.     continue;
  1003. #endif
  1005.   name = d->d_name;
  1007.   if ((!meta && strcmp (pattern, name) == 0)
  1008.       || fnmatch (pattern, name,
  1009.   (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
  1010.   ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
  1011. #ifdef _AMIGA
  1012.   | FNM_CASEFOLD
  1013. #endif
  1014.  ) == 0)
  1015.     {
  1016.       struct globlink *new
  1017. = (struct globlink *) __alloca (sizeof (struct globlink));
  1018.       len = NAMLEN (d);
  1019.       new->name = (char *) malloc (len + 1);
  1020.       if (new->name == NULL)
  1021. goto memory_error;
  1022. #ifdef HAVE_MEMPCPY
  1023.       *((char *) mempcpy ((__ptr_t) new->name, name, len)) = '';
  1024. #else
  1025.       memcpy ((__ptr_t) new->name, name, len);
  1026.       new->name[len] = '';
  1027. #endif
  1028.       new->next = names;
  1029.       names = new;
  1030.       ++nfound;
  1031.       if (!meta)
  1032. break;
  1033.     }
  1034. }
  1035.     }
  1037.   if (nfound == 0 && (flags & GLOB_NOMAGIC) && !meta)
  1038.     flags |= GLOB_NOCHECK;
  1040.   if (nfound == 0 && (flags & GLOB_NOCHECK))
  1041.     {
  1042.       size_t len = strlen (pattern);
  1043.       nfound = 1;
  1044.       names = (struct globlink *) __alloca (sizeof (struct globlink));
  1045.       names->next = NULL;
  1046.       names->name = (char *) malloc (len + 1);
  1047.       if (names->name == NULL)
  1048. goto memory_error;
  1049. #ifdef HAVE_MEMPCPY
  1050.       *((char *) mempcpy (names->name, pattern, len)) = '';
  1051. #else
  1052.       memcpy (names->name, pattern, len);
  1053.       names->name[len] = '';
  1054. #endif
  1055.     }
  1057.   if (nfound != 0)
  1058.     {
  1059.       pglob->gl_pathv
  1060. = (char **) realloc (pglob->gl_pathv,
  1061.      (pglob->gl_pathc +
  1062.       ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
  1063.       nfound + 1) *
  1064.      sizeof (char *));
  1065.       if (pglob->gl_pathv == NULL)
  1066. goto memory_error;
  1068.       if (flags & GLOB_DOOFFS)
  1069. while (pglob->gl_pathc < pglob->gl_offs)
  1070.   pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  1072.       for (; names != NULL; names = names->next)
  1073. pglob->gl_pathv[pglob->gl_pathc++] = names->name;
  1074.       pglob->gl_pathv[pglob->gl_pathc] = NULL;
  1076.       pglob->gl_flags = flags;
  1077.     }
  1079.   save = errno;
  1080.   if(stream) {
  1081.     if (flags & GLOB_ALTDIRFUNC)
  1082.       (*pglob->gl_closedir) (stream);
  1083.     else
  1084.       closedir ((DIR *) stream);
  1085.   }
  1086.   __set_errno (save);
  1088.   return nfound == 0 ? GLOB_NOMATCH : 0;
  1090.  memory_error:
  1091.   {
  1092.     int save = errno;
  1093.     if (flags & GLOB_ALTDIRFUNC)
  1094.       (*pglob->gl_closedir) (stream);
  1095.     else
  1096.       closedir ((DIR *) stream);
  1097.     __set_errno (save);
  1098.   }
  1099.   while (names != NULL)
  1100.     {
  1101.       if (names->name != NULL)
  1102. free ((__ptr_t) names->name);
  1103.       names = names->next;
  1104.     }
  1105.   return GLOB_NOSPACE;
  1106. }
  1108. #endif /* HAVE_GLOB */