libevent学习笔记【使用篇】——Connection listeners.md

绝地灬酷狼 2022-09-26 11:49 227阅读 0赞

本文整理自[libevent官方手册][libevent]

libevent 提供了一种用于监听和接受TCP连接的便捷方式——**evconnlistener机制**

### 创建和释放 evconnlistener 的接口 ###

下面接口用于创建和释放evconnlistener

struct evconnlistener *evconnlistener_new(struct event_base *base,
        evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
        evutil_socket_t fd);
    struct evconnlistener *evconnlistener_new_bind(struct event_base *base,
        evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
        const struct sockaddr *sa, int socklen);
    void evconnlistener_free(struct evconnlistener *lev);

函数`evconnlistener_new`和`evconnlistener_new_bind`都用于分配和返回一个新的用于监听连接的对象。 每个用于监听的对象都使用`event_base`来维护一个建立的连接。当有新的TCP 连接发生时，回调函数就会调用。  
下面介绍以上接口使用到的参数“

*  **base：** event\_base对象。参考event\_base。
 *  **cb：** 回调函数， 当有新的TCP连接发生时，会唤醒回调函数。
 *  **ptr：** 传递给回调函数的参数。
 *  **flags：** 一些标志， 后面会进一步介绍。
 *  **backlog：** 监听队列允许容纳的最大连接数。
 *  **fd：** 函数`evconnlistener_new`假设我们已经绑定了套接字到要监听的端口上，`fd`参数就是我们已经绑定的socket套接字。
 *  **sa：** `evconnlistener_new_bind`帮助我们绑定监听地址。sa就是传入的监听地址。
 *  **socklen：** sa的长度。

***如果使用的是`evconnlistener_new`，需要保证传入的socket套接字处于non-blocking模式，可以通过`evutil_make_socket_nonblocking`等方法进行设置***

**常用的flag值：**

*  **LEV\_OPT\_LEAVE\_SOCKETS\_BLOCKING：**默认情况下listener会把接收到的连接设置为non-blocking模式。 这个flag则是将连接设置为blocking状态（少用）
 *  **LEV\_OPT\_CLOSE\_ON\_FREE：**释放listener时，先关闭潜在的套接字
 *  **LEV\_OPT\_REUSEABLE：**一些系统平台在默认情况下即使已经关闭了socket，也要等待一段时间才能使用对应的port， 而这个flag则设置成只要已关闭socket就是重新使用对应的port。

### 关于回调函数 ###

回调函数原型如下：

typedef void (*evconnlistener_cb)(struct evconnlistener *listener,
        evutil_socket_t sock, struct sockaddr *addr, int len, void *ptr);

参数解释如下：

*  **listener：** 即接受连接的lister
 *  **sock：** 新连接创建的新套接字
 *  **addr：** 连接发起者的地址
 *  **len：** 地址长度
 *  **ptr：** 从`evconnlistener_new`和`evconnlistener_bind_new`传来的参数。

**libevent提供调整回调函数的接口**  
下面接口可以重新设置回调函数，或者调整回调函数中的参数。

void evconnlistener_set_cb(struct evconnlistener *lev,
        evconnlistener_cb cb, void *arg);

### 开启和关闭监听 ###

listener允许临时关闭和重新开启监听

int evconnlistener_disable(struct evconnlistener *lev);
    int evconnlistener_enable(struct evconnlistener *lev);

### Example ###

#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)
    {
            /* This callback is invoked when there is data to read on bev. */
            struct evbuffer *input = bufferevent_get_input(bev);
            struct evbuffer *output = bufferevent_get_output(bev);
    
            /* Copy all the data from the input buffer to the output buffer. */
            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)
    {
            /* We got a new connection! Set up a bufferevent for it. */
            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;
            }
    
            /* Clear the sockaddr before using it, in case there are extra * platform-specific fields that can mess us up. */
            memset(&sin, 0, sizeof(sin));
            /* This is an INET address */
            sin.sin_family = AF_INET;
            /* Listen on 0.0.0.0 */
            sin.sin_addr.s_addr = htonl(0);
            /* Listen on the given port. */
            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;
    }

[libevent]: http://www.wangafu.net/~nickm/libevent-book/Ref8_listener.html