目录递归读取

最新推荐文章于 2019-09-02 09:21:34 发布

wangcjlj_tc

最新推荐文章于 2019-09-02 09:21:34 发布

阅读量401

点赞数

文章标签： hierarchy struct sockets each file path

本文链接：https://blog.csdn.net/wangcjlj_tc/article/details/1711159

版权

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>

typedef int Myfunc(const char *, const struct stat *, int);
/* function type that's called for each filename */

static Myfunc myfunc;
static int myftw(char *, Myfunc *);
static int dopath(Myfunc *);

static long nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;

int
main(int argc, char *argv[])
{
int ret;

if (argc != 2)
    {
  fprintf(stderr,"usage: ftw <starting-pathname>");
        exit(0);
    }

ret = myftw(argv[1], myfunc); /* does it all */

if ( (ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock) == 0)
  ntot = 1;  /* avoid divide by 0; print 0 for all counts */
printf("regular files = %7ld, %5.2f %%/n", nreg, nreg*100.0/ntot);
printf("directories    = %7ld, %5.2f %%/n", ndir, ndir*100.0/ntot);
printf("block special = %7ld, %5.2f %%/n", nblk, nblk*100.0/ntot);
printf("char special   = %7ld, %5.2f %%/n", nchr, nchr*100.0/ntot);
printf("FIFOs          = %7ld, %5.2f %%/n", nfifo, nfifo*100.0/ntot);
printf("symbolic links = %7ld, %5.2f %%/n", nslink,nslink*100.0/ntot);
printf("sockets        = %7ld, %5.2f %%/n", nsock, nsock*100.0/ntot);

return(ret);
}

/*
* Descend through the hierarchy, starting at "pathname".
* The caller's func() is called for every file.
*/

#define FTW_F 1  /* file other than directory */
#define FTW_D 2  /* directory */
#define FTW_DNR 3  /* directory that can't be read */
#define FTW_NS 4  /* file that we can't stat */

static char *fullpath; /* contains full pathname for every file */

static int     /* we return whatever func() returns */
myftw(char *pathname, Myfunc *func)
{
fullpath = (char *)malloc(PATH_MAX+1); /* malloc's for PATH_MAX+1 bytes */
         /* ({Prog pathalloc}) */
strcpy(fullpath, pathname);  /* initialize fullpath */

return(dopath(func));
}
/*
* Descend through the hierarchy, starting at "fullpath".
* If "fullpath" is anything other than a directory, we lstat() it,
* call func(), and return. For a directory, we call ourself
* recursively for each name in the directory.
*/
static int     /* we return whatever func() returns */
dopath(Myfunc* func)
{
struct stat  statbuf;
struct dirent *dirp;
DIR    *dp;
int    ret;
char   *ptr;

if (lstat(fullpath, &statbuf) < 0)
return(func(fullpath, &statbuf, FTW_NS)); /* stat error */

if (S_ISDIR(statbuf.st_mode) == 0)
return(func(fullpath, &statbuf, FTW_F)); /* not a directory */

/*
* It's a directory. First call func() for the directory,
* then process each filename in the directory.
*/

if ( (ret = func(fullpath, &statbuf, FTW_D)) != 0)
return(ret);

ptr = fullpath + strlen(fullpath); /* point to end of fullpath */
*ptr++ = '/';
*ptr = 0;

if ( (dp = opendir(fullpath)) == NULL)
return(func(fullpath, &statbuf, FTW_DNR));
/* can't read directory */

while ( (dirp = readdir(dp)) != NULL) {
  if (strcmp(dirp->d_name, ".") == 0 ||
      strcmp(dirp->d_name, "..") == 0)
    continue;  /* ignore dot and dot-dot */

strcpy(ptr, dirp->d_name); /* append name after slash */

if ( (ret = dopath(func)) != 0) /* recursive */
break; /* time to leave */
}
ptr[-1] = 0; /* erase everything from slash onwards */

if (closedir(dp) < 0)
fprintf(stderr,"can't close directory %s", fullpath);

return(ret);
}
static int
myfunc(const char *pathname, const struct stat *statptr, int type)
{
switch (type) {
case FTW_F:
  switch (statptr->st_mode & S_IFMT) {
  case S_IFREG: nreg++;  break;
  case S_IFBLK: nblk++;  break;
  case S_IFCHR: nchr++;  break;
  case S_IFIFO:  nfifo++;  break;
  case S_IFLNK: nslink++; break;
  case S_IFSOCK: nsock++; break;
  case S_IFDIR:
   fprintf(stderr,"for S_IFDIR for %s", pathname);
     /* directories should have type = FTW_D */
  }
  break;