1. #include <sys/epoll.h>
    2. #include <sys/socket.h>
    3. #include <netinet/in.h>
    4. #include <unistd.h>
    5. #include <arpa/inet.h>
    6. #include <sys/types.h>
    7. #include <stdio.h>
    8. #define EPOLLEVENTS 64
    9. #define FDSIZE      128
    10. #define MAX_SIZE    1024
    11. int main(int argc, char **argv){
    15. }
    16. static int socket_bind(const char* ip,int port){
    17.     int listenfd;
    18.     struct sockaddr_in serveraddr;
    19.     listenfd = socket(AF_INET, SOCK_STREAM, 0);
    20.     if (listenfd==-1)
    21.     {
    22.         perror("socket error");
    23.         exit(-1);
    24.     }
    25.     bzero(&serveraddr,sizeof(serveraddr));
    26.     serveraddr.sin_family = AF_INET;
    27.     inet_pton(AF_INET,ip,&serveraddr.sin_addr);
    28.     serveraddr.sin_port = htons(port);
    29.     if (bind(listenfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))==-1)
    30.     {
    31.         perror("bind error");
    32.         exit(-1);
    33.     }
    34.     return listenfd;
    35. }
    38. static void do_epoll(int listenfd){
    39.     int epolldf;
    40.     struct epoll_event events[EPOLLEVENTS];
    41.     int read_cnt;
    42.     char buf[MAX_SIZE];
    43.     memset(buf,0,MAX_SIZE);
    44.     epolldf = epoll_create(FDSIZE);
    45.     add_event(epolldf,listenfd,EPOLLIN);
    46.     for (;;)
    47.     {
    48.         read_cnt = epoll_wait(epolldf,events,EPOLLEVENTS,-1);
    49.         handle_events(epolldf,events,read_cnt,listenfd,buf);
    50.     }
    51.     close(epolldf);
    54. }
    56. static void handle_events(int epollfd, struct epoll_event* evnets,int num,int listenfd,char* buf){
    57.     int i;
    58.     int fd;
    59.     for ( i = 0; i < num; i++)
    60.     {
    61.         fd = evnets[i].data.fd;
    62.         if ((fd==listenfd) && (evnets[i].events&EPOLLIN))
    63.         {
    64.             handle_accept(epollfd,listenfd);
    65.         }else if (evnets[i].events&EPOLLIN){
    66.             do_read(epollfd,fd,buf);
    68.         }else if (evnets[i].events&EPOLLOUT){
    69.             do_write(epollfd,fd,buf);
    70.         }
    72.     }
    74. }
    76. static void add_event(int epollfd, int fd,int state){
    77.     struct epoll_event ev;
    78.     ev.events = state;
    79.     ev.data.fd = fd;
    80.     if (epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev)<0)
    81.     {
    82.         printf("add event failed! \r\n");
    83.     }
    85. }
    87. static void delete_event(int epollfd, int fd,int state){
    88.     struct epoll_event ev;
    89.     ev.events = state;
    90.     ev.data.fd = fd;
    91.     if (epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev)<0)
    92.     {
    93.         printf("delete event failed! \r\n");
    94.     }
    96. }
    98. static void modify_event(int epollfd, int fd,int state){
    99.     struct epoll_event ev;
    100.     ev.events = state;
    101.     ev.data.fd = fd;
    102.     if (epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev)<0)
    103.     {
    104.         printf("modify event failed! \r\n");
    105.     }
    107. }
    108. static void handle_accept(int epollfd, int listenfd){
    109.     int clifd;
    110.     struct sockaddr_in cliaddr;
    111.     socklen_t cliaddrlen;
    112.     clifd = accept(epollfd, (struct sockaddr*)&cliaddr, &cliaddrlen);
    113.     if (clifd == -1)
    114.     {
    115.         perror("accept error \n");
    116.     }else{
    117.         printf("accept a new client%s:%d\n",
    118.                 inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
    119.         add_event(epollfd,clifd,EPOLLIN);
    120.     }
    123. }
    124. static void do_read(int epollfd,int fd, char *buf){
    125.     int nread;
    126.     nread = read(fd,buf,MAX_SIZE);
    127.     if (nread== -1)
    128.     {
    129.         perror("read error \n");
    130.         delete_event(epollfd,fd,EPOLLIN);
    131.         close(fd);
    132.     }else if (nread==0){
    133.         fprintf(stderr,"client closed\n");
    134.         delete_event(epollfd,fd,EPOLLIN);
    135.         close(fd);
    136.     }else{
    137.         modify_event(epollfd,fd,EPOLLOUT);
    138.     }
    140. }
    141. static void do_write(int epollfd,int fd,char* buf){
    142.     int nwrite;
    143.     nwrite = write(epollfd,buf,strlen(buf));
    144.     if (nwrite == -1)
    145.     {
    146.         perror("write error \n");
    147.         delete_event(epollfd,fd,EPOLLOUT);
    148.         close(fd);
    150.     }else
    151.     {
    152.         modify_event(epollfd,fd,EPOLLIN);
    153.         memset(buf,0,MAX_SIZE);
    154.     }
    157. }