读目录

Posted fireway

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了读目录相关的知识，希望对你有一定的参考价值。

读目录

头文件<dirent.h>相关函数介绍

    对某个目录具有访问权限的任何用户都可以读目录
    但是，为了防止文件系统产生混乱，只有内核才能写目录
    一个目录的写权限位和执行权限位决定了在该目录中能否创建新文件以及删除文件，并不是能否写目录本身
    UNIX现在包含了一套与目录有关的程序，它们是POSIX.1的一部分。很多实现阻止应用程序使用read函数去读取目录的内容，由此进一步将应用程序与目录中实现相关的细节隔离。
  1. #include <dirent.h>
  3. DIR *opendir(const char *pathname);
  4. DIR *fdopendir(int fd);
  5.                                                      Both return: pointer if OK, NULL on error
  7. struct dirent *readdir(DIR *dp);
  8.                                       Returns: pointer if OK, NULL at end of directory or error
  10. void rewinddir(DIR *dp);
  11. int closedir(DIR *dp);
  13.                                                                   Returns: 0 if OK, ?1 on error
  15. long telldir(DIR *dp);
  16.                                       Returns: current location in directory associated with dp
  18. void seekdir(DIR *dp, long loc);
图1 <dirent.h>文件里的函数原型
  telldir和seekdir函数不是基本POSIX.1标准组成部分，是Single UNIX Specification中的XSI扩展
    定义在<dirent.h>头文件中的dirent结构与实现有关，实现此结构体的定义至少包含下列两个成员：
ino_t d_ino;                  /* i-node number */
char  d_name[];           /* null-terminated filename */
    注意，d_name项的大小没有指定，但必须保证它能包含至少NAME_MAX个字节（不包含终止null字节）
    DIR结构是一个内部结构，上述7个函数用这个内部结构保存当前正在被读的目录的有关信息
    由opendir和fdopendir返回的指向DIR结构的指针由另外5个函数使用
    opendir执行初始化操作，使第一个readdir返回目录中的第一个目录项
    注意，目录中各个目录项的顺序与实现有关，它们通常并不按字母顺序排序

实例

    编写一个遍历文件层次结构的程序，并统计各种类型文件的数量
  1. /**
  2.  * 文件内容： 编写一个遍历文件层次结构的程序，并统计各种类型文件的数量
  3.  * 文件时间： 2016年 11月 13日 星期日 15:30:31 CST
  4.  * 作者： [email protected]
  5.  */
  6. #include <stdio.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <unistd.h>
  10. #include <dirent.h>
  11. #include <string.h>
  12. #include <stdarg.h>    // ISO C variable aruments
  13. #include <stdlib.h>
  14. #include <errno.h>

  16. #define MAXLINE 4096    // max line length 

  18. // function type that is called for each filename
  19. typedef	int	MyFunc(const char *, const struct stat *, int);
  21. static MyFunc g_myFunc;
  23. static char *g_fullPath;
  24. static size_t g_pathLen;
  26. static long g_nTotal = 0L;
  27. static long g_nReg = 0L;
  28. static long g_nDir = 0L;
  29. static long g_nBlk = 0L;
  30. static long g_nChr = 0L;
  31. static long g_nFifo = 0L;
  32. static long g_nSlink = 0L;
  33. static long g_nSock = 0L;
  35. #define FTW_F 1    /* file other than directory */
  36. #define FTW_D 2    /* directory */
  37. #define FTW_DNR 3  /* directory that can‘t be read */
  38. #define FTW_NS 4   /* file that we can‘t stat */
  40. static void	err_doit(int, int, const char *, va_list);
  41. static int myFtw(char *, MyFunc *);
  42. static int doPath(MyFunc *myFunc);
  44. /**
  45.  * Print a message and return to caller.
  46.  * Caller specifies "errnoflag".
  47.  */
  48. static void err_doit(int errnoflag, int error, const char *fmt, va_list ap)
  49. {
  50.     char buf[MAXLINE] = { 0 };
  52.     vsnprintf(buf, MAXLINE - 1, fmt, ap);
  53.     if (errnoflag)
  54.     {
  55.         snprintf(buf+strlen(buf), MAXLINE-strlen(buf)-1, ": %s",
  56.                  strerror(error));
  57.     }
  58.     strcat(buf, "\n");
  59.     fflush(stdout);		/* in case stdout and stderr are the same */
  60.     fputs(buf, stderr);
  61.     fflush(NULL);		/* flushes all stdio output streams */
  62. }
  64. /**
  65.  * Fatal error unrelated to a system call.
  66.  * Print a message and terminate.
  67.  */
  68. static void err_quit(const char *fmt, ...)
  69. {
  70.     va_list		ap;
  72.     va_start(ap, fmt);
  73.     err_doit(0, 0, fmt, ap);
  74.     va_end(ap);
  75.     exit(1);
  76. }
  78. /**
  79.  * Nonfatal error related to a system call.
  80.  * Print a message and return.
  81.  */
  82. static void err_ret(const char *fmt, ...)
  83. {
  84.     va_list		ap;
  86.     va_start(ap, fmt);
  87.     err_doit(1, errno, fmt, ap);
  88.     va_end(ap);
  89. }
  91. /**
  92.  * Fatal error related to a system call.
  93.  * Print a message and terminate.
  94.  */
  95. static void err_sys(const char *fmt, ...)
  96. {
  97.     va_list		ap;
  99.     va_start(ap, fmt);
  100.     err_doit(1, errno, fmt, ap);
  101.     va_end(ap);
  102.     exit(1);
  103. }
  105. /**
  106.  * Fatal error related to a system call.
  107.  * Print a message, dump core, and terminate.
  108.  */
  109. static void err_dump(const char *fmt, ...)
  110. {
  111.     va_list		ap;
  113.     va_start(ap, fmt);
  114.     err_doit(1, errno, fmt, ap);
  115.     va_end(ap);
  116.     abort();		/* dump core and terminate */
  117.     exit(1);		/* shouldn‘t get here */
  118. }
  120. int main(int argc, char ** argv)
  121. {
  122.     int ret = 0;
  124.     if (argc != 2)
  125.     {
  126.         err_quit("usage: ftw <starting-pathname>");
  127.     }
  129.     ret = myFtw(argv[1], g_myFunc);
  131.     g_nTotal = g_nReg + g_nDir + g_nBlk + g_nChr + g_nFifo + g_nSlink + g_nSock;
  132.     if (0 == g_nTotal)
  133.     {
  134.         g_nTotal = 1L;
  135.     }
  136.     printf("regular files  = %7ld,     %5.2f %%\n", g_nReg, g_nReg * 100.0 / g_nTotal);
  137.     printf("directories    = %7ld,     %5.2f %%\n", g_nDir, g_nDir * 100.0 / g_nTotal);
  138.     printf("block special  = %7ld,     %5.2f %%\n", g_nBlk, g_nBlk * 100.0 / g_nTotal);
  139.     printf("char special   = %7ld,     %5.2f %%\n", g_nChr, g_nChr * 100.0 / g_nTotal);
  140.     printf("FIFOS          = %7ld,     %5.2f %%\n", g_nFifo, g_nFifo * 100.0 / g_nTotal);
  141.     printf("symbolic links = %7ld,     %5.2f %%\n", g_nSlink, g_nSlink * 100.0 / g_nTotal);
  142.     printf("sockets        = %7ld,     %5.2f %%\n", g_nSock, g_nSock * 100.0 / g_nTotal);
  144.     // remember free
  145.     if (g_fullPath != NULL)
  146.     {
  147.         free(g_fullPath);
  148.         g_fullPath = NULL;
  149.     }
  151.     exit(ret);
  152. }
  154. static long	g_posix_version = 0L;
  155. static long g_xsi_version = 0L;
  157. #ifdef	PATH_MAX
  158. static long	g_pathMax = PATH_MAX;
  159. #else
  160. static long	g_pathMax = 0;
  161. #endif
  163. /* If PATH_MAX is indeterminate, no guarantee this is adequate */
  164. #define	PATH_MAX_GUESS	1024
  166. char *path_alloc(size_t *sizep)
  167. {
  168.     char *ptr = NULL;
  169.     size_t size = 0;
  171.     if (g_posix_version == 0)
  172.     {
  173.         g_posix_version = sysconf(_SC_VERSION);
  174.     }
  176.     if (g_xsi_version == 0)
  177.     {
  178.         g_xsi_version = sysconf(_SC_XOPEN_VERSION);
  179.     }
  181.     if (g_pathMax == 0)
  182.     {
  183.         /* first time through */
  184.         errno = 0;
  185.         if ((g_pathMax = pathconf("/", _PC_PATH_MAX)) < 0)
  186.         {
  187.             if (errno == 0)
  188.             {
  189.                 g_pathMax = PATH_MAX_GUESS;	/* it‘s indeterminate */
  190.             }
  191.             else
  192.             {
  193.                 err_sys("pathconf error for _PC_PATH_MAX");
  194.             }
  195.         }
  196.         else
  197.         {
  198.             g_pathMax++;		/* add one since it‘s relative to root */
  199.         }
  200.     }
  202.     /*
  203.      * Before POSIX.1-2001, we aren‘t guaranteed that PATH_MAX includes
  204.      * the terminating null byte.  Same goes for XPG3.
  205.      */
  206.     if ((g_posix_version < 200112L) && (g_xsi_version < 4))
  207.     {
  208.         size = g_pathMax + 1;
  209.     }
  210.     else
  211.     {
  212.         size = g_pathMax;
  213.     }
  215.     if ((ptr = malloc(size)) == NULL)
  216.     {
  217.         err_sys("malloc error for pathname");
  218.     }
  219.     if ((ptr = memset(ptr, 0, size)) == NULL)
  220.     {
  221.         err_sys("memset error for pathname");
  222.     }
  224.     if (sizep != NULL)
  225.     {
  226.         *sizep = size;
  227.     }
  229.     return(ptr);
  230. }
  232. static int myFtw(char *pathName, MyFunc *myFunc)
  233. {
  234.     g_fullPath = path_alloc(&g_pathLen);
  235.     if (g_pathLen < strlen(pathName))
  236.     {
  237.         g_pathLen = strlen(pathName) * 2;
  238.         if (realloc(g_fullPath, g_pathLen) == NULL)
  239.         {
  240.             err_sys("realloc failed");
  241.         }
  242.     }
  243.     strcpy(g_fullPath, pathName);
  244.     return doPath(myFunc);
  245. }
  247. /**
  248.  * we return whatever myFunc return
  249.  */
  250. static int doPath(MyFunc *myFunc)
  251. {
  252.     struct stat statBuf;
  254.     if (lstat(g_fullPath, &statBuf) < 0) // stat error
  255.     {
  256.         return myFunc(g_fullPath, &statBuf, FTW_NS);
  257.     }
  258.     if (S_ISDIR(statBuf.st_mode) == 0)  // not a diretctory
  259.     {
  260.         return myFunc(g_fullPath, &statBuf, FTW_F);
  261.     }
  263.     // It‘s a directory, first call myFunc() for the directory,
  264.     // then process each filename in the directory.
  265.     int ret = 0;
  266.     if (ret = myFunc(g_fullPath, &statBuf, FTW_D) != 0)
  267.     {
  268.         return ret;
  269.     }
  271.     int n = strlen(g_fullPath);
  272.     if (n + NAME_MAX + 2 > g_pathLen)   // expand path buffer
  273.     {
  274.         g_pathLen *= 2;
  275.         if ((g_fullPath = realloc(g_fullPath, g_pathLen)) == NULL)
  276.         {
  277.             err_sys("realloc failed");
  278.         }
  279.     }
  280.     g_fullPath[n++] = ‘/‘;
  281.     g_fullPath[n] = ‘\0‘;
  283.     DIR *dp = NULL;
  284.     if ((dp = opendir(g_fullPath)) == NULL) // can‘t read directory
  285.     {
  286.         return myFunc(g_fullPath, &statBuf, FTW_DNR);
  287.     }
  289.     struct dirent *pDir = NULL;
  290.     while((pDir = readdir(dp)) != NULL)
  291.     {
  292.         if (0 == strcmp(".", pDir->d_name) || 0 == strcmp("..", pDir->d_name))
  293.         {
  294.             continue; // ignore dot and dot-dot
  295.         }
  296.         strcpy(&(g_fullPath[n]), pDir->d_name); // append name after "/"
  297.         if ((ret = doPath(myFunc)) != 0) // recursive
  298.         {
  299.             break; // time to leave
  300.         }
  301.     }
  303.     g_fullPath[n - 1] = ‘\0‘; // erase everything from slash onward
  305.     if (closedir(dp) < 0)
  306.     {
  307.         err_ret("can‘t close directory %s", g_fullPath);
  308.     }
  309.     return ret;
  310. }
  312. static int ftw_f(const char *pathName, const struct stat *statPtr, int type)
  313. {
  314.     switch(statPtr->st_mode & S_IFMT)
  315.     {
  316.     case S_IFREG:
  317.         g_nReg++;
  318.         break;
  319.     case S_IFBLK:
  320.         g_nBlk++;
  321.         break;
  322.     case S_IFCHR:
  323.         g_nChr++;
  324.         break;
  325.     case S_IFIFO:
  326.         g_nFifo++;
  327.         break;
  328.     case S_IFLNK:
  329.         g_nSlink++;
  330.         break;
  331.     case S_IFSOCK:
  332.         g_nSock++;
  333.         break;
  334.     case S_IFDIR: // directories should have type = FTW_D
  335.         err_dump("for S_IFDIR for %s, directories should have type = FTW_D", pathName);
  336.         break;
  337.     default:
  338.         err_dump("%s unknown type %d for pathname %s", __FUNCTION__, type, pathName);
  339.         break;
  340.     }
  341. }
  343. static int g_myFunc(const char *pathName, const struct stat *statPtr, int type)
  344. {
  345.     switch (type)
  346.     {
  347.     case FTW_F:
  348.         ftw_f(pathName, statPtr, type);
  349.         break;
  350.     case FTW_D:
  351.         g_nDir++;
  352.         break;
  353.     case FTW_DNR:
  354.         err_ret("can‘t read directory %s", pathName);
  355.         break;
  356.     case FTW_NS:
  357.         err_ret("stat error for %s", pathName);
  358.         break;
  359.     default:
  360.         err_dump("%s unknown type %d for pathname %s", __FUNCTION__, type, pathName);
  361.         break;
  362.     }
  364.     return 0;
  365. }
图2. 递归降序遍历目录层次结构，并按文件类型计数
    程序运行如下：
$ ./a.out  .
regular files  =       4,     33.33 %
directories    =       6,     50.00 %
block special  =       0,      0.00 %
char special   =       0,      0.00 %
FIFOS          =       0,      0.00 %
symbolic links =       2,     16.67 %
sockets        =       0,      0.00 %

参考

UNIX环境高级编程（第三版）    4.22 读目录

 

以上是关于读目录的主要内容，如果未能解决你的问题，请参考以下文章

如何进行 Java 代码阅读分析？

[Go] 通过 17 个简短代码片段，切底弄懂 channel 基础

C# 获得目录创建时间的源码片段

ReentrantReadWriteLock场景应用

VsCode 代码片段-提升研发效率

读构建之法第十七章有感（作业四）