Libevent（5）— 连接监听器

转自： http://name5566.com/4220.html

参考文献列表：
http://www.wangafu.net/~nickm/libevent-book/

此文编写的时候，使用到的 Libevent 为 2.0.21

Libevent 提供了连接监听器 evconnlistener

创建 evconnlistener 实例

 
 
// 连接监听器回调函数原型
typedef void (*evconnlistener_cb)(
    struct evconnlistener *listener,
    // 新的 socket
    evutil_socket_t sock,
    // 新的 socket 对应的地址
    struct sockaddr *addr,
    int len,
    // 用户自定义数据
    void *ptr
);
 
// 创建一个新的连接监听器
struct evconnlistener *evconnlistener_new(
    struct event_base *base,
    // 一个新的连接到来时此回调被调用
    evconnlistener_cb cb,
    // 用户自定义数据，会被传递给 cb 回调函数
    void *ptr,
    // 连接监听器的选项（下面会详细谈到）
    unsigned flags,
    // 为标准的 listen 函数的 backlog 参数
    // 如果为负数，Libevent 将尝试选择一个合适的值
    int backlog,
    // socket
    // Libevent 假定此 socket 已经绑定
    evutil_socket_t fd
);
 
// 创建一个新的连接监听器
// 大多数参数含义同于 evconnlistener_new
struct evconnlistener *evconnlistener_new_bind(
    struct event_base *base,
    evconnlistener_cb cb,
    void *ptr,
    unsigned flags,
    int backlog,
    // 指定需要绑定的 socket 地址
    const struct sockaddr *sa,
    int socklen
);

连接监听器的常用选项如下：

1. LEV_OPT_CLOSE_ON_FREE
   当关闭连接监听器其底层 socket 也被自动释放
2. LEV_OPT_REUSEABLE
   设置 socket 绑定的地址可以重用
3. LEV_OPT_THREADSAFE
   设置连接监听器为线程安全的

释放连接监听器

 
 
void evconnlistener_free(struct evconnlistener *lev);

错误检测
如果连接监听器出错，我们可以得到通知：

 
 
// 连接监听器错误回调函数原型
typedef void (*evconnlistener_errorcb)(struct evconnlistener *lis, void *ptr);
 
// 为连接监听器设置错误回调函数
void evconnlistener_set_error_cb(struct evconnlistener *lev,
    evconnlistener_errorcb errorcb);

一个详细的范例（echo 服务器）

 
 
#include <event2/listener.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
 
#include <arpa/inet.h>
 
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
 
// 读取回调函数
static void
echo_read_cb(struct bufferevent *bev, void *ctx)
{
    struct evbuffer *input = bufferevent_get_input(bev);
    struct evbuffer *output = bufferevent_get_output(bev);
 
    // 将输入缓冲区的数据直接拷贝到输出缓冲区
    evbuffer_add_buffer(output, input);
}
 
// 事件回调函数
static void
echo_event_cb(struct bufferevent *bev, short events, void *ctx)
{
    if (events & BEV_EVENT_ERROR)
        perror("Error from bufferevent");
    if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
        bufferevent_free(bev);
    }
}
 
// 连接监听器回调函数
static void
accept_conn_cb(struct evconnlistener *listener,
    evutil_socket_t fd, struct sockaddr *address, int socklen,
    void *ctx)
{
    // 为新的连接分配并设置 bufferevent
    struct event_base *base = evconnlistener_get_base(listener);
    struct bufferevent *bev = bufferevent_socket_new(
        base, fd, BEV_OPT_CLOSE_ON_FREE);
 
    bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
 
    bufferevent_enable(bev, EV_READ|EV_WRITE);
}
 
// 连接监听器错误回调函数
static void
accept_error_cb(struct evconnlistener *listener, void *ctx)
{
    struct event_base *base = evconnlistener_get_base(listener);
    // 获取到错误信息
    int err = EVUTIL_SOCKET_ERROR();
    fprintf(stderr, "Got an error %d (%s) on the listener. "
        "Shutting down.\n", err, evutil_socket_error_to_string(err));
 
    // 退出事件循环
    event_base_loopexit(base, NULL);
}
 
int
main(int argc, char **argv)
{
    struct event_base *base;
    struct evconnlistener *listener;
    struct sockaddr_in sin;
 
    int port = 9876;
 
    if (argc > 1) {
        port = atoi(argv[1]);
    }
    if (port<=0 || port>65535) {
        puts("Invalid port");
        return 1;
    }
 
    base = event_base_new();
    if (!base) {
        puts("Couldn't open event base");
        return 1;
    }
 
    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(0);
    sin.sin_port = htons(port);
 
    listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
        LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
        (struct sockaddr*) & sin, sizeof(sin));
    if (!listener) {
        perror("Couldn't create listener");
        return 1;
    }
    evconnlistener_set_error_cb(listener, accept_error_cb);
 
    event_base_dispatch(base);
    return 0;
}