11.1 HelloWorld服务器

  1. #include <string.h>
  2. #include <errno.h>
  3. #include <stdio.h>
  4. #include <signal.h>
  5. #ifndef WIN32
  6. #include <netinet/in.h>
  7. # ifdef _XOPEN_SOURCE_EXTENDED
  8. #  include <arpa/inet.h>
  9. # endif
  10. #include <sys/socket.h>
  11. #endif
  13. #include <event2/bufferevent.h>
  14. #include <event2/buffer.h>
  15. #include <event2/listener.h>
  16. #include <event2/util.h>
  17. #include <event2/event.h>
  19. static const char MESSAGE[] = "Hello, World!\n";
  21. static const int PORT = 9995;
  23. static void listener_cb(struct evconnlistener *, evutil_socket_t,
  24.     struct sockaddr *, int socklen, void *);
  25. static void conn_writecb(struct bufferevent *, void *);
  26. static void conn_eventcb(struct bufferevent *, short, void *);
  27. static void signal_cb(evutil_socket_t, short, void *);
  29. int
  30. main(int argc, char **argv)
  31. {
  32.         struct event_base *base;
  33.         struct evconnlistener *listener;
  34.         struct event *signal_event;
  36.         struct sockaddr_in sin;
  37. #ifdef WIN32
  38.         WSADATA wsa_data;
  39.         WSAStartup(0x0201, &wsa_data);
  40. #endif
  42.         base = event_base_new();
  43.         if (!base) {
  44.                 fprintf(stderr, "Could not initialize libevent!\n");
  45.                 return 1;
  46.         }
  48.         memset(&sin, 0, sizeof(sin));
  49.         sin.sin_family = AF_INET;
  50.         sin.sin_port = htons(PORT);
  52.         listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
  53.             LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
  54.             (struct sockaddr*)&sin,
  55.             sizeof(sin));
  57.         if (!listener) {
  58.                 fprintf(stderr, "Could not create a listener!\n");
  59.                 return 1;
  60.         }
  62.         signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
  64.         if (!signal_event || event_add(signal_event, NULL)<0) {
  65.                 fprintf(stderr, "Could not create/add a signal event!\n");
  66.                 return 1;
  67.         }
  69.         event_base_dispatch(base);
  71.         evconnlistener_free(listener);
  72.         event_free(signal_event);
  73.         event_base_free(base);
  75.         printf("done\n");
  76.         return 0;
  77. }
  79. static void
  80. listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
  81.     struct sockaddr *sa, int socklen, void *user_data)
  82. {
  83.         struct event_base *base = user_data;
  84.         struct bufferevent *bev;
  86.         bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
  87.         if (!bev) {
  88.                 fprintf(stderr, "Error constructing bufferevent!");
  89.                 event_base_loopbreak(base);
  90.                 return;
  91.         }
  92.         bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL);
  93.         bufferevent_enable(bev, EV_WRITE);
  94.         bufferevent_disable(bev, EV_READ);
  96.         bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
  97. }
  99. static void
  100. conn_writecb(struct bufferevent *bev, void *user_data)
  101. {
  102.         struct evbuffer *output = bufferevent_get_output(bev);
  103.         if (evbuffer_get_length(output) == 0) {
  104.                 printf("flushed answer\n");
  105.                 bufferevent_free(bev);
  106.         }
  107. }
  109. static void
  110. conn_eventcb(struct bufferevent *bev, short events, void *user_data)
  111. {
  112.         if (events & BEV_EVENT_EOF) {
  113.                 printf("Connection closed.\n");
  114.         } else if (events & BEV_EVENT_ERROR) {
  115.                 printf("Got an error on the connection: %s\n",
  116.                     strerror(errno));/*XXX win32*/
  117.         }
  118.         /* None of the other events can happen here, since we haven't enabled
  119.          * timeouts */
  120.         bufferevent_free(bev);
  121. }
  123. static void
  124. signal_cb(evutil_socket_t sig, short events, void *user_data)
  125. {
  126.         struct event_base *base = user_data;
  127.         struct timeval delay = { 2, 0 };
  129.         printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");
  131.         event_base_loopexit(base, &delay);
  132. }

11.2 基于事件服务器

11.2.1 服务端

  1. #include <event2/event-config.h>
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <sys/queue.h>
  6. #include <unistd.h>
  7. #include <sys/time.h>
  8. #include <fcntl.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <errno.h>
  14. #include <event.h>
  16. static void
  17. fifo_read(evutil_socket_t fd, short event, void *arg)
  18. {
  19.         char buf[255];
  20.         int len;
  21.         struct event *ev = arg;
  23.         /* Reschedule this event */
  24.         event_add(ev, NULL);
  26.         fprintf(stderr, "fifo_read called with fd: %d, event: %d, arg: %p\n",
  27.             (int)fd, event, arg);
  28.         len = read(fd, buf, sizeof(buf) - 1);
  30.         if (len == -1) {
  31.                 perror("read");
  32.                 return;
  33.         } else if (len == 0) {
  34.                 fprintf(stderr, "Connection closed\n");
  35.                 return;
  36.         }
  38.         buf[len] = '\0';
  40.         fprintf(stdout, "Read: %s\n", buf);
  41. }
  43. int
  44. main(int argc, char **argv)
  45. {
  46.         struct event evfifo;
  48.         struct stat st;
  49.         const char *fifo = "event.fifo";
  50.         int socket;
  52.         if (lstat(fifo, &st) == 0) {
  53.                 if ((st.st_mode & S_IFMT) == S_IFREG) {
  54.                         errno = EEXIST;
  55.                         perror("lstat");
  56.                         exit(1);
  57.                 }
  58.         }
  60.         unlink(fifo);
  61.         if (mkfifo(fifo, 0600) == -1) {
  62.                 perror("mkfifo");
  63.                 exit(1);
  64.         }
  66.         /* Linux pipes are broken, we need O_RDWR instead of O_RDONLY */
  67.         socket = open(fifo, O_RDONLY | O_NONBLOCK, 0);
  69.         if (socket == -1) {
  70.                 perror("open");
  71.                 exit(1);
  72.         }
  74.         fprintf(stderr, "Write data to %s\n", fifo);
  76.         /* Initalize the event library */
  77.         event_init();
  79.         /* Initalize one event */
  80.         event_set(&evfifo, socket, EV_READ, fifo_read, &evfifo);
  82.         /* Add it to the active events, without a timeout */
  83.         event_add(&evfifo, NULL);
  85.         event_dispatch();
  87.         return (0);
  88. }

11.2.2 客户端

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <fcntl.h>
  6. #include <pthread.h>
  8. int main(int argc, char *argv[])
  9. {
  10.     int fd = 0;
  11.     char *str = "hello libevent!";
  13.     fd = open("event.fifo", O_RDWR);
  14.     if (fd < 0) {
  15.         perror("open error");
  16.         exit(1);
  17.     }
  19.     while (1) {
  20.         write(fd, str, strlen(str));
  21.         sleep(1);
  22.     }
  24.     close(fd);
  26.         return 0;
  27. }

11.3 回显服务器

  1. #include <event2/listener.h>
  2. #include <event2/bufferevent.h>
  3. #include <event2/buffer.h>
  5. #include <arpa/inet.h>
  7. #include <string.h>
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  12. static void
  13. echo_read_cb(struct bufferevent *bev, void *ctx)
  14. {
  15.         /* This callback is invoked when there is data to read on bev. */
  16.         struct evbuffer *input = bufferevent_get_input(bev);
  17.         struct evbuffer *output = bufferevent_get_output(bev);
  19.         /* Copy all the data from the input buffer to the output buffer. */
  20.         evbuffer_add_buffer(output, input);
  21. }
  23. static void
  24. echo_event_cb(struct bufferevent *bev, short events, void *ctx)
  25. {
  26.         if (events & BEV_EVENT_ERROR)
  27.                 perror("Error from bufferevent");
  28.         if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
  29.                 bufferevent_free(bev);
  30.         }
  31. }
  33. static void
  34. accept_conn_cb(struct evconnlistener *listener,
  35.     evutil_socket_t fd, struct sockaddr *address, int socklen,
  36.     void *ctx)
  37. {
  38.         /* We got a new connection! Set up a bufferevent for it. */
  39.         struct event_base *base = evconnlistener_get_base(listener);
  40.         struct bufferevent *bev = bufferevent_socket_new(
  41.                 base, fd, BEV_OPT_CLOSE_ON_FREE);
  43.         bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
  45.         bufferevent_enable(bev, EV_READ|EV_WRITE);
  46. }
  48. static void
  49. accept_error_cb(struct evconnlistener *listener, void *ctx)
  50. {
  51.         struct event_base *base = evconnlistener_get_base(listener);
  52.         int err = EVUTIL_SOCKET_ERROR();
  53.         fprintf(stderr, "Got an error %d (%s) on the listener. "
  54.                 "Shutting down.\n", err, evutil_socket_error_to_string(err));
  56.         event_base_loopexit(base, NULL);
  57. }
  59. int
  60. main(int argc, char **argv)
  61. {
  62.         struct event_base *base;
  63.         struct evconnlistener *listener;
  64.         struct sockaddr_in sin;
  66.         int port = 9876;
  68.         if (argc > 1) {
  69.                 port = atoi(argv[1]);
  70.         }
  71.         if (port<=0 || port>65535) {
  72.                 puts("Invalid port");
  73.                 return 1;
  74.         }
  76.         base = event_base_new();
  77.         if (!base) {
  78.                 puts("Couldn't open event base");
  79.                 return 1;
  80.         }
  82.         /* Clear the sockaddr before using it, in case there are extra
  83.          * platform-specific fields that can mess us up. */
  84.         memset(&sin, 0, sizeof(sin));
  85.         /* This is an INET address */
  86.         sin.sin_family = AF_INET;
  87.         /* Listen on 0.0.0.0 */
  88.         sin.sin_addr.s_addr = htonl(0);
  89.         /* Listen on the given port. */
  90.         sin.sin_port = htons(port);
  92.         listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
  93.             LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
  94.             (struct sockaddr*)&sin, sizeof(sin));
  95.         if (!listener) {
  96.                 perror("Couldn't create listener");
  97.                 return 1;
  98.         }
  99.         evconnlistener_set_error_cb(listener, accept_error_cb);
  101.         event_base_dispatch(base);
  102.         return 0;
  103. }

11.4 http服务器

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>     //for getopt, fork
  4. #include <string.h>     //for strcat
  5. //for struct evkeyvalq
  6. #include <sys/queue.h>
  7. #include <event.h>
  8. //for http
  9. //#include <evhttp.h>
  10. #include <event2/http.h>
  11. #include <event2/http_struct.h>
  12. #include <event2/http_compat.h>
  13. #include <event2/util.h>
  14. #include <signal.h>
  16. #define MYHTTPD_SIGNATURE   "myhttpd v 0.0.1"
  18. //处理模块
  19. void httpd_handler(struct evhttp_request *req, void *arg) {
  20.     char output[2048] = "\0";
  21.     char tmp[1024];
  23.     //获取客户端请求的URI(使用evhttp_request_uri或直接req->uri)
  24.     const char *uri;
  25.     uri = evhttp_request_uri(req);
  26.     sprintf(tmp, "uri=%s\n", uri);
  27.     strcat(output, tmp);
  29.     sprintf(tmp, "uri=%s\n", req->uri);
  30.     strcat(output, tmp);
  31.     //decoded uri
  32.     char *decoded_uri;
  33.     decoded_uri = evhttp_decode_uri(uri);
  34.     sprintf(tmp, "decoded_uri=%s\n", decoded_uri);
  35.     strcat(output, tmp);
  37.     //解析URI的参数(即GET方法的参数)
  38.     struct evkeyvalq params;
  39.     //将URL数据封装成key-value格式,q=value1, s=value2
  40.     evhttp_parse_query(decoded_uri, &params);
  41.     //得到q所对应的value
  42.     sprintf(tmp, "q=%s\n", evhttp_find_header(&params, "q"));
  43.     strcat(output, tmp);
  44.     //得到s所对应的value
  45.     sprintf(tmp, "s=%s\n", evhttp_find_header(&params, "s"));
  46.     strcat(output, tmp);
  48.     free(decoded_uri);
  50.     //获取POST方法的数据
  51.     char *post_data = (char *) EVBUFFER_DATA(req->input_buffer);
  52.     sprintf(tmp, "post_data=%s\n", post_data);
  53.     strcat(output, tmp);
  55.     /*
  56.        具体的：可以根据GET/POST的参数执行相应操作，然后将结果输出
  57.        ...
  58.      */
  60.     /* 输出到客户端 */
  62.     //HTTP header
  63.     evhttp_add_header(req->output_headers, "Server", MYHTTPD_SIGNATURE);
  64.     evhttp_add_header(req->output_headers, "Content-Type", "text/plain; charset=UTF-8");
  65.     evhttp_add_header(req->output_headers, "Connection", "close");
  66.     //输出的内容
  67.     struct evbuffer *buf;
  68.     buf = evbuffer_new();
  69.     evbuffer_add_printf(buf, "It works!\n%s\n", output);
  70.     evhttp_send_reply(req, HTTP_OK, "OK", buf);
  71.     evbuffer_free(buf);
  73. }
  74. void show_help() {
  75.     char *help = "http://localhost:8080\n"
  76.         "-l <ip_addr> interface to listen on, default is 0.0.0.0\n"
  77.         "-p <num>     port number to listen on, default is 1984\n"
  78.         "-d           run as a deamon\n"
  79.         "-t <second>  timeout for a http request, default is 120 seconds\n"
  80.         "-h           print this help and exit\n"
  81.         "\n";
  82.     fprintf(stderr,"%s",help);
  83. }
  84. //当向进程发出SIGTERM/SIGHUP/SIGINT/SIGQUIT的时候，终止event的事件侦听循环
  85. void signal_handler(int sig) {
  86.     switch (sig) {
  87.         case SIGTERM:
  88.         case SIGHUP:
  89.         case SIGQUIT:
  90.         case SIGINT:
  91.             event_loopbreak();  //终止侦听event_dispatch()的事件侦听循环，执行之后的代码
  92.             break;
  93.     }
  94. }
  96. int main(int argc, char *argv[]) {
  97.     //自定义信号处理函数
  98.     signal(SIGHUP, signal_handler);
  99.     signal(SIGTERM, signal_handler);
  100.     signal(SIGINT, signal_handler);
  101.     signal(SIGQUIT, signal_handler);
  103.     //默认参数
  104.     char *httpd_option_listen = "0.0.0.0";
  105.     int httpd_option_port = 8080;
  106.     int httpd_option_daemon = 0;
  107.     int httpd_option_timeout = 120; //in seconds
  109.     //获取参数
  110.     int c;
  111.     while ((c = getopt(argc, argv, "l:p:dt:h")) != -1) {
  112.         switch (c) {
  113.             case 'l' :
  114.                 httpd_option_listen = optarg;
  115.                 break;
  116.             case 'p' :
  117.                 httpd_option_port = atoi(optarg);
  118.                 break;
  119.             case 'd' :
  120.                 httpd_option_daemon = 1;
  121.                 break;
  122.             case 't' :
  123.                 httpd_option_timeout = atoi(optarg);
  124.                 break;
  125.             case 'h' :
  126.             default :
  127.                 show_help();
  128.                 exit(EXIT_SUCCESS);
  129.         }
  130.     }
  132.     //判断是否设置了-d，以daemon运行
  133.     if (httpd_option_daemon) {
  134.         pid_t pid;
  135.         pid = fork();
  136.         if (pid < 0) {
  137.             perror("fork failed");
  138.             exit(EXIT_FAILURE);
  139.         }
  140.         if (pid > 0) {
  141.             //生成子进程成功，退出父进程
  142.             exit(EXIT_SUCCESS);
  143.         }
  144.     }
  146.     /* 使用libevent创建HTTP Server */
  148.     //初始化event API
  149.     event_init();
  151.     //创建一个http server
  152.     struct evhttp *httpd;
  153.     httpd = evhttp_start(httpd_option_listen, httpd_option_port);
  154.     evhttp_set_timeout(httpd, httpd_option_timeout);
  156.     //指定generic callback
  157.     evhttp_set_gencb(httpd, httpd_handler, NULL);
  158.     //也可以为特定的URI指定callback
  159.     //evhttp_set_cb(httpd, "/", specific_handler, NULL);
  161.     //循环处理events
  162.     event_dispatch();
  164.     evhttp_free(httpd);
  165.     return 0;
  166. }