Socket epoll

 

 

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/epoll.h>

#define EPOLLSIZE 100
#define MAXEVENTS 100
#define LINESIZE 1024

int main()
{
        int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
        if (listen_fd == -1)
        {
                perror("socket error");
                exit(errno);
        }

        int yes = 1;
        if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
        {
                perror("setsockopt error");
                exit(errno);
        }

        struct sockaddr_in server_addr;
        memset(&server_addr, 0, sizeof(server_addr));
        server_addr.sin_family = AF_INET;
        server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        server_addr.sin_port = htons(55555);

        if (bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
        {
                perror("bind error");
                exit(errno);
        }

        if (listen(listen_fd, 10) == -1)
        {
                perror("listen error");
                exit(errno);
        }

        int epollfd = epoll_create(EPOLLSIZE);
        if (epollfd == -1)
        {
                perror("epoll_create error");
                exit(errno);
        }

        struct epoll_event event;
        event.data.fd = listen_fd;
        event.events = EPOLLIN | EPOLLET;
        if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_fd, &event) == -1)
        {
                perror("epoll_ctrl error");
                exit(errno);
        }

        struct epoll_event* events = calloc(MAXEVENTS, sizeof(struct epoll_event));

        while (1)
        {
                int nfds = epoll_wait(epollfd, events, MAXEVENTS, -1);
                if (nfds == -1)
                {
                        perror("epoll_wait error");
                        exit(errno);
                }
                int n = 0;
                for (n=0; n<nfds; n++)
                {
                        if(events[n].data.fd == listen_fd)
                        {
                                struct sockaddr_in client_addr;
                                int addr_len = sizeof(client_addr);
                                int client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &addr_len);
                                if (client_fd == -1)
                                {
                                        perror("accept error");
                                        continue;
                                }
                                printf("accept client %d\n", client_fd);
                                event.data.fd = client_fd;
                                event.events = EPOLLIN | EPOLLET;
                                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, client_fd, &event) == -1)
                                {
                                        perror("client epoll_ctl error");
                                        continue;
                                }
                        }
                        else
                        {
                                char rb[LINESIZE] = {0};
                                int len = recv(events[n].data.fd, rb, LINESIZE, 0);
                                if (len == -1)
                                {
                                        perror("recv error");
                                        continue;
                                }
                                printf("recv from client[%d] len[%d]:%s\n", events[n].data.fd, len, rb);
                        }
                }
        }

        return 0;
}