网络编程06-服务器编程非阻塞IO、多路复用

struct timeval {
2 long tv_sec; /* seconds 秒*/
3 long tv_usec; /* microseconds 微秒*/
4 };
5
void FD_CLR(int fd, fd_set *set); //把文件描述符集合里fd清0 6
int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否置1 7
void FD_SET(int fd, fd_set *set); //把文件描述符集合里fd位置1 8
void FD_ZERO(fd_set *set); //把文件描述符集合里所有位清0

返回值：
成功
有数据到达 ---->状态发生变化的文件描述符的总数
没有数据到达，超时-->0
失败 -1
注意：
1、select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024，单纯改变进程打开的文件描述符
个数并不能改变select监听文件个数
2、解决1024以下客户端时使用select是很合适的，但如果链接客户端过多，select采用的是轮询模
型，会大大降低服务器响应效率
3、可以进行跨平台

/*4_accept非阻塞IO轮训服务器*/
#include <stdio.h>
#include <unistd.h>
#include <string.h>
/*socket*/
#include <sys/types.h>			/* See NOTES */  //man 2 socket
/*inet_addr*/        
#include <sys/socket.h>  //man 3 inet_addr
#include <netinet/in.h>
#include <arpa/inet.h>
/*fcntl*/
#include <fcntl.h>  //man 2 fcntl
 
#define SERVER_IP	"192.168.11.2"
#define SERVER_PORT	60000
 
int main(int argc,char **argv)
{
	//创建套接字
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd < 0)
	{
		perror("socket fail");
		return -1;
	}
 
	//所以设置端口号可以复用,这两条语句放在 绑定bind 之前
	int optval = 1;
	setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));
 
	//绑定
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);
	server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
	bind(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
		
	//监听
	listen(socket_fd,20);
 
	//添加非阻塞属性到socket_fd套接字中
	int status = fcntl(socket_fd, F_GETFL); //得到文件描述符的状态-->F_GETFL
	status |= O_NONBLOCK ;//在原来的基础上新增非阻塞属性
	fcntl(socket_fd, F_SETFL,status); //把变量status的状态设置到文件描述符中
	
	//接收
	int socket_client;
	int client_cnt[20],cnt=0,j=0;
	//初始化客户端的套接字
	for(j=0;j<20;j++)
	{
		client_cnt[j] = -1;
	}	
	
	struct sockaddr_in client_addr;
	socklen_t addrlen = sizeof(client_addr);
	
	int ret;
	char buf[1024] = {0};
	
	//在不开进程和线程的情况，同时能够接受多个客户端
	while(1)
	{
 
		//由于socket_fd套接字带有阻塞属性，所以导致accept函数阻塞
		socket_client = accept(socket_fd,(struct sockaddr *)&client_addr,&addrlen);
		if(socket_client != -1)
		{
			char *ip = inet_ntoa(client_addr.sin_addr);
			int port = ntohs(client_addr.sin_port);
			printf("有新的客户端上线 [ip:%s port:%d]\n",ip,port);
			
			//将socket_client设置为非阻塞属性存放在数组中
			int status = fcntl(socket_client, F_GETFL); //得到文件描述符的状态-->F_GETFL
			status |= O_NONBLOCK ;//在原来的基础上新增非阻塞属性
			fcntl(socket_client, F_SETFL,status); //把变量status的状态设置到文件描述符中
			
			//将所有的客户端套接字存放在数组中
			client_cnt[cnt++] = socket_client;	
			//cnt表示的是数组里面有效的客户端套接字
			//printf("cnt = %d\n",cnt);
		}
		
		#if 0 //查看数组里面所有的客户端套接字(调试用)
		for(j=0;j<20;j++)
		{
			printf("%d ",client_cnt[j]);	
		}
		printf("\n");
		
		printf("等待连接中....\n");
		sleep(1);	
		#endif
		
		//遍历数组里面所有的套接字(循环接受每一个客户端发过来的数据)
		for(j=0;j<cnt;j++) //cnt是数组里面有效的套接字
		{
			memset(buf,0,sizeof(buf));
 
			//默认状态下recv这个函数是阻塞属性,但是现在的recv是非阻塞的
			ret = recv(client_cnt[j],buf,sizeof(buf),0);
			if(ret > 0) //只打印有效的数据
				printf("buf:%s ret:%d\n",buf,ret);
			
		}
	}
	
	//关闭套接字
	close(socket_fd);
}
 
 
 
 
/*5_accept非阻塞IO轮训服务器ip与端口*/
#include <stdio.h>
#include <unistd.h>
#include <string.h>
/*socket*/
#include <sys/types.h>			/* See NOTES */  //man 2 socket
/*inet_addr*/        
#include <sys/socket.h>  //man 3 inet_addr
#include <netinet/in.h>
#include <arpa/inet.h>
/*fcntl*/
#include <fcntl.h>  //man 2 fcntl
 
#define SERVER_IP	"192.168.11.2"
#define SERVER_PORT	60000
 
struct  client_info
{
	int cli_socket;
	struct sockaddr_in cli_addr;
};
 
int main(int argc,char **argv)
{
	//创建套接字
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd < 0)
	{
		perror("socket fail");
		return -1;
	}
 
	//所以设置端口号可以复用,这两条语句放在 绑定bind 之前
	int optval = 1;
	setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));
 
	//绑定
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);
	server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
	bind(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
		
	//监听
	listen(socket_fd,20);
 
	//添加非阻塞属性到socket_fd套接字中
	int status = fcntl(socket_fd, F_GETFL); //得到文件描述符的状态-->F_GETFL
	status |= O_NONBLOCK ;//在原来的基础上新增非阻塞属性
	fcntl(socket_fd, F_SETFL,status); //把变量status的状态设置到文件描述符中
	
	//初始化客户端的套接字
	int cnt = 0,j=0;
	struct  client_info info[100];
	for(j=0;j<100;j++)
		info[j].cli_socket = -1;
	
	struct sockaddr_in client_addr;
	socklen_t addrlen = sizeof(client_addr);
 
	//接收
	int socket_client;	
	int ret;
	char buf[1024] = {0};
	//在不开进程和线程的情况，同时能够接受多个客户端
	while(1)
	{
 
		//由于socket_fd套接字带有阻塞属性，所以导致accept函数阻塞
		socket_client = accept(socket_fd,(struct sockaddr *)&client_addr,&addrlen);
		if(socket_client != -1)
		{
			char *ip = inet_ntoa(client_addr.sin_addr);
			int port = ntohs(client_addr.sin_port);
			printf("有新的客户端上线 [ip:%s port:%d]\n",ip,port);
			
			//将socket_client设置为非阻塞属性存放在数组中
			int status = fcntl(socket_client, F_GETFL); //得到文件描述符的状态-->F_GETFL
			status |= O_NONBLOCK ;//在原来的基础上新增非阻塞属性
			fcntl(socket_client, F_SETFL,status); //把变量status的状态设置到文件描述符中
			
			//将所有的客户端套接字存放在数组中
			//cnt表示的是数组里面有效的客户端套接字
			info[cnt].cli_socket = socket_client;
			info[cnt].cli_addr = client_addr;
			cnt++;
		}
		
		#if 0 //查看数组里面所有的客户端套接字(调试用)
		for(j=0;j<20;j++)
		{
			printf("%d ",info[j].cli_socket);	
		}
		printf("\n");
		
		printf("等待连接中....\n");
		sleep(1);	
		#endif
		
		//遍历数组里面所有的套接字(循环接受每一个客户端发过来的数据)
		for(j=0;j<cnt;j++) //cnt是数组里面有效的套接字
		{
			memset(buf,0,sizeof(buf));
 
			//默认状态下recv这个函数是阻塞属性,但是现在的recv是非阻塞的
/* 			ret = recv(client_cnt[j],buf,sizeof(buf),0);
			if(ret > 0) //只打印有效的数据
				printf("buf:%s ret:%d\n",buf,ret); */
				
			ret = recv(info[j].cli_socket,buf,sizeof(buf),0);	
			if(ret > 0) //只打印有效的数据
				printf("[ip:%s port:%d]buf:%s ret:%d\n",
				inet_ntoa(info[j].cli_addr.sin_addr),
				ntohs(info[j].cli_addr.sin_port),
				buf,ret); 
		}
	}
	
	//关闭套接字
	close(socket_fd);
}
 
 
 
 
 
/*6_使用多路复用select实现TCP服务器*/
#include<stdio.h>
#include<stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include<stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
 
#define SERVER_IP "192.168.11.2"
#define SERVER_PORT	60000
 
void sys_err(const char*err)
{
	fprintf(stderr,"%s\n",strerror(errno));
	exit(0);
}
 
int main()
{
	int ret,max_fd,i=0,imax=0;
	int client[FD_SETSIZE]; //存储所有客户端的文件描述符//该宏系统已经定义好了 文件描述符的总数 1024
	
	struct sockaddr_in clientAddr;//存储连接上来的客户端的IP地址和端口号
	int len = sizeof(struct sockaddr_in);
	
	printf("服务器 Port:%d PID:%d \n",SERVER_PORT,getpid());
	
	//1、建立套接字(监听套接字)
	int socket_fd = socket(AF_INET,SOCK_STREAM, 0);
	if(socket_fd == -1)
	{
		sys_err("socket error");
		//perror("bind"); //两种错误条释放作用一样
	}
	//端口复用
	int optval = 1;
	setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&optval, sizeof(optval));
 
	//2、绑定自己的IP地址和端口号
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);//short
	//server_addr.sin_addr.s_addr = htonl(INADDR_ANY); //表示本机任意IP地址
	server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
	
	ret = bind(socket_fd,(struct sockaddr*)&server_addr,sizeof(struct sockaddr_in));
	if(ret == -1)
	{
		sys_err("bind error");
	}
	
	//3、设置监听
	listen(socket_fd,128);
	
	//定义文件描述符集合
	fd_set rset,allset;
	//清空集合
	FD_ZERO(&allset);
	
	FD_SET(socket_fd, &allset); //把监听套接字 加入到集合中
	//最大的文件描述符，在没有客户端进来之前，最大的文件描述符最大值就是socket_fd
	max_fd = socket_fd;
	
	//初始化为 -1 给存放客户端套接字的数组初始化
	for(int k=0; k<FD_SETSIZE; k++)
	{
		client[k] = -1;
	}
	
	//设置阻塞的时间
	struct timeval t;
	t.tv_sec = 5;
	t.tv_usec = 0;
	
	while(1)
	{
		rset = allset; //每次循环的时候都需要重新设置select的集合
		//多路复用 ，同时监听 多个套接字文件描述符的状态  --阻塞监听
		//nready表示的是状态发生变化的文件描述符的总数,(不是里面存放了多少个描述符)
		int nready = select(max_fd+1,&rset, NULL,NULL, NULL);
		if(nready == -1)
		{
			perror("select error");
			break;
		}
		
		//程序走到这里，说明集合中的文件描述符的状态一定发生变化了
	
		//如果是监听套接字文件描述符发生变化了，说明一定是有新客户端连接上来了
		if(FD_ISSET(socket_fd, &rset))
		{
			//接收新的客户端
			int new_clientfd = accept(socket_fd, (struct sockaddr*)&clientAddr,&len);
			
			printf("有新的客户端连接上来  IP:%s Port:%hu new_clientfd:%d\n",
					inet_ntoa(clientAddr.sin_addr),
					ntohs(clientAddr.sin_port),
					new_clientfd);
					
			//把新的客户端文件描述符加入到集合中 
			FD_SET(new_clientfd, &allset);
			//更新文件描述符最大值
			if(new_clientfd > max_fd)
				max_fd = new_clientfd;
			
			//将连接上来的客户端文件描述符 加入到 数组中
			for(i=0; i<FD_SETSIZE; i++)
			{
				if(client[i] <0 )
				{
					client[i] = new_clientfd;
					break;
				}
			}
			
			//imax = i;//存放客户端套接字数组里面的最大的下标值(可以通过这个值来记录你客户端数目)
			
			//说明该集合中只有监听套接字文件描述符发生变化
			if(--nready == 0)
				continue;
		}	
		
		//程序走到这里，说明有客户端发送数据过来
		for(i=0; i<FD_SETSIZE; i++)
		{
			if(client[i] <0)
				continue;
			
			//说明该客户端发送数据过来了,
			//客户端套接字的状态就发生变化这句话if(FD_ISSET(client[i], &rset))就成立
			if(FD_ISSET(client[i], &rset))
			{
				char buf[1024] = {0};
				int ret = read(client[i],buf,sizeof(buf));
				if(ret == 0) //该客户端断开了
				{
					printf("有客户端断开了.....\n");
					close(client[i]);//关闭文件描述符
					
					FD_CLR(client[i],&allset);//将该客户端从 文件集合中删除
					client[i] = -1;  //该文件描述符对应的数组位置置 -1
				}
				
				printf("recv:%s\n",buf);
				//说明所有发生变化的文件描述符 已经被我们处理完了，则退出
				if(--nready == 0)
					break;
			}		
		}	
	}
	
	//关闭
	close(socket_fd);		
	
	return 0;
}

Client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/*socket*/
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
/*ip*/
#include <netinet/in.h> //man 3 inet_addr
#include <arpa/inet.h>
 
//服务器的IP地址
#define SERVER_IP	"192.168.11.2"
#define SERVER_PORT	60000
 
int main(int argc,char **argv)
{
	//建立套接字--socket
	int socket_fd;
	//AF_INET-->ipv4  SOCK_STREAM-->tcp
	socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd < 0)
	{
		perror("socket fail");
		return -1;
	}
	printf("socket_fd = %d\n",socket_fd);
	
	//填充IP地址(服务器)--新结构体
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET; //ipv4
	server_addr.sin_port = htons(SERVER_PORT);//host to net(本机端口号转网络端口号)
	server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);//将本机IP转换为网络IP
	
	//连接服务器
	int ret;
	ret = connect(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	if(ret < 0)
	{
		printf("connect fail\n");
		return -1;
	}
	
	//给服务器发送数据
	char buf[1024] = {0};
	while(1)
	{	
		memset(buf,0,sizeof(buf));
		scanf("%s",buf);
		ret = send(socket_fd,buf,strlen(buf),0);
		printf("send success ret:%d\n",ret);
	}
	
	//关闭套接字
	close(socket_fd);
	return 0;
}