UNIX环境高级编程-文件类型

 

 

相关函数列表

 

 

1. //stat获取文件的状态信息  
2. //fstat 根据fd返回相关信息  
3. //lstat 返回该符号链接有关信息  
4. //fstatat为一个相当于当前打开目录的路径名返回文件统计信息  
5. #include   
6. int stat(const char *restrict pathname, struct stat *restrict buf);  
7. int fstat(int fd, struct stat *buf);  
8. int fstat(const char *restrict pathname, struct stat *restrict buf);  
9. int fstatat(int fd, const char *restrict pathname, struct stat *restrict buf,   int flag);  
10.   
11.   
12. //stat 结构体  
13. struct stat {  
14.     mode_t       st_mode;   //文件类型和权限   
15.     ino_t        st_ino;    //i-node数量  
16.     dev_t        st_dev;    //设备数量(文件系统)  
17.     dev_t        st_rdev;   //设备数量  
18.     nlink_t      st_nlink;  //链接数  
19.     uid_t        st_uid;    //UID数  
20.     gid_t        st_gid;    //GID数  
21.     off_t        st_size;   //文件大小  
22.     struct timespec   st_atime;   //上次访问时间  
23.     struct timespec   st_mtime;   //修改时间  
24.     struct timespec   st_ctime;   //文件状态修改时间,i-node  
25.     blksize_t   st_bklsize;       //块数量  
26.     blkcnt_t    st_blocks;        //被分配了多少磁盘块  
27. };  
28.   
29. //timespec结构体  
30. struct timespec {  
31.     time_t     tv_sec;  //秒  
32.     long       tv_nsec; //纳秒  
33. };  
34.   
35.   
36. //测试文件是否打开，写入，执行正常  
37. #include   
38. int access(const char *pathname, int mode);  
39. int faccessat(int fd, const char *pathname, int mode, int flag);  
40. //access函数的mode标志  
41. R_OK       测试读权限  
42. W_OK       测试写权限  
43. X_OK       测试执行权限  
44.   
45. //设置进程文件模式屏蔽字  
46. //跟chmod不同，这里设置的S_IRUSR,S_IWUSR是屏蔽掉这个权限，也就是说umask(0)表示全部权限，  
47. //而umask(S_IRUSR,S_IWUSR)是屏蔽掉当前用户的读写权限  
48. //创建一个文件，目录默认的权限就来自于umask，umask设置的权限就是默认创建目录的权限  
49. //文件权限略不同，会在目录权限的基础上去掉所有的执行权限  
50. #include   
51. mode_t umask(mode_t cmask);  
52.   
53. //更改现有文件的访问权限  
54. #include   
55. int chmod(const char *pathname, mode_t mode);  
56. int fchmod(int fd, mode_t mode);  
57. int fchmodeat(int fd, const char *pathname, mode_t mode, int flag);  
58.   
59. //更改文件的用户ID和组ID  
60. //fchown和lchown更改符号链接本身的所有者，而不是符号链接指向的文件所有者  
61. //uid 和 gid参考/etc/passwd文件  
62. #include   
63. int chown(const char *pathname, uid_t owner, gid_t group);  
64. int fchown(int fd, uid_t owner, gid_t group);  
65. int fchownat(int fd, const char *pathname, uid_t owner, gid_t group);  
66. int lchown(const char *pathname, uid_t owner, gid_t group);  
67.   
68.   
69. //文件截断  
70. #include   
71. int truncate(const char *pathname, off_t length);  
72. int ftruncate(int fd, off_t length);  
73.   
74.   
75. //任何一个文件可以有多个目录项指向其 i节点，link函数用来创建指向现有文件的链接  
76. #include   
77. int link(const char *existingpath, const char *newpath);  
78. int linkat(int efd, const char *existingpath, int nfd, const char *newpath, int flag);  
79.   
80. //删除一个现有的目录项  
81. #include   
82. int unlink(const char *pathname);  
83. int unlinkat(int fd, const char *pathname, int flag);  
84.   
85. //可以用remove函数删除对一个文件或目录的链接，对于文件remove和unlink相同，对于目录remove和  
86. //rmdir相同  
87. #include   
88. int remove(const char *pathname);  
89.   
90. //对目录和文件重命名  
91. #include   
92. int rename(const char *pathname, const char *newname);  
93. int renameat(int oldfd, const char *oldname, int newfd, const char *newname);  
94.   
95. //创建符号链接  
96. #include   
97. int symlink(const char *actualpath, const char *sympath);  
98. int symlikdat(const char *actualpath, int fd, const char *sympath);  
99.   
100. //打开符号链接  
101. #include   
102. ssize_t readlink(const char *restrict pathname, char *restrict buf, size_t bufsize);  
103. ssize_t readlinkat(int fd, const char *restrict pathname, char *restrict buf,size bufsize);  
104.   
105.   
106. //更改文件的访问时间和修改时间  
107. #include   
108. int futimens(int fd, const struct timespec times[2]);  
109. int utimensat(int fd, const char *path, const struct timespec times[2], int flag);  
110.   
111. //timespec结构体如下  
112. struct timeval {  
113.     time_t tv_sec;  //秒  
114.     long  tv_usec;  //毫秒  
115. };  
116.   
117. //创建目录  
118. #include   
119. int mkdir(const char *pathname, mode_t mode);  
120. int mkdirat(int fd, const char *pathname, mode_t mode);  
121.   
122. //删除一个空目录  
123. #include   
124. int rmdir(const char *pathname);  
125.   
126.   
127. //更改当前工作目录，获取当前工作目录的完成路径  
128. #include   
129. int chdir(const char *pathname);  
130. int fchdir(int fd);  
131. char *getcwd(char *buf, size_t size);  
132.   
133. //读目录  
134. #include   
135. DIR  *opendir(const char *pathname);  
136. DIR  *fdopendir(int *fd);              //这两个函数成功返回指针，出错返回NULL  
137. struct dirent  *readdir(DIR *dp);      //成功返回指针，出错返回NULL  
138. void rewinddir(DIR *dp);                 
139. int  closedir(DIR *dp);                //成功返回0，出错返回-1  
140. long telldir(DIR *dp);                 //返回值与dp关联的目录中的当前位置  
141. void seekdir(DIR *dp, long loc);  
142.   
143. //DIR结构体如下  
144. struct DIR {  
145.     ino_t  d_ino;  
146.     char   d_name[];  
147. };  

 

 

UNIX中的文件类型

类型	说明
普通文件(regular file)	最常用的文件类型，这种文件包含了某些形式的数据，至于是二进制还是文本 类型，对于UNIX内核而已并无区别，对普通文件的内容解释是由处理该文件 的应用程序进行
目录文件(directory file)	这种文件包含了其他文件的名字以及指向与这些玩呢间有关信息的指针。对于 一个目录文件具有读权限的人已进场都可以读该目录的内容，但只有内核可以 直接写目录文件。
块特殊文件 (block special file)	这种类型的文件提供对设备(如磁盘)带缓冲的访问，每次访问以固定长度单位 进行
字符特殊文件 (character special file)	这种类型的文件提供对设备不带缓冲的访问，每次访问长度可变。系统中的 所有设备那么是字符特殊文件，那么是块特殊文件。
FIFO	这种类型的文件用于进程间通信，有时也沉默命名管道(named pipe)
套接字(socket)	这种类型的文件用于进程间的网络通讯。套接字也可用于一台宿主机上进程 之间的非网络通信
符号链接 (symbolic link)	这种类型的文件指向另一个文件

 

 

stat结构中的st_mode成员 中的文件类型宏

宏	文件类型
S_ISREG()	普通文件
S_ISDIR()	目录文件
S_ISCHR()	字符特殊文件
S_ISBLK()	块特殊文件
S_ISFIFO()	管道或FIFO
S_ISLNK()	符号链接
S_ISSOCK()	套接字

 

POSIX.1允许实现将进场通讯(IPC)对象(如消息队列和信号量等)说明为文件。下列类型参数并非st_mode，

而是指向stat结构的指针

宏	对象的类型
S_TYPEISMQ()	消息队列
S_TYPEISSEM()	信号量
S_TYPEISSHM()	共享存储对象

 

文件访问权限

st_mode屏蔽	含义	对普通文件的影响	对目录的影响
S_IRUSR	用户读	许可用户读文件	许可用户读目录项
S_IWUSR	用户写	许可用户写文件	许可用户在目录中删除和创建文件
S_IXUSR	用户执行	许可用户执行文件	许可用户在目录中搜索给定路径名
S_IRGRP	组读	许可组读文件	许可组读目录项
S_IWGRP	组写	许可组写文件	许可组在目录中删除和创建文件
S_IXGRP	组执行	许可组执行文件	许可组在目录中搜索给定路径名
S_IROTH	其他读	许可其他读文件	许可其他读目录项
S_IWOTH	其他写	许可其他写文件	许可其他在目录中删除和创建目录
S_IXOTH	其他执行	许可其他执行文件	许可其他在目录中搜索给定路径名
S_ISUID S_ISGID	设置用户ID 设置组ID	执行时设置有效用户ID 若组执行位设置，则执行时设置 有效组ID，否则强制性锁起作用	(未使用) 将在目录中创建的新文件的组ID设置为 目录的组ID
S_ISVTX	粘着位	在交换区缓存程序正文(若支持)	限制在目录中删除和重命名文件

 

 

每次打开创建删除文件内核都会进程文件访问权限测试，具体如下：

1.若进程的有小用户ID是0(超级用户)则允许访问，这给予超级用户对整个文件系统进程处理的最充分权利

2.若进程的有小用户ID等于文件的所有者ID(也就是进程拥有此文件)，那么如果所有者适当的访问权限位被

   设置，则允许访问，否则拒绝。

3.若进程的有小组ID或进程的附属组ID之一等于文件的组ID，那么如果组适当的访问权限位被设置则允许

   访问，否则拒绝。

4.若其他用户适当的访问权限位被设置则允许访问，否则拒绝。

 

较详细的柱面组的i 节点和数据块

 

 

 

 

查看文件类型的列子:

1. #include   
2. #include   
3. #include   
4. #include   
5. int main(int argc, char *argv[]) {  
6.         int i;  
7.         struct stat buf;  
8.         char *ptr;  
9.         for(i=1;i
10.             printf("%s : ",argv[i]);  
11.             if( lstat(argv[i], &buf) < 0 ) {  
12.                 printf("lstat error\r\n");  
13.                 continue;  
14.             }  
15.   
16.             if( S_ISREG(buf.st_mode) ) {  
17.                 ptr = "regular file";  
18.             }  
19.             else if( S_ISDIR(buf.st_mode) ) {  
20.                 ptr = "directory file";  
21.             }  
22.             else if( S_ISCHR(buf.st_mode) ) {  
23.                 ptr = "character special file";  
24.             }  
25.             else if( S_ISBLK(buf.st_mode) ) {  
26.                 ptr = "block special file";  
27.             }  
28.             else if( S_ISFIFO(buf.st_mode) ) {  
29.                 ptr = "file file";  
30.             }  
31.             else if( S_ISLNK(buf.st_mode) ) {  
32.                 ptr = "synbolic line file";  
33.             }  
34.             else if( S_ISSOCK(buf.st_mode) ) {  
35.                 ptr = "socket file";  
36.             }  
37.             else {  
38.                 ptr = "unkonwn mode";  
39.            }  
40.             printf("%s\r\n",ptr);  
41.         }//end for  
42.         return 0;  
43. }  

 

测试文件是否可以正常打开(可以测试是否可读，可执行)

1. #include   
2. #include   
3. #include   
4. #include   
5. int main(int argc, char *argv[]) {  
6.   
7.         if(argc < 2) {  
8.                 printf("input path\r\n");  
9.                 return 1;  
10.         }  
11.   
12.         if( access(argv[1], R_OK) < 0 ) {  
13.                 printf("access error for %s",argv[1]);  
14.                 printf("\r\n");  
15.         } else {  
16.                 printf("read access ok\r\n");  
17.         }  
18.   
19.         if( open(argv[1],O_RDONLY) < 0 ) {  
20.                 printf("open error for %s",argv[1]);  
21.                 printf("\r\n");  
22.         } else {  
23.                 printf("open for reading ok\r\n");  
24.         }  
25.         return 0;  
26. }  

 

umask

1. #include   
2. #include   
3. #include   
4. #define RWRWRW (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)  
5. int main(int argc, char *argv[]) {  
6.         umask(0);  
7.         if( creat("aaa",RWRWRW) < 0 ) {  
8.                 printf("create error aaa\r\n");  
9.         }  
10.         umask(S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);  
11.         if( creat("bbb",RWRWRW) < 0 ) {  
12.                 printf("create error for bbb\r\n");  
13.         }  
14.         return 0;  
15. }  

 

改变文件权限和所有者，文件截断

1. #include   
2. #include   
3. #include   
4. int main(int argc, char *argv[]) {  
5.         struct stat buf;  
6.         if(stat("bbb",&buf) < 0) {  
7.                 printf("stat error\r\n");  
8.         }  
9.         if( chmod("bbb", (buf.st_mode | S_IRGRP | S_IWGRP | S_IXGRP)) < 0 ) {  
10.                 printf("chmod error\r\n");  
11.         }  
12.         if( chown("bbb", 0, 0) < 0 ) {  
13.                 printf("chown error\r\n");  
14.         }  
15.         if(truncate("hehe.txt",10) < 0) {  
16.                 printf("truncate error\r\n");  
17.         }  
18.         return 0;  
19. }  

 

硬链接，软链接，重命名，创建删除目录

1. #include   
2. #include   
3. #include   
4. #include   
5. int main(int argc, char *argv[]) {  
6.         //hard link  
7.         if(link("aaa","aaa_hard") < 0) {  
8.                 printf("link error\r\n");  
9.         }  
10.         if(unlink("bbb") < 0) {  
11.                 printf("unlink error\r\n");  
12.         }  
13.         if(remove("mask") < 0) {  
14.                 printf("remove error\r\n");  
15.         }  
16.   
17.         //rename  
18.         if(rename("xx","rename_xx") < 0) {  
19.                 printf("rename xx error\r\n");  
20.         }  
21.         if(rename("xx2","rename_xx2") < 0) {  
22.                 printf("rename xx2 error\r\n");  
23.         }  
24.   
25.         //symbol link  
26.         if(symlink("aaa","aaa_symlink") < 0) {  
27.                 printf("symlink error\r\n");  
28.         }  
29.         char buf[1024];  
30.         int result = readlink("aaa_mylink",buf,1024);  
31.         if(result > 0) {  
32.                 int i;  
33.                 for(i=0;i
34.                     printf("buf[%d]--%c\r\n",i,buf[i]);  
35.                 }  
36.         }  
37.   
38.         //test dir  
39.         if(mkdir("aaa_dir",S_IRUSR|S_IWUSR|S_IXUSR) < 0) {  
40.                 printf("create aaa_dir error\r\n");  
41.         }  
42.         if(rmdir("test_dir") < 0) {  
43.                 printf("remove dir error\r\n");  
44.         }  
45.         return 0;  
46. }  

 

修改文件访问时间和创建时间，当前工作目录

1. #include   
2. #include   
3. #include   
4. #include   
5. int main(int argc, char *argv[]) {  
6.         int i,fd;  
7.         struct stat buf;  
8.         struct timespec time[2];  
9.         char *path ="/data0/test/test.log";  
10.         if(stat(path,&buf) < 0) {  
11.                 printf("stat error\r\n");  
12.         }  
13.         if((fd=open(path, O_RDWR|O_TRUNC)) < 0) {  
14.                 printf("open error\r\n");  
15.         }  
16.         time[0] = buf.st_atim;  
17.         time[1] = buf.st_mtim;  
18.         if(futimens(fd,time) < 0) {  
19.                 printf("futimens error\r\n");  
20.         }  
21.         close(fd);  
22.   
23.         if(chdir("/tmp") < 0) {  
24.                 printf("chdir error\r\n");  
25.         }  
26.         char buffer[1024];  
27.         char *dir = getcwd(buffer,1024);   
28.         printf("path=%s\r\n",dir);  
29.         return 0;  
30. }  

 

 

 

 

 

参考

umask

硬链接和符号链接的区别

文件和目录

Linux磁盘分区和文件系统

关于linux中的软链接和硬链接

linux关于readlink函数获取运行路径的小程序