Socket programming -- poll model

utilize poll The model implements multiple clients and one server CS Model —— multiple IO Multiplexing technology

【 Last one 】：select Model
【 Read before reading 】：poll Detailed explanation

• poll function

 Same as select, Delegate the kernel to monitor read and write events 
int poll(struct pollfd* fds, nfds_t nfds, int timeout);
param:
	fds:  Incoming and outgoing parameters 
		fds.fd:  File descriptor to monitor , If fd=-1, Indicates that the kernel is no longer monitored 
		fds.events: POLLIN- Read events 
					POLLOUT- Write events 
		fds.revents:  Events returned , Indicates that the kernel tells the program which file descriptors have events 
	nfds:  Tell the kernel the scope of monitoring , The concrete is fds Maximum value of array subscript +1
	timeout:  Timeout time 
			-1： Permanent blocking 
			0： Go back to 
			>0： Blocking time 
return:
	>0:  Indicates the number of file descriptors 
	=0:  No file descriptor changes 
	-1:  Abnormal said 

Be careful

1. struct pollfd In structure fd If the member is assigned to -1, Will not be monitored by the kernel ;
2. Compare with select,poll There is no essential change , however poll Not subject to 1024 The limitation of ;
3. select It can be used across platforms ,poll Only in linux Upper use

The server code is as follows , The client code remains unchanged

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<netinet/in.h>
#include<errno.h>
#include<poll.h>

int main()
{
    
	int lfd = socket(AF_INET, SOCK_STREAM, 0);
	if(lfd < 0)
	{
    
		perror("socket error");
		return -1;
	}

	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	int ret = bind(lfd, (struct sockaddr*)&serv, sizeof(serv));
	if(ret < 0)
	{
    
		perror("bind error");
		return -1;
	}

	listen(lfd, 128);
	
	int i;
	struct pollfd client[1024];
	for(i=0; i<1024; i++)
	{
    
		client[i].fd = -1;
	}
	// Delegate the listening file descriptor to the kernel for monitoring 
	client[0].fd = lfd;
	client[0].events = POLLIN;


	int nready;
	int max=0;// Indicates the scope of kernel monitoring , In the beginning 1 individual 
	int cfd;
	int sockfd;
	int n;

	char buf[1024];
	while(1)
	{
    
		nready = poll(client, max+1, -1);
		if(nready < 0)
		{
    
			if(errno == EINTR)
				continue;
			perror("poll error\n");
			exit(-1);
		}

		// There is a client connection request coming 
		if((client[0].fd == lfd) && (client[0].revents & POLLIN))
		{
    
			cfd = accept(lfd, NULL, NULL);
			// seek client Available positions in the array 
			for(i=1; i<1024; i++)
			{
    
				if(client[i].fd == -1)
				{
    
					client[i].fd = cfd;
					client[i].events = POLLIN;
					break;
				}
			}
			// If no location is available , Close the connection 
			if(i == 1024)
			{
    
				close(cfd);
				continue;
			}

			max = i > max ? i : max;
			// Description only the listening descriptor is set to 1, You can skip 
			if(--nready == 0)
			{
    
				continue;
			}
		}

		// Some data has been sent 
		for(i=1; i<=max; i++)
		{
    
			// if fd=-1, Indicates that the connection is closed or there is no connection 
			if(client[i].fd == -1)
			{
    
				continue;
			}

			if(client[i].revents == POLLIN)
			{
    
				sockfd = client[i].fd;
				memset(buf, 0, sizeof(buf));
				n = read(sockfd, buf, sizeof(buf));
				if(n <= 0)
				{
    
					close(sockfd);
					client[i].fd = -1;
					printf("read error or client close\n");
				}
				printf("n == [%d], buf == [%s]\n", n, buf);

				for(int j=0; j<n; j++)
				{
    
					buf[j] = toupper(buf[j]);
				}

				write(sockfd, buf, n);
			}
		}
	}

	close(lfd);
	return 0;
}

【 Next 】：epoll Model