ftw.c
上传用户:zibowangxu
上传日期:2007-01-04
资源大小:331k
文件大小:7k
源码类别:

Ftp客户端

开发平台:

Unix_Linux

  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: ftw.c,v 1.9 1999/10/04 13:40:03 wuftpd Exp $
  25.  
  26. ****************************************************************************/
  27. #include "../src/config.h"
  28. #ifdef HAVE_DIRENT_H
  29. #include <dirent.h>
  30. #else
  31. #include <sys/dir.h>
  32. #endif
  33. #include <errno.h>
  34. #include <string.h>
  35. #include <stdlib.h>
  36. #include <sys/param.h>
  37. #include <sys/stat.h>
  38. #include <sys/stat.h>
  39. #include "ftw.h"
  40. #define NODESC -1
  41. #ifdef HAVE_LSTAT
  42. #define ISLINK(sb) ((sb.st_mode&S_IFMT) == S_IFLNK)
  43. #else
  44. #define lstat stat
  45. #endif
  46. #define ISDIR(sb) ((sb.st_mode&S_IFMT) == S_IFDIR)
  47. #define ISDOT(dp) 
  48. (dp->d_name[0] == '.' && (!dp->d_name[1] || 
  49.     (dp->d_name[1] == '.' && !dp->d_name[2])))
  50. extern int errno;
  51. static int g_fds, (*g_fn) (), g_opts;
  52. static char *bp;
  53. int treewalk(char *path, int (*fn) ( /* ??? */ ), int maxfds, int opts);
  54. /*
  55.  * cycle through the directories at the top of the tree, otherwise, once
  56.  * you run out of descriptors you have to keep reusing the same one and
  57.  * it gets *real* slow.
  58.  */
  59. typedef struct d_fd {
  60.     struct d_fd *next;
  61.     DIR *dirp;
  62.     off_t off;
  63. } FD;
  64. static FD *freep, *node;
  65. static int walk(register char *name)
  66. {
  67. #ifdef HAVE_DIRENT_H
  68.     register struct dirent *dp;
  69. #else
  70.     register struct direct *dp;
  71. #endif
  72.     register int rval;
  73.     struct stat sb;
  74.     FD cur;
  75.     char *save;
  76.     if (!freep)
  77. freep = &cur;
  78.     else
  79. node->next = &cur;
  80.     node = &cur;
  81.     cur.off = 0;
  82.   getfd:if (!g_fds) {
  83. freep->off = telldir(freep->dirp);
  84. closedir(freep->dirp);
  85. freep = freep->next;
  86. ++g_fds;
  87.     }
  88.     if (!(cur.dirp = opendir(bp))) {
  89. if (errno == EMFILE) {
  90.     g_fds = 0;
  91.     goto getfd;
  92. }
  93. return (errno == EACCES ? (*g_fn) (bp, &sb, FTW_DNR) : -1);
  94.     }
  95.     else
  96. --g_fds;
  97.     for (; *name; ++name);
  98.     *name++ = '/';
  99.     for (rval = 0, dp = readdir(cur.dirp); dp; dp = readdir(cur.dirp)) {
  100. if (ISDOT(dp))
  101.     continue;
  102. (void) strcpy(name, dp->d_name);
  103. if (lstat(bp, &sb)) {
  104.     rval = errno == EACCES ?
  105. (*g_fn) (bp, &sb, FTW_NS) : -1;
  106.     if (rval)
  107. break;
  108. }
  109. #ifdef HAVE_LSTAT
  110. if (ISLINK(sb) && g_opts & FTW_SYMLINK)
  111.     if (stat(bp, &sb))
  112. continue;
  113. #endif
  114. if (!ISDIR(sb)) {
  115.     rval = (*g_fn) (bp, &sb, FTW_F);
  116.     if (rval)
  117. break;
  118.     continue;
  119. }
  120. if (g_opts & FTW_DIRLAST)
  121. #ifdef HAVE_D_NAMLEN
  122.     save = name + dp->d_namlen;
  123. #else
  124.     save = name + strlen(dp->d_name);
  125. #endif
  126. rval = (*g_fn) (bp, &sb, FTW_D);
  127. if ((rval && rval != NODESC) || (rval = walk(name)))
  128.     break;
  129. if (g_opts & FTW_DIRLAST) {
  130.     *save = '';
  131.     rval = (*g_fn) (dp->d_name, &sb, FTW_D2);
  132.     if (rval)
  133. if (rval == NODESC)
  134.     rval = 0;
  135. else
  136.     break;
  137. }
  138. if (cur.off) {
  139.     *name = '';
  140.     if ((cur.dirp = opendir(bp))) {
  141. seekdir(cur.dirp, cur.off);
  142. /* tricky; if we have to reset the directory pointer we know
  143.  * it's the next one to reuse */
  144. freep = &cur;
  145. --g_fds;
  146.     }
  147.     /* directory moved from under us!!! */
  148.     else {
  149. rval = -1;
  150. break;
  151.     }
  152. }
  153.     }
  154.     closedir(cur.dirp);
  155.     ++g_fds;
  156.     return (rval);
  157. }
  158. static int chwalk(register char *name)
  159. {
  160. #ifdef HAVE_DIRENT_H
  161.     register struct dirent *dp;
  162. #else
  163.     register struct direct *dp;
  164. #endif
  165.     register int rval;
  166.     struct stat sb;
  167.     FD cur;
  168.     char *pwd, *getwd(char *);
  169.     if (!freep)
  170. freep = &cur;
  171.     else
  172. node->next = &cur;
  173.     node = &cur;
  174.     cur.off = 0;
  175.     if (chdir(name))
  176. return (errno == EACCES ? (*g_fn) (name, &sb, FTW_DNR) : -1);
  177.   getfd:if (!g_fds) {
  178. freep->off = telldir(freep->dirp);
  179. closedir(freep->dirp);
  180. freep = freep->next;
  181. ++g_fds;
  182.     }
  183.     if (!(cur.dirp = opendir("."))) {
  184. if (errno == EMFILE) {
  185.     g_fds = 0;
  186.     goto getfd;
  187. }
  188. return (errno == EACCES ? (*g_fn) (".", &sb, FTW_DNR) : -1);
  189.     }
  190.     else
  191. --g_fds;
  192.     for (rval = 0, dp = readdir(cur.dirp); dp; dp = readdir(cur.dirp)) {
  193. if (ISDOT(dp))
  194.     continue;
  195. if (lstat(dp->d_name, &sb)) {
  196.     rval = errno == EACCES ?
  197. (*g_fn) (dp->d_name, &sb, FTW_NS) : -1;
  198.     if (rval)
  199. break;
  200. }
  201. pwd = NULL;
  202. #ifdef HAVE_LSTAT
  203. if (ISLINK(sb) && g_opts & FTW_SYMLINK) {
  204.     if (stat(dp->d_name, &sb))
  205. continue;
  206.     if (ISDIR(sb)) {
  207. /* NOSTRICT */
  208. if (!(pwd = malloc((u_int) MAXPATHLEN))) {
  209.     rval = -1;
  210.     break;
  211. }
  212. if (!getwd(pwd)) {
  213.     rval = -1;
  214.     break;
  215. }
  216.     }
  217. }
  218. #endif
  219. if (!ISDIR(sb)) {
  220.     rval = (*g_fn) (dp->d_name, &sb, FTW_F);
  221.     if (rval)
  222. break;
  223.     continue;
  224. }
  225. rval = (*g_fn) (dp->d_name, &sb, FTW_D);
  226. if ((rval && rval != NODESC) || (rval = chwalk(dp->d_name)))
  227.     break;
  228. if (g_opts & FTW_DIRLAST) {
  229.     rval = (*g_fn) (dp->d_name, &sb, FTW_D2);
  230.     if (rval)
  231. if (rval == NODESC)
  232.     rval = 0;
  233. else
  234.     break;
  235. }
  236. if (pwd && chdir(pwd)) {
  237.     rval = -1;
  238.     break;
  239. }
  240. if (cur.off) {
  241.     if ((cur.dirp = opendir("."))) {
  242. seekdir(cur.dirp, cur.off);
  243. /* tricky; if we have to reset the directory pointer we know
  244.  * it's the next one to reuse */
  245. freep = &cur;
  246. --g_fds;
  247.     }
  248.     /* directory moved from under us!!! */
  249.     else {
  250. rval = -1;
  251. break;
  252.     }
  253. }
  254.     }
  255.     closedir(cur.dirp);
  256.     ++g_fds;
  257.     if (chdir(".."))
  258. return (-1);
  259.     return (rval);
  260. }
  261. #ifndef HAVE_FTW
  262. /* S5 compatible ftw(BA_LIB) */
  263. int ftw(char *path, int (*fn) ( /* ??? */ ), int maxfds)
  264. {
  265.     return (treewalk(path, fn, maxfds, 0));
  266. }
  267. #endif
  268. int treewalk(char *path, int (*fn) ( /* ??? */ ), int maxfds, int opts)
  269. {
  270.     struct stat sb;
  271.     int rval;
  272.     char *pwd, *getwd(char *);
  273.     if (lstat(path, &sb))
  274. return (errno == EACCES ? (*fn) (path, &sb, FTW_NS) : -1);
  275.     pwd = NULL;
  276. #ifdef HAVE_LSTAT
  277.     if (ISLINK(sb) && opts & FTW_SYMLINK) {
  278. if (stat(path, &sb))
  279.     return (0);
  280. if (ISDIR(sb)) {
  281.     /* NOSTRICT */
  282.     if (!(pwd = malloc((u_int) MAXPATHLEN)))
  283. return (-1);
  284.     if (!getwd(pwd))
  285. return (-1);
  286. }
  287.     }
  288. #endif
  289.     if (!ISDIR(sb))
  290. return ((*fn) (path, &sb, FTW_F));
  291.     if (!maxfds)
  292. return (-1);
  293.     g_fds = maxfds == -1 ? getdtablesize() : maxfds;
  294.     g_fn = fn;
  295.     g_opts = opts;
  296.     if (!(opts & FTW_CHDIR) && !(bp = malloc((u_int) MAXPATHLEN))) {
  297. errno = ENOMEM;
  298. return (-1);
  299.     }
  300.     rval = (*fn) (path, &sb, FTW_D);
  301.     if (rval == NODESC)
  302. rval = 0;
  303.     else if (!rval) {
  304. if (opts & FTW_CHDIR)
  305.     rval = chwalk(path);
  306. else
  307.     rval = walk(strcpy(bp, path));
  308. if (!rval && opts & FTW_DIRLAST) {
  309.     rval = (*fn) (path, &sb, FTW_D2);
  310.     if (rval == NODESC)
  311. rval = 0;
  312. }
  313.     }
  314.     if (pwd && chdir(pwd))
  315. return (-1);
  316.     return (rval);
  317. }