读目录

读目录

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

    对某个目录具有访问权限的任何用户都可以读目录

    但是，为了防止文件系统产生混乱，只有内核才能写目录

    一个目录的写权限位和执行权限位决定了在该目录中能否创建新文件以及删除文件，并不是能否写目录本身

    UNIX现在包含了一套与目录有关的程序，它们是POSIX.1的一部分。很多实现阻止应用程序使用read函数去读取目录的内容，由此进一步将应用程序与目录中实现相关的细节隔离。

1. #include<dirent.h>
3. DIR*opendir(constchar*pathname);
4. DIR*fdopendir(int fd);
5. Bothreturn: 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:0if 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. * 作者： firewaywei@126.com
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>
15.  
16. #define MAXLINE 4096// max line length
17.  
18. // function type that is called for each filename
19. typedefintMyFunc(constchar*,conststruct stat *,int);
21. staticMyFunc g_myFunc;
23. staticchar*g_fullPath;
24. staticsize_t g_pathLen;
26. staticlong g_nTotal =0L;
27. staticlong g_nReg =0L;
28. staticlong g_nDir =0L;
29. staticlong g_nBlk =0L;
30. staticlong g_nChr =0L;
31. staticlong g_nFifo =0L;
32. staticlong g_nSlink =0L;
33. staticlong 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. staticvoid err_doit(int,int,constchar*, va_list);
41. staticint myFtw(char*,MyFunc*);
42. staticint doPath(MyFunc*myFunc);
44. /**
45. * Print a message and return to caller.
46. * Caller specifies "errnoflag".
47. */
48. staticvoid err_doit(int errnoflag,int error,constchar*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," ");
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. staticvoid err_quit(constchar*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. staticvoid err_ret(constchar*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. staticvoid err_sys(constchar*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. staticvoid err_dump(constchar*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 %% ", g_nReg, g_nReg *100.0/ g_nTotal);
137. printf("directories = %7ld, %5.2f %% ", g_nDir, g_nDir *100.0/ g_nTotal);
138. printf("block special = %7ld, %5.2f %% ", g_nBlk, g_nBlk *100.0/ g_nTotal);
139. printf("char special = %7ld, %5.2f %% ", g_nChr, g_nChr *100.0/ g_nTotal);
140. printf("FIFOS = %7ld, %5.2f %% ", g_nFifo, g_nFifo *100.0/ g_nTotal);
141. printf("symbolic links = %7ld, %5.2f %% ", g_nSlink, g_nSlink *100.0/ g_nTotal);
142. printf("sockets = %7ld, %5.2f %% ", 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. staticlong g_posix_version =0L;
155. staticlong g_xsi_version =0L;
157. #ifdef PATH_MAX
158. staticlong g_pathMax = PATH_MAX;
159. #else
160. staticlong 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. staticint 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. staticint 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]='';
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]='';// 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. staticint ftw_f(constchar*pathName,conststruct 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. staticint g_myFunc(constchar*pathName,conststruct 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. return0;
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 读目录