[系统运维]网络编程知识四之IO模型 设置获取socket属性

一.I/O模型讲解
1)阻塞(block)IO ：
当资源不满足条件。 此时进程阻塞。进程休眠，不会浪费CPU。最简单效率低。并且进程最终会阻塞在其中一个阻塞函数上，而其它的函数没法及时调用。

常见的阻塞I/O：read / write fgets/scanf send/recv accept

2)非阻塞的方式调用(noblock)
问题：需要不断轮询每个函数，浪费cpu资源 。若是没有数据，则让进程立即返回错误。
错误码如下：
普通文件描述符 EAGAIN
套接字 EAGAIN or EWOULDBLOCK
错误码路径:
/usr/include/asm-generic/errno.h

3)IO多路复用
同时监控多个文件，用一个单进程同时对多路阻塞的IO进行控制,降低系统资源的消耗，提高效率

4)异步信号通知[了解即可]
文件就绪的时候，通过驱动发送信号给应用程序，然后让应用程序对文件进行操作。

二.非阻塞的实现IO

1>文件描述符的属性修改函数

头文件：#include <unistd.h>   
       #include <fcntl.h>
open()
int fcntl(int fd, int cmd); 
int fcntl(int fd, int cmd, long arg);
功能：对文件描述符的一些属性进行设置或者修改。第三个arg参数是否使用由cmd参数的值来决定。
参数：
    @ fd         操作的文件描述符
    @cmd        操作的指令
                 F_GETFL (get file)    arg被忽略不适用  
                            获得fd的文件标志(O_RDONLY ,O_WRONLY,O_RDWR三者选一被获得， 0，1，2，分别是三者的值 ）。    
                 F_SETFL (set file）   通过arg给文件描述符设置状态标志。
                                    arg 可用标志：
                                    O_NONBLOCK（非阻塞的IO，例如read没有文件可读的时候，返回-1和errno置EAGAIN错误）
返回值：若是cmd 为F_GETFL 返回一个相应的文件标志。
       若是cmd 为F_SETFL  成功返回0，失败返回-1.

例如：

//把文件描述符设置为非阻塞模式。
int flags = fcntl(fd ,F_GETFL); //获得文件的当前标志位.
flags |= O_NONBLOCK. //在当前标志位添加负责非阻塞的标志.
fcntl(fd,F_SETFL,flags) ;//重新设置fd的状态标志。

fcntl.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//./a.out newfile
int main(int argc, const char *argv[])
{
	int fd = 0;	
	int flag = 0;
	if(argc < 2)
	{
		fprintf(stderr,"Usage : %s newfile\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

//	fd  = open(argv[1],O_RDONLY);	
//  fd  = open(argv[1],O_WRONLY | O_CREAT | O_TRUNC,0666);	
    fd  = open(argv[1],O_RDWR | O_CREAT | O_TRUNC);	
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}
	//1.获得当前文件标志位
	flag = fcntl(fd,F_GETFL);
	switch(flag)
	{
	case O_RDONLY:
		printf("File flag is O_RDONLY\n");
		break;
	case O_WRONLY:
		printf("File flag is O_WRONLY\n");
		break;
	case O_RDWR:
		printf("File flag is O_RDWR\n");
		break;
	}
	printf("flag : %d\n",flag);
	return 0;
}

三.IO多路复用的实现

1.本质：
通过一个单进程创建一个文件描述符表，把多路阻塞的IO存放如表中，进控制。降低系统资源的消耗，提高效率。

2.基本思想
while(1)
{
利用selcet函数同时监控多个文件。如果没有文件就绪，就阻塞休眠。只要有一个文件就绪，就返回找出就绪的文件，然后处理就绪的文件。
}

常用函数：

1.头文件 
#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
功能：实现IO多路复用，检测指定的文件描述符
参数：
@        nfds                文件描述符的个数   （最大的文件描述符maxfd + 1）
@        readfsd             监控的"读操作"文件描述符表
@        writefds            监控的"写操作"文件描述符表
@        exceptfds        其它的文件描述符集合 （一般是指异常的文件描述符集合）
@        timeout            NULL               阻塞方式调用
             struct timeval结构体中的数据为  0     超时时间设置为0s，
												非阻塞的方式调用
                          自己指定超时时间        指定的时间内等待

struct timeval{
        long  tv_sec;    //设置秒数
        long  tv_usec; //设置微秒
}


返回值：
成功 ,  若是返回值>0  返回就绪的文件的描述符的个数，并且在文件描述符表中清除其他未就绪的文件描述符。
       若是返回值=0  ， 连接超时
 错误，返回-1， 并置errno

例如：
//设置5s中的超时时间
struct timeval tm = {5,0};
//设置8000微秒的超时时间
struct timeval tm = {0,800}

select (…，&tm)

思考：为什么我们的select第一个参数是最大的文件描述符 + 1呢？

typedef struct{
	long int fds_bits[1024 / 32];
}fd_set;
FD_ISSET

注意：fd_set 结构体 实质为一个long类似的数组每一个数组元素都能与一打开的socket文件描述符建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪一socket或文件发生了可读或可写事件。

 //将fd 从 set 的文件描述符数组集合中清除 [file descriptor clear]
void FD_CLR(int fd, fd_set *set); 

//判断 fd在set的文件描述符数组集合中是否已被设置(就绪)  [file descriptor set]
int  FD_ISSET(int fd, fd_set *set);                                

 //将fd添加到 set对应的文件描述符数组集合中 
void FD_SET(int fd, fd_set *set); 

//将set文件描述符数组集合清零,
void FD_ZERO(fd_set *set);   

例如：
假如我们的服务端想要从键盘输入数据，并且还能接受用户的连接。我们就可以进行如下操作：
利用监测listen_fd STDIN_FILENO 它们是否进行了读操作
<1>建立文件描述符表

fd_set  readfds;   // 定义一个读文件描述符集合
fd_set  readfds_bak; //对文件描述符集合的一个备份

FD_ZERO(&readfds_bak); //将表清空
FD_SET(STDIN_FILENO,&readfds_bak); //添加要监控的文件描述符集合
FD_SET(listenfd,&readfds_bak);

//找到最大的文件描述符
maxfd = listen_fd > STDIN_FILENO ? listenfd :STDIN_FILENO;

while(1)
{
    //重新添加关注的文件描述符集合。
    //由于select每次找到对应的文件描述符集合就会清除文件描述符集合。
    //因此，我们这里创建了一个reasfds_bak,select真正检测的是readfds中
    //的数据，对我们的readfds_bak没有影响。每次清楚之后，重新再把需要检测的文件
    //监控的文件描述符集合赋值回去。
    readfs = readfds_bak;
    n = select(maxfd + 1, &readfds,NULL,NULL,NULL);

   //从0到最大的文件描述符开始，对所有的描述符监控
    for(i = 0；i < =maxfd,;i++)
    {
            if(FD_ISSET(i,readfs))   //判断readfs中对应的文件描述符是否就绪
           {
              //说明标准数据就绪
              if(i === STDIN_FILENO)
              {
						//读的时候一定有数据
                      fgets(buf,sizeof（buf）,stdin);
                      fputs(buf,stdout);
              }else if(i == listenfd)
              {
                      //说明有用户请求连接。
                      connect_fd = accept();
              }
            }
    }
    
}

练习：select函数应用于tcp服务器
1.监测标准输入，listen_fd，若标准输入就绪，读数据并打印，若有新连接请求，提取并打印请求方ip和端口如果有用户输入数据，则接收用户数据并打印出来。
server.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define N 1024
//./a.out ip port
int main(int argc, const char *argv[])
{
	char buf[1024] = {0};
	int listen_fd = 0;
	int connect_fd = 0;
	struct sockaddr_in my_addr;
	struct sockaddr_in client_addr;
	int len = sizeof(my_addr);
	int n = 0 ;

	fd_set rfds; //添加文件描述符读表
	fd_set rfds_bak; //添加文件描述符读表的备份
	int maxfd = 0;
	int i = 0;

	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建监听套接字
	listen_fd = socket(AF_INET,SOCK_STREAM,0);
	if(listen_fd < 0)
	{
		perror("Fail to socket");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和端口
	memset(&my_addr,0,sizeof(my_addr));	
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(atoi(argv[2]));
	my_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//3.把ip和port进行绑定
	if(bind(listen_fd,(struct sockaddr *)&my_addr,len) < 0)
	{
		perror("Fail to bind");	
		exit(EXIT_FAILURE);
	}

	//4.监听客户端的连接
	listen(listen_fd,5);
	printf("Listen....\n");


	//思考：若是我们的服务端需要从键盘输入数据存放到缓冲去中，并且我们的accept
	//     需要接受多个用户的连接请求，除了并发服务器外，还有什么方法？
	// 使用IO多路复用
		
	//1.将关注的表清除，创建一个空表
	FD_ZERO(&rfds_bak);
	FD_ZERO(&rfds);

	//2.STDIN_FILENO,listen_fd,将我们需要的数据添加到表中
	FD_SET(STDIN_FILENO,&rfds_bak);
	FD_SET(listen_fd,&rfds_bak);
	

	//3.寻找最大的文件描述符
	maxfd = listen_fd > STDIN_FILENO ? listen_fd : STDIN_FILENO; 


	while(1)
	{
		//由于每次循环找到，匹配的文件描述符表后，里面的数据
		//会被清除掉，因此，我们需要一个备份
		rfds = rfds_bak;			
		n = select(maxfd + 1,&rfds,NULL,NULL,NULL);
		if(n < 0)
		{
			perror("Fail to select");	
			exit(EXIT_FAILURE);
		}
	
		//0,1,3,4,5,6,7,8,9
		//遍历从0到maxfd中，所有的文件描述符
		for(i = 0;i <= maxfd;i++)
		{
			if(FD_ISSET(i,&rfds))	
			{
				//若是标准输入，表示用户从键盘输入了数据
				//存放到缓冲区，我们可以
				if(i == STDIN_FILENO)	//一直是就绪				
				{
					putchar('>');	

					fgets(buf,sizeof(buf),stdin);
					printf("buf : %s\n",buf);
				}else if(i == listen_fd){ 
					//5.准备接收客户端的连接请求
					connect_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&len);	
					if(connect_fd < 0)
					{
						perror("Fail to accept");	
						exit(EXIT_FAILURE);
					}
					
					printf("=============================================");
					printf("connect_fd : %d\n",connect_fd);
					printf("client IP : %s\n",inet_ntoa(client_addr.sin_addr));
					printf("client port : %d\n", ntohs(client_addr.sin_port));
					printf("=============================================");

					FD_SET(connect_fd,&rfds_bak);
					//重新找到最大的文件描述符集合
					maxfd = connect_fd > maxfd ? connect_fd : maxfd;
				}
			
			}
		}
	}

	close(listen_fd);
	close(connect_fd);
	exit(EXIT_SUCCESS);
}

client.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>

#define N 1024
//./a.out ip port
int main(int argc, const char *argv[])
{
	char buf[1024] = {0};
	int sockfd = 0;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	int len = sizeof(server_addr);
	int n = 0 ;
	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建监听套接字
	sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd < 0)
	{
		perror("Fail to socket");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和端口
	memset(&server_addr,0,sizeof(server_addr));	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(atoi(argv[2]));
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//3.准备向服务端的请求连接
	if(connect(sockfd,(struct sockaddr *)&server_addr,len) < 0)
	{
		perror("Fail to accept");	
		exit(EXIT_FAILURE);
	}

	while(1)
	{
		memset(buf,0,sizeof(buf));
		putchar('>');
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf) - 1] = '\0';

		n = send(sockfd,buf,strlen(buf),0);	

		if(n < 0)
		{
			perror("Fail to recv!\n");	
			exit(EXIT_FAILURE);
		}else if(n == 0){
			printf("clinet is not connect\n");	
			exit(EXIT_FAILURE);
		}

		if(strncmp(buf,"quit",4) == 0)
			break;

	}

	close(sockfd);
	exit(EXIT_SUCCESS);
}

四.设置，获得socket属性

#include <sys/types.h>       
#include <sys/socket.h>

int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
功能：获得或者设置socket属性
参数:
    @sockfd          指定socket
    @level           指定操作socket层次
                     可选SOL_SOCKET    //通用的socket选项
                          IPPROTO_IP    //IP层
                          IPPROTO_TCP   //TCP层            
   @optname     由level来选择控制的方式
                    SOL_SOCKET  :SO_BROADCAST 允许发送广播包
                                :SO_RCVTIMEO  接收超时
                                :SO_KEEPALIVE 保持连接

    @optval  设置相应控制方式的值,定义变量传地址
    @optlen  optval之的大小
返回值：成功返回0;失败返回-1,置errno

例如：
设置5s的超时
struct timeval tm = {5,0};
if (setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&tm,sizeof(tm)) < 0)
{
    perror("setsockopt fail");
    exit(EXIT_FAILURE);
}

网络超时检测的方法
1>设置socket超时

struct timeval
  {
    __time_t tv_sec;	 /* Seconds.  */
    __suseconds_t tv_usec;	/* Microseconds.  */
  };
  
socket 用sockfd

socklen_t len = sizeof(struct timeval); 
struct timeval tv;

tv.tv_sec = 5;    //超时5s
tv.tv_usec = 0;
//检测5s时间的超时检测
if(setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&tv,len) < 0)
handle_error();

Service.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>	       /* See NOTES */

//./a.out ip port
int main(int argc, const char *argv[])
{
	int sockfd = 0;	
	struct sockaddr_in my_addr;
	struct sockaddr_in client_addr;
	socklen_t len =  sizeof(my_addr);
	int n = 0;
	char buf[1024] = {0};

	struct timeval tv = {5,0};//设置5s的超时机制
	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建文件描述符
	sockfd = socket(AF_INET,SOCK_DGRAM ,0);
	if(sockfd < 0)
	{
		perror("Fail to socket!");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和port，方便绑定
	memset(&my_addr,0,sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(atoi(argv[2]));
	my_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//3.把ip地址和port与sockfd绑定
	if(bind(sockfd,(struct sockaddr *)&my_addr,len) < 0)
	{
		perror("Fail to bind");	
		exit(EXIT_FAILURE);
	}

	//把sockfd设置为5s的接收超时
	if(setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)) < 0)
	{
		perror("Fail to setsocketopt");	
		exit(EXIT_FAILURE);
	}

	//4.接收数据 ,循环接收，阻塞接收，若是没有数据
	//发送过来，则阻塞
	while(1)
	{
		memset(buf,0,sizeof(buf));
		n = recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&client_addr,&len);
		if(n < 0)
		{ 
			perror("recvfrom timeout deal with....\n");	
			continue;
		}else{

		printf("===============================\n");
		printf("Recv from IP : %s\n",inet_ntoa(client_addr.sin_addr));
		printf("Recv fromt port : %d\n", ntohs(client_addr.sin_port));
		printf("Recv %d bytes : %s\n",n,buf);
		}
	}
	return 0;
}

client.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>

//./a.out ip port
int main(int argc, const char *argv[])
{
	int sockfd = 0;	
	struct sockaddr_in server_addr;
	socklen_t len =  sizeof(server_addr);
	int n = 0;
	char buf[1024] = {0};
	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建文件描述符
	sockfd = socket(AF_INET,SOCK_DGRAM ,0);
	if(sockfd < 0)
	{
		perror("Fail to socket!");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和port，方便绑定
	memset(&server_addr,0,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(atoi(argv[2]));
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//发送数据
	while(1)
	{
		memset(buf,0,sizeof(buf));
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf) - 1] = '\0'; //'\n'-->'\0'

		n = sendto(sockfd,buf,strlen(buf),0,(struct sockaddr *)&server_addr,len);
		if(n < 0)
		{
			perror("Fail to recvfrom");	
			exit(EXIT_FAILURE);
		}

	}
	return 0;
}

每5s中如果没有输入的话就会出现出错提醒。

2>select函数设置超时检测

int select(int nfds, fd_set *readfds, fd_set *writefds,
        fd_set *exceptfds, struct timeval *timeout);

socket由sockfd标识
例：
fd_set rfds,fds_bak;

FD_ZERO(&fds_bak);
FD_SET(&sockfd,&fds_bak);
struct timeval tv = {5,0};

Service.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define N 1024
//./a.out ip port
int main(int argc, const char *argv[])
{
	char buf[1024] = {0};
	int listen_fd = 0;
	int connect_fd = 0;
	struct sockaddr_in my_addr;
	struct sockaddr_in client_addr;
	int len = sizeof(my_addr);
	int n = 0 ;

	struct timeval tv = {10, 0};
	struct timeval *p = NULL;
	p = &tv;

	fd_set rfds; //添加文件描述符读表
	fd_set rfds_bak; //添加文件描述符读表的备份
	int maxfd = 0;
	int i = 0;

	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建监听套接字
	listen_fd = socket(AF_INET,SOCK_STREAM,0);
	if(listen_fd < 0)
	{
		perror("Fail to socket");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和端口
	memset(&my_addr,0,sizeof(my_addr));	
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(atoi(argv[2]));
	my_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//3.把ip和port进行绑定
	if(bind(listen_fd,(struct sockaddr *)&my_addr,len) < 0)
	{
		perror("Fail to bind");	
		exit(EXIT_FAILURE);
	}

	//4.监听客户端的连接
	listen(listen_fd,5);
	printf("Listen....\n");


	//思考：若是我们的服务端需要从键盘输入数据存放到缓冲去中，并且我们的accept
	//     需要接受多个用户的连接请求，除了并发服务器外，还有什么方法？
	// 使用IO多路复用
		
	//1.将关注的表清除，创建一个空表
	FD_ZERO(&rfds_bak);
	FD_ZERO(&rfds);

	//2.STDIN_FILENO,listen_fd,将我们需要的数据添加到表中
	FD_SET(STDIN_FILENO,&rfds_bak);
	FD_SET(listen_fd,&rfds_bak);
	

	//3.寻找最大的文件描述符
	maxfd = listen_fd > STDIN_FILENO ? listen_fd : STDIN_FILENO; 


	while(1)
	{
		//由于每次循环找到，匹配的文件描述符表后，里面的数据
		//会被清除掉，因此，我们需要一个备份
		rfds = rfds_bak;	
		//设置10s的超时，10s后超时非阻塞调用		
		n = select(maxfd + 1,&rfds,NULL,NULL,p);
		if(n < 0)
		{
			perror("Fail to select");	
			exit(EXIT_FAILURE);
		} else if (n == 0) {
			printf("select will timeout!\n");
			sleep(1);
			p->tv_sec = 10;
			p->tv_usec = 0;
		}
	
		//0,1,3,4,5,6,7,8,9
		//遍历从0到maxfd中，所有的文件描述符
		for(i = 0;i <= maxfd;i++)
		{
			if(FD_ISSET(i,&rfds))	
			{
				//若是标准输入，表示用户从键盘输入了数据
				//存放到缓冲区，我们可以
				if(i == STDIN_FILENO)	//一直是就绪				
				{
					putchar('>');	

					fgets(buf,sizeof(buf),stdin);
					printf("buf : %s\n",buf);
				}else if(i == listen_fd){ 
					//5.准备接收客户端的连接请求
					connect_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&len);	
					if(connect_fd < 0)
					{
						perror("Fail to accept");	
						exit(EXIT_FAILURE);
					}
					
					printf("=============================================");
					printf("connect_fd : %d\n",connect_fd);
					printf("client IP : %s\n",inet_ntoa(client_addr.sin_addr));
					printf("client port : %d\n", ntohs(client_addr.sin_port));
					printf("=============================================");

					FD_SET(connect_fd,&rfds_bak);
					//重新找到最大的文件描述符集合
					maxfd = connect_fd > maxfd ? connect_fd : maxfd;
				} else {
					memset(buf, 0, sizeof(buf));
					n = recv(i, buf, sizeof(buf), 0);
					if (n < 0) {
						perror("Fail to recv");
						exit(EXIT_FAILURE);
					} else if (n == 0) {
						printf("client no connect\n");
						exit(EXIT_FAILURE);
					}
					//打印出接受的数据字节数
					printf("Recv %d bytes: %s\n", n, buf);

					//若是发现接受的字符串是quit，说明客户端断开连接i
					//此时的i应该从文件描述符集合中清除，FD_CLR, close(i)
					if (strncmp(buf, "quit", 4) == 0) {
						FD_CLR(i, &rfds_bak);
						close(i);
					}
				}
			
			}
		}
	}

	close(listen_fd);
	close(connect_fd);
	exit(EXIT_SUCCESS);
}

rfds = fds_bak;
select(maxfd + 1,&rfds,NULL,NULL,&tv); //设置5s的超时，非阻塞

3> 超时机制的常用实例。针对不同的网络异常进行处理

1. 客户端出了问题(死机、重启了、网络断了…)
2. 服务端出了问题(死机、重启了、网络断了、内存耗尽、…)
3. 网络不正常

解决方法：设置心跳包。

Keepalive，是TCP中一个可以检测死TCP连接的机制。原理很简单，TCP协议会在空闲了一定的时间之后发送数据给对方。如果对方在一定的时间内没有回应，则表示超时，撤销连接。

typedef struct
{
     int type;        //发送包的类型，数据包，还是心跳包
     char buf[1024]; //发送的数据
}

#define  DATA_PACKET   10   //数据包
#define HEADT_PACKET  20    //心跳包

客户端： 创建子线程每过1s发送一个心跳包，主线程正常从键盘输入数据发送。
心跳包类型 MSG msg = {HEART_PACKET,“I am alive！”}；
服务器端:
客气子进程进行接收客户端消息。通过alarm设置定时，收到正常包正常打印，收到心跳包重新打印数据，若是一定时间内没有收到内没有收到心跳包，就结束当前进程。

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>	       /* See NOTES */
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define N 1024

typedef struct {
	int type;
	char buf[1024];
} msg_t;

#define DATA_PACKET 10
#define HEADT_PACKET 20

void handle_alarm() {
	printf("the GAME OVER!\n");
	exit(EXIT_SUCCESS);
	return;
}

void do_client(int sockfd) {
	msg_t msg;
	int n = 0;

	if (signal(SIGALRM, handler_alarm) == SIG_ERR) {
		perror("Fail to signal");
		exit(EXIT_FAILURE);
	}
	//10s后发送SIGALARM信号，10s是超时时间，10s后若是没有，收到心跳包，则结束该进程。
	//这里的定时不能删掉，否则第一次建立连接套接字后，服务器会一直阻塞在下面的recv等待
	//用户的发送数据，有了这条语句后10s没有数据发过来的话直接发送SIGALARM,处理handler_alarm函数，结束进程
	
	alarm(10);

	while(1) {
		memset(&msg, 0, sizeof(msg));
		if ((n = recv(sockfd, &msg, sizeof(msg), 0)) > 0)
		{
			if (msg.type == DATA_PACKET) {
				printf("Recv %d bytes : %s\n", strlen(msg.buf), msg.buf);
				continue;
			} else if (msg.type == HEADT_PACKET) {
				printf("head recv : %s\n", msg.buf);
				alarm(10);
			}
			if (strncmp(msg.buf, "quit", 4) == 0)
				break;
		}
		exit(EXIT_SUCCESS);
	}
}

void handler_process(int signum) {
	waitpid(-1, NULL, WNOHANG);
	printf("child exit is success!\n");
	return;
}

//./a.out ip port
int main(int argc, const char *argv[])
{
	char buf[1024] = {0};
	int listen_fd = 0;
	int connect_fd = 0;
	struct sockaddr_in my_addr;
	struct sockaddr_in client_addr;
	int len = sizeof(my_addr);
	int n = 0 ;

	pid_t pid;
	int ret =0;
	
	struct timeval tv = {10, 0};
	struct timeval *p = NULL;
	p = &tv;

	fd_set rfds; //添加文件描述符读表
	fd_set rfds_bak; //添加文件描述符读表的备份
	int maxfd = 0;
	int i = 0;

	if(argc < 3)
	{
		fprintf(stderr,"Usage : %s ip port!\n",argv[0]);	
		exit(EXIT_FAILURE);
	}
	
	//对僵尸态子进程进行回收
	if (signal(SIGCHLD, handler_process) ==  SIG_ERR) {
		perror("Fail to signal");
		exit(EXIT_FAILURE);
	}

	//1.通过socket创建监听套接字
	listen_fd = socket(AF_INET,SOCK_STREAM,0);
	if(listen_fd < 0)
	{
		perror("Fail to socket");	
		exit(EXIT_FAILURE);
	}

	//2.填充服务器自己的ip地址和端口
	memset(&my_addr,0,sizeof(my_addr));	
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(atoi(argv[2]));
	my_addr.sin_addr.s_addr = inet_addr(argv[1]);

	//3.把ip和port进行绑定
	if(bind(listen_fd,(struct sockaddr *)&my_addr,len) < 0)
	{
		perror("Fail to bind");	
		exit(EXIT_FAILURE);
	}

	//4.监听客户端的连接
	listen(listen_fd,5);
	printf("Listen....\n");


	//思考：若是我们的服务端需要从键盘输入数据存放到缓冲去中，并且我们的accept
	//     需要接受多个用户的连接请求，除了并发服务器外，还有什么方法？
	// 使用IO多路复用
		
	//1.将关注的表清除，创建一个空表
	FD_ZERO(&rfds_bak);
	FD_ZERO(&rfds);

	//2.STDIN_FILENO,listen_fd,将我们需要的数据添加到表中
	FD_SET(STDIN_FILENO,&rfds_bak);
	FD_SET(listen_fd,&rfds_bak);
	

	//3.寻找最大的文件描述符
	maxfd = listen_fd > STDIN_FILENO ? listen_fd : STDIN_FILENO; 


	while(1)
	{
		//由于每次循环找到，匹配的文件描述符表后，里面的数据
		//会被清除掉，因此，我们需要一个备份
		rfds = rfds_bak;	
		//设置10s的超时，10s后超时非阻塞调用		
		n = select(maxfd + 1,&rfds,NULL,NULL,p);
		if(n < 0)
		{
			perror("Fail to select");	
			exit(EXIT_FAILURE);
		} else if (n == 0) {
			printf("select will timeout!\n");
			sleep(1);
			p->tv_sec = 10;
			p->tv_usec = 0;
		}
	
		//0,1,3,4,5,6,7,8,9
		//遍历从0到maxfd中，所有的文件描述符
		for(i = 0;i <= maxfd;i++)
		{
			if(FD_ISSET(i,&rfds))	
			{
				//若是标准输入，表示用户从键盘输入了数据
				//存放到缓冲区，我们可以
				if(i == STDIN_FILENO)	//一直是就绪				
				{
					putchar('>');	

					fgets(buf,sizeof(buf),stdin);
					printf("buf : %s\n",buf);
				}else if(i == listen_fd){ 
					//5.准备接收客户端的连接请求
					connect_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&len);	
					if(connect_fd < 0)
					{
						perror("Fail to accept");	
						exit(EXIT_FAILURE);
					}
					
					printf("=============================================");
					printf("connect_fd : %d\n",connect_fd);
					printf("client IP : %s\n",inet_ntoa(client_addr.sin_addr));
					printf("client port : %d\n", ntohs(client_addr.sin_port));
					printf("=============================================");

					FD_SET(connect_fd,&rfds_bak);
					//重新找到最大的文件描述符集合
					maxfd = connect_fd > maxfd ? connect_fd : maxfd;
				} else {
					memset(buf, 0, sizeof(buf));
					n = recv(i, buf, sizeof(buf), 0);
					if (n < 0) {
						perror("Fail to recv");
						exit(EXIT_FAILURE);
					} else if (n == 0) {
						printf("client no connect\n");
						exit(EXIT_FAILURE);
					}
					//打印出接受的数据字节数
					printf("Recv %d bytes: %s\n", n, buf);

					//若是发现接受的字符串是quit，说明客户端断开连接i
					//此时的i应该从文件描述符集合中清除，FD_CLR, close(i)
					if (strncmp(buf, "quit", 4) == 0) {
						FD_CLR(i, &rfds_bak);
						close(i);
					}
				}
			
			}
		}
	}

	close(listen_fd);
	close(connect_fd);
	exit(EXIT_SUCCESS);
}

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖