linux遍历文件目录

借鉴的百度文库，特此梳理。用了多少库呢，你猜

作业要求

程序能够实现与ls命令类似的功能，处理对象可以有0到多个。

1. 0个：列出当前目录下所有文件
2. 多个：如果是：
   普通文件：列出文件
   目录：列出目录下所有文件
3. 实现自定义选项r,a,l,h,m以及–
   r 递归方式列出子目录（每项要含路径，类似find的-print输出风格，需要设计递归程序）
   a 列出文件名第一个字符为圆点的普通文件（默认情况下不列出文件名首字符为圆点的文件）
   l 后跟一整数，限定文件大小的最小值（字节）
   h 后跟一整数，限定文件大小的最大值（字节）
   m 后跟一整数n，限定文件的最近修改时间必须在n天内
   – 显式地终止命令选项分析

示例

编辑，编译
vi list.c
make list 或者 gcc list.c –o list
运行举例
./list –l 100 –h 5000 /bin /etc 列出大小在100~5000之间的文件
./list –a -r -l 50000 –m 2 递归式列出当前目录树下大小超50KB且2天内修改过的文件（包括文件名首字符为圆点的文件）
./list – -l
./list *

延伸学习

用于处理命令选项的库函数getopt_long，用这个函数重新设计选项处理部分，设计长短格式选项。体会这个库函数功能的设计思想

功能分析

1. 运行在终端的该程序，自然是要直接从命令行获取参数——使用argc、argv[]
2. 需要能够判断一个路径的类型，以根据题目进行不同处理
3. 需要能够读取文件/目录的一些属性，以便进行列举
4. 需要设计递归算法，以完成递归遍历目录

实现步骤

获取命令行参数

C语言的main函数自带两个参数：argc、argv[]，这两个参数分别记录了输入时以空格隔开的参数个数以及各个参数字符串。借助这两个参数，可以简洁明了获取任意的输入参数。

题目中要求，能够获取诸如-r、-a等参数，这些参数具有如下特点：

1. 在本次程序实现中并不必严格要求它们的输入先后顺序
2. 只要检测到某些参数，它们就应当生效

可以设置一些标志变量，通过遍历argv，当识别出特定的标识符时，就将标志位置1。代码如下：

#include <stdio.h>

int r_flag, a_flag, l_flag, h_flag, m_flag, _flag;
void initFlag() {
	r_flag = 0;		//-r
	a_flag = 0;		//-a
	l_flag = 0;		//-l
	h_flag = 0;		//-h
	m_flag = 0;		//-m
	_flag = 0;		//--
}

int main(int argc, char* argv[]) {
	initFlag();
	printf("%d\n", argc);
	for (int i = 1; i < argc; i++) {
		switch (argv[i][1]) {
		case 'r':r_flag = 1; break;
		case 'l':l_flag = 1; break;
		case 'a':a_flag = 1; break;
		case 'h':h_flag = 1; break;
		case 'm':m_flag = 1; break;
		case '-':_flag = 1; break;
		default:break;
		}
	}
	return 0;
}

判断路径类型

实际的命令行输入中我们可能也会输入一个绝对路径，要求该程序处理那个路径下的业务。

当在命令行参数中具有文件路径时，路径字符串的开头是字符‘/’，因此，可以利用这一点识别并记录命令行中的路径参数。如果没有从命令行输入任何路径，那么就将路径设置为当前工作目录“./”

//convert string to number
int str_to_num(char ch[]) {
	int sum = 0;
	for (int i = 0; ch[i] >= 48 && ch[i] <= 57; i++) {
		sum = sum * 10 + ch[i] - 48;
	}
	return sum;
}

int main(int argc, char* argv[]) {
	char path[255];
	initFlag();
	memset(path, 0, sizeof(path));
	for (int i = 1; i < argc; i++) {
		if (argv[i][0] == '/') {
			for (int j = 0; argv[i][j] != '\0'; j++) {
				path[j] = argv[i][j];
			}
		}
		else {
			switch (argv[i][1]) {
			case 'r':r_flag = 1; break;
			case 'a':a_flag = 1; break;
			case 'l':l_flag = 1; i++; l_low = str_to_num(argv[i]); break;
			case 'h':h_flag = 1; i++; h_high = str_to_num(argv[i]); break;
			case 'm':m_flag = 1; i++; m_days = str_to_num(argv[i]); break;
			case '-':_flag = 1; break;
			default:break;
			}
		}
	}
	if (_flag) {
		initFlag();
	}
	//if it does not have a path, default path is the current DIR
	if (path[0] == '\0') {
		path[0] = '.';
	}
	//try to read the path
	readPath(path);
	return 0;
}

C语言有现成的处理路径的结构体和对应的函数。可以使用库stat.h、types.h下的stat结构体函数对路径进行处理。stat结构具有如下描述：

struct stat {
	dev_t     st_dev;         /* 存储该文件的块设备的设备号ID */
	ino_t     st_ino;         /* inode号 */
	mode_t    st_mode;        /* 访问权限及文件类型 */
	nlink_t   st_nlink;       /* link数 */
	uid_t     st_uid;         /* 文件主ID */
	gid_t     st_gid;         /* 组ID */
	dev_t     st_rdev;        /* device ID (if special file) */
	off_t     st_size;        /* 文件大小（字节数）*/
	blksize_t st_blksize;     /* blocksize for filesystem I/O */
	blkcnt_t  st_blocks;      /* 分配的512字节尺寸块个数 */
	struct timespec st_atim;  /* access时间 */
	struct timespec st_mtim;  /* modification时间 */
	struct timespec st_ctim;  /* change时间 */
};

可见，我们可以利用stat打开一个路径，并针对st_mode这个属性判断当前路径的真实意义。st_mode具有如下可能性：

判断变量	变量意义
S_ISREG	普通磁盘文件
S_ISDIR	目录文件
S_ISCHR	字符设备文件
S_ISIFO	管道文件
S_ISLNK	符号连接文件

本次实验中主要使用到了目录文件和普通磁盘文件的判断。

如果判断当前路径是目录，则进入该目录，根据-r、-a等信息确认如何列出目录下的所有内容。其中，递归遍历需要自行设计。
如果该路径已经是文件，直接打印该文件信息。

判断路径的函数内容如下：

int readPath(char* path) {
	struct stat st;
	char temp[255];
	//if the path is current DIR, refresh it with the absolute DIR of current workspace
	if (path[0] == '.') {
		path = temp;
		getcwd(path, 255);
	}
	//read path failed
	if (stat(path, &st) != 0) {
		perror("stat read failed\n");
		return -1;
	}
	//read a DIR success
	if (S_ISDIR(st.st_mode)) {
		getDir(path);
	}
	//read a File success
	else if (S_ISREG(st.st_mode)) {
		printFile(path);
	}
	else {
		printf("even not a file\n");
	}
	return 0;
}

实现针对目录、文件的不同处理方法

如果一个路径是目录

dirent.h下的dir处理函数针对一条路径进行处理。

库函数	函数意义
opendir	打开目录得到句柄（NULL表示失败）
readdir	获取一个目录项返回值指针指向的dirent结构体（返回NULL表示已经读到目录尾）
closedir	关闭不再使用的目录句柄

dirent结构体：记录i节点号和文件名(d_ino和d_name成员)。这一点和stat结构很相似，因为接下来会用到很重要的一个概念：i节点号。

我们以课程示例图为例：

i节点号是文件系统管理里很重要的一个概念。在硬链接里，目录表就是由目录项构成，而目录项就是一个“文件名-i节点号”对。

“.”就相当于指向自己的i节点号的文件，“. .”就相当于指向自己上一级的i节点号的文件。其实很好理解，因为我们运行一个程序或是利用cd走相对路径时，都是写的“./”，而利用cd命令返回上一级目录则是写的“. ./”。因此，每个目录里这两个文件肯定都是存在的，只是正常情况下不使用-a时ls不会把它们列出来。

递归的时候，每当读到一个新路径，就对该路径进行读取，readPath()可以获得该路径到底是目录还是文件，是文件就列出，是目录就直接进去读取……也就是说，readPath()和getDir()一同构成了递归读取。

//read a DIR
int getDir(char* path) {
	DIR* dir = NULL;
	struct dirent* entry;
	//opendir failed
	if ((dir = opendir(path)) == NULL) {
		printf("Can't open the DIR\n");
		return -1;
	}
	//change the path to current workspace DIR
	chdir(path);
	//not the order to recurrsively read the DIR, list all files below
	if (!r_flag) {
		while ((entry = readdir(dir)) != NULL) {
			printFile(entry->d_name);
		}
	}
	//recurrsion read
	else {
		//rewind the dir to current DIR
		rewinddir(dir);
		while ((entry = readdir(dir)) != NULL){
			//list all files except "." and ".."
		    if ((strcmp(entry->d_name, ".") == 0) || (strcmp(entry->d_name, "..") == 0))
				continue;
		    readPath(entry->d_name);
		}
	}
	//close the DIR
	if (closedir(dir)) {
		printf("Can't close the DIR\n");
		return -1;
	}
	chdir("..");
	return 0;
}

如果一个路径是文件

如何列出一个文件的信息呢？自然还是使用stat结构体了，我们只需要善用其中的st_size、st_mode、st_mtime即可。

void printFile(char* path) {
	struct stat st;
	time_t tp;
	char* filename = NULL;
	//current time, in order that we can compare with each other
	time(&tp);
	if (stat(path, &st)) {
		perror("lstat error");
		return -1;
	}
	if ((filename = strrchr(path, '/')) != NULL)
		filename++;
	else
		filename = path;
	if ((S_ISDIR(st.st_mode) ||
		S_ISREG(st.st_mode)) &&
           //minimum size unset/set
		(l_flag == 0 || (l_flag == 1 && (st.st_size >= l_low))) &&
           //maximum size unset/set
		(h_flag == 0 || (h_flag == 1 && (st.st_size <= h_high))) &&
           //modified time unset/set
		(m_flag == 0 || (m_flag == 1 && ((tp - st.st_mtime) <= m_days * 24 * 60 * 60))) &&
           //all type unset/set
		(a_flag == 0 || (a_flag == 1 && filename[0] == '.')))
		printf("%s\t%10ld\t%s\t%10lddays\n", (S_ISDIR(st.st_mode) ? "DIR" : "FILE"), st.st_size, filename, (tp - st.st_mtime) / (24 * 60 * 60));
}

结果测试

./list *

-l与-h

-r

-a

-m

- -

getopt()函数的使用

getopt()函数是命令行参数解析函数，将传递给mian()函数的argc,argv作为参数，getopt() 所设置的全局变量包括：

1. char *optarg——当前选项参数字串(如果有的话)。不是选项的字串，如上命令的话，它的值先是"qing er"，后是123。
2. int optind——argv的当前索引值(下一个argv)。当getopt()在while循环中使用时，循环结束后，剩下的字串视为操作数，在 argv[optind]至argv[argc-1]中可以找到剩下的那些操作数。
3. int opterr——opterr非零表示产生的错误要输出到stderr上，初值为1。
4. int optopt——当发现无效选项字符之时，getopt()函数或返回’?‘字符，或返回’:'字符，并且optopt包含了所发现的无效选项字符。它还是一个选项，是不在选项字串"a🅱️cd::e"中的选项，但不是程序参数(操作数)，不是选项参数。
5. optind：实际上真正的参数是用第二个main()函数的参数开始，也就是argv[1],所以optind的初始值为1；
   选项和参数写在一起，他们占用一个main()函数参数字符串argv[n],如上面选项-c,其参数123，写在一起-c123：所以他两占一起占用argv[5]。
   另外，getopt()会改变argv[]中参数的顺序。经过多次getopt()后，argv[]中的选项和选项的参数会被放置在数组前面，而optind 会指向第一个非选项和参数的位置。

修改后的main函数如下：

int main(int argc, char* argv[]) {
	//char path[255];
	initFlag();
	memset(path, 0, sizeof(path));
	char vet;
	while ((vet = getopt(argc, argv, "ral:h:m:")) != -1) {
		switch (vet) {
		case 'r': r_flag = 1; break;
		case 'a': a_flag = 1; break;
		case 'l': l_flag = 1; l_low = atol(optarg); break;
		case 'h': h_flag = 1; h_high = atol(optarg); break;
		case 'm': m_flag = 1; m_days = atol(optarg); break;
		case '?': printf("encountered a unrecognized option: %c\n", (char)optopt); break;
		default: printf("Usage: -a -r -l int -h int -m int"); break;
		}
	}
	if (_flag) {
		initFlag();
	}
	//if it does not have a path, default path is current DIR
	//if (path[0] == '\0') {
	//	path[0] = '.';
	//}
	readPath(argv[optind]);
	return 0;
}

对于getopt_long函数的长短格式：

1. optstring：短选项字符串。形式如“a🅱️💿”，分别表示程序支持的命令行短选项有-a、-b、-c、-d，冒号含义如下：
   (1)只有一个字符，不带冒号——只表示选项，如-c
   (2)一个字符，后接一个冒号——表示选项后面带一个参数，如-a 100
   (3)一个字符，后接两个冒号——表示选项后面带一个可选参数，即参数可有可无， 如果带参数，则选项与参数直接不能有空格。
2. longopts：表示长选项结构体。
   (1)name:表示选项的名称,比如daemon,dir,out等。
   (2)has_arg:表示选项后面是否携带参数。该参数有三个不同值，如下：
   a: no_argument(或者是0)时：参数后面不跟参数值，eg: --version,–help
   b: required_argument(或者是1)时：参数输入格式为：–参数 值 或者 --参数=值。eg:–dir=/home
   c: optional_argument(或者是2)时：参数输入格式只能为：–参数=值
   (3)flag:这个参数有两个意思，空或者非空。
   a:如果参数为空NULL，那么当选中某个长选项的时候，getopt_long将返回val值。
   eg，可执行程序 --help，getopt_long的返回值为h.
   b:如果参数不为空，那么当选中某个长选项的时候，getopt_long将返回0，并且将flag指针参数指向val值。
   eg: 可执行程序 --http-proxy=127.0.0.1:80 那么getopt_long返回值为0，并且lopt值为1。
   (4)val：表示指定函数找到该选项时的返回值，或者当flag非空时指定flag指向的数据的值val。

struct option {  
     const char *name;  
     int         has_arg;  
     int        *flag;  
     int         val;  
};  
eg:
 static struct option longOpts[] = {
      { "daemon", no_argument, NULL, 'D' },
      { "dir", required_argument, NULL, 'd' },
      { "out", required_argument, NULL, 'o' },
      { "log", required_argument, NULL, 'l' },
      { "split", required_argument, NULL, 's' },
      { "http-proxy", required_argument, &lopt, 1 },
      { "http-user", required_argument, &lopt, 2 },
      { "http-passwd", required_argument, &lopt, 3 },
      { "http-proxy-user", required_argument, &lopt, 4 },
      { "http-proxy-passwd", required_argument, &lopt, 5 },
      { "http-auth-scheme", required_argument, &lopt, 6 },
      { "version", no_argument, NULL, 'v' },
      { "help", no_argument, NULL, 'h' },
      { 0, 0, 0, 0 }
};

其他注意事项：

1. 在getopt的执行中，每次进入都会更新optind变量，该变量指向下一个argv参数；
2. 如getopt返回-1，表示argv[]中的所有选项被解析出，optind指向第一个非选项的argument元素；这里要注意，在getopt执行过程中会将单独的argument交换到argv数组的后面，option选项提前，如：cmd -a file1 -b file2,如果a/b均为不带参数的选项，这最终argv数组变为：cmd -a -b file1 file2;
3. optstring指定选项合法的选项，一个字符代表一个选项，在字符后面加一个’:‘表示该选项带一个参数，字符后带两个’:'表示该选项带可选参数(参数可有可无)，若有参数，optarg指向该该参数，否则optarg为0；
4. 如果getopt不能识别一个选项字符，它会打印一个错误消息到stderr上，并将该字符存放到optopt中，返回’?’；调用程序可以设置opterr=0设置不打印错误信息；注意：要使能打印错误信息，optstring的第一个字符（或者在第一个字符是+/-之后）不能是’:’，否则也不会打印错误;
5. 如果optstring中指定了option需要参数，但在命令行没有参数，那么getopt将返回’?’，如果在optstring的第一个字符（或者在第一个字符是+/-之后）是’:’，那么将返回’:’;
6. 函数的返回类型为int，在编程的时候返回值类型范围要包含-1，如果返回值接收定义为char，在一些系统中char是无符号的，将导致程序错误；
7. 当传入的argv中的选项全部被解析，getopt()返回-1，这也是getopt进行选项解析的循环截至条件；
8. 如果argv中解析出optstring中描述的选项字符，则返回该字符，如果该选项指定了参数，则全局变量optarg指向该参数；
9. 如果getopt遇到一个非optstring指定的选项字符，这表示该选项是未识别的，返回’?’,并且将该选项存放到全局变量optopt中；
10. 如果optstring指定了选项必须带参数，但传入的相应option丢失了参数，返回值依赖于optstring的第一个字符，若第一个字符是’:’，返回’:’,否则返回’?’；由于非法的选项返回也是’?’，所以常常optstring的第一个字符指定为’:’；同时将该选项存放到全局变量 optopt中；