struct timeval {
2 long tv_sec; /* seconds second*/
3 long tv_usec; /* microseconds microseconds*/
4 };
5
void FD_CLR(int fd, fd_set *set); //Clear fd in the file descriptor set to 0 6
int FD_ISSET(int fd, fd_set *set); //Test whether the fd in the file descriptor set is set to 1 7
void FD_SET(int fd, fd_set *set); //Put the fd position 1 8 in the file descriptor set
void FD_ZERO(fd_set *set); //Clear all bits in the file descriptor set to 0

return value:
success
 data arrives ---->The total number of file descriptors whose state has changed
 No data arrived, timeout-->0
 fail -1
 Notice:
1,select The number of file descriptors that can be monitored is limited by FD_SETSIZE,Generally 1024, simply change the file descriptor opened by the process
 The number cannot be changed select Monitor the number of files
2,Used when solving clients below 1024 select is fine, but if there are too many linked clients, select polling mode
 type, will greatly reduce the server response efficiency
3,Can be cross-platform

/*4_accept Non-blocking IO polling server*/
#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)
{
	//create socket
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd < 0)
	{
		perror("socket fail");
		return -1;
	}

	//So setting the port number can be reused, these two statements are placed before bind bind
	int optval = 1;
	setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));

	//bind
	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));
		
	//monitor
	listen(socket_fd,20);

	//Add non-blocking attribute to socket_fd socket
	int status = fcntl(socket_fd, F_GETFL); //Get the status of the file descriptor --> F_GETFL
	status |= O_NONBLOCK ;//Add non-blocking properties on the basis of the original
	fcntl(socket_fd, F_SETFL,status); //Set the state of the variable status to the file descriptor
	
	//take over
	int socket_client;
	int client_cnt[20],cnt=0,j=0;
	//Initialize the client's socket
	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};
	
	//Can accept multiple clients at the same time without opening processes and threads
	while(1)
	{

		//Because the socket_fd socket has the blocking attribute, the accept function is blocked
		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("A new client is online [ip:%s port:%d]\n",ip,port);
			
			//Set socket_client as a non-blocking attribute and store it in an array
			int status = fcntl(socket_client, F_GETFL); //Get the status of the file descriptor --> F_GETFL
			status |= O_NONBLOCK ;//Add non-blocking properties on the basis of the original
			fcntl(socket_client, F_SETFL,status); //Set the state of the variable status to the file descriptor
			
			//Store all client sockets in an array
			client_cnt[cnt++] = socket_client;	
			//cnt represents the valid client sockets in the array
			//printf("cnt = %d\n",cnt);
		}
		
		#if 0 //View all client sockets in the array (for debugging)
		for(j=0;j<20;j++)
		{
			printf("%d ",client_cnt[j]);	
		}
		printf("\n");
		
		printf("waiting for connection....\n");
		sleep(1);	
		#endif
		
		//Traverse all sockets in the array (loop to receive data from each client)
		for(j=0;j<cnt;j++) //cnt is a valid socket in the array
		{
			memset(buf,0,sizeof(buf));

			//By default, the recv function is a blocking attribute, but now recv is non-blocking
			ret = recv(client_cnt[j],buf,sizeof(buf),0);
			if(ret > 0) //print only valid data
				printf("buf:%s ret:%d\n",buf,ret);
			
		}
	}
	
	//close the socket
	close(socket_fd);
}




/*5_accept Non-blocking IO polling server ip and port*/
#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)
{
	//create socket
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd < 0)
	{
		perror("socket fail");
		return -1;
	}

	//So setting the port number can be reused, these two statements are placed before bind bind
	int optval = 1;
	setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));

	//bind
	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));
		
	//monitor
	listen(socket_fd,20);

	//Add non-blocking attribute to socket_fd socket
	int status = fcntl(socket_fd, F_GETFL); //Get the status of the file descriptor --> F_GETFL
	status |= O_NONBLOCK ;//Add non-blocking properties on the basis of the original
	fcntl(socket_fd, F_SETFL,status); //Set the state of the variable status to the file descriptor
	
	//Initialize the client's socket
	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);

	//take over
	int socket_client;	
	int ret;
	char buf[1024] = {0};
	//Can accept multiple clients at the same time without opening processes and threads
	while(1)
	{

		//Because the socket_fd socket has the blocking attribute, the accept function is blocked
		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("A new client is online [ip:%s port:%d]\n",ip,port);
			
			//Set socket_client as a non-blocking attribute and store it in an array
			int status = fcntl(socket_client, F_GETFL); //Get the status of the file descriptor --> F_GETFL
			status |= O_NONBLOCK ;//Add non-blocking properties on the basis of the original
			fcntl(socket_client, F_SETFL,status); //Set the state of the variable status to the file descriptor
			
			//Store all client sockets in an array
			//cnt represents the valid client sockets in the array
			info[cnt].cli_socket = socket_client;
			info[cnt].cli_addr = client_addr;
			cnt++;
		}
		
		#if 0 //View all client sockets in the array (for debugging)
		for(j=0;j<20;j++)
		{
			printf("%d ",info[j].cli_socket);	
		}
		printf("\n");
		
		printf("waiting for connection....\n");
		sleep(1);	
		#endif
		
		//Traverse all sockets in the array (loop to receive data from each client)
		for(j=0;j<cnt;j++) //cnt is a valid socket in the array
		{
			memset(buf,0,sizeof(buf));

			//By default, the recv function is a blocking attribute, but now recv is non-blocking
/* 			ret = recv(client_cnt[j],buf,sizeof(buf),0);
			if(ret > 0) //print only valid data
				printf("buf:%s ret:%d\n",buf,ret); */
				
			ret = recv(info[j].cli_socket,buf,sizeof(buf),0);	
			if(ret > 0) //print only valid data
				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 the socket
	close(socket_fd);
}





/*6_Implementing a TCP server using multiplexed select*/
#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]; //Store the file descriptors of all clients//The macro system has been defined The total number of file descriptors is 1024
	
	struct sockaddr_in clientAddr;//Store the IP address and port number of the connected client
	int len = sizeof(struct sockaddr_in);
	
	printf("server Port:%d PID:%d \n",SERVER_PORT,getpid());
	
	//1. Create a socket (listen socket)
	int socket_fd = socket(AF_INET,SOCK_STREAM, 0);
	if(socket_fd == -1)
	{
		sys_err("socket error");
		//perror("bind"); //The release of the two error bars is the same
	}
	//Port multiplexing
	int optval = 1;
	setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&optval, sizeof(optval));

	//2. Bind your own IP address and port number
	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); //Indicates any IP address of the machine
	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. Set up monitoring
	listen(socket_fd,128);
	
	//Define a set of file descriptors
	fd_set rset,allset;
	//empty collection
	FD_ZERO(&allset);
	
	FD_SET(socket_fd, &allset); //Add the listening socket to the collection
	//The largest file descriptor, before no client comes in, the largest file descriptor value is socket_fd
	max_fd = socket_fd;
	
	//Initialize to -1 to initialize the array holding client sockets
	for(int k=0; k<FD_SETSIZE; k++)
	{
		client[k] = -1;
	}
	
	//set blocking time
	struct timeval t;
	t.tv_sec = 5;
	t.tv_usec = 0;
	
	while(1)
	{
		rset = allset; //Every time you loop, you need to reset the select collection
		//Multiplexing, listening to the status of multiple socket file descriptors at the same time -- blocking listening
		//nready represents the total number of file descriptors whose status has changed, (not how many descriptors are stored in it)
		int nready = select(max_fd+1,&rset, NULL,NULL, NULL);
		if(nready == -1)
		{
			perror("select error");
			break;
		}
		
		//The program comes here, indicating that the state of the file descriptors in the collection must have changed
	
		//If the file descriptor of the listening socket has changed, it means that a new client must be connected.
		if(FD_ISSET(socket_fd, &rset))
		{
			//Receive new clients
			int new_clientfd = accept(socket_fd, (struct sockaddr*)&clientAddr,&len);
			
			printf("A new client is connected  IP:%s Port:%hu new_clientfd:%d\n",
					inet_ntoa(clientAddr.sin_addr),
					ntohs(clientAddr.sin_port),
					new_clientfd);
					
			//Add the new client file descriptor to the set 
			FD_SET(new_clientfd, &allset);
			//update file descriptor max
			if(new_clientfd > max_fd)
				max_fd = new_clientfd;
			
			//Add the connected client file descriptor to the array
			for(i=0; i<FD_SETSIZE; i++)
			{
				if(client[i] <0 )
				{
					client[i] = new_clientfd;
					break;
				}
			}
			
			//imax = i;//Store the largest subscript value in the client socket array (you can use this value to record the number of your clients)
			
			//Indicates that only the listening socket file descriptor changes in the set
			if(--nready == 0)
				continue;
		}	
		
		//The program goes here, indicating that there is a client sending data
		for(i=0; i<FD_SETSIZE; i++)
		{
			if(client[i] <0)
				continue;
			
			//Indicates that the client has sent data,
			//The state of the client socket changes, the sentence if(FD_ISSET(client[i], &rset)) is established
			if(FD_ISSET(client[i], &rset))
			{
				char buf[1024] = {0};
				int ret = read(client[i],buf,sizeof(buf));
				if(ret == 0) //The client is disconnected
				{
					printf("A client is disconnected.....\n");
					close(client[i]);//close file descriptor
					
					FD_CLR(client[i],&allset);//remove this client from the file collection
					client[i] = -1;  //The array position corresponding to the file descriptor is set to -1
				}
				
				printf("recv:%s\n",buf);
				//Indicates that all changed file descriptors have been processed by us, then exit
				if(--nready == 0)
					break;
			}		
		}	
	}
	
	//closure
	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 address of the server
#define SERVER_IP	"192.168.11.2"
#define SERVER_PORT	60000

int main(int argc,char **argv)
{
	//Create a socket --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);
	
	//Fill IP address (server) -- new structure
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET; //ipv4
	server_addr.sin_port = htons(SERVER_PORT);//host to net (local port number to network port number)
	server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);//Convert local IP to network IP
	
	//connect to the server
	int ret;
	ret = connect(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	if(ret < 0)
	{
		printf("connect fail\n");
		return -1;
	}
	
	//send data to server
	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 the socket
	close(socket_fd);
	return 0;
}