Libevent
快速可移植非阻塞式网络编程
修订历史
版本
日期
作者
备注
V1.0
2016-11-15
周勇
Libevent编程中文帮助文档
文档是2009-2012年由Nick-Mathewson基于Attribution-Noncommercial-Share Alike许可协议3.0创建,未来版本将会使用约束性更低的许可来创建.
此外,本文档的源代码示例也是基于BSD的"3条款"或"修改"条款.详情请参考BSD文件全部条款.本文档最新下载地址:
英文:http://libevent.org/
中文:http://blog.csdn.net/zhouyongku/article/details/53431750
请下载并运行"gitclonegit://github.com/nmathewson/libevent- book.git"获取本文档描述的最新版本源码.
11.高级话题
本章描述 bufferevent的一些对通常使用不必要的高级特征.如果只想学习如何使用bufferevent,可以跳过这一章,直接阅读下一章.
11.1成对的Bufferevent
有时候网络程序需要与自身通信.比如说,通过某些协议对用户连接进行隧道操作的程序,有时候也需要通过同样的协议对自身的连接进行隧道操作.当然,可以通过打开一个到自身监听端口的连接,让程序使用这个连接来达到这种目标.但是,通过网络栈来与自身通信比较浪费资源.
替代的解决方案是,创建一对成对的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版本引入.
11.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之前都会经过"输入"过滤器的转换;所有通过底层bufferevent发送的数据在被发送到底层bufferevent之前都会经过"输出"过滤器的转换.
向底层 bufferevent添加过滤器将替换其回调函数.可以向底层bufferevent的evbuffer添加回调函数,但是如果想让过滤器正确工作,就不能再设置bufferevent本身的回调函数.input_filter和output_filter函数将随后描述.options参数支持所有通常的选项.如果设置了BEV_OPT_CLOSE_ON_FREE , 那 么 释 放 过 滤bufferevent也 会 同 时 释 放 底 层bufferevent.ctx参数是传递给过滤函数的任意指针;如果提供了free_context,则在释放ctx之前它会被调用.
底层输入缓冲区有数据可读时,输入过滤器函数会被调用;过滤器的输出缓冲区有新的数据待写入时,输出过滤器函数会被调用.两个过滤器函数都有一对evbuffer参数:从source读取数据;向destination写入数据,而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的读取和写入.然而,这样可能会让过滤器不能成功取得所需要的数据.
不需要同时指定输入和输出过滤器:没有给定的过滤器将被一个不进行数据转换的过滤器取代.
11.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,将会以最大值来代替默认值.函数成功返回0,失败返回-1.
这两个"get"函数分别返回当前每次loop循环读和写的最大数.
函数首次加入是在LibEvent-2.1.1-alpha版本.
11.4Bufferevent和速率限制
某些程序需要限制单个或者一组 bufferevent使用的带宽. 2.0.4-alpha和2.0.5-alpha版本添加了为单个或者一组bufferevent设置速率限制的基本功能.
11.4.1速率限制模型
libevent的速率限制使用记号存储器(token bucket)算法确定在某时刻可以写入或者读取多少字节.每个速率限制对象在任何给定时刻都有一个"读存储器( read bucket )"和一个"写存储器(write bucket)",其大小决定了对象可以立即读取或者写入多少字节.每个存储器有一个填充速率,一个最大突发尺寸,和一个时间单位,或者说"滴答(tick)".一个时间单位流逝后,存储器被填充一些字节(决定于填充速率)——但是如果超过其突发尺寸,则超出的字节会丢失.
因此,填充速率决定了对象发送或者接收字节的最大平均速率,而突发尺寸决定了在单次突
发中可以发送或者接收的最大字节数;时间单位则确定了传输的平滑程度.
11.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之前进行释放是不安全的.
11.4.3为一组Eventbuffer设置速率限制
如果要限制一组 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_new函 数.使 用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版本中,组速率限制试图实现总体的公平,但是具体实现可能在小的时间范围内并不公平.如果你强烈关注调度的公平性,请帮助提供未来版本的补丁.
11.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或者组(如果有)的速率限制,以及一次最大读写数据量的情况下,现在可以读或者写的字节数.
接口
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.
11.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或者速率限制组的当前读或者写存储器.注意:减小是有符=号的.如果要增加存储器,就传入负值.
11.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版本首次引入.
11.4.7 速率限制实现的限制
2.0版本的libevent的速率限制具有一些实现上的限制:
-
不是每种 bufferevent类型都良好地或者说完整地支持速率限制.bufferevent速率限制组不能嵌套,一个bufferevent在某时刻只能属于一个速率限制组.
-
速率限制实现仅计算 TCP分组传输的数据,不包括TCP头部.
-
读速率限制实现依赖于 TCP栈通知应用程序仅仅以某速率消费数据,并且在其缓冲区满的时候将数据推送到TCP连接的另一端.
-
某些 bufferevent实现(特别是Windows中的IOCP实现)可能调拨过度.
-
存储器开始于一个滴答的通信量.这意味着bufferevent可以立即开始读取或者写入,而不用等待一个滴答的时间.但是这也意味着速率被限制为N.1个滴答的bufferevent可能传输N+1个滴答的通信量.
-
滴答不能小于1毫秒,毫秒的小数部分都被忽略.
11.5Bufferevent和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中声明.
11.5.1创建和使用基于SSL的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时,如果SSL对象已经设置了套接字,就不需要提供套接字了:只要传递-1就可以.也可以随后调用bufferevent_setfd()来设置.
示例
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协议的优秀版本(SSLV3和TLS版本)支出一个经过验证的关闭操作,可以区分故意关闭或者恶意诱导终止缓冲.默认情况下我们将连接上的适当关闭之外的都做为错误处理,如果allow_dirty_shutdown标志设置为1,则认为连接关闭是BEV_EVENT_EOF.
allow_dirty_shutdown首次被加入到LibEvent是在2.1.1-alpha版本.
示例
/* 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;
}
11.5.2线程和OpenSSL的一些说明
LibEvent的线程建造机制将不包括OpenSSL锁定.由于OpenSSL使用无数的全局变量,必须配置OpenSSL是线程安全的,虽然这个过程是LibEvent范围外的事,这一话题足以引起讨论.
示例:让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;
}