Libevent：8Bufferevents高级主题

本章描述的是Libevent的bufferevent实现的一些高级特性，这对于普通应用来说并非必须的。如果你只是学习如何使用bufferevent，则应该跳过本章去阅读evbuffer的章节。

一：成对的bufferevent

有时，网络程序可能需要与自己本身进行对话。比如，某个程序用来在某些协议之上进行隧道用户链接，而有时它需要在这种协议之上，隧道与自己的连接。当然，这可以通过打开一个到自己监听端口的链接来实现，然而通过网络栈来实现与自己的对话，显然是浪费资源的。

作为替代，可以创建一对“成对的”bufferevent（paired  bufferevents），写入一个bufferevent的字节都会在另一个bufferevent上接收到（反之亦然），但是不使用任何实际的socket平台。

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的状态，而这又会引起另一个bufferevent回调函数的调用，如此会一直循环往复下去。如果回调函数不被延迟，那么这种调用链条就会导致栈溢出，饿死其他链接，并且使得所有回调函数都折返。

“bufferevent对”支持flush；无论是设置为BEV_NORMAL 还是BEV_FLUSH，都会使所有相关数据从bufferevent对的一端传送到另一端，而忽略水位线的限制。 设置BEV_FINISHED还会使对端bufferevent额外的产生EOF事件。

释放“bufferevent对”的一端，不会使得另一端也自动释放或是产生EOF事件；这只会使得对端的bufferevent变为unlink。一旦bufferevent变为unlink状态，那它就再也不能进行读写数据，也不会产生任何事件了。

struct bufferevent  *bufferevent_pair_get_partner(struct  bufferevent  *bev)

有时会需要在给定“bufferevent对”的一端的情况下，得到对端的bufferevent。这可以通过调用bufferevent_pair_get_partner函数进行实现。如果bev是“bufferevent对”的一个成员，而且对端bufferevent依然存在，则该函数会返回对端bufferevent，否则会返回NULL。

二：过滤型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之前都会经过输入过滤器进行转换，而且所有传送到底层bufferevent的数据，之前都会发送到过滤型bufferevent，通过输出过滤器进行转换。

为一个底层bufferevent添加过滤，会替换底层bufferevent的回调函数。依然可以向底层bufferevent的evbuffers添加回调函数，但是如果希望过滤器还能工作的话，就不能设置bufferevent本身的回调函数。

输入过滤器input_filter和输出过滤器output_filter函数在下面进行描述。options中支持所有常用选项。如果设置了BEV_OPT_CLOSE_ON_FREE，那么释放过滤型bufferevent也会释放底层bufferevent。ctx是一个传递给过滤函数的可选指针；如果提供了free_context函数的话，则在关闭过滤型bufferevent之前，该函数会在ctx上进行调用。

当底层bufferevent的输入缓冲区中有新的可读数据时，就会调用输入过滤器函数。当过滤型bufferevent的输出缓冲区中有新的可写数据时，就会调用输出过滤器函数。每个过滤器函数都会接收一对evbuffers作为参数：从source
evbuffer中读取数据，向destination evbuffer中写入数据。dst_limit参数描述了向destination中添加数据的上限。过滤器函数可以忽略该参数，但是这样做可能会违反高水位线或速率限制。如果dst_limit置为-1，则表示无限制。mode参数用于在输出时改变过滤器的行为。如果置为BEV_NORMAL，意味着便于转化的输出，置为BEV_FLUSH意味着尽可能多的输出，BEV_FINISHED意味着过滤器函数需要在流的末尾进行必要的清理工作。最后，过滤器函数的ctx参数是在调用函数bufferevent_filter_new()时提供的void指针。

只要有任何数据成功的写入了目标buffer中，过滤器函数就必须返回BEV_OK，BEV_NEED_MORE意味着不能再向目标buffer写入更多的数据了，除非获得更多的输入，或者使用不同的flush模式。如果过滤器中发生了不可恢复的错误，则返回BEV_ERROR。

创建过滤器会使能底层bufferevent上的读和写操作。无需亲自管理读写：当不再需要读取时，过滤器就会挂起底层bufferevent的读操作。对于2.0.8-rc以及之后的版本，允许独立于过滤器，对底层bufferevent的输入和输出操作进行使能或禁止操作。但是这样做的话，有可能会使得过滤器不能得到它想要的数据。

输入过滤器和输出过滤器无需全部指定，如果省略了某个过滤器，则数据不会被转化而直接被转送。

三：限制单次读写最大量

默认情况下，在每次event loop的调用中，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，那么将会设置最大量为默认值。这些函数成功时返回0，失败是返回-1.

两个get函数返回当前每次loop调用时的读写最大量。

四：bufferevent的速率限制

某些程序会希望限制单个bufferevent或者一组bufferevent所能使用的带宽。Libevent 2.0.4-alpha
和 Libevent 2.0.5-alpha增加了基本功能用来限制单个bufferevent，或者将bufferevent分配到一个“速率限制组”（rate-limited group）当中。

1：速率限制模式

Libevent的速率限制，使用令牌桶算法来决定每次读写的数据量。在任何给定时间，每一个速率限制对象，都有一个“读桶”和“写桶”，它们的大小决定了该对象能够立即读写的字节数。每个桶都有一个填充速率，一个突发量的最大值以及一个时间单元（或tick）。当经过了一个时间单元之后，桶按照填充速率产生新的令牌—但是如果填充量大于突发量的话，多余的字节将会丢失。

所以，填充速率决定了对象发送和接受字节的最大平均速率，而突发量决定了在单次突发中所能发送和接受的最大数据量。时间单元决定了流量的流畅度。

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或一组bufferevents的读写的对象。调用ev_token_bucket_cfg_new函数可以创建ev_token_bucket_cfg结构，调用该函数需要提供最大平均读速率，最大读突发量，最大写速率，最大写突发量，以及tick的长度。如果tick_len参数为NULL，则tick长度默认为一秒。如果发生错误，该函数返回NULL。

注意，read_rate和write_rate参数按照每tick的字节数进行度量。也就是说，如果tick为1/10秒，并且read_rate为300，那么最大平均读速率为每秒3000个字节。不支持超过EV_RATE_LIMIT_MAX的速率和突发量。

为了限制一个bufferevent的传输速率，可以以一个ev_token_bucket_cfg为参数来调用函数bufferevent_set_rate_limit。该函数成功时返回0，失败时返回-1。相同ev_token_bucket_cfg结构可以设置任意数量的bufferevent。如果以NULL为cfg参数调用函数bufferevent_set_rate_limit，则可以移除bufferevent的速率限制。

调用ev_token_bucket_cfg_free函数可以释放ev_token_bucket_cfg结构。注意，直到没有任何bufferevent使用该ev_token_bucket_cfg结构时，释放它才是安全的。

3：设置一组bufferevent的速率限制

如果想限制多个bufferevent的总带宽使用，可以将多个bufferevent分配到一个速率限制组（rate
limiting group）。

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_remove_from_rate_limit_group，将bufferevent加入和退出改组。这些函数成功时返回0，失败是返回-1.

同一时间，一个bufferevent只能属于一个速率限制组。一个bufferevent可以同时有一个独立的速率限制（通过bufferevent_set_rate_limit设置）以及一个组速率限制。当他们都被设置时，则使用较小值。

调用函数bufferevent_rate_limit_group_set_cfg，可以改变一个组的速率限制。该函数成功时返回0，失败是返回-1.bufferevent_rate_limit_group_free函数释放一个速率限制组，并且移除其所有成员。

在Libevent2.0中，组速率限制保证总体上的公平，但是在实现上可能对于较小时间跨度来说是不公平的。如果你非常在意调度公平性，请帮助实现未来版本的补丁。

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的值超过分配值的话（刷新bufferevent），这些值可以为负数。

ev_ssize_t bufferevent_get_max_to_read(struct  bufferevent  *bev);

ev_ssize_t bufferevent_get_max_to_write(struct  bufferevent  *bev);

ev_ssize_t bufferevent_get_max_to_read(struct  bufferevent  *bev);

ev_ssize_t bufferevent_get_max_to_write(struct  bufferevent  *bev);

这些函数根据应用到该bufferevent上的任何速率限制、它的速率限制组，以及由Libevent视为一个整体的任何每次读写最大值，该函数返回bufferevent当前正要读写的字节数。

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为一个bufferevent组的读写字节总数。这些字节总数在group建立的时候置为0，当在组上再次调用bufferevent_rate_limit_group_reset_totals时，该值重置为0。

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或速率限制组的读写桶大小。注意这种减少是有符号的：如果希望增加一个桶容量，则可以传递一个负数。

6：设置速率限制组中的最小共享（the smallest share）

一般不希望将每个tick中所有可得流量均匀的分布到速率限制组中的所有bufferevent上。比如，如果一个速率限制组有10,000个激活的bufferevent，每个tick总共有10,000个字节用来输出，因为系统调用以及TCP报文头的原因，每个bufferevent每个tick只能输出1个字节的话是很没有效率的。

为了解决这种问题，每一个速率限制组都有“最小共享”（minimum share）的概念。在上面的情况中，不采用每个bufferevent每次tick写1个字节这种方式，而是允许每个tick中，10000/SHARE个bufferevent写SHARE个字节，而其余的bufferevent可以不输出任何字节。每一个tick中，哪些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，则将禁用最小共享的代码。

7：速率限制实现中的限制

在Libevent 2.0中，需要知道速率限制的实现具有某些限制：

l  不是所有bufferevent类型都能很好的支持速率限制，有些根本不支持。

l  速率限制组不允许嵌套，并且一个bufferevent同一时间只能属于一个速率限制组。

l  速率限制的实现仅仅对传输的TCP报文体重的字节数进行计数，不包含TCP报文头。

l  读限制的实现依赖于TCP协议栈，注意，应用程序只能以一定的速率吸收数据，并且当缓冲区变满时，将数据推送到TCP链接的另一端。

l  某些bufferevent的实现（特别是window的IOCP实现）可以过量使用（over-commit）

l  令牌桶可以以一个完整tick的流量为开始。这意味着一个bufferevent可以立即开始读写操作，而不需要等待一个完整的tick过去之后才开始，这还意味着，如果一个bufferevent被限制速率为N.1个tick，他也可以传输N+1个tick的流量。

l  ticks可以小于1毫秒，而且所有毫秒的小数部分将会被忽略。

五：bufferevent和SSL

bufferevent可以使用OpenSSL库来实现SSL/TLS安全传输层。因为大多数应用不需要连接OpenSSL，所以该功能在一个独立的库：“libevent_openssl”中实现。未来版本的Libevent可以支持其他的SSL/TLS库，比如NSS或GnuTLS，但是当前只支持OpenSSL。

注意，本节并非介绍OpenSSL，SSL/TLS或一般性密码学的教程。

下面所有的函数都是在文件“event2/bufferevent_ssl.h”中声明。

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通信的过滤型bufferevent，或者一种基于socket的bufferevent，使OpenSSL直接与网络通信。每种类型都必须提供一个SSL对象以及对该对象状态的描述。如果SSL当前作为客户端，则状态应该是BUFFEREVENT_SSL_CONNECTING，如果SSL当前作为服务端，则状态是BUFFEREVENT_SSL_ACCEPTING，或者如果SSL的握手已经完成了，则SSL的状态是BUFFEREVENT_SSL_OPEN。

可以使用常用的选项：BEV_OPT_CLOSE_ON_FREE使得在openssl bufferevent关闭时，也会关闭SSL对象以及底层fd或bufferevent。

一旦握手建立，则会以BEV_EVENT_CONNECTED为标志产生新的bufferevent事件回调。

如果创建一个基于socket的bufferevent，而且SSL对象已经有一个socket了，可以不需要提供socket了：直接传递-1即可。可以后续通过bufferevent_setfd设置fd。

注意，当在SSL bufferevent上设置BEV_OPT_CLOSE_ON_FREE标志时，在SSL连接上不会执行干净的关闭。这就会有两个问题：一，链接看起来像是被另一端破坏了，而不是干净的关闭了：对端无法告知到底是关闭了链接，还是由攻击或者其他原因导致的断链。第二，OpenSSL会将会话视为“损坏”的，而且将会话从缓存中移除，这样就会导致负载下的SSL程序性能严重下降。

当前唯一的解决办法就是进行手动的懒惰SSL关闭。尽管这违反了TLS RFC，但是这可以保证一旦关闭连接会话仍然保留在缓存中。下面是这种解决办法的代码实现：

SSL*ctx = bufferevent_openssl_get_ssl(bev);

/*

* SSL_RECEIVED_SHUTDOWN tells SSL_shutdown toact as if we had already

* received a close notify from the otherend.  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 realclose notify will never be

* received. In effect, both sides will think that they have completed a

* clean shutdown and keep their sessionsvalid.  This strategy will fail

* if the socket is not ready for writing, inwhich case this hack will

* lead to an unclean shutdown and lost sessionon 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协议的好版本（比如SSLv3，以及所有的TLS版本）都支持关闭认证操作，这可以在底层缓冲区中区分出到底是偶然的关闭还是恶意的终止。默认情况下，将除了正确关闭之外的所有关闭都视为链接错误。如果allow_dirty_shutdown标志为1，则将连接中的关闭视为 BEV_EVENT_EOF。

一个简单的基于SSL的回显服务

/*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>

staticvoid

ssl_readcb(structbufferevent * 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);

}

staticvoid

ssl_acceptcb(structevconnlistener *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);

}

staticSSL_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 nopoint 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 -outcert.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(intargc, 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;

}

2：多线程和OpenSSL的注意事项

多线程机制的Libevent没有覆盖OpenSSL的锁。自从OpenSSL使用了大量的全局变量依赖，必须将OpenSSL配置为线程安全的。尽管该话题已经超出了Libevent的范围，但是还是值得深入讨论的。

如何使OpenSSL为线程安全的简单例子

/*

* Please refer to OpenSSL documentation toverify you are doing this correctly,

* Libevent does not guarantee this code is thecomplete 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 */

staticunsigned long

get_thread_id_cb(void)

{

return (unsigned long)pthread_self();

}

staticvoid

thread_lock_cb(intmode, 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;

}