libevent学习笔记【使用篇】——6a. Bufferevents高级话题

深碍√TFBOYSˉ_ 2022-07-16 12:19 417阅读 0赞

原文：[http://blog.csdn.net/windeal3203/article/details/52849236][http_blog.csdn.net_windeal3203_article_details_52849236]  
译自： [http://www.wangafu.net/~nickm/libevent-book/Ref6a\_advanced\_bufferevents.html][http_www.wangafu.net_nickm_libevent-book_Ref6a_advanced_bufferevents.html]  
本章描述bufferevent的一些对通常使用不必要的高级特征。如果只想学习如何使用bufferevent，可以跳过这一章，直接阅读下一章。

# 1. 成对的bufferevents #

有时， 网络程序可能需要和自己通信。 举个例子：通过某些协议对用户连接进行隧道操作的程序，有时候也需要通过同样的协议对自身的连接进行隧道操作。当然，可以通过打开一个到自身监听端口的连接，让程序使用这个连接来达到这种目标。但是，通过网络栈来与自身通信比较浪费资源。  
　　有一种替代方案是：创建一对成对的bufferevent。这样，写入到一个bufferevent的字节都被另一个接收（反过来也是），但是不需要使用真正的套接字。

int bufferevent_pair_new(struct event_base *base, int options,
        struct bufferevent *pair[2]);

调用`bufferevent_pair_new()`会把`pair[0]`和`pair[1]` 设置为一对相互连接的bufferevent。除了`BEV_OPT_CLOSE_ON_FREE`无效、`BEV_OPT_DEFER_CALLBACKS`总是打开的之外，所有通用的选项都是支持的。  
　　为什么bufferevent需要带延迟回调运行？通常某一方上的操作会调用一个通知另一方的回调，从而调用另一方的回调，如此这样进行很多步。如果不延迟回调，这种调用链常常会导致栈溢出或者饿死其他连接，而且还要求所有的回调是可重入的。  
成对的bufferevent支持flush：设置模式参数为`BEV_NORMAL`或者`BEV_FLUSH`会强制要求所有相关数据从对中的一个bufferevent传输到另一个中，而忽略可能会限制传输的水位设置。增加`BEV_FINISHED`到模式参数中还会让对端的bufferevent产生EOF事件。  
释放对中的任何一个成员不会自动释放另一个，也不会产生EOF事件。释放仅仅会使对中的另一个成员成为断开的。bufferevent一旦断开，就不能再成功读写数据或者产生任何事件了。

struct bufferevent *bufferevent_pair_get_partner(struct bufferevent *bev)

有时候在给出了对的一个成员时，需要获取另一个成员，这时候可以使用`bufferevent_pair_get_partner()`。如果bev是对的成员，而且对的另一个成员仍然存在，函数将返回另一个成员；否则，函数返回NULL。

bufferevent对由2.0.1-alpha版本引入，而bufferevent\_pair\_get\_partner()函数由2.0.6版本引入。

# 2 过滤bufferevent #

有时候需要转换传递给某bufferevent对象的所有数据，这可以通过添加一个压缩层，或者将协议包装到另一个协议中进行传输来实现。

enum bufferevent_filter_result {
            BEV_OK = 0,
            BEV_NEED_MORE = 1,
            BEV_ERROR = 2
    };
    typedef enum bufferevent_filter_result (*bufferevent_filter_cb)(
        struct evbuffer *source, struct evbuffer *destination, ev_ssize_t dst_limit,
        enum bufferevent_flush_mode mode, void *ctx);
    
    
    struct bufferevent *bufferevent_filter_new(struct bufferevent *underlying,
            bufferevent_filter_cb input_filter,
            bufferevent_filter_cb output_filter,
            int options,
            void (*free_context)(void *),
            void *ctx);

`bufferevent_filter_new()`函数创建一个封装现有的“底层”bufferevent的过滤bufferevent。所有通过底层bufferevent接收的数据在到达过滤bufferevent之前都会经过“input”过滤器的转换；所有通过底层bufferevent发送的数据在被发送到底层bufferevent之前都会经过“output”过滤器的转换。  
向底层bufferevent添加过滤器将替换其回调函数。可以向底层bufferevent的evbuffer添加回调函数，但是如果想让过滤器正确工作，就不能再设置bufferevent本身的回调函数。  
`input_filter`和`output_filter`函数将在后面描述。`options`参数支持所有通常的选项。如果设置了`BEV_OPT_CLOSE_ON_FREE`，那么释放过滤bufferevent也会同时释放底层bufferevent。`ctx`参数是传递给过滤函数的任意指针；如果提供了`free_context` 实参，则在释放`ctx`之前它会被调用。  
底层输入缓冲区有数据可读时，input filter函数会被调用；过滤器的输出缓冲区有新的数据待写入时，output filter函数会被调用。两个过滤器函数都有一对evbuffer参数：从source evbuffer读取数据；向destination evbuffer写入数据，而`dst_limit`参数描述了可以写入到`destination`的字节数上限。过滤器函数可以忽略这个参数，但是这样可能会违背高水位或者速率限制。如果`dst_limit`是-1，则没有限制。`mode`参数向过滤器描述了写入的方式。值`BEV_NORMAL`表示应该在方便转换的基础上写入尽可能多的数据；而`BEV_FLUSH`表示写入尽可能多的数据；`BEV_FINISHED`表示过滤器函数应该在流的末尾执行额外的清理操作。最后，过滤器函数的`ctx`参数就是传递给`bufferevent_filter_new()`函数的指针（ctx参数）。  
如果成功向目标缓冲区写入了任何数据，过滤器函数应该返回`BEV_OK`；如果不获得更多的输入，或者不使用不同的清空（flush）模式，就不能向目标缓冲区写入更多的数据，则应该返回`BEV_NEED_MORE`；如果过滤器上发生了不可恢复的错误，则应该返回`BEV_ERROR`。  
创建过滤器将启用底层bufferevent的读取和写入。随后就不需要自己管理读取和写入了：过滤器在不想读取的时候会自动挂起底层bufferevent的读取。从2.0.8-rc版本开始，可以在过滤器之外独立地启用/禁用底层bufferevent的读取和写入。然而，这样可能会让过滤器不能成功取得所需要的数据。  
不需要同时指定输入和输出过滤器：没有给定的过滤器将被一个不进行数据转换的过滤器取代。

# 3 限制每次读写的最大值 #

默认情况下，bufferevent在每一次请求的时候，不会读、写（可能的）最大字节数，因为这会导致不可预知的错误和资源匮乏。 然而，这种默认值，可能不一定所有的情况都生效。

int bufferevent_set_max_single_read(struct bufferevent *bev, size_t size);
    int bufferevent_set_max_single_write(struct bufferevent *bev, size_t size);
    
    ev_ssize_t bufferevent_get_max_single_read(struct bufferevent *bev);
    ev_ssize_t bufferevent_get_max_single_write(struct bufferevent *bev);

两个`set` 函数分别替换了当前读写的最大值。 如果`size`值为0 或者大于`EV_SSIZE_MAX`, 则可读、可写的maxima被设置为默认值。函数返回0表示成功，-1表示失败。  
两个get函数分别用于返回当前每次读写的maxima。  
这些函数在2.1.1-alpha开始被加入。

# 4 bufferevent和速率限制 #

某些程序需要限制单个或者一组bufferevent使用的带宽。2.0.4-alpha和2.0.5-alpha版本添加了为单个或者一组bufferevent设置速率限制的基本功能。

## 4.1 速率限制模型 ##

libevent的速率限制使用**记号存储器（token bucket）**算法确定在某时刻可以写入或者读取多少字节。每个速率限制对象在任何给定时刻都有一个**读存储器（read bucket）**和一个**写存储器（write bucket）**，其大小决定了对象允许立即读取或者写入多少字节。每个bucket有一个填充速率，一个最大突发尺寸，和一个时间单位，或者说“滴答（tick）”。每当一个时间单位流逝后，存储器被填充一些字节（决定于填充速率）——但是如果超过其突发尺寸，则超出的字节会丢失。  
因此，填充速率决定了对象发送或者接收字节的最大平均速率，而突发尺寸决定了在单次突发中可以发送或者接收的最大字节数；时间单位则确定了传输的平滑程度。

## 4.2 在bufferevent上设置速率限制 ##

#define EV_RATE_LIMIT_MAX EV_SSIZE_MAX
    struct ev_token_bucket_cfg;
    struct ev_token_bucket_cfg *ev_token_bucket_cfg_new(
            size_t read_rate, size_t read_burst,
            size_t write_rate, size_t write_burst,
            const struct timeval *tick_len);
    void ev_token_bucket_cfg_free(struct ev_token_bucket_cfg *cfg);
    int bufferevent_set_rate_limit(struct bufferevent *bev,
        struct ev_token_bucket_cfg *cfg);

一个`ev_token_bucket_cfg`结构体表示用于限制单个或者一组bufferevent的用于限制读写的一对记号存储器的配置值。要创建一个`ev_token_bucket_cfg`，调用`ev_token_bucket_cfg_new`函数，并且提供最大平均读取速率、最大突发读取量、最大平均写入速率、最大突发写入量，以及一个滴答的长度。如果`tick_len`参数为`NULL`，则默认的滴答长度为一秒。如果发生错误，函数会返回`NULL`。  
注意：`read_rate`和`write_rate`参数的单位是字节每滴答。也就是说，如果滴答长度是十分之一秒，`read_rate`是300，则最大平均读取速率是3000字节每秒。此外，不支持大于`EV_RATE_LIMIT_MAX`的速率或者突发量。  
要限制bufferevent的传输速率，使用一个`ev_token_bucket_cfg`，对其调用`bufferevent_set_rate_limit()`。成功时函数返回0，失败时返回-1。可以对任意数量的bufferevent使用相同的`ev_token_bucket_cfg`。要移除速率限制，可以调用`bufferevent_set_rate_limit()`，传递`NULL`作为`cfg`参数值。  
调用`ev_token_bucket_cfg_free()`可以释放`ev_token_bucket_cfg`。注意：当前在没有任何bufferevent使用`ev_token_bucket_cfg`之前进行释放是不安全的。

## 4.3 设置一组bufferevent的速率限制 ##

如果要限制一组bufferevent总的带宽使用，可以将它们分配到一个速率限制组中。

struct bufferevent_rate_limit_group;
    
    struct bufferevent_rate_limit_group *bufferevent_rate_limit_group_new(
            struct event_base *base,
            const struct ev_token_bucket_cfg *cfg);
    int bufferevent_rate_limit_group_set_cfg(
            struct bufferevent_rate_limit_group *group,
            const struct ev_token_bucket_cfg *cfg);
    void bufferevent_rate_limit_group_free(struct bufferevent_rate_limit_group *);
    int bufferevent_add_to_rate_limit_group(struct bufferevent *bev,
        struct bufferevent_rate_limit_group *g);
    int bufferevent_remove_from_rate_limit_group(struct bufferevent *bev);

要创建速率限制组，使用一个`event_base`和一个已经初始化的`ev_token_bucket_cfg`作为参数调用`bufferevent_rate_limit_group`函数。使用`bufferevent_add_to_rate_limit_group`将bufferevent添加到组中；使用`bufferevent_remove_from_rate_limit_group`从组中删除bufferevent。这些函数成功时返回0，失败时返回-1。  
单个bufferevent在某时刻只能是一个速率限制组的成员。bufferevent可以同时有单独的速率限制（通过`bufferevent_set_rate_limit`设置）和组速率限制。设置了这两个限制时，对每个bufferevent，较低的限制将被应用。  
调用`bufferevent_rate_limit_group_set_cfg`修改组的速率限制。函数成功时返回0，失败时返回-1。`bufferevent_rate_limit_group_free`函数释放速率限制组，移除所有成员。  
在2.0版本中，组速率限制试图实现总体的公平，但是具体实现可能在小的时间范围内并不公平。如果你强烈关注调度的公平性，请帮助提供未来版本的补丁。

## 4.4 检查当前速率限制 ##

有时候需要得知应用到给定bufferevent或者组的速率限制，为此，libevent提供了函数：

ev_ssize_t bufferevent_get_read_limit(struct bufferevent *bev);
    ev_ssize_t bufferevent_get_write_limit(struct bufferevent *bev);
    ev_ssize_t bufferevent_rate_limit_group_get_read_limit(
            struct bufferevent_rate_limit_group *);
    ev_ssize_t bufferevent_rate_limit_group_get_write_limit(
            struct bufferevent_rate_limit_group *);

上述函数返回以字节为单位的bufferevent或者组的读写记号存储器大小。注意：如果bufferevent已经被强制超过其配置（清空(flush)操作就会这样），则这些值可能是负数。

ev_ssize_t bufferevent_get_max_to_read(struct bufferevent *bev);
    ev_ssize_t bufferevent_get_max_to_write(struct bufferevent *bev);

这些函数返回了一个bufferevent能够立即读写的字节数， 这里考虑了任何应用到bufferevent的速率限制， 比如组速率限制（如果有的话），以及libevent全局设置的maximum-to-read/write-at-a-time values。

void bufferevent_rate_limit_group_get_totals(
        struct bufferevent_rate_limit_group *grp,
        ev_uint64_t *total_read_out, ev_uint64_t *total_written_out);
    void bufferevent_rate_limit_group_reset_totals(
        struct bufferevent_rate_limit_group *grp);

每个`bufferevent_rate_limit_group`跟踪经其发送的总的字节数，这可用于跟踪组中所有bufferevent总的使用情况。对一个组调用`bufferevent_rate_limit_group_get_totals`会分别设置`total_read_out`和`total_written_out`为组的总读取和写入字节数。组创建的时候这些计数从0开始，调用`bufferevent_rate_limit_group_reset_totals`会复位计数为0。

## 4.5 手动调整速率限制 ##

对于有复杂需求的程序，可能需要手动调整记号存储器的当前值。比如说，如果程序不通过使用bufferevent的方式产生一些通信量时。

int bufferevent_decrement_read_limit(struct bufferevent *bev, ev_ssize_t decr);
    int bufferevent_decrement_write_limit(struct bufferevent *bev, ev_ssize_t decr);
    int bufferevent_rate_limit_group_decrement_read(
            struct bufferevent_rate_limit_group *grp, ev_ssize_t decr);
    int bufferevent_rate_limit_group_decrement_write(
            struct bufferevent_rate_limit_group *grp, ev_ssize_t decr);

这些函数减小某个bufferevent或者速率限制组的当前读或者写存储器。注意：减小是有符号的。如果要增加存储器，就传入负值。

## 4.6 设置速率限制组的最小可能共享 ##

通常，不希望在每个滴答中为速率限制组中的所有bufferevent平等地分配可用的字节。比如说，有一个含有10000个活动bufferevent的速率限制组，它在每个滴答中可以写入10000字节，那么，因为系统调用和TCP头部的开销，让每个bufferevent在每个滴答中仅写入1字节是低效的。  
为解决此问题，速率限制组有一个“最小共享（minimum share）”的概念。在上述情况下，不是允许每个bufferevent在每个滴答中写入1字节，而是在每个滴答中允许某个bufferevent写入指定（最小共享）字节，而其余的bufferevent将不允许写入。允许哪个bufferevent写入将在每个滴答中随机选择。  
默认的最小共享值具有较好的性能，当前（2.0.6-rc版本）其值为64。可以通过这个函数调整最小共享值：

int bufferevent_rate_limit_group_set_min_share(
            struct bufferevent_rate_limit_group *group, size_t min_share);

设置min\_share为0将会完全禁止最小共享。  
速率限制功能从引入开始就具有最小共享了，而修改最小共享的函数在2.0.6-rc版本首次引入。

## 4.7 速率限制实现的限制 ##

就2.0版本来说，libevent的速率限制具有一些实现上的限制：

*  不是每种bufferevent类型都良好地或者说完整地支持速率限制。
 *  bufferevent速率限制组不能嵌套，一个bufferevent在某时刻只能属于一个速率限制组。
 *  速率限制实现仅计算TCP分组传输的数据，不包括TCP头部。
 *  读速率限制实现依赖于TCP栈通知应用程序仅仅以某速率消费数据，并且在其缓冲区满的时候将数据推送到TCP连接的另一端。
 *  某些bufferevent实现（特别是Windows中的IOCP实现）可能调拨过度。
 *  存储器开始于一个滴答的通信量。这意味着bufferevent可以立即开始读取或者写入，而不用等待一个滴答的时间。但是这也意味着速率被限制为N.1个滴答的bufferevent可能传输N+1个滴答的通信量。
 *  滴答不能小于1毫秒，毫秒的小数部分都被忽略。

# 5 Bufferevent 和 SSL #

bufferevent可以使用OpenSSL库实现SSL/TLS安全传输层。因为很多应用不需要或者不想链接OpenSSL，这部分功能在单独的libevent\_openssl库中实现。未来版本的libevent可能会添加其他SSL/TLS库，如NSS或者GnuTLS，但是当前只有OpenSSL。  
OpenSSL功能在2.0.3-alpha版本引入，然而直到2.0.5-beta和2.0.6-rc版本才能良好工作。  
这一节不包含对OpenSSL、SSL/TLS或者密码学的概述。  
这一节描述的函数都在`event2/bufferevent_ssl.h`中声明。

## 5.1 创建和使用基于OpenSSL的bufferevent ##

enum bufferevent_ssl_state {
            BUFFEREVENT_SSL_OPEN = 0,
            BUFFEREVENT_SSL_CONNECTING = 1,
            BUFFEREVENT_SSL_ACCEPTING = 2
    };
    
    struct bufferevent *
    bufferevent_openssl_filter_new(struct event_base *base,
        struct bufferevent *underlying,
        SSL *ssl,
        enum bufferevent_ssl_state state,
        int options);
    
    struct bufferevent *
    bufferevent_openssl_socket_new(struct event_base *base,
        evutil_socket_t fd,
        SSL *ssl,
        enum bufferevent_ssl_state state,
        int options);

可以创建两种类型的SSL bufferevent：基于过滤器的、在另一个底层bufferevent之上进行通信的buffervent；或者基于套接字的、直接使用OpenSSL进行网络通信的bufferevent。这两种bufferevent都要求提供SSL对象及其状态描述。如果SSL当前作为客户端在进行协商，状态应该是`BUFFEREVENT_SSL_CONNECTING`；如果作为服务器在进行协商，则是`BUFFEREVENT_SSL_ACCEPTING`；如果SSL握手已经完成，则状态是`BUFFEREVENT_SSL_OPEN`。  
接受通常的选项。`BEV_OPT_CLOSE_ON_FREE`表示在关闭`openssl bufferevent`对象的时候同时关闭SSL对象和底层fd或者bufferevent。  
一旦握手完成，新的bufferevent的事件回调会被唤醒，并携带了`BEV_EVENT_CONNECTED`标志。  
创建基于套接字的bufferevent时，如果SSL对象已经设置了套接字，就不需要提供套接字了：只要传递-1就可以。也可以随后调用`bufferevent_setfd()`来设置。  
/// TODO: 一旦`bufferevent_shutdown`API完成时，移除以下内容。  
注意： 当`BEV_OPT_CLOSE_ON_FREE`被设置在SSL bufferevent时， SSL 连接并不会执行clean shutdown。 这会导致两个问题： 首先，在对端看起来，连接似乎是broken了，而不是被清洁后关闭： 对端不会被告是你关闭了连接， 或者是连接受到了第三方的攻击而broken了； 其次， OpenSSL会将这个会话视为“bad”， 并且在session cache中被移除。 这会导致SSL应用程序性能的严重恶化。  
目前，仅有的workground是使用lasy SSL 手动shutdowns。 虽然它不符合TLS RFC， 但可以保证会话被关闭时也会保留在cache中。 下面是当前workgroud的实现：

SSL *ctx = bufferevent_openssl_get_ssl(bev);
    
    /*
     * SSL_RECEIVED_SHUTDOWN tells SSL_shutdown to act as if we had already
     * received a close notify from the other end.  SSL_shutdown will then
     * send the final close notify in reply.  The other end will receive the
     * close notify and send theirs.  By this time, we will have already
     * closed the socket and the other end's real close notify will never be
     * received.  In effect, both sides will think that they have completed a
     * clean shutdown and keep their sessions valid.  This strategy will fail
     * if the socket is not ready for writing, in which case this hack will
     * lead to an unclean shutdown and lost session on the other end.
     */
    SSL_set_shutdown(ctx, SSL_RECEIVED_SHUTDOWN);
    SSL_shutdown(ctx);
    bufferevent_free(bev);

SSL *bufferevent_openssl_get_ssl(struct bufferevent *bev);

这个函数返回OpenSSL bufferevent使用的SSL对象。如果`bev`不是一个基于OpenSSL的bufferevent，则返回`NULL`。

unsigned long bufferevent_get_openssl_error(struct bufferevent *bev);

这个函数返回给定bufferevent的第一个未决的OpenSSL错误；如果没有未决的错误，则返回0。错误值的格式与openssl库中的`ERR_get_error()`返回的相同。

int bufferevent_ssl_renegotiate(struct bufferevent *bev);

调用这个函数要求SSL重新协商，bufferevent会调用合适的回调函数。这是个高级功能，通常应该避免使用，除非你确实知道自己在做什么，特别是有些SSL版本具有与重新协商相关的安全问题。

int bufferevent_openssl_get_allow_dirty_shutdown(struct bufferevent *bev);
    void bufferevent_openssl_set_allow_dirty_shutdown(struct bufferevent *bev,
        int allow_dirty_shutdown);

所有好的设计的SSL协议（SSLv 和 TLS）都支持 在shutdown操作时进行权限认证， 这能够将主动（有意的）关闭 与 意外，或者遭受攻击的关闭区别开来。 默认情况下，我们将所有shutdown都视为连接上的error。 如果`allow_dirty_shutdown`被设置为1， 我们会将连接的关闭视为`BEV_EVENT_EOF`。

`allow_dirty_shutdown` 函数在Libevent 2.1.1-alpha中加入。

**\* Example： 一个简单的基于SSL的echo服务器\***

/* Simple echo server using OpenSSL bufferevents */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    #include <openssl/ssl.h>
    #include <openssl/err.h>
    #include <openssl/rand.h>
    
    #include <event.h>
    #include <event2/listener.h>
    #include <event2/bufferevent_ssl.h>
    
    static void
    ssl_readcb(struct bufferevent * bev, void * arg)
    {
        struct evbuffer *in = bufferevent_get_input(bev);
    
        printf("Received %zu bytes\n", evbuffer_get_length(in));
        printf("----- data ----\n");
        printf("%.*s\n", (int)evbuffer_get_length(in), evbuffer_pullup(in, -1));
    
        bufferevent_write_buffer(bev, in);
    }
    
    static void
    ssl_acceptcb(struct evconnlistener *serv, int sock, struct sockaddr *sa,
                 int sa_len, void *arg)
    {
        struct event_base *evbase;
        struct bufferevent *bev;
        SSL_CTX *server_ctx;
        SSL *client_ctx;
    
        server_ctx = (SSL_CTX *)arg;
        client_ctx = SSL_new(server_ctx);
        evbase = evconnlistener_get_base(serv);
    
        bev = bufferevent_openssl_socket_new(evbase, sock, client_ctx,
                                             BUFFEREVENT_SSL_ACCEPTING,
                                             BEV_OPT_CLOSE_ON_FREE);
    
        bufferevent_enable(bev, EV_READ);
        bufferevent_setcb(bev, ssl_readcb, NULL, NULL, NULL);
    }
    
    static SSL_CTX *
    evssl_init(void)
    {
        SSL_CTX  *server_ctx;
    
        /* Initialize the OpenSSL library */
        SSL_load_error_strings();
        SSL_library_init();
        /* We MUST have entropy, or else there's no point to crypto. */
        if (!RAND_poll())
            return NULL;
    
        server_ctx = SSL_CTX_new(SSLv23_server_method());
    
        if (! SSL_CTX_use_certificate_chain_file(server_ctx, "cert") ||
            ! SSL_CTX_use_PrivateKey_file(server_ctx, "pkey", SSL_FILETYPE_PEM)) {
            puts("Couldn't read 'pkey' or 'cert' file. To generate a key\n"
               "and self-signed certificate, run:\n"
               " openssl genrsa -out pkey 2048\n"
               " openssl req -new -key pkey -out cert.req\n"
               " openssl x509 -req -days 365 -in cert.req -signkey pkey -out cert");
            return NULL;
        }
        SSL_CTX_set_options(server_ctx, SSL_OP_NO_SSLv2);
    
        return server_ctx;
    }
    
    int
    main(int argc, char **argv)
    {
        SSL_CTX *ctx;
        struct evconnlistener *listener;
        struct event_base *evbase;
        struct sockaddr_in sin;
    
        memset(&sin, 0, sizeof(sin));
        sin.sin_family = AF_INET;
        sin.sin_port = htons(9999);
        sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
    
        ctx = evssl_init();
        if (ctx == NULL)
            return 1;
        evbase = event_base_new();
        listener = evconnlistener_new_bind(
                             evbase, ssl_acceptcb, (void *)ctx,
                             LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 1024,
                             (struct sockaddr *)&sin, sizeof(sin));
    
        event_base_loop(evbase, 0);
    
        evconnlistener_free(listener);
        SSL_CTX_free(ctx);
    
        return 0;
    }

### 5.2 OpenSSL 与 线程 的一些注意事项 ###

Libevent内建的线程机制不支持Openssl锁。 因为Openssl使用了大量的全局变量， 你必须把OpenSSL配置为线程安全。 这部分内容不属于Libevent的范畴， 这一话题还有待讨论。

**\* Example： 一个很简单的关于如何开启Openssl线程安全的例子\***

/* * Please refer to OpenSSL documentation to verify you are doing this correctly, * Libevent does not guarantee this code is the complete picture, but to be used * only as an example. */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include <pthread.h>
    #include <openssl/ssl.h>
    #include <openssl/crypto.h>
    
    pthread_mutex_t * ssl_locks;
    int ssl_num_locks;
    
    /* Implements a thread-ID function as requied by openssl */
    static unsigned long
    get_thread_id_cb(void)
    {
        return (unsigned long)pthread_self();
    }
    
    static void
    thread_lock_cb(int mode, int which, const char * f, int l)
    {
        if (which < ssl_num_locks) {
            if (mode & CRYPTO_LOCK) {
                pthread_mutex_lock(&(ssl_locks[which]));
            } else {
                pthread_mutex_unlock(&(ssl_locks[which]));
            }
        }
    }
    
    int
    init_ssl_locking(void)
    {
        int i;
    
        ssl_num_locks = CRYPTO_num_locks();
        ssl_locks = malloc(ssl_num_locks * sizeof(pthread_mutex_t));
        if (ssl_locks == NULL)
            return -1;
    
        for (i = 0; i < ssl_num_locks; i++) {
            pthread_mutex_init(&(ssl_locks[i]), NULL);
        }
    
        CRYPTO_set_id_callback(get_thread_id_cb);
        CRYPTO_set_locking_callback(thread_lock_cb);
    
        return 0;
    }

[http_blog.csdn.net_windeal3203_article_details_52849236]: http://blog.csdn.net/windeal3203/article/details/52849236
[http_www.wangafu.net_nickm_libevent-book_Ref6a_advanced_bufferevents.html]: http://www.wangafu.net/~nickm/libevent-book/Ref6a_advanced_bufferevents.html