Epoll's et, lt working mode -- example program

The following is a server program , It can be done by LT or ET Two modes receive the data sent by the client , And print to standard output .

#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<assert.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<errno.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<sys/epoll.h>
#include<pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

/*  Set the file descriptor to non blocking  */
int setnonblocking(int fd)
{
    
	int old_option = fcntl(fd, F_GETFL);
	int new_option = old_option | O_NONBLOCK;
	fcntl(fd, F_SETFL, new_option);
	return old_option;
}

/*  File descriptors  fd  Upper  EPOLLIN  Sign up to  epollfd  Directed  epoll  In the kernel event table , Parameters  enable_et  Specify whether or not  fd  Enable  ET  Pattern  */
void addfd(int epollfd, int fd, bool enable_et)
{
    
	epoll_event event;
	event.data.fd = fd;
	event.events = EPOLLIN;
	if (enable_et)
	{
    
		event.events |= EPOLLET;
	}
	epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
	setnonblocking(fd);
}

/* LT  Pattern workflow  */
void lt(epoll_event* events, int number, int epollfd, int listenfd)
{
    
	char buf[BUFFER_SIZE];
	for (int i = 0; i < number; i++)
	{
    
		int sockfd = events[i].data.fd;
		if (sockfd == listenfd)
		{
    
			struct sockaddr_in client_address;
			socklen_t client_addrlength = sizeof(client_address);
			int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
			addfd(epollfd, connfd, false);	/*  hold  connfd  Add to the kernel event table , And disable  ET  Pattern  */
		}
		else if (events[i].events & EPOLLIN)
		{
    
			/*  as long as  socket  There is still unread data in the read cache , This code is triggered  */
			printf("EPOLLIN event trigger once\n");
			memset(buf, '\0', BUFFER_SIZE);
			int ret = recv(sockfd, buf, BUFFER_SIZE - 1, 0);
			if (ret <= 0)
			{
    
				close(sockfd);
				continue;
			}
			printf("get %d bytes of content: %s\n", ret, buf);
		}
		else
		{
    
			printf("something else happened \n");
		}
	}
}

/* ET  Mode workflow  */
void et(epoll_event* events, int number, int epollfd, int listenfd)
{
    
	char buf[BUFFER_SIZE];
	for (int i = 0; i < number; i++)
	{
    
		int sockfd = events[i].data.fd;
		if (sockfd == listenfd)
		{
    
			struct sockaddr_in client_address;
			socklen_t client_addrlength = sizeof(client_address);
			int connfd = accept(sockfd, (struct sockaddr*)&client_address, &client_addrlength);
			addfd(epollfd, connfd, true);	/*  hold  connfd  Add to the kernel event table , And open  ET  Pattern  */
		}
		else if (events[i].events & EPOLLIN)
		{
    
			/*  This code will not be triggered repeatedly , So you have to cycle through the data , To make sure that  socket  Read all data in the cache  */
			printf("EPOLLIN event trigger once\n");
			while (1)
			{
    
				memset(buf, '\0', BUFFER_SIZE);
				int ret = recv(sockfd, buf, BUFFER_SIZE - 1, 0);
				if (ret < 0)
				{
    
					/*  For non blocking IO, If the following conditions are true, it means that all data has been read . thereafter ,epoll You can trigger it again  sockfd  Upper  EPOLLIN  event , Perform the next read operation */
					if (errno == EAGAIN || errno == EWOULDBLOCK)
					{
    
						printf("raed later\n");
						break;
					}
					close(sockfd);
					break;
				}
				else if (ret == 0)	/*  return 0, Indicates that the other party has closed the connection  */
				{
    
					close(sockfd);
				}
				else 
				{
    
					printf("get %d bytes of content: %s\n", ret, buf);
				}
			}
		}
		else
		{
    
			printf("something else happened \n");
		}
	}
}

int main(int argc, char* argv[])
{
    
	if (argc <= 2)
	{
    
		return 1;
	}
	const char* ip = argv[1];
	int port = atoi(argv[2]);
	
	int ret = 0;
	struct sockaddr_in address;
	bzero(&address, sizeof(address));
	address.sin_family = AF_INET;
	address.sin_port = htons(port);
	inet_pton(AF_INET, ip, &address.sin_addr);

	int listenfd = socket(PF_INET, SOCK_STREAM, 0);
	assert(listenfd >= 0);

	ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
	assert(ret != -1);

	ret = listen(listenfd, 5);
	assert(ret != -1);

	epoll_event events[MAX_EVENT_NUMBER];
	int epollfd = epoll_create(10);
	assert(epollfd != -1);
	addfd(epollfd, listenfd, true);

	while (1)
	{
    
		int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
		if (ret < 0)
		{
    
			printf("epoll filure\n");
			break;
		}

		// lt(events, ret, epollfd, listenfd);
		et(events, ret, epollfd, listenfd);
	}

	close(listenfd);
	return 0;
}