嵌入式成长轨迹17 【Linux应用编程强化】【Linux下的C编程下】【文件系统编程】

一 Linux文件系统简介
文件系统主要体现在对文件和目录的组织上。Linux系统使用标准的树型目录结构，在系统安装时，安装程序就已经为用户创建了文件系统和完整而固定的目录结构，并指定了每个目录的作用和其中的文件类型。目录的最上层为根目录，其他所有目录都是从根目录出发而生成的子目录，根目录下的子目录可以任意嵌套。

1、 Linux系统调用
所谓系统调用是指操作系统提供给用户程序的一组“特殊”接口，用户程序可以通过这组“特殊”接口来获得操作系统内核提供的特殊服务。

在linux中用户程序不能直接访问内核提供的服务。为了更好的保护内核空间，将程序的运行空间分为内核空间和用户空间，他们运行在不同的级别上，在逻辑上是相互隔离的。

2 文件I/O介绍
可用的文件I / O函数——打开文件、读文件、写文件等等。大多数linux文件I / O只需用到5个函数：open、read、write、lseek 以及close。

不带缓存指的是每个r e a d和w r i t e都调用内核中的一个系统调用。这些不带缓存的I / O函数不是ANSI C的组成部分，但是P O S I X 组成部分。

3 文件描述符
对于内核而言，所有打开文件都由文件描述符引用。文件描述符是一个非负整数。当打开一个现存文件或创建一个新文件时，内核向进程返回一个文件描述符。当读、写一个文件时，用o p e n或c r e a t返回的文件描述符标识该文件，将其作为参数传送给r e a d或w r i t e。

二文件的基本操作
1 创建/打开文件
创建/打开一个文件可以使用open函数，它有两种形式。
#include <fcntl.h>

#include <sys/stat.h>

#include <sys/types.h>
int open(const char *filename, int flags);
int open(const char *filename, int flags, mode_t mode);

flags取值
O_RDONLY、O_WRONLY、O_RDWR、O_APPEND、O_CREAT、O_EXEC/O_EXCL、O_NOBLOCK、O_TRUNC

S_IRUSR
O_RDONLY 只读打开。
O_WRONLY 只写打开。
O_RDWR 读、写打开。
O_APPEND 每次写时都加到文件的尾端。
O_CREAT 若此文件不存在则创建它。使用此选择项时，需同时说明第三个参数mode，用其说明该新文件的存取许可权位。
O_EXCL 如果同时指定了O_CREAT，而文件已经存在，则出错。这可测试一个文件是否存在，如果不存在则创建此文件成为一个原子操作。
O_TRUNC 如果此文件存在，而且为只读或只写成功打开，则将其长度截短为0。
O_NOCTTY 如果p a t h n a m e指的是终端设备，则不将此设备分配作为此进程的控制终端。
O_NONBLOCK 如果p a t h n a m e指的是一个F I F O、一个块特殊文件或一个字符特殊文件，则此选择项为此文件的本次打开操作和后续的I / O操作设置非阻塞方式。
O_SYNC 使每次w r i t e都等到物理I / O操作完成。

对于open函数而言，仅当创建新文件时才使用第三个参数。
mod取值
S_IWUSR、S_IXUSR、S_IRWXU
S_IRGRP、S_IWGRP、S_IXGRP、S_IRWXG
S_IROTH、S_IWOTH、S_IXOTH、S_IRWXO
S_ISUID、S_ISGID

 1 /* example1.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <fcntl.h>
 5 #include <sys/stat.h>
 6 #include <sys/types.h>
 7 int main()
 8 {
 9   int fd;       /* 定义文件描述符 */
10   /* 打开文件，如果文件不存在，则创建一个新文件，并用后面的选项设置其访问权限 */
11   fd = open("test", O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP );
12   printf("fd = %d\n", fd1);
13   return 0;
14 }

 1 /* example2.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <error.h>
 5 #include <fcntl.h>
 6 #include <sys/stat.h>
 7 #include <sys/types.h>
 8 int main()
 9 {
10   int fd;       /* 定义文件描述符 */
11   fd = open("test", O_CREAT | O_EXCL, 00750);
12   if (fd == -1)
13   {
14     perror("open error");    /* 如果文件打开失败，调用perror函数输出错误信息 */
15     exit(1);
16   }
17  // …
18   return 0;
19 }

2 关闭文件
int close(int fd);

3 读写文件
文件打开之后，就可以对文件进行读写操作了。

1）．read函数

ssize_t read(int fd, void *buffer, size_t count);
有多种情况可使实际读到的字节数少于要求读字节数：
读普通文件时，在读到要求字节数之前已到达了文件尾端。例如，若在到达文件尾端之前还有3 0个字节，而要求读1 0 0个字节，则r e a d返回3 0，下一次再调用r e a d时，它将返回0 (文件尾端)。
当从终端设备读时，通常一次最多读一行(第11章将介绍如何改变这一点)。
当从网络读时，网络中的缓冲机构可能造成返回值小于所要求读的字节数。
某些面向记录的设备，例如磁带，一次最多返回一个记录。

读操作从文件的当前位移量处开始，在成功返回之前，该位移量增加实际读得的字节数。

2）．write函数

ssize_t write(int fd, const void *buffer,
size_t count);
返回：若成功为已写的字节数，若出错为- 1
其返回值通常与参数count的值不同，否则表示出错。w r i t e出错的一个常见原因是：磁盘已写满，或者超过了对一个给定进程的文件长度限制。

对于普通文件，写操作从文件的当前位移量处开始。如果在打开该文件时，指定了O _ A P P E N D选择项，则在每次写操作之前，将文件位移量设置在文件的当前结尾处。在一次成功写之后，该文件位移量增加实际写的字节数。

3）．lseek函数
off_t lseek(int fd, off_t offset, int whence);

whence取值
SEEK_SET、SEEK_CUR、SEEK_END

  lseek(int fd, 0, SEEK_SET);
  lseek(int fd, 0, SEEK_END);
  lseek(int fd, 0, SEEK_CUR);

复制一个文件1到另一个文件2，若文件2不存在则将其创建

 1 /* example3.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 #include <error.h>
 6 #include <fcntl.h>
 7 #include <sys/stat.h>
 8 #include <sys/types.h>
 9 #define BUFFER_SIZE 256  /* 缓冲区大小，这里设置为256，主要是为了使程序进行多次循环 */
10 int main(int argc, char **argv)
11 {
12   int fd1, fd2;       /* 定义文件描述符 */
13   int cntr, cntw;
14   char buffer[BUFFER_SIZE];    /* 定义缓冲区 */
15   char *ptr;
16   if(argc != 3)       /* 检查命令行参数个数 */
17   {
18     printf("too few arguments.\n");
19     exit(1);
20   }
21   fd1 = open(argv[1], O_RDONLY);   /* 打开源文件 */
22   if (fd1 == -1)      /* 如果源文件打开失败，输出错误信息并退出 */
23   {
24     perror("open file1 failed ");
25     exit(1);
26   }
27   fd2 = open(argv[2], O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);  /* 创建/打开目标文件 */
28   if (fd2 == -1)       /* 如果目标文件创建/打开失败，输出错误信息并退出 */
29   {
30     perror("open file2 failed ");
31     exit(1);
32   }
33   while((cntr = read(fd1, buffer, BUFFER_SIZE)) != 0)  /* 进行文件拷贝，首先从源文件中读取数据 */
34   {
35     if(cntr == -1)     /* 读取过程中有错误发生 */
36     {
37       perror("read error");
38       break;
39     }
40     else if(cntr > 0)     /* 读取成功，数据的长度为cntr */
41     {
42       ptr = buffer;
43       while((cntw = write(fd2, ptr, cntr)) != 0)   /* 将读取的数据写入到目标文件之中 */
44       {
45         if(cntw == -1)     /* 写入过程中有错误发生，跳出内层循环*/
46         {
47           perror("write error");
48           break;
49         }
50         else if(cntw == cntr)    /* 写入字节数与读取字节数相同，数据全部写入 */
51           break;
52         else if(cntw > 0)     /* 写入字节数小于读取字节数，只有部分数据写入 */
53         {
54           ptr += cntw;    /* 指向未写入的数据，接下来再次执行写入操作 */
55           cntr -= cntw;
56         }
57       }
58       if(cntw == -1)     /* 写入过程中有错误发生，跳出外层循环 */
59         break;
60     }
61   }
62   close(fd1);       /* 关闭源文件 */
63   close(fd2);       /* 关闭目标文件 */
64   printf(“Done!\n”);
65   return 0;
66 }

 1 /* example4.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 #include <string.h>
 6 #include <error.h>
 7 #include <fcntl.h>
 8 #include <sys/stat.h>
 9 #include <sys/types.h>
10 #define NAME_LEN 16
11 #define STUDENT_NUM 32
12 struct student
13 {
14   unsigned int id;      /* 学号 */
15   char name[NAME_LEN];    /* 姓名 */
16 };
17 int main(int argc, char **argv)
18 {
19   int fd;        /* 定义文件描述符 */
20   struct student std;
21   int id;
22   char name[NAME_LEN];
23   if(argc != 2)      /* 检查命令行参数个数 */
24   {
25     printf("too few arguments.\n");
26     exit(1);
27   }
28   fd = open(argv[1], O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);   /* 创建文件 */
29   if (fd == -1)       /* 如果文件创建失败，输出错误信息并退出 */
30   {
31     perror("open failed ");
32     exit(1);
33   }
34   printf("Please input the student information.\n");
35   for(;;)       /* 循环写入学生信息 */
36   {
37     printf("ID : ");
38     scanf("%d", &id);    /* 从键盘输入学生的学号 */
39     if(id < 0)       /* 如果输入的学号为负值，退出程序 */
40     {
41       printf("Complete!\n");
42       exit(0);
43     }
44     else
45     {
46       printf("Name : ");
47       scanf("%16s", name);    /* 从键盘输入学生的姓名 */
48       std.id = id;
49       bzero(std.name, NAME_LEN);  /* 将std结构中的name清零 */
50       strcpy(std.name, name);   /* 将输入的姓名复制到std结构中 */
51       lseek(fd, id*sizeof(std), SEEK_SET);   /* 根据学生的学号设置文件的写入位置 */
52       write(fd, (char *)&std, sizeof(std));   /* 将学号，姓名写入到文件中 */
53     }
54   }
55   close(fd);       /* 关闭文件 */
56   return 0;
57 }

4 文件的其他操作
1）．dup函数
int dup(int oldfd);

2）．symlink函数创建符号链接

int symlink(const char * oldpath,const char *newpath);3）．link函数创建硬链接

int link(const char * oldpath,const char *newpath);

4）．unlink函数删除链接 int unlink(const char *pathname);

 1 /* example5.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 #include <error.h>
 6 int main(int argc, char **argv)
 7 {
 8   int ret;
 9   if(argc != 3)       /* 检查命令行参数个数 */
10   {
11     printf("too few arguments\n");
12     exit(1);
13   }
14   ret = symlink(argv[1], argv[2]);   /* 创建文件的硬连接 */
15   if(ret == -1)       /* 如果硬连接创建失败，输出错误信息并退出 */
16   {
17     perror("symlink failed");
18     exit(1);
19   }
20   printf("Done!\n");
21   return 0;
22 }

三文件的属性
文件有很多属性，除了上面介绍的访问权限外，还有文件的大小、创建时间、访问时间等。Linux系统下提供了一些函数，可以获取和设置文件的属性

1 获取文件的属性
1）．stat函数
   int stat(const char *file_name, struct stat *buf);
struct stat {

   dev_t st_dev;
   ino_t st_ino;
   mode_t st_mode;
   nlink_t st_nlink;
   uid_t st_uid;
   gid_t st_gid;
   dev_t st_rdev;
   off_t st_size;
   unsigned long st_blksize;

   unsigned long st_blocks;   time_t st_atime;
   time_t st_mtime;
   time_t st_ctime;
};

S_IFSOCK

S_IFLNKS_IFREG

S_IFBLK

S_IFDIR
S_IFCHR
S_IFIFO

S_ISSOCK(st_mode)

S_ISLNK(st_mode)

S_ISREG(st_mode)

S_ISBLK(st_mode)

S_ISDIR(st_mode)

S_ISCHR(st_mode)

S_ISBLK(st_mode)

获取文件属性并输出类型

 1 /* example6.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 #include <sys/stat.h>
 6 int main(int argc, char **argv)
 7 {
 8   struct stat st;
 9   if(argc != 2)       /* 检查命令行参数个数 */
10   {
11     printf("too few arguments.\n");
12     exit(1);
13   }
14   stat(argv[1], &st);      /* 获取文件的属性 */
15   printf("File Size: %ld Byte\n", st.st_size); /* 输出文件的大小 */
16   printf("File Type : ");
17   switch(st.st_mode & S_IFMT)   /* 判断文件的类型 */
18   {
19     case S_IFSOCK:     /* 套接字 */
20       printf("Socket\n");
21       break;
22     case S_IFLNK:       /* 符号连接 */
23       printf("Symbolic link\n");
24       break;
25     case S_IFREG:      /* 普通文件 */
26       printf("Regular file\n");
27       break;
28     case S_IFBLK:       /* 块设备文件 */
29       printf("Block device\n");
30       break;
31     case S_IFDIR:       /* 目录文件 */
32       printf("Directory\n");
33       break;
34     case S_IFCHR:      /* 字符设备文件 */
35       printf("Character device\n");
36       break;
37     case S_IFIFO:       /* 管道文件 */
38       printf("FIFO\n");
39       break;
40     default:
41       ;
42   }
43   return 0;
44 }

2）．fstat函数

int fstat(int fd, struct stat *buf);

3）．access函数用来更改正在使用的文件属性

int access(const char *pathname, int mode); R_OK、 W_OK、 X_OK、 F_OK

 1 /* example7.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 int main(int argc, char **argv)
 6 {
 7   if(argc != 2)       /* 检查命令行参数个数 */
 8   {
 9     printf("too few arguments.\n");
10     exit(1);
11   }
12   if(access(argv[1], F_OK) != -1)   /* 判断文件是否存在 */
13   {
14     if(access(argv[1], R_OK) != -1)   /* 判断文件是否可读 */
15       printf("read\n");
16     if(access(argv[1], W_OK) != -1)   /* 判断文件是否可写 */
17       printf("write\n");
18     if(access(argv[1], X_OK) != -1)   /* 判断文件是否可执行 */
19       printf("execute\n");
20   }
21   else
22   {
23     printf("%s does not exist\n", argv[1]);   /* 文件不存在 */
24   }
25   return 0;
26 }

2 设置文件的属性
设置文件属性可以使用的函数主要有：chmod、chown、utime以及fcntl等。
1）．chmod函数

int chmod(const char *path, mode_t mode);

 1 /* example8.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <error.h>
 5 #include <sys/types.h>
 6 #include <sys/stat.h>
 7 int main(int argc, char **argv)
 8 {
 9   int ret;
10   if(argc != 2)       /* 检查命令行参数个数 */
11   {
12     printf("too few arguments\n");
13     exit(1);
14   }
15   ret = chmod(argv[1], S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);  /* 修改文件的访问权限 */
16   if(ret == -1)       /* 如果文件权限修改失败，输出错误信息并退出 */
17   {
18     perror("chmod failed");
19     exit(1);
20   }
21   printf("Done!\n");
22   return 0;
23 }

2）．chown函数

int chown(const char *path, uid_t owner,gid_t group);
3）．utime函数

int utime(const char *filename, struct utimbuf *buf);

4）．fcntl函数

int fcntl(int fd , int cmd);
int fcntl(int fd, int cmd, long arg);

int fcntl(int fd, int cmd, struct flock *lock);

F_DUPFD、F_SETFD、F_SETFL

#include <sys/types.h>
#include <unistd.h>
#include <fcnt1.h>
int fcnt1(int filedes, int cmd,... struct flock flockptr ) ;

所希望的锁类型：F_RDLCK（共享读锁）、F_WRLCK（独占性写锁）或F_UNLCK（解锁一个区域）
要加锁或解锁的区域的起始地址，由l_start和l_whence两者决定。l_stat是相对位移量（字节），l_whence则决定了相对位移量的起点。
区域的长度，由l_len表示。

关于加锁和解锁区域的说明还要注意下列各点：
该区域可以在当前文件尾端处开始或越过其尾端处开始，但是不能在文件起始位置之前开始或越过该起始位置。
如若l_len为0，则表示锁的区域从其起点（由l_start和l_whence决定）开始直至最大可能位置为止。也就是不管添写到该文件中多少数据，它都处于锁的范围。
为了锁整个文件，通常的方法是将l_start说明为0，l_whence说明为SEEK_SET，l_len说明为0。

 1 //fcntl.c
 2 #include <sys/types.h>
 3 #include <sys/socket.h>
 4 #include <sys/wait.h>
 5 #include <stdio.h>
 6 #include <stdlib.h>
 7 #include <errno.h>
 8 #include <string.h>
 9 #include <sys/un.h>
10 #include <sys/time.h>
11 #include <sys/ioctl.h>
12 #include <unistd.h>
13 #include <netinet/in.h>
14 #include <fcntl.h>
15 #include <unistd.h>
16 
17 #define SERVPORT 3333
18 #define BACKLOG 10
19 #define MAX_CONNECTED_NO 10
20 #define MAXDATASIZE 100
21 
22 int main()
23 {
24  struct sockaddr_in server_sockaddr,client_sockaddr;
25  int sin_size,recvbytes,flags;
26  int sockfd,client_fd;
27  char buf[MAXDATASIZE];
28  if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1){
29   perror("socket");
30   exit(1);
31  }
32  printf("socket success!,sockfd=%d\n",sockfd);
33  server_sockaddr.sin_family=AF_INET;
34  server_sockaddr.sin_port=htons(SERVPORT);
35  server_sockaddr.sin_addr.s_addr=INADDR_ANY;
36  bzero(&(server_sockaddr.sin_zero),8);
37  if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))==-1){
38   perror("bind");
39   exit(1);
40  }
41  printf("bind success!\n");
42  if(listen(sockfd,BACKLOG)==-1){
43   perror("listen");
44   exit(1);
45  }
46  printf("listening....\n");
47  if((flags=fcntl( sockfd, F_SETFL, 0))<0)
48    perror("fcntl F_SETFL");
49   flags |= O_NONBLOCK;
50   if(fcntl( sockfd, F_SETFL,flags)<0)
51    perror("fcntl");
52  while(1){
53   sin_size=sizeof(struct sockaddr_in);
54   if((client_fd=accept(sockfd,(struct sockaddr*)&client_sockaddr,&sin_size))==-1){
55    perror("accept");
56    exit(1);
57   }
58   if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))==-1){
59    perror("recv");
60    exit(1);
61   }
62   if(read(client_fd,buf,MAXDATASIZE)<0){
63    perror("read");
64    exit(1);
65   }
66   printf("received a connection :%s",buf);
67  close(client_fd);
68  exit(1);
69  }/*while*/
70 }
71 
72

四目录文件的操作
1.创建目录文件
int mkdir(canst char *pathname, mode_t mode);

 1 /* example9.c */
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <unistd.h>
 5 #include <error.h>
 6 #include <fcntl.h>
 7 #include <sys/stat.h>
 8 #include <sys/types.h>
 9 int main(int argc, char **argv)
10 {
11   int ret;
12   if(argc != 2)       /* 检查命令行参数个数 */
13   {
14     printf("too few arguments\n");
15     exit(1);
16   }
17   ret = mkdir(argv[1], S_IRUSR | S_IXUSR); /* 创建目录文件 */
18   if(ret == -1)       /* 如果目录文件创建失败，输出错误信息并退出 */
19   {
20     perror("mkdir failed");
21     exit(1);
22   }
23   printf("Done!\n");
24   return 0;
25 }

2. 打开目录文件

DIR *opendir(const char *name);

3. 关闭目录文件

int closedir(DIR *dir);

 1 /* example10.c */
 2 #include<stdlib.h>
 3 #include<stdio.h>
 4 #include<unistd.h>
 5 #include<string.h>
 6 #include<sys/types.h>
 7 #include<dirent.h>
 8 int main(int argc, char **argv)
 9 {
10   DIR *dp;
11   struct dirent *dirp;
12   if(argc != 2)        /* 检查命令行参数个数 */
13   {
14     printf("too few arguments\n");
15     exit(1);
16   }
17   dp = opendir(argv[1]);     /* 打开目录文件 */
18   if(dp == NULL)       /* 如果目录文件打开失败，输出错误信息并退出 */
19   {
20     perror("opendir error");
21     exit(1);
22   }
23   while((dirp = readdir(dp)) != NULL)   /* 读取目录文件 */
24   {
25     if((strcmp(dirp->d_name, ".") == 0) || (strcmp(dirp->d_name, "..") == 0)) /* 跳过当前目录和父文件 */
26       continue;
27     if(dirp->d_type == DT_DIR)    /* 子目录 */
28     {
29       printf("%s <directory>\n", dirp->d_name);
30     }
31     else        /* 普通文件 */
32       printf("%s\n", dirp->d_name);
33   }
34   closedir(dp);       /* 关闭目录文件 */
35   return 0;
36 }

4. 读取目录文件

struct dirent *readdir(DIR * dir);

struct dirent {

    ino_t d_ino;
    ff_t d_off;
     signed short int d_reclen;

unsigned char d_type;
    char d_name[256];
};

5. 获取当前工作目录

char *getcwd(char *buf, size_t size);
6. 更改当前工作目录
int chdir(const char *path);

 1 /* example11.c */
 2 #include<stdlib.h>
 3 #include<stdio.h>
 4 #include<unistd.h>
 5 #include<error.h>
 6 #define BUFFER_SIZE 64
 7 int main()
 8 {
 9   int ret;
10   char buf[BUFFER_SIZE];
11   getcwd(buf, sizeof(buf));   /* 获取当前工作目录 */
12   printf("%s\n", buf);
13   ret = chdir("..");     /* 更改工作目录 */
14   if(ret == -1)       /* 如果目录更改失败，输出错误信息并退出 */
15   {
16     perror("chdir error");
17     exit(1);
18   }
19   getcwd(buf, sizeof(buf));    /* 获取更改后的工作目录 */
20   printf("%s\n", buf);
21   return 0;
22 }

五 select 实现I/O复用
1、I/O处理的五种模型
1）阻塞I/O模型：若所调用的I/O函数没有完成相关的功能就会使进程挂起，直到相关数据到达才会返回。如：终端、网络设备的访问。
2）非阻塞模型：当请求的I/O操作不能完成时，则不让进程休眠，而且返回一个错误。如：open、read、write访问。
3）I/O多路转接模型：如果请求的I/O 操作阻塞，且他不是真正阻塞I/O，而且让其中的一个函数等待，在这期间， I/O还能进行其他操作。如：select函数。
4）信号驱动I/O模型：在这种模型下，通过安装一个信号处理程序，系统可以自动捕获特定信号的到来，从而启动I/O。
5）异步I/O模型：在这种模型下，当一个描述符已准备好，可以启动I/O时，进程会通知内核。由内核进行后续处理，这种用法现在较少。

2、select函数
传向select的参数告诉内核：
(1) 我们所关心的描述符。
(2) 对于每个描述符我们所关心的条件（是否读一个给定的描述符？是否想写一个给定的描述符？是否关心一个描述符的异常条件？）。
(3) 希望等待多长时间（可以永远等待，等待一个固定量时间，或完全不等待）。
从s e l e c t返回时，内核告诉我们：
(1) 已准备好的描述符的数量。
(2) 哪一个描述符已准备好读、写或异常条件。

#include <sys/types.h>/* fd_set data type */
#include <sys/time.h> /* struct timeval */
#include <unistd.h> /* function prototype might be here */
int select (int numfds, fd_set *readfds,fd_set *writefds, fd_set *exceptfds,struct timeval * timeout) ;
返回：准备就绪的描述符数，若超时则为0，若出错则为- 1。

timeout值：
NULL：永远等待，直到捕捉到信号或文件描述符已准备好为止；
具体值： struct timeval 类型的指针，若等待为timeout时间还没有文件描述符准备好，就立即返回；
0：从不等待，测试所有指定的描述符并立即返回；

先说明最后一个参数，它指定愿意等待的时间：

struct timeval
{
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
}；

select函数根据希望进行的文件操作对文件描述符进行分类处理，这里，对文件描述符的处理主要设计4个宏函数：

FD_ZERO(fd_set *set) 清除一个文件描述符集；
FD_SET(int fd, fd_set *set) 将一个文件描述符加入文件描述符集中；
FD_CLR(int fd, fd_set *set) 将一个文件描述符从文件描述符集中清除；
FD_ISSET(int fd, fd_set *set) 测试该集中的一个给定位是否有变化；

在使用select函数之前，首先使用FD_ZERO和FD_SET来初始化文件描述符集,并使用select函数时，可循环使用FD_ISSET测试描述符集，在执行完成对相关的文件描述符后，使用FD_CLR来清除描述符集

 1 //select.c
 2 #include <sys/types.h>
 3 #include <sys/socket.h>
 4 #include <sys/wait.h>
 5 #include <stdio.h>
 6 #include <stdlib.h>
 7 #include <errno.h>
 8 #include <string.h>
 9 #include <sys/un.h>
10 #include <sys/time.h>
11 #include <sys/ioctl.h>
12 #include <unistd.h>
13 #include <netinet/in.h>
14 #define SERVPORT 3333
15 #define BACKLOG 10
16 #define MAX_CONNECTED_NO 10
17 #define MAXDATASIZE 100
18 int main()
19 {
20  struct sockaddr_in server_sockaddr,client_sockaddr;
21  int sin_size,recvbytes;
22  fd_set readfd;
23  fd_set writefd;
24  int sockfd,client_fd;
25  char buf[MAXDATASIZE];
26  if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1){
27   perror("socket");
28   exit(1);
29  }
30  printf("socket success!,sockfd=%d\n",sockfd);
31  server_sockaddr.sin_family=AF_INET;
32  server_sockaddr.sin_port=htons(SERVPORT);
33  server_sockaddr.sin_addr.s_addr=INADDR_ANY;
34  bzero(&(server_sockaddr.sin_zero),8);
35  if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))==-1){
36   perror("bind");
37   exit(1);
38  }
39  printf("bind success!\n");
40  if(listen(sockfd,BACKLOG)==-1){
41   perror("listen");
42   exit(1);
43  }
44  printf("listening....\n");
45  FD_ZERO(&readfd);
46  FD_SET(sockfd,&readfd);
47  while(1){
48  sin_size=sizeof(struct sockaddr_in);
49  if(select(MAX_CONNECTED_NO,&readfd,NULL,NULL,(struct timeval *)0)>0){
50   if(FD_ISSET(sockfd,&readfd)>0){
51    if((client_fd=accept(sockfd,(struct sockaddr *)&client_sockaddr,&sin_size))==-1){
52     perror("accept");
53     exit(1);
54    }
55    if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))==-1){
56     perror("recv");
57     exit(1);
58    }
59    if(read(client_fd,buf,MAXDATASIZE)<0){
60     perror("read");
61     exit(1);
62    }
63    printf("received a connection :%s",buf);
64   }/*if*/
65   close(client_fd);
66   }/*select*/
67  }/*while*/
68 }
69 
70

六常见面试题
常见面试题1：什么是超级块和索引节点，他们的作用分别是什么？

常见面试题2：对文件进行操作时，如何确定当前读写位置？

posted @ 2012-03-25 20:59 MooreZHENG 阅读(297) 评论(0) 编辑收藏举报

刷新页面返回顶部

MooreZHENG

嵌入式成长轨迹17 【Linux应用编程强化】【Linux下的C编程 下】【文件系统编程】

嵌入式成长轨迹17 【Linux应用编程强化】【Linux下的C编程下】【文件系统编程】