epoll 简单封装

3721阅读　1评论2012-03-21　hnney
分类：LINUX

myevent.h

点击(此处)折叠或打开

  1. #ifndef __MY_EVENTS_H__
  2. #define __MY_EVENTS_H__

  4. #include <sys/epoll.h>

  6. #define EV_READ 0x01
  7. #define EV_WRITE 0x02
  8. #define EV_PERSIST 0x04
  9. #define EV_ET 0x08


  12. typedef int (*_handle_callback)(int fd, int evop);

  14. struct event_t {
  15.     _handle_callback callback;
  16.     struct epoll_event *events;
  17.     int nevents;
  18.     int epfd;
  19. };

  21. event_t* event_init (_handle_callback callback, int size = 10240); 
  22. int event_destroy(event_t* handle);
  23. int event_add (event_t* handle, int fd, int op);
  24. int event_del (event_t* handle, int fd);
  25. int event_modify (event_t* handle, int fd, int op);
  26. int event_dispatch (event_t *handle, int timeout = -1);

  28. #endif //_MY_EVENTS_H__

myevent.cpp


点击(此处)折叠或打开

  1. #include "myevent.h"
  2. #include <stdlib.h>
  3. #include <unistd.h>

  5. #ifndef EPOLLRDHUP
  6. #define USE_OWN_RDHUP
  7. #define EPOLLRDHUP 0x2000
  8. #endif

  10. event_t* event_init (_handle_callback callback, int size)
  11. {
  12.     struct event_t* handle;
  13.     int epfd = epoll_create (32000);
  14.     if (epfd < 0) {
  15.         return NULL;
  16.     }
  17.     handle = (struct event_t*)malloc (sizeof (struct event_t));
  18.     if (!handle) {
  19.         return NULL;
  20.     }
  21.     handle->epfd = epfd;
  22.     handle->nevents = size;
  23.     handle->callback = callback;
  24.     handle->events = (struct epoll_event*) malloc (sizeof (epoll_event) * size); 
  25.     if (!handle->events) {
  26.         free (handle);
  27.         return NULL;
  28.     }
  29.     return handle;
  30. }

  32. int event_destroy (event_t *handle)
  33. {
  34.     if (handle) {
  35.         if (handle->epfd > 0) {
  36.             close (handle->epfd);
  37.         }
  38.         if (handle->events) {
  39.             free (handle->events);
  40.         }
  41.         free (handle);
  42.     }
  43.     return 0;
  44. }

  46. int event_add (event_t* handle, int fd, int op)
  47. {
  48.     struct epoll_event ev;
  49.     ev.data.fd = fd;
  50.     ev.events = EPOLLERR | EPOLLHUP | EPOLLRDHUP;
  51.     if (op & EV_WRITE) {
  52.         ev.events |= EPOLLOUT;
  53.     }
  54.     if (op & EV_READ) {
  55.         ev.events |= EPOLLIN;
  56.     }
  57.     if (op & EV_ET) {
  58.         ev.events |= EPOLLET;
  59.     }
  60.     if (epoll_ctl (handle->epfd, EPOLL_CTL_ADD, fd, &ev) < 0) {
  61.         return -1;
  62.     }
  63.     return 0;
  64. }

  66. int event_del (event_t* handle, int fd)
  67. {
  68.     struct epoll_event ev;
  69.     ev.data.fd = fd;
  70.     if (epoll_ctl (handle->epfd, EPOLL_CTL_DEL, fd, &ev) < 0) {
  71.         return -1;
  72.     }
  73.     return 0;
  74. }

  76. int event_modify (event_t* handle, int fd, int op)
  77. {
  78.     struct epoll_event ev;
  79.     ev.data.fd = fd; 
  80.     ev.events = EPOLLERR | EPOLLHUP | EPOLLRDHUP;
  81.     if (op & EV_WRITE) {
  82.         ev.events |= EPOLLOUT;
  83.     }
  84.     if (op & EV_READ) {
  85.         ev.events |= EPOLLIN; 
  86.     }
  87.     if (op & EV_ET) {
  88.         ev.events |= EPOLLET;
  89.     }
  90.     if (epoll_ctl (handle->epfd, EPOLL_CTL_MOD, fd, &ev) < 0) {
  91.         return -1;
  92.     }
  93.     return 0;
  94. }

  96. int event_dispatch (event_t *handle, int timeout) {
  97.     struct epoll_event *events = handle->events;
  98.     //for (;;) {
  99.         int res = epoll_wait (handle->epfd, events, handle->nevents, timeout);
  100.         for (int i = 0; i < res; i++) {
  101.             int op = 0;
  102.             if (events[i].events & (EPOLLERR|EPOLLHUP|EPOLLRDHUP) ) {
  103.                 op |= EV_READ | EV_WRITE;
  104.             }
  105.             else {
  106.                 if (events[i].events & EPOLLIN) {
  107.                     op |= EV_READ;
  108.                 }
  109.                 if (events[i].events & EPOLLOUT) {
  110.                     op |= EV_WRITE;
  111.                 }
  112.             }
  113.             handle->callback (events[i].data.fd, op);
  114.         }
  115.     //}
  116.     return 0;
  117. }

  119. #ifdef USE_OWN_RDHUP
  120. #undef EPOLLRDHUP
  121. #undef USE_OWN_RDHUP
  122. #endif


上一篇：单向链表
下一篇：GIT图解

文章评论