Basic Concepts and Usage of Epoll

#include <sys/epoll.h>

int epoll_create(int size)

#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

typedef union epoll_data
{
    void *ptr;
    int fd;
    __uint32_t u32;
    __uint64_t u64;
} epoll_data_t

struct epoll_event 
{
    __uint32_t events;  /* Epoll events */
    epoll_data_t data;  /* User data variable */
}

#include <sys/epoll.h>

int  epoll_wait(int  epfd,  struct epoll_event * events, int maxevents, int timeout)

#include <cstdio>
#include <iostream>
#include <string.h>
#include <fcntl.h>
using namespace std;
#include <sys/unistd.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

/**
* In a general connection setup, the client sends a connection request using connect(), and the server accepts it using accept().
* However, if the server is busy with other tasks, it may not be able to accept(). In this case, the connection request waits in a queue.
* 'backlog' is the maximum number of connection requests that can wait without being accepted.
* Usually, a value of around 5 is used. If a very large value is used, it consumes kernel resources.
* Therefore, it represents the maximum number of clients waiting for a connection, not the maximum number of connectable clients.
*/
#define LISTEN_BACKLOG 15

int main()
{
    printf("hello from Leviathan_for_Linux!\n");
    int error_check; // Socket creation
    int server_fd = socket(PF_INET, SOCK_STREAM, 0);
    if (server_fd < 0)
    {
        printf("socket() error\n");
        return 0;
    }

    // Set server fd to Non-Blocking Socket. Configured to use Edge Trigger.
    int flags = fcntl(server_fd, F_GETFL);
    flags |= O_NONBLOCK;

    if (fcntl(server_fd, F_SETFL, flags) < 0)
    {
        printf("server_fd fcntl() error\n");
        return 0;
    }

    // Set socket options.
    // Option -> SO_REUSEADDR : Allow port reuse on abnormal termination
    int option = true;
    error_check = setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));

    if (error_check < 0)
    {
        printf("setsockopt() error[%d]\n", error_check);
        close(server_fd);
        return 0;
    }

    // Set socket attributes
    struct sockaddr_in mSockAddr;
    memset(&mSockAddr, 0, sizeof(mSockAddr));
    mSockAddr.sin_family = AF_INET;
    mSockAddr.sin_port = htons(1818);
    mSockAddr.sin_addr.s_addr = htonl(INADDR_ANY); // INADDR_ANY : Use available LAN card IP

    // Bind socket attributes to socket fd
    error_check = bind(server_fd, (struct sockaddr*)&mSockAddr, sizeof(mSockAddr));
    if (error_check < 0)
    {
        printf("bind() error[%d]\n", error_check);
        close(server_fd);
        return 0;
    }

    // Wait for connection
    if (listen(server_fd, LISTEN_BACKLOG) < 0)
    {
        printf("listen() error\n");
        close(server_fd);
        return 0;
    }

    // Create Epoll fd
    int epoll_fd = epoll_create(1024);    // Function to create kernel polling space of size
    if (epoll_fd < 0)
    {
        printf("epoll_create() error\n");
        close(server_fd);
        return 0;
    }

    // Register server fd to epoll
    // EPOLLET => Use Edge Trigger
    // If we correspond Level Trigger and Edge Trigger to a socket buffer:
    // Level Trigger judges based on the level of the socket buffer, i.e., the presence of data.
    // Even if you read and processed it, if you didn't read fully, the event continues to occur.
    // For example, if 1000 bytes arrived and you read only 600 bytes, Level Trigger continues to generate events.
    // However, in Edge Trigger, even if you only read 600 bytes, no further events occur.
    // This is because there is no further state change based on the moment of reading.
    // LT or ET can easily be set as an option.
    // Note that select / poll supports only Level Trigger.

    struct epoll_event events;
    events.events = EPOLLIN | EPOLLET;
    events.data.fd = server_fd;
    
    /* server events set(read for accept) */
    // epoll_ctl : Interface to register the FD epoll should monitor and the event occurring on that FD.
    // EPOLL_CTL_ADD : Add interesting file descriptor
    // EPOLL_CTL_MOD : Modify existing file descriptor
    // EPOLL_CTL_DEL : Delete existing file descriptor from interest list
    
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &events) < 0)
    {
        printf("epoll_ctl() error\n");
        close(server_fd);
        close(epoll_fd);
        return 0;
    }

    // epoll wait.
    // Investigate what happened to FDs of interest.
    // The list of events is passed to the epoll_events[] array.
    // Return value is the number of events, max number of events is MAX_EVENTS
    // timeout    -1         --> Wait for event forever (blocking)
    //             0         --> Do not wait for event.
    //            0 < n      --> Wait for (n)ms
    
    int MAX_EVENTS = 1024;
    struct epoll_event epoll_events[MAX_EVENTS];
    int event_count;
    int timeout = -1;

    while (true)
    {
        event_count = epoll_wait(epoll_fd, epoll_events, MAX_EVENTS, timeout);
        printf("event count[%d]\n", event_count);
        if (event_count < 0)
        {
            printf("epoll_wait() error [%d]\n", event_count);
            return 0;
        }

        for (int i = 0; i < event_count; i++)
        {
            // Accept
            if (epoll_events[i].data.fd == server_fd)
            {
                int client_fd;
                int client_len;
                struct sockaddr_in client_addr;

                printf("User Accept\n");
                client_len = sizeof(client_addr);
                client_fd = accept(server_fd, (struct sockaddr*)&client_addr, (socklen_t*)&client_len);

                // Set client fd to Non-Blocking Socket. Configured to use Edge Trigger.
                int flags = fcntl(client_fd, F_GETFL);
                flags |= O_NONBLOCK;

                if (fcntl(client_fd, F_SETFL, flags) < 0)
                {
                    printf("client_fd[%d] fcntl() error\n", client_fd);
                    return 0;
                }

                if (client_fd < 0)
                {
                    printf("accept() error [%d]\n", client_fd);
                    continue;
                }

                // Register client fd to epoll
                struct epoll_event events;

                events.events = EPOLLIN | EPOLLET;
                events.data.fd = client_fd;

                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &events) < 0)
                {
                    printf("client epoll_ctl() error\n");
                    close(client_fd);
                    continue;
                }
            }
            else
            {
                // Handle send data from clients registered in epoll
                int str_len;
                int client_fd = epoll_events[i].data.fd;
                char data[4096];

                str_len = read(client_fd, &data, sizeof(data));
                if (str_len == 0)
                {
                    // Client disconnect request
                    printf("Client Disconnect [%d]\n", client_fd);
                    close(client_fd);
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                }
                else
                {
                    // If not a disconnect request, process according to content.
                    printf("Recv Data from [%d]\n", client_fd);
                }
            }
        }
    }
}