Epolloneshot event of epoll -- instance program

This example program is a server , He receives user data , And output to standard output , He is characterized by ： For each of these EPOLLIN event , Wake up a thread to deal with him , And the main process continues to execute , That is to enter the next cycle , call epoll_wait Listen for other events .

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

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024

struct fds
{
    
	int epollfd;
	int sockfd;
};

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;
}

/*  take  fd  Upper  EPOLLIN  and  EPOLLET  Event registration to  epollfd  Directed  epoll  In the kernel event table , Parameters  oneshot  Specify whether to register  fd  Upper  EPOLLONESHOT  event  */
void addfd(int epollfd, int fd, bool oneshot)
{
    
	epoll_event event;
	event.events = EPOLLIN | EPOLLET;
	if (oneshot)
	{
    
		event.events |= EPOLLONESHOT;
	}
	epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
	setnonblocking(fd);
}

/*  Reset  fd  Events on the . After doing this , Even though  fd  Upper  EPOLLONESHOT  Event is registered , But the operating system still triggers  fd  Upper  EPOLLIN  event , And trigger only once  */
void reset_oneshot(int epollfd, int fd)
{
    
	epoll_event event;
	event.data.fd = fd;
	event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
	epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}

/*  The worker thread  */
void* worker(void* arg)
{
    
	int sockfd = ((fds*)arg)->sockfd;
	int epollfd = ((fds*)arg)->epollfd;
	printf("start new thread to receive data on fd %d\n", sockfd);
	char buf[BUFFER_SIZE];
	memset(buf, '\0', BUFFER_SIZE);

	/*  Cyclic reading  sockfd  The data on the , Guide encountered  EAGAIN  error  */
	while (1)
	{
    
		int ret = recv(sockfd, buf, BUFFER_SIZE - 1, 0);
		if (ret == 0)
		{
    
			close(sockfd);
			printf("foreiner closed the connection\n");
			break;
		}
		else if (ret < 0)
		{
    
			if (errno == EAGAIN)
			{
    
				reset_oneshot(epollfd, sockfd);
				printf("read later\n");
				break;
			}
		}
		else
		{
    
			printf("get content: %s\n", buf);
			/*  Sleep  5s, Simulate the data processing process  */
			sleep(5);
		}
	}
	printf("end thread receiving data on fd: %d\n", sockfd);
}

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);
	/*  Be careful , monitor sockfd listenfd  Can't register on EPOLLONESHOT event , Otherwise, because the program can only handle one client connection ！ Because the connection request of subsequent customers will no longer trigger  listenfd  Upper  EPOLLIN  event */
	addfd(epollfd, listenfd, false);

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

		for (int i = 0; i < ret; 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);
				/*  Register for each non listening file descriptor  EPOLLONESHOT  event  */
				addfd(epollfd, connfd, true);
			}
			else if (events[i].events & EPOLLIN)	/*  For each  EPOLLIN  Event opens a thread , Then the process proceeds to the next  epoll_wait */
			{
    
				pthread_t thread;
				fds fds_for_new_worker;
				fds_for_new_worker.epollfd = epollfd;
				fds_for_new_worker.sockfd = sockfd;
				/*  Start a new worker thread as  sockfd  service  */
				pthread_create(&thread, NULL, worker, (void*)&fds_for_new_worker);
			}
			else
			{
    
				printf("something else happened\n");
			}
		}
	}

	close(listenfd);
	return 0;
}