　　本文是关于libevent库第一篇博文，主要由例子来说明如何利用该库。后续博文再深入研究该库原理。

libevent库简介

　　就如libevent官网上所写的“libevent - an event notification library”，libevent就是一个基于事件通知机制的库，支持/dev/poll、kqueue、event ports、select、poll和epoll事件机制，也因此它是一个跨操作系统的库（支持Linux、*BSD、Mac OS X、Solaris、Windows等）。目前应用该库的有Chromium、Memcached、NTP、tmux等应用。

　　libevent 库实际上没有更换select()、poll()或其他机制的基础，而是使用对于每个平台最高效的高性能解决方案，在其实现外加上一个包装器。

　　为了实际处理每个请求，libevent 库提供一种事件机制，它作为底层网络后端的包装器。事件系统让为连接添加处理函数变得非常简便，同时降低了底层 I/O 复杂性。这是 libevent 系统的核心。

　　libevent 库的其他组件提供其他功能，包括缓冲的事件系统（用于缓冲发送到客户端/从客户端接收的数据）以及 HTTP、DNS 和 RPC 系统的核心实现。

　　另外，libevent库非常轻量级，这让我们学习它的源码难度低了不少。关于源码分析具体可参考：

　　Libevent源码分析

　　libevent源码深度剖析

　　如果要生成libevent库的文档，可参考博文使用Doxygen生成libevent document（2.0.15）-- CHM格式。

回显服务端示例

简易流程

　　创建 libevent 服务器的基本方法是，注册当发生某一操作（比如接受来自客户端的连接）时应该执行的函数，然后调用主事件循环event_base_dispatch()。执行过程的控制由 libevent系统处理。注册事件和将调用的函数之后，事件系统开始自治；在应用程序运行时，可以在事件队列中添加（注册）或删除（取消注册）事件。事件注册非常方便，可以通过它添加新事件以处理新打开的连接，从而构建灵活的网络处理系统。

　　例如，可以打开一个监听套接字，然后注册一个回调函数，每当需要调用accept()函数以打开新连接时调用这个回调函数，这样就创建了一个网络服务器。下边所示的代码片段说明了这个基本过程：

 int main(int argc, char **argv)

 {

     /* Declare a socket file descriptor. */

     evutil_socket_t listenfd;

     /* Setup listening socket */

     /* Make the listen socket reuseable and non-blocking. */

     evutil_make_listen_socket_reuseable(listenfd);

     evutil_make_socket_nonblocking(listenfd);

     /* Declare an event_base to host events. */

     struct event_base *base = event_base_new();

     /* Register listen event. */

     struct event *listen_event;

     listen_event = event_new(base, listenfd, EV_READ | EV_PERSIST, do_accetp, (void *)base);

     event_add(listen_event, NULL);

     /* Start the event loop. */

     event_base_dispatch(base);

     /* End. */

     close(listenfd);
     return ;

 }

　　下边详细介绍上边程序中用到的libevent中的API：

　　1）evutil_socket_t 定义于Util.h头文件中，用于跨平台表示socket的ID（在Linux下表示的是其文件描述符），如下所示：

/**

 * A type wide enough to hold the output of "socket()" or "accept()".  On

 * Windows, this is an intptr_t; elsewhere, it is an int. */

#ifdef WIN32

#define evutil_socket_t intptr_t

#else

#define evutil_socket_t int

#endif

　　2）evutil_make_listen_socket_reuseable 函数声明于Util.h，实现于Evutil.c，用于跨平台将socket设置为可重用（实际上是将端口设为可重用，具体可参照博文Linux 套接字编程中的 5 个隐患中的第3个隐患），具体定义如下：

int

evutil_make_listen_socket_reuseable(evutil_socket_t sock)

{

#ifndef WIN32

    int one = ;

    /* REUSEADDR on Unix means, "don't hang on to this address after the

     * listener is closed."  On Windows, though, it means "don't keep other

     * processes from binding to this address while we're using it. */

    return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*) &one,

        (ev_socklen_t)sizeof(one));

#else

    return ;

#endif

}

　　同样，evutil_make_socket_nonblocking函数也声明于Util.h，实现于Evutil.c，用于跨平台将socket设置为非阻塞，具体定义如下：

int

evutil_make_socket_nonblocking(evutil_socket_t fd)

{

#ifdef WIN32

    {

        u_long nonblocking = ;

        if (ioctlsocket(fd, FIONBIO, &nonblocking) == SOCKET_ERROR) {

            event_sock_warn(fd, "fcntl(%d, F_GETFL)", (int)fd);

            return -;

        }

    }

#else

    {

        int flags;

        if ((flags = fcntl(fd, F_GETFL, NULL)) < ) {

            event_warn("fcntl(%d, F_GETFL)", fd);

            return -;

        }

        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -) {

            event_warn("fcntl(%d, F_SETFL)", fd);

            return -;

        }

    }

#endif

    return ;

}

　　3）event_base结构体定义在event_internal.h中，它记录了所有的等待和已激活的事件，并当有事件被激活时通知调用者。默认地，我们用event_base_new函数就可以新建一个event_base对象。event_base_new函数的定义如下：

struct event_base *

event_base_new(void)

{

    struct event_base *base = NULL;

    struct event_config *cfg = event_config_new();

    if (cfg) {

        base = event_base_new_with_config(cfg);

        event_config_free(cfg);

    }

    return base;

}

　　也就是说实际上该函数调用了event_base_new_with_config来创建event_base对象，所以我们也可以利用event_config_new和event_base_new_with_config定制event_base对象。

　　4）event结构体定义在event_struct.h文件中，主要记录事件的相关属性。event_new函数用于创建一个event对象，具体定义如下：

struct event *

event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)

{

    struct event *ev;

    ev = mm_malloc(sizeof(struct event));

    if (ev == NULL)

        return (NULL);

    if (event_assign(ev, base, fd, events, cb, arg) < ) {

        mm_free(ev);

        return (NULL);

    }

    return (ev);

}

// Parameters:

    // base            the event base to which the event should be attached.

    // fd              the file descriptor or signal to be monitored, or -1.

    // events          desired events to monitor: bitfield of EV_READ, EV_WRITE, EV_SIGNAL, EV_PERSIST, EV_ET.

    // callback        callback function to be invoked when the event occurs

    // callback_arg    an argument to be passed to the callback function

// Returns:

    // a newly allocated struct event that must later be freed with event_free().

　　在上边程序中，cb是回调函数，其原型如下：

/**

   A callback function for an event.

   It receives three arguments:

   @param fd An fd or signal

   @param events One or more EV_* flags

   @param arg A user-supplied argument.

   @see event_new()

 */

typedef void (*event_callback_fn)(evutil_socket_t, short, void *);

　　5）event_base_dispatch函数开启事件轮询（event_base_loop提供同样功能，不过更为灵活，实际event_base_dispatch只是event_base_loop的特例），定义如下：

int

event_base_dispatch(struct event_base *event_base)

{

    return (event_base_loop(event_base, ));

}

实际例子

　　一个完整的服务器端的程序如下：

 #include <stdio.h>

 #include <stdlib.h>

 #include <errno.h>

 #include <assert.h>

 #include <unistd.h>

 #include <netinet/in.h>

 #include <sys/socket.h>

 #include <arpa/inet.h>

 #include <sys/types.h>

 #include <event2/event.h>

 #include <event2/bufferevent.h>

 #define SERV_PORT 9877

 #define LISTEN_BACKLOG 32

 #define MAX_LINE 1024

 void do_accetp(evutil_socket_t listenfd, short event, void *arg);

 void read_cb(struct bufferevent *bev, void *arg);

 void error_cb(struct bufferevent *bev, short event, void *arg);

 void write_cb(struct bufferevent *bev, void *arg);

 int main(int argc, int **argv)

 {

     evutil_socket_t listenfd;

     if((listenfd = socket(AF_INET, SOCK_STREAM, )) < )

     {

         perror("socket\n");

         return ;

     }

     struct sockaddr_in servaddr;

     bzero(&servaddr, sizeof(servaddr));

     servaddr.sin_family = AF_INET;

     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

     servaddr.sin_port = htons(SERV_PORT);

     if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < )

     {

         perror("bind\n");

         return ;

     }

     if(listen(listenfd, LISTEN_BACKLOG) < )

     {

         perror("listen\n");

         return ;

     }

     printf("Listening...\n");

     evutil_make_listen_socket_reuseable(listenfd);

     evutil_make_socket_nonblocking(listenfd);

     struct event_base *base = event_base_new();

     if(base == NULL)

     {

         perror("event_base\n");

         return ;

     }

     const char *eventMechanism = event_base_get_method(base);

     printf("Event mechanism used is %s\n", eventMechanism);

     struct event *listen_event;

     listen_event = event_new(base, listenfd, EV_READ | EV_PERSIST, do_accetp, (void *)base);

     event_add(listen_event, NULL);

     event_base_dispatch(base);

     if(close(listenfd) < )

     {

         perror("close\n");

         return ;

     }

     printf("The End\n");

     return ;

 }

 void do_accetp(evutil_socket_t listenfd, short event, void *arg)

 {

     struct event_base *base = (struct event_base *)arg;

     evutil_socket_t fd;

     struct sockaddr_in cliaddr;

     socklen_t clilen;

     fd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);

     if(fd < )

     {

         perror("accept\n");

         return;

     }

     if(fd > FD_SETSIZE)

     {

         perror("fd > FD_SETSIZE");

         if(close(fd) < )

         {

             perror("close\n");

             return;

         }

         return;

     }

     printf("Accept: fd = %u\n", fd);

     struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

     bufferevent_setcb(bev, read_cb, NULL, error_cb, arg);

     bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST);

 }

 void read_cb(struct bufferevent *bev, void *arg)

 {

     char line[MAX_LINE + ];

     int n;

     evutil_socket_t fd = bufferevent_getfd(bev);

     while((n = bufferevent_read(bev, line, MAX_LINE)) > )

     {

         line[n] = '\0';

         printf("fd = %u, read line: %s", fd, line);

         bufferevent_write(bev, line, n);

     }

 }

 void error_cb(struct bufferevent *bev, short event, void *arg)

 {

     evutil_socket_t fd = bufferevent_getfd(bev);

     printf("fd = %u, ", fd);

     if(event & BEV_EVENT_TIMEOUT)

         printf("Time out.\n");  // if bufferevent_set_timeouts() is called

     else if(event & BEV_EVENT_EOF)

         printf("Connection closed.\n");

     else if(event & BEV_EVENT_ERROR)

         printf("Some other error.\n");

     bufferevent_free(bev);

 }

 void write_cb(struct bufferevent *bev, void *arg)

 {

     // leave blank

 }

　　注意：在Linux下编译时需要加libevent静态库event，即gcc ... -levent。

　　上边程序中用到的bufferevent值得再说明一下。bufferevent由一个底层的传输端口（如套接字）、一个读取缓冲区和一个写入缓冲区组成。与通常的事件在底层传输端口已经就绪，可以读取或者写入的时候执行回调不同的是，bufferevent在读取或者写入了足够量的数据之后调用用户提供的回调。详细可参考博文libevent参考手册第六章：bufferevent：概念和入门。

　　利用bufferevent的简易流程如下：

 struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

 bufferevent_setcb(bev, read_cb, NULL, error_cb, arg);

 bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST);

　　 bufferevent_setcb使得我们可以定制我们自己的回调函数，这里我们只用到了读和错误回调函数。最后，我们要调用bufferevent_enable来使得bufferevent启动。

客户端示例

　　客户端用到的libevent的API跟服务端的基本一样。具体程序如下：

 #include <stdio.h>

 #include <stdlib.h>

 #include <errno.h>

 #include <unistd.h>

 #include <string.h>

 #include <netinet/in.h>

 #include <sys/socket.h>

 #include <arpa/inet.h>

 #include <sys/types.h>

 #include <event2/event.h>

 #include <event2/bufferevent.h>

 #define SERV_PORT 9877

 #define MAX_LINE 1024

 void cmd_msg_cb(int fd, short event, void *arg);

 void read_cb(struct bufferevent *bev, void *arg);

 void error_cb(struct bufferevent *bev, short event, void *arg);

 int main(int argc, char *argv[])

 {

     if(argc < )

     {

         perror("usage: echocli <IPadress>");

         return ;

     }

     evutil_socket_t sockfd;

     if((sockfd = socket(AF_INET, SOCK_STREAM, )) < )

     {

         perror("socket\n");

         return ;

     }

     struct sockaddr_in servaddr;

     bzero(&servaddr, sizeof(servaddr));

     servaddr.sin_family = AF_INET;

     servaddr.sin_port = htons(SERV_PORT);

     if(inet_pton(AF_INET, argv[], &servaddr.sin_addr) < )

     {

         perror("inet_ntop\n");

         return ;

     }

     if(connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < )

     {

         perror("connect\n");

         return ;

     }

     evutil_make_socket_nonblocking(sockfd);

     printf("Connect to server sucessfully!\n");

     struct event_base *base = event_base_new();

     if(base == NULL)

     {

         perror("event_base\n");

         return ;

     }

     const char *eventMechanism = event_base_get_method(base);

     printf("Event mechanism used is %s\n", eventMechanism);

     printf("sockfd = %d\n", sockfd);

     struct bufferevent *bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);

     struct event *ev_cmd;

     ev_cmd = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST, cmd_msg_cb, (void *)bev);

     event_add(ev_cmd, NULL);

     bufferevent_setcb(bev, read_cb, NULL, error_cb, (void *)ev_cmd);

     bufferevent_enable(bev, EV_READ | EV_PERSIST);

     event_base_dispatch(base);

     printf("The End.");

     return ;

 }

 void cmd_msg_cb(int fd, short event, void *arg)

 {

     char msg[MAX_LINE];

     int nread = read(fd, msg, sizeof(msg));

     if(nread < )

     {

         perror("stdio read fail\n");

         return;

     }

     struct bufferevent *bev = (struct bufferevent *)arg;

     bufferevent_write(bev, msg, nread);

 }

 void read_cb(struct bufferevent *bev, void *arg)

 {

     char line[MAX_LINE + ];

     int n;

     evutil_socket_t fd = bufferevent_getfd(bev);

     while((n = bufferevent_read(bev, line, MAX_LINE)) > )

     {

         line[n] = '\0';

         printf("fd = %u, read from server: %s", fd, line);

     }

 }

 void error_cb(struct bufferevent *bev, short event, void *arg)

 {

     evutil_socket_t fd = bufferevent_getfd(bev);

     printf("fd = %u, ", fd);

     if(event & BEV_EVENT_TIMEOUT)

         printf("Time out.\n");  // if bufferevent_set_timeouts() is called

     else if(event & BEV_EVENT_EOF)

         printf("Connection closed.\n");

     else if(event & BEV_EVENT_ERROR)

         printf("Some other error.\n");

     bufferevent_free(bev);

     struct event *ev = (struct event *)arg;

     event_free(ev);

 }

参考资料

　　libevent入门

　　A tiny introduction to asynchronous IO

　　使用 libevent 和 libev 提高网络应用性能

　 libevent参考手册第六章：bufferevent：概念和入门

巴特西

轻量级网络库libevent初探