epoll

服务器端

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

#define BUFESIZE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000

// 把socket设置为非阻塞方式
void setNonBlocking(int sock)
{
    int opts = fcntl(sock, F_GETFL);
    if(opts < 0)
    {
        perror("fcntl(sock, F_GETFL");
        exit(1);
    }

    opts |= O_NONBLOCK;
    if(fcntl(sock, F_SETFL, opts) < 0)
    {
        perror("fcntl(sock, SETFL, opts");
        exit(1);
    }
}

int main(int argc, char *argv[])
{
    int port;

    if(argc == 2)
    {
        if((port = atoi(argv[1])) < 0)
        {
            fprintf(stderr, "Usage:%s port\n", argv[0]);
            return 1;
        }
    }
    else
    {
        fprintf(stderr, "Usage%s port\n", argv[0]);
        return 1;
    }

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);

    setNonBlocking(listenfd);

    // 创建epoll句柄
    // int epoll_create(int size);
    // size: epll支持的最大句柄数
    int epfd = epoll_create(256);

    // epoll要监听的事件
    struct epoll_event ev;
    ev.data.fd = listenfd;          // 文件描述符
    ev.events = EPOLLIN | EPOLLET;  // 读 | 边缘触发

    // 事件注册
    // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    struct sockaddr_in serveraddr;
    bzero(&serveraddr, sizeof(serveraddr);
    serveraddr.sin_family = AF_INET;    // 地址族
    char *local_addr = "127.0.0.1";
    inet_aton(local_addr, &(serveraddr.sin_addr));  // 地址
    serveraddr.sin_port = htons(port);  // 端口

    bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);

    struct sockaddr_in clientaddr;
    socklen_t clilen;
    char buf[BUFESIZE];
    struct epoll_event events[20];  // epoll_wait成功之后，储存所有的读写事件
    int n;

    while(1)
    {
        // 等待直到注册的事件发生
        // int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
        // 返回需要处理的事件数目，如返回0表示已超时
        int nfds = epoll_wait(epfd, events, 20, 500);

        for(int i=0; i<nfds; ++i)
        {
            if(events[i].data.fd == listenfd)  // 有新的连接
            {
                int clientfd = accept(listenfd, (struct sockaddr *)&clientaddr, &clilen);
                if(clientfd < 0)
                {
                    perror("clientfd < 0");
                    exit(1);
                }
                setNonBlocking(clientfd);

                char *str = inet_ntoa(clientaddr.sin_addr);
                printf("accept a connection from %s\n", str);

                ev.data.fd = clientfd;
                ev.events = EPOLLIN | EPOLLET;

                // 将新的fd添加到epoll的监听队列中
                epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &ev);
            }
            else if(events[i].events & EPOLLIN)  // 接收到数据，读socket
            {
                printf("EPOLLIN\n");

                int sockfd;
                if((sockfd = events[i].data.fd) < 0)
                    continue;

                if((n = read(sockfd, buf, BUFESIZE)) < 0)
                {
                    if(errno == ECONNRESET)
                    {
                        close(sockfd);
                        events[i].data.fd = -1;
                    }
                    else
                        printf("read error");

                }
                else if(n == 0)
                {
                    close(sockfd);
                    events[i].data.fd = -1;
                }

                buf[n] = '\0';
                printf("read %s\n", buf);

                ev.data.fd = sockfd;
                ev.events = EPOLLOUT | EPOLLET;

                // 修改标识符，等待下一个循环时发送数据
                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
            }
            else if(events[i].events & EPOLLOUT)  // 有数据待发送，写socket
            {
                printf("EPOLLOUT\n");

                int sockfd = events[i].data.fd;
                write(sockfd, buf, n);

                ev.data.fd = sockfd;
                ev.events = EPOLLIN | EPOLLET;

                // 修改标识符，等待下一个循环时接收数据
                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
            }
        }
    }


    return 0;
}

客户端

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main()
{
    int sockid = socket(AF_INET, SOCK_STREAM, 0);

    if(sockid == -1)
        perror("socket");

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    saddr.sin_port = htons(5000);

    if(connect(sockid, (struct sockaddr*)&saddr, sizeof(saddr)) == -1)
        perror("connect");

    char buf[100] = "Hello!";

    write(sockid, buf, sizeof(buf));

    read(sockid, buf, sizeof(buf));

    printf("%s\n", buf);

    close(sockid);

    return 0;
}

参考
https://blog.csdn.net/ljx0305/article/details/4065058
http://blog.jobbole.com/93566/