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

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

Ftp客户端

开发平台：

Unix_Linux

glob.c：源码内容
  1. /****************************************************************************  
  2.  
  3.   Copyright (c) 1999 WU-FTPD Development Group.  
  4.   All rights reserved.
  5.   
  6.   Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994
  7.     The Regents of the University of California.
  8.   Portions Copyright (c) 1993, 1994 Washington University in Saint Louis.
  9.   Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc.
  10.   Portions Copyright (c) 1989 Massachusetts Institute of Technology.
  11.   Portions Copyright (c) 1998 Sendmail, Inc.
  12.   Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman.
  13.   Portions Copyright (c) 1997 by Stan Barber.
  14.   Portions Copyright (c) 1997 by Kent Landfield.
  15.   Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
  16.     Free Software Foundation, Inc.  
  17.  
  18.   Use and distribution of this software and its source code are governed 
  19.   by the terms and conditions of the WU-FTPD Software License ("LICENSE").
  20.  
  21.   If you did not receive a copy of the license, it may be obtained online
  22.   at http://www.wu-ftpd.org/license.html.
  23.  
  24.   $Id: glob.c,v 1.8 1999/09/21 04:17:06 wuftpd Exp $
  25.  
  26. ****************************************************************************/
  27. /* AIX requires this to be the first thing in the file.  */
  29. #include "../config.h"
  30. #include "../src/config.h"
  32. #if defined _AIX && !defined __GNUC__
  33. #pragma alloca
  34. #endif
  36. #ifdef HAVE_CONFIG_H
  37. #include <config.h>
  38. #endif
  40. /* Enable GNU extensions in glob.h.  */
  41. #ifndef _GNU_SOURCE
  42. #define _GNU_SOURCE 1
  43. #endif
  45. #include <errno.h>
  46. #include <sys/types.h>
  47. #include <sys/stat.h>
  49. /* Outcomment the following line for production quality code.  */
  50. /* #define NDEBUG 1 */
  51. #include <assert.h>
  53. #include <stdio.h> /* Needed on stupid SunOS for assert.  */
  54. #include <unistd.h> /* Needed on stupid SunOS for getlogin. */
  56. /* Comment out all this code if we are using the GNU C Library, and are not
  57.    actually compiling the library itself.  This code is part of the GNU C
  58.    Library, but also included in many other GNU distributions.  Compiling
  59.    and linking in this code is a waste when using the GNU C library
  60.    (especially if it is a shared library).  Rather than having every GNU
  61.    program understand `configure --with-gnu-libc' and omit the object files,
  62.    it is simpler to just do this in the source for each such file.  */
  64. #define GLOB_INTERFACE_VERSION 1
  65. #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
  66. #include <gnu-versions.h>
  67. #if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
  68. #define ELIDE_CODE
  69. #endif
  70. #endif
  72. #ifndef ELIDE_CODE
  74. #if defined STDC_HEADERS || defined __GNU_LIBRARY__
  75. #include <stddef.h>
  76. #endif
  78. #if defined HAVE_UNISTD_H || defined _LIBC
  79. #include <unistd.h>
  80. #ifndef POSIX
  81. #ifdef _POSIX_VERSION
  82. #define POSIX
  83. #endif
  84. #endif
  85. #endif
  87. #if !defined _AMIGA && !defined VMS && !defined WINDOWS32
  88. #include <pwd.h>
  89. #endif
  91. #if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
  92. extern int errno;
  93. #endif
  94. #ifndef __set_errno
  95. #define __set_errno(val) errno = (val)
  96. #endif
  98. #ifndef NULL
  99. #define NULL 0
  100. #endif
  103. #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
  104. #include <dirent.h>
  105. #define NAMLEN(dirent) strlen((dirent)->d_name)
  106. #else
  107. #define dirent direct
  108. #define NAMLEN(dirent) (dirent)->d_namlen
  109. #ifdef HAVE_SYS_NDIR_H
  110. #include <sys/ndir.h>
  111. #endif
  112. #ifdef HAVE_SYS_DIR_H
  113. #include <sys/dir.h>
  114. #endif
  115. #ifdef HAVE_NDIR_H
  116. #include <ndir.h>
  117. #endif
  118. #ifdef HAVE_VMSDIR_H
  119. #include "vmsdir.h"
  120. #endif /* HAVE_VMSDIR_H */
  121. #endif
  124. /* In GNU systems, <dirent.h> defines this macro for us.  */
  125. #ifdef _D_NAMLEN
  126. #undef NAMLEN
  127. #define NAMLEN(d) _D_NAMLEN(d)
  128. #endif
  130. /* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
  131.    if the `d_type' member for `struct dirent' is available.  */
  132. #ifdef _DIRENT_HAVE_D_TYPE
  133. #define HAVE_D_TYPE 1
  134. #endif
  137. #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
  138. /* Posix does not require that the d_ino field be present, and some
  139.    systems do not provide it. */
  140. #define REAL_DIR_ENTRY(dp) 1
  141. #else
  142. #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
  143. #endif /* POSIX */
  145. #if sparc && !__svr4__
  146. #include <string.h>
  147. #include <dirent.h>
  148. #endif
  150. #if defined STDC_HEADERS || defined __GNU_LIBRARY__
  151. #include <stdlib.h>
  152. #include <string.h>
  153. #define ANSI_STRING
  154. #else /* No standard headers.  */
  156. extern char *getenv();
  158. #ifdef HAVE_STRING_H
  159. #include <string.h>
  160. #define ANSI_STRING
  161. #else
  162. #include <strings.h>
  163. #endif
  164. #ifdef HAVE_MEMORY_H
  165. #include <memory.h>
  166. #endif
  168. #endif /* Standard headers.  */
  170. #ifndef HAVE_MEMCPY
  171. #define memcpy(d, s, n) bcopy ((s), (d), (n))
  172. #endif
  173. #ifndef ANSI_STRING
  175. #ifndef bzero
  176. extern void bzero();
  177. #endif
  178. #ifndef bcopy
  179. extern void bcopy();
  180. #endif
  182. #define strrchr rindex
  183. /* memset is only used for zero here, but let's be paranoid.  */
  184. #define memset(s, better_be_zero, n) 
  185.   (((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
  186. #endif /* Not ANSI_STRING.  */
  188. #if !defined HAVE_STRCOLL && !defined _LIBC
  189. #define strcoll strcmp
  190. #endif
  192. #if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
  193. #define HAVE_MEMPCPY 1
  194. #define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
  195. #endif
  198. #ifndef __GNU_LIBRARY__
  199. #ifdef __GNUC__
  200. __inline
  201. #endif
  202. #ifndef __SASC
  203. #ifdef WINDOWS32
  204. static void *
  205. #else
  206. static char *
  207. #endif
  208.      my_realloc(p, n)
  209.      char *p;
  210.      unsigned int n;
  211. {
  212.     /* These casts are the for sake of the broken Ultrix compiler,
  213.        which warns of illegal pointer combinations otherwise.  */
  214.     if (p == NULL)
  215. return (char *) malloc(n);
  216.     return (char *) realloc(p, n);
  217. }
  219. #define realloc my_realloc
  220. #endif /* __SASC */
  221. #endif /* __GNU_LIBRARY__ */
  224. #if !defined __alloca && !defined __GNU_LIBRARY__
  226. #ifdef __GNUC__
  227. #undef alloca
  228. #define alloca(n) __builtin_alloca (n)
  229. #else /* Not GCC.  */
  230. #ifdef HAVE_ALLOCA_H
  231. #include <alloca.h>
  232. #else /* Not HAVE_ALLOCA_H.  */
  233. #ifndef _AIX
  234. #ifdef WINDOWS32
  235. #include <malloc.h>
  236. #else
  237. extern char *alloca();
  238. #endif /* WINDOWS32 */
  239. #endif /* Not _AIX.  */
  240. #endif /* sparc or HAVE_ALLOCA_H.  */
  241. #endif /* GCC.  */
  243. #define __alloca alloca
  245. #endif
  247. #ifndef __GNU_LIBRARY__
  248. #define __stat stat
  249. #ifdef STAT_MACROS_BROKEN
  250. #undef S_ISDIR
  251. #endif
  252. #ifndef S_ISDIR
  253. #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
  254. #endif
  255. #endif
  257. #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
  258. #undef size_t
  259. #define size_t unsigned int
  260. #endif
  262. /* Some system header files erroneously define these.
  263.    We want our own definitions from <fnmatch.h> to take precedence.  */
  264. #undef FNM_CASEFOLD
  265. #undef FNM_NOESCAPE
  266. #undef FNM_PERIOD
  267. #include "../src/wu_fnmatch.h"
  269. /* Some system header files erroneously define these.
  270.    We want our own definitions from <glob.h> to take precedence.  */
  271. #undef GLOB_ERR
  272. #undef GLOB_MARK
  273. #undef GLOB_NOSORT
  274. #undef GLOB_DOOFFS
  275. #undef GLOB_NOCHECK
  276. #undef GLOB_APPEND
  277. #undef GLOB_NOESCAPE
  278. #undef GLOB_PERIOD
  279. #include "wuftpd_glob.h"
  281. static
  282. #if __GNUC__ - 0 >= 2
  283.        inline
  284. #endif
  285. const char *next_brace_sub __P((const char *begin));
  286. static int glob_in_dir __P((const char *pattern, const char *directory,
  287.     int flags,
  288.     int         (*errfunc) __P((const char *, int)),
  289.     glob_t * pglob));
  290. static int prefix_array __P((const char *prefix, char **array, size_t n));
  291. static int collated_compare __P((const __ptr_t, const __ptr_t));
  294. /* Find the end of the sub-pattern in a brace expression.  We define
  295.    this as an inline function if the compiler permits.  */
  296. static
  297. #if __GNUC__ - 0 >= 2
  298.        inline
  299. #endif
  300. const char *
  301.      next_brace_sub(begin)
  302.      const char *begin;
  303. {
  304.     unsigned int depth = 0;
  305.     const char *cp = begin;
  307.     while (1) {
  308. if (depth == 0) {
  309.     if (*cp != ',' && *cp != '}' && *cp != '') {
  310. if (*cp == '{')
  311.     ++depth;
  312. ++cp;
  313. continue;
  314.     }
  315. }
  316. else {
  317.     while (*cp != '' && (*cp != '}' || depth > 0)) {
  318. if (*cp == '}')
  319.     --depth;
  320. ++cp;
  321.     }
  322.     if (*cp == '')
  323. /* An incorrectly terminated brace expression.  */
  324. return NULL;
  326.     continue;
  327. }
  328. break;
  329.     }
  331.     return cp;
  332. }
  334. /* Do glob searching for PATTERN, placing results in PGLOB.
  335.    The bits defined above may be set in FLAGS.
  336.    If a directory cannot be opened or read and ERRFUNC is not nil,
  337.    it is called with the pathname that caused the error, and the
  338.    `errno' value from the failing call; if it returns non-zero
  339.    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
  340.    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
  341.    Otherwise, `glob' returns zero.  */
  342. int glob(pattern, flags, errfunc, pglob)
  343.      const char *pattern;
  344.      int flags;
  345.      int (*errfunc) __P((const char *, int));
  346.      glob_t *pglob;
  347. {
  348.     const char *filename;
  349.     char *dirname;
  350.     size_t dirlen;
  351.     int status;
  352.     int oldcount;
  354.     if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0) {
  355. __set_errno(EINVAL);
  356. return -1;
  357.     }
  359.     if (flags & GLOB_BRACE) {
  360. const char *begin = strchr(pattern, '{');
  361. if (begin != NULL) {
  362.     /* Allocate working buffer large enough for our work.  Note that
  363.        we have at least an opening and closing brace.  */
  364.     int firstc;
  365.     char *alt_start;
  366.     const char *p;
  367.     const char *next;
  368.     const char *rest;
  369.     size_t rest_len;
  370. #ifdef __GNUC__
  371.     char onealt[strlen(pattern) - 1];
  372. #else
  373.     char *onealt = (char *) malloc(strlen(pattern) - 1);
  374.     if (onealt == NULL) {
  375. if (!(flags & GLOB_APPEND))
  376.     globfree(pglob);
  377. return GLOB_NOSPACE;
  378.     }
  379. #endif
  381.     /* We know the prefix for all sub-patterns.  */
  382. #ifdef HAVE_MEMPCPY
  383.     alt_start = mempcpy(onealt, pattern, begin - pattern);
  384. #else
  385.     memcpy(onealt, pattern, begin - pattern);
  386.     alt_start = &onealt[begin - pattern];
  387. #endif
  389.     /* Find the first sub-pattern and at the same time find the
  390.        rest after the closing brace.  */
  391.     next = next_brace_sub(begin + 1);
  392.     if (next == NULL) {
  393. /* It is an illegal expression.  */
  394. #ifndef __GNUC__
  395. free(onealt);
  396. #endif
  397. return glob(pattern, flags & ~GLOB_BRACE, errfunc, pglob);
  398.     }
  400.     /* Now find the end of the whole brace expression.  */
  401.     rest = next;
  402.     while (*rest != '}') {
  403. rest = next_brace_sub(rest + 1);
  404. if (rest == NULL) {
  405.     /* It is an illegal expression.  */
  406. #ifndef __GNUC__
  407.     free(onealt);
  408. #endif
  409.     return glob(pattern, flags & ~GLOB_BRACE, errfunc, pglob);
  410. }
  411.     }
  412.     /* Please note that we now can be sure the brace expression
  413.        is well-formed.  */
  414.     rest_len = strlen(++rest) + 1;
  416.     /* We have a brace expression.  BEGIN points to the opening {,
  417.        NEXT points past the terminator of the first element, and END
  418.        points past the final }.  We will accumulate result names from
  419.        recursive runs for each brace alternative in the buffer using
  420.        GLOB_APPEND.  */
  422.     if (!(flags & GLOB_APPEND)) {
  423. /* This call is to set a new vector, so clear out the
  424.    vector so we can append to it.  */
  425. pglob->gl_pathc = 0;
  426. pglob->gl_pathv = NULL;
  427.     }
  428.     firstc = pglob->gl_pathc;
  430.     p = begin + 1;
  431.     while (1) {
  432. int result;
  434. /* Construct the new glob expression.  */
  435. #ifdef HAVE_MEMPCPY
  436. mempcpy(mempcpy(alt_start, p, next - p), rest, rest_len);
  437. #else
  438. memcpy(alt_start, p, next - p);
  439. memcpy(&alt_start[next - p], rest, rest_len);
  440. #endif
  442. result = glob(onealt,
  443.       ((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))
  444.        | GLOB_APPEND), errfunc, pglob);
  446. /* If we got an error, return it.  */
  447. if (result && result != GLOB_NOMATCH) {
  448. #ifndef __GNUC__
  449.     free(onealt);
  450. #endif
  451.     if (!(flags & GLOB_APPEND))
  452. globfree(pglob);
  453.     return result;
  454. }
  456. if (*next == '}')
  457.     /* We saw the last entry.  */
  458.     break;
  460. p = next + 1;
  461. next = next_brace_sub(p);
  462. assert(next != NULL);
  463.     }
  465. #ifndef __GNUC__
  466.     free(onealt);
  467. #endif
  469.     if (pglob->gl_pathc != firstc)
  470. /* We found some entries.  */
  471. return 0;
  472.     else if (!(flags & (GLOB_NOCHECK | GLOB_NOMAGIC)))
  473. return GLOB_NOMATCH;
  474. }
  475.     }
  477.     /* Find the filename.  */
  478.     filename = strrchr(pattern, '/');
  479.     if (filename == NULL) {
  480. filename = pattern;
  481. #ifdef _AMIGA
  482. dirname = (char *) "";
  483. #else
  484. dirname = (char *) ".";
  485. #endif
  486. dirlen = 0;
  487.     }
  488.     else if (filename == pattern) {
  489. /* "/pattern".  */
  490. dirname = (char *) "/";
  491. dirlen = 1;
  492. ++filename;
  493.     }
  494.     else {
  495. dirlen = filename - pattern;
  496. dirname = (char *) __alloca(dirlen + 1);
  497. #ifdef HAVE_MEMPCPY
  498. *((char *) mempcpy(dirname, pattern, dirlen)) = '';
  499. #else
  500. memcpy(dirname, pattern, dirlen);
  501. dirname[dirlen] = '';
  502. #endif
  503. ++filename;
  504.     }
  506.     if (filename[0] == '' && dirlen > 1)
  507. /* "pattern/".  Expand "pattern", appending slashes.  */
  508.     {
  509. int val = glob(dirname, flags | GLOB_MARK, errfunc, pglob);
  510. if (val == 0)
  511.     pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
  512. return val;
  513.     }
  515.     if (!(flags & GLOB_APPEND)) {
  516. pglob->gl_pathc = 0;
  517. pglob->gl_pathv = NULL;
  518.     }
  520.     oldcount = pglob->gl_pathc;
  522. #ifndef VMS
  523.     if ((flags & GLOB_TILDE) && dirname[0] == '~') {
  524. if (dirname[1] == '' || dirname[1] == '/') {
  525.     /* Look up home directory.  */
  526.     char *home_dir = getenv("HOME");
  527. #ifdef _AMIGA
  528.     if (home_dir == NULL || home_dir[0] == '')
  529. home_dir = "SYS:";
  530. #else
  531. #ifdef WINDOWS32
  532.     if (home_dir == NULL || home_dir[0] == '')
  533. home_dir = "c:/users/default"; /* poor default */
  534. #else
  535.     if (home_dir == NULL || home_dir[0] == '') {
  536. int success;
  537. #if defined HAVE_GETLOGIN_R || defined _LIBC
  538. extern int getlogin_r __P((char *, size_t));
  539. size_t buflen = sysconf(_SC_LOGIN_NAME_MAX) + 1;
  540. char *name;
  542. if (buflen == 0)
  543.     /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
  544.        a moderate value.  */
  545.     buflen = 16;
  546. name = (char *) __alloca(buflen);
  548. success = getlogin_r(name, buflen) >= 0;
  549. #else
  550. /*            extern char *getlogin __P (); */
  551. char *name;
  553. success = (name = getlogin()) != NULL;
  554. #endif
  555. if (success) {
  556. #if defined HAVE_GETPWNAM_R || defined _LIBC
  557.     size_t pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
  558.     char *pwtmpbuf;
  559.     struct passwd pwbuf, *p;
  561.     pwtmpbuf = (char *) __alloca(pwbuflen);
  563.     success = (__getpwnam_r(name, &pwbuf, pwtmpbuf,
  564.     pwbuflen, &p) >= 0);
  565. #else
  566.     struct passwd *p = getpwnam(name);
  567.     success = p != NULL;
  568. #endif
  569.     if (success)
  570. home_dir = p->pw_dir;
  571. }
  572.     }
  573.     if (home_dir == NULL || home_dir[0] == '')
  574. home_dir = (char *) "~"; /* No luck.  */
  575. #endif /* WINDOWS32 */
  576. #endif
  577.     /* Now construct the full directory.  */
  578.     if (dirname[1] == '')
  579. dirname = home_dir;
  580.     else {
  581. char *newp;
  582. size_t home_len = strlen(home_dir);
  583. newp = (char *) __alloca(home_len + dirlen);
  584. #ifdef HAVE_MEMPCPY
  585. mempcpy(mempcpy(newp, home_dir, home_len),
  586. &dirname[1], dirlen);
  587. #else
  588. memcpy(newp, home_dir, home_len);
  589. memcpy(&newp[home_len], &dirname[1], dirlen);
  590. #endif
  591. dirname = newp;
  592.     }
  593. }
  594. #if !defined _AMIGA && !defined WINDOWS32
  595. else {
  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. user_name = (char *) __alloca(end_name - dirname);
  604. #ifdef HAVE_MEMPCPY
  605. *((char *) mempcpy(user_name, dirname + 1, end_name - dirname))
  606.     = '';
  607. #else
  608. memcpy(user_name, dirname + 1, end_name - dirname);
  609. user_name[end_name - dirname - 1] = '';
  610. #endif
  611.     }
  613.     /* Look up specific user's home directory.  */
  614.     {
  615. #if defined HAVE_GETPWNAM_R || defined _LIBC
  616. size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
  617. char *pwtmpbuf = (char *) __alloca(buflen);
  618. struct passwd pwbuf, *p;
  619. if (__getpwnam_r(user_name, &pwbuf, pwtmpbuf, buflen, &p) >= 0)
  620.     home_dir = p->pw_dir;
  621. else
  622.     home_dir = NULL;
  623. #else
  624. struct passwd *p = getpwnam(user_name);
  625. if (p != NULL)
  626.     home_dir = p->pw_dir;
  627. else
  628.     home_dir = NULL;
  629. #endif
  630.     }
  631.     /* If we found a home directory use this.  */
  632.     if (home_dir != NULL) {
  633. char *newp;
  634. size_t home_len = strlen(home_dir);
  635. size_t rest_len = end_name == NULL ? 0 : strlen(end_name);
  636. newp = (char *) __alloca(home_len + rest_len + 1);
  637. #ifdef HAVE_MEMPCPY
  638. *((char *) mempcpy(mempcpy(newp, home_dir, home_len),
  639.    end_name, rest_len)) = '';
  640. #else
  641. memcpy(newp, home_dir, home_len);
  642. memcpy(&newp[home_len], end_name, rest_len);
  643. newp[home_len + rest_len] = '';
  644. #endif
  645. dirname = newp;
  646.     }
  647. }
  648. #endif /* Not Amiga && not WINDOWS32.  */
  649.     }
  650. #endif /* Not VMS.  */
  652.     if (__glob_pattern_p(dirname, !(flags & GLOB_NOESCAPE))) {
  653. /* The directory name contains metacharacters, so we
  654.    have to glob for the directory, and then glob for
  655.    the pattern in each directory found.  */
  656. glob_t dirs;
  657. register int i;
  659. status = glob(dirname,
  660.       ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE))
  661.        | GLOB_NOSORT | GLOB_ONLYDIR),
  662.       errfunc, &dirs);
  663. if (status != 0)
  664.     return status;
  666. /* We have successfully globbed the preceding directory name.
  667.    For each name we found, call glob_in_dir on it and FILENAME,
  668.    appending the results to PGLOB.  */
  669. for (i = 0; i < dirs.gl_pathc; ++i) {
  670.     int oldcount;
  672.     oldcount = pglob->gl_pathc;
  673.     status = glob_in_dir(filename, dirs.gl_pathv[i],
  674.  ((flags | GLOB_APPEND)
  675.   & ~(GLOB_NOCHECK | GLOB_ERR)),
  676.  errfunc, pglob);
  677.     if (status == GLOB_NOMATCH)
  678. /* No matches in this directory.  Try the next.  */
  679. continue;
  681.     if (status != 0) {
  682. globfree(&dirs);
  683. globfree(pglob);
  684. return status;
  685.     }
  687.     /* Stick the directory on the front of each name.  */
  688.     if (prefix_array(dirs.gl_pathv[i],
  689.      &pglob->gl_pathv[oldcount],
  690.      pglob->gl_pathc - oldcount)) {
  691. globfree(&dirs);
  692. globfree(pglob);
  693. return GLOB_NOSPACE;
  694.     }
  695. }
  697. flags |= GLOB_MAGCHAR;
  699. if (pglob->gl_pathc == oldcount)
  700.     /* No matches.  */
  701.     if (flags & GLOB_NOCHECK) {
  702. size_t len = strlen(pattern) + 1;
  703. char *patcopy = (char *) malloc(len);
  704. if (patcopy == NULL)
  705.     return GLOB_NOSPACE;
  706. memcpy(patcopy, pattern, len);
  708. pglob->gl_pathv
  709.     = (char **) realloc(pglob->gl_pathv,
  710. (pglob->gl_pathc +
  711.  ((flags & GLOB_DOOFFS) ?
  712.   pglob->gl_offs : 0) +
  713.  1 + 1) *
  714. sizeof(char *));
  715. if (pglob->gl_pathv == NULL) {
  716.     free(patcopy);
  717.     return GLOB_NOSPACE;
  718. }
  720. if (flags & GLOB_DOOFFS)
  721.     while (pglob->gl_pathc < pglob->gl_offs)
  722. pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  724. pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
  725. pglob->gl_pathv[pglob->gl_pathc] = NULL;
  726. pglob->gl_flags = flags;
  727.     }
  728.     else
  729. return GLOB_NOMATCH;
  730.     }
  731.     else {
  732. status = glob_in_dir(filename, dirname, flags, errfunc, pglob);
  733. if (status != 0)
  734.     return status;
  736. if (dirlen > 0) {
  737.     /* Stick the directory on the front of each name.  */
  738.     if (prefix_array(dirname,
  739.      &pglob->gl_pathv[oldcount],
  740.      pglob->gl_pathc - oldcount)) {
  741. globfree(pglob);
  742. return GLOB_NOSPACE;
  743.     }
  744. }
  745.     }
  747.     if (flags & GLOB_MARK) {
  748. /* Append slashes to directory names.  */
  749. int i;
  750. struct stat st;
  751. for (i = oldcount; i < pglob->gl_pathc; ++i)
  752.     if (((flags & GLOB_ALTDIRFUNC) ?
  753.  (*pglob->gl_stat) (pglob->gl_pathv[i], &st) :
  754.  __stat(pglob->gl_pathv[i], &st)) == 0 &&
  755. S_ISDIR(st.st_mode)) {
  756. size_t len = strlen(pglob->gl_pathv[i]) + 2;
  757. char *new = realloc(pglob->gl_pathv[i], len);
  758. if (new == NULL) {
  759.     globfree(pglob);
  760.     return GLOB_NOSPACE;
  761. }
  762. strcpy(&new[len - 2], "/");
  763. pglob->gl_pathv[i] = new;
  764.     }
  765.     }
  767.     if (!(flags & GLOB_NOSORT))
  768. /* Sort the vector.  */
  769. qsort((__ptr_t) & pglob->gl_pathv[oldcount],
  770.       pglob->gl_pathc - oldcount,
  771.       sizeof(char *), collated_compare);
  773.     return 0;
  774. }
  777. /* Free storage allocated in PGLOB by a previous `glob' call.  */
  778. void globfree(pglob)
  779.      register glob_t *pglob;
  780. {
  781.     if (pglob->gl_pathv != NULL) {
  782. register int i;
  783. for (i = 0; i < pglob->gl_pathc; ++i)
  784.     if (pglob->gl_pathv[i] != NULL)
  785. free((__ptr_t) pglob->gl_pathv[i]);
  786. free((__ptr_t) pglob->gl_pathv);
  787.     }
  788. }
  791. /* Do a collated comparison of A and B.  */
  792. static int collated_compare(a, b)
  793.      const __ptr_t a;
  794.      const __ptr_t b;
  795. {
  796.     const char *const s1 = *(const char *const *const) a;
  797.     const char *const s2 = *(const char *const *const) b;
  799.     if (s1 == s2)
  800. return 0;
  801.     if (s1 == NULL)
  802. return 1;
  803.     if (s2 == NULL)
  804. return -1;
  805.     return strcoll(s1, s2);
  806. }
  809. /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
  810.    elements in place.  Return nonzero if out of memory, zero if successful.
  811.    A slash is inserted between DIRNAME and each elt of ARRAY,
  812.    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
  813. static int prefix_array(dirname, array, n)
  814.      const char *dirname;
  815.      char **array;
  816.      size_t n;
  817. {
  818.     register size_t i;
  819.     size_t dirlen = strlen(dirname);
  821.     if (dirlen == 1 && dirname[0] == '/')
  822. /* DIRNAME is just "/", so normal prepending would get us "//foo".
  823.    We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
  824. dirlen = 0;
  826.     for (i = 0; i < n; ++i) {
  827. size_t eltlen = strlen(array[i]) + 1;
  828. char *new = (char *) malloc(dirlen + 1 + eltlen);
  829. if (new == NULL) {
  830.     while (i > 0)
  831. free((__ptr_t) array[--i]);
  832.     return 1;
  833. }
  835. #ifdef HAVE_MEMPCPY
  836. {
  837.     char *endp = (char *) mempcpy(new, dirname, dirlen);
  838.     *endp++ = '/';
  839.     mempcpy(endp, array[i], eltlen);
  840. }
  841. #else
  842. memcpy(new, dirname, dirlen);
  843. new[dirlen] = '/';
  844. memcpy(&new[dirlen + 1], array[i], eltlen);
  845. #endif
  846. free((__ptr_t) array[i]);
  847. array[i] = new;
  848.     }
  850.     return 0;
  851. }
  854. /* Return nonzero if PATTERN contains any metacharacters.
  855.    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
  856. int __glob_pattern_p(pattern, quote)
  857.      const char *pattern;
  858.      int quote;
  859. {
  860.     register const char *p;
  861.     int open = 0;
  863.     for (p = pattern; *p != ''; ++p)
  864. switch (*p) {
  865. case '?':
  866. case '*':
  867.     return 1;
  869. case '\':
  870.     if (quote && p[1] != '')
  871. ++p;
  872.     break;
  874. case '[':
  875.     open = 1;
  876.     break;
  878. case ']':
  879.     if (open)
  880. return 1;
  881.     break;
  882. }
  884.     return 0;
  885. }
  886. #ifdef _LIBC
  887. weak_alias(__glob_pattern_p, glob_pattern_p)
  888. #endif
  891. /* Like `glob', but PATTERN is a final pathname component,
  892.    and matches are searched for in DIRECTORY.
  893.    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
  894.    The GLOB_APPEND flag is assumed to be set (always appends).  */
  895.      static int
  896.          glob_in_dir(pattern, directory, flags, errfunc, pglob)
  897.      const char *pattern;
  898.      const char *directory;
  899.      int flags;
  900.      int (*errfunc) __P((const char *, int));
  901.      glob_t *pglob;
  902. {
  903.     __ptr_t stream;
  905.     struct globlink {
  906. struct globlink *next;
  907. char *name;
  908.     };
  909.     struct globlink *names = NULL;
  910.     size_t nfound;
  911.     int meta;
  912.     int save;
  914.     stream = ((flags & GLOB_ALTDIRFUNC) ?
  915.       (*pglob->gl_opendir) (directory) :
  916.       (__ptr_t) opendir(directory));
  917.     if (stream == NULL) {
  918. if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
  919.     (flags & GLOB_ERR))
  920.     return GLOB_ABORTED;
  921. nfound = 0;
  922. meta = 0;
  923.     }
  924.     else if (pattern[0] == '') {
  925. /* This is a special case for matching directories like in
  926.    "*a/".  */
  927. names = (struct globlink *) __alloca(sizeof(struct globlink));
  928. names->name = (char *) malloc(1);
  929. if (names->name == NULL)
  930.     goto memory_error;
  931. names->name[0] = '';
  932. names->next = NULL;
  933. nfound = 1;
  934. meta = 0;
  935.     }
  936.     else {
  937. nfound = 0;
  938. meta = __glob_pattern_p(pattern, !(flags & GLOB_NOESCAPE));
  939. if (meta)
  940.     flags |= GLOB_MAGCHAR;
  942. while (1) {
  943.     const char *name;
  944.     size_t len;
  945.     struct dirent *d = ((flags & GLOB_ALTDIRFUNC) ?
  946. (*pglob->gl_readdir) (stream) :
  947. readdir((DIR *) stream));
  948.     if (d == NULL)
  949. break;
  950.     if (!REAL_DIR_ENTRY(d))
  951. continue;
  953. #ifdef HAVE_D_TYPE
  954.     /* If we shall match only directories use the information
  955.        provided by the dirent call if possible.  */
  956.     if ((flags & GLOB_ONLYDIR)
  957. && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR)
  958. continue;
  959. #endif
  961.     name = d->d_name;
  963.     if ((!meta && strcmp(pattern, name) == 0)
  964. || wu_fnmatch(pattern, name,
  965.       (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
  966.       ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
  967. #ifdef _AMIGA
  968.       | FNM_CASEFOLD
  969. #endif
  970. ) == 0) {
  971. struct globlink *new
  972. = (struct globlink *) __alloca(sizeof(struct globlink));
  973. len = NAMLEN(d);
  974. new->name = (char *) malloc(len + 1);
  975. if (new->name == NULL)
  976.     goto memory_error;
  977. #ifdef HAVE_MEMPCPY
  978. *((char *) mempcpy((__ptr_t) new->name, name, len)) = '';
  979. #else
  980. memcpy((__ptr_t) new->name, name, len);
  981. new->name[len] = '';
  982. #endif
  983. new->next = names;
  984. names = new;
  985. ++nfound;
  986. if (!meta)
  987.     break;
  988.     }
  989. }
  990.     }
  992.     if (nfound == 0 && (flags & GLOB_NOMAGIC) && !meta)
  993. flags |= GLOB_NOCHECK;
  995.     if (nfound == 0 && (flags & GLOB_NOCHECK)) {
  996. size_t len = strlen(pattern);
  997. nfound = 1;
  998. names = (struct globlink *) __alloca(sizeof(struct globlink));
  999. names->next = NULL;
  1000. names->name = (char *) malloc(len + 1);
  1001. if (names->name == NULL)
  1002.     goto memory_error;
  1003. #ifdef HAVE_MEMPCPY
  1004. *((char *) mempcpy(names->name, pattern, len)) = '';
  1005. #else
  1006. memcpy(names->name, pattern, len);
  1007. names->name[len] = '';
  1008. #endif
  1009.     }
  1011.     if (nfound != 0) {
  1012. pglob->gl_pathv
  1013.     = (char **) realloc(pglob->gl_pathv,
  1014. (pglob->gl_pathc +
  1015.       ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
  1016.  nfound + 1) *
  1017. sizeof(char *));
  1018. if (pglob->gl_pathv == NULL)
  1019.     goto memory_error;
  1021. if (flags & GLOB_DOOFFS)
  1022.     while (pglob->gl_pathc < pglob->gl_offs)
  1023. pglob->gl_pathv[pglob->gl_pathc++] = NULL;
  1025. for (; names != NULL; names = names->next)
  1026.     pglob->gl_pathv[pglob->gl_pathc++] = names->name;
  1027. pglob->gl_pathv[pglob->gl_pathc] = NULL;
  1029. pglob->gl_flags = flags;
  1030.     }
  1032.     save = errno;
  1033.     if (flags & GLOB_ALTDIRFUNC)
  1034. (*pglob->gl_closedir) (stream);
  1035.     else
  1036. closedir((DIR *) stream);
  1037.     __set_errno(save);
  1039.     return nfound == 0 ? GLOB_NOMATCH : 0;
  1041.   memory_error:
  1042.     {
  1043. int save = errno;
  1044. if (flags & GLOB_ALTDIRFUNC)
  1045.     (*pglob->gl_closedir) (stream);
  1046. else
  1047.     closedir((DIR *) stream);
  1048. __set_errno(save);
  1049.     }
  1050.     while (names != NULL) {
  1051. if (names->name != NULL)
  1052.     free((__ptr_t) names->name);
  1053. names = names->next;
  1054.     }
  1055.     return GLOB_NOSPACE;
  1056. }
  1058. #endif /* Not ELIDE_CODE.  */