🔗 bufferevent高级特性#

一、概述#

除了基本的socket bufferevent，libevent还提供了多种高级bufferevent类型，包括pair（成对连接）、filter（过滤器）等。这些特性使得bufferevent可以用于更复杂的场景。

二、bufferevent_pair#

2.1 概述#

bufferevent_pair 创建两个相互连接的bufferevent，写入其中一个的数据可以从另一个读取。这非常适合进程内通信、测试、以及构建复杂的数据流管道。

2.2 创建API#

1
#include <event2/bufferevent.h>
2

3
/* 创建一对相互连接的bufferevent
4
 * @param base     event_base
5
 * @param options  选项标志
6
 * @param pair     输出数组，存储两个bufferevent
7
 * @return         0成功，-1失败
8
 */
9
int bufferevent_pair_new(struct event_base *base, int options,
10
                         struct bufferevent *pair[2]);
11

12
/* 获取pair的另一个端点 */
13
struct bufferevent *bufferevent_pair_get_partner(struct bufferevent *bev);

2.3 基本示例#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <event2/event.h>
5
#include <event2/bufferevent.h>
6

7
static void read_cb(struct bufferevent *bev, void *arg) {
8
    char buf[1024];
9
    size_t n;
10

11
    while ((n = bufferevent_read(bev, buf, sizeof(buf) - 1)) > 0) {
12
        buf[n] = '\0';
13
        printf("Received: %s", buf);
14
    }
15
}
16

17
int main() {
18
    struct event_base *base = event_base_new();
19
    struct bufferevent *pair[2];
20

21
    // 创建一对bufferevent
22
    if (bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair) < 0) {
23
        fprintf(stderr, "Failed to create pair\n");
24
        return 1;
25
    }
26

27
    // 设置回调
28
    bufferevent_setcb(pair[1], read_cb, NULL, NULL, NULL);
29
    bufferevent_enable(pair[1], EV_READ);
30

31
    // 从pair[0]写入，pair[1]读取
32
    const char *msg = "Hello from pair[0]!\n";
33
    bufferevent_write(pair[0], msg, strlen(msg));
34

35
    // 处理事件
36
    event_base_loop(base, EVLOOP_ONCE);
37

38
    // 获取伙伴
39
    struct bufferevent *partner = bufferevent_pair_get_partner(pair[0]);
40
    printf("Partner of pair[0] is pair[1]: %s\n",
41
           partner == pair[1] ? "yes" : "no");
42

43
    // 释放（只需释放一个，另一个会自动关闭）
44
    bufferevent_free(pair[0]);
45
    bufferevent_free(pair[1]);
46

47
    event_base_free(base);
48
    return 0;
49
}

2.4 进程间通信示例#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <unistd.h>
5
#include <sys/socket.h>
6
#include <event2/event.h>
7
#include <event2/bufferevent.h>
8

9
static void on_read_from_stdin(struct bufferevent *bev, void *arg) {
10
    struct bufferevent *partner = arg;
11
    char buf[1024];
12
    size_t n;
13

14
    while ((n = bufferevent_read(bev, buf, sizeof(buf))) > 0) {
15
        // 转发到伙伴
16
        bufferevent_write(partner, buf, n);
17
    }
18
}
19

20
static void on_read_from_partner(struct bufferevent *bev, void *arg) {
21
    char buf[1024];
22
    size_t n;
23

24
    while ((n = bufferevent_read(bev, buf, sizeof(buf))) > 0) {
25
        // 输出到stdout
26
        write(STDOUT_FILENO, "Echo: ", 6);
27
        write(STDOUT_FILENO, buf, n);
28
    }
29
}
30

31
int main() {
32
    struct event_base *base = event_base_new();
33
    struct bufferevent *pair[2];
34

35
    bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair);
36

37
    // 创建stdin的bufferevent
38
    struct bufferevent *stdin_bev = bufferevent_socket_new(
39
        base, STDIN_FILENO, 0);
40

41
    // stdin -> pair[0]
42
    bufferevent_setcb(stdin_bev, on_read_from_stdin, NULL, NULL, pair[0]);
43
    bufferevent_enable(stdin_bev, EV_READ);
44

45
    // pair[1] -> stdout
46
    bufferevent_setcb(pair[1], on_read_from_partner, NULL, NULL, NULL);
47
    bufferevent_enable(pair[1], EV_READ);
48

49
    printf("Type something and press Enter (Ctrl+D to exit):\n");
50

51
    event_base_dispatch(base);
52

53
    bufferevent_free(stdin_bev);
54
    bufferevent_free(pair[0]);
55
    bufferevent_free(pair[1]);
56
    event_base_free(base);
57

58
    return 0;
59
}

三、bufferevent_filter#

3.1 概述#

bufferevent_filter 是一种包装器，可以在底层bufferevent之上添加数据转换层。它允许在读写数据时进行自定义处理，如压缩、加密、编码转换等。

3.2 创建API#

1
#include <event2/bufferevent.h>
2

3
/* 过滤器回调函数类型 */
4
typedef enum bufferevent_filter_result (*bufferevent_filter_cb)(
5
    struct evbuffer *src, struct evbuffer *dst,
6
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx);
7

8
/* 创建过滤bufferevent
9
 * @param base          event_base
10
 * @param underlying    底层bufferevent
11
 * @param input_filter  输入过滤器（读取时调用）
12
 * @param output_filter 输出过滤器（写入时调用）
13
 * @param options       选项标志
14
 * @param free_ctx      释放上下文的函数
15
 * @param ctx           过滤器上下文
16
 */
17
struct bufferevent *bufferevent_filter_new(
18
    struct event_base *base,
19
    struct bufferevent *underlying,
20
    bufferevent_filter_cb input_filter,
21
    bufferevent_filter_cb output_filter,
22
    int options,
23
    void (*free_ctx)(void *), void *ctx);
24

25
/* 过滤器返回值 */
26
enum bufferevent_filter_result {
27
    BEV_OK = 0,      // 成功
28
    BEV_NEED_MORE,   // 需要更多数据
29
    BEV_ERROR        // 错误
30
};
31

32
/* 刷新模式 */
33
enum bufferevent_flush_mode {
34
    BEV_NORMAL = 0,  // 正常
35
    BEV_FLUSH,       // 刷新
36
    BEV_FINISHED     // 完成
37
};

3.3 大写转换过滤器示例#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <ctype.h>
5
#include <event2/event.h>
6
#include <event2/bufferevent.h>
7
#include <event2/buffer.h>
8

9
static enum bufferevent_filter_result uppercase_filter(
10
    struct evbuffer *src, struct evbuffer *dst,
11
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx) {
12

13
    char buf[1024];
14
    size_t n;
15

16
    while ((n = evbuffer_remove(src, buf, sizeof(buf))) > 0) {
17
        // 转换为大写
18
        for (size_t i = 0; i < n; i++) {
19
            buf[i] = toupper((unsigned char)buf[i]);
20
        }
21
        evbuffer_add(dst, buf, n);
22
    }
23

24
    return BEV_OK;
25
}
26

27
static void read_cb(struct bufferevent *bev, void *arg) {
28
    char buf[1024];
29
    size_t n;
30

31
    while ((n = bufferevent_read(bev, buf, sizeof(buf) - 1)) > 0) {
32
        buf[n] = '\0';
33
        printf("Received (filtered): %s", buf);
34
    }
35
}
36

37
int main() {
38
    struct event_base *base = event_base_new();
39
    struct bufferevent *pair[2];
40

41
    bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair);
42

43
    // 在pair[1]上添加过滤器
44
    struct bufferevent *filtered = bufferevent_filter_new(
45
        base, pair[1],
46
        uppercase_filter,  // 输入过滤器
47
        NULL,              // 无输出过滤器
48
        BEV_OPT_CLOSE_ON_FREE,
49
        NULL, NULL);
50

51
    bufferevent_setcb(filtered, read_cb, NULL, NULL, NULL);
52
    bufferevent_enable(filtered, EV_READ);
53

54
    // 写入小写数据
55
    const char *msg = "hello, world!\n";
56
    printf("Sending: %s", msg);
57
    bufferevent_write(pair[0], msg, strlen(msg));
58

59
    event_base_loop(base, EVLOOP_ONCE);
60

61
    bufferevent_free(pair[0]);
62
    bufferevent_free(filtered);
63
    event_base_free(base);
64

65
    return 0;
66
}

3.4 Base64编码过滤器#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <event2/event.h>
5
#include <event2/bufferevent.h>
6
#include <event2/buffer.h>
7

8
static const char base64_table[] =
9
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
10

11
static enum bufferevent_filter_result base64_encode_filter(
12
    struct evbuffer *src, struct evbuffer *dst,
13
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx) {
14

15
    unsigned char in[3];
16
    char out[4];
17
    size_t n;
18

19
    while ((n = evbuffer_remove(src, in, 3)) > 0) {
20
        // 编码
21
        out[0] = base64_table[in[0] >> 2];
22
        out[1] = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)];
23

24
        if (n > 1) {
25
            out[2] = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)];
26
            out[3] = (n > 2) ? base64_table[in[2] & 0x3f] : '=';
27
        } else {
28
            out[2] = '=';
29
            out[3] = '=';
30
        }
31

32
        evbuffer_add(dst, out, 4);
33
    }
34

35
    if (mode == BEV_FLUSH || mode == BEV_FINISHED) {
36
        evbuffer_add(dst, "\n", 1);
37
    }
38

39
    return BEV_OK;
40
}
41

42
static void read_cb(struct bufferevent *bev, void *arg) {
43
    char buf[1024];
44
    size_t n;
45

46
    while ((n = bufferevent_read(bev, buf, sizeof(buf) - 1)) > 0) {
47
        buf[n] = '\0';
48
        printf("%s", buf);
49
    }
50
}
51

52
int main() {
53
    struct event_base *base = event_base_new();
54
    struct bufferevent *pair[2];
55

56
    bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair);
57

58
    struct bufferevent *filtered = bufferevent_filter_new(
59
        base, pair[1],
60
        base64_encode_filter,
61
        NULL,
62
        BEV_OPT_CLOSE_ON_FREE,
63
        NULL, NULL);
64

65
    bufferevent_setcb(filtered, read_cb, NULL, NULL, NULL);
66
    bufferevent_enable(filtered, EV_READ);
67

68
    const char *msg = "Hello, World!";
69
    printf("Original: %s\n", msg);
70
    printf("Base64: ");
71
    bufferevent_write(pair[0], msg, strlen(msg));
72

73
    event_base_loop(base, EVLOOP_ONCE);
74

75
    bufferevent_free(pair[0]);
76
    bufferevent_free(filtered);
77
    event_base_free(base);
78

79
    return 0;
80
}

3.5 行缓冲过滤器#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <event2/event.h>
5
#include <event2/bufferevent.h>
6
#include <event2/buffer.h>
7

8
typedef struct {
9
    char *partial_line;
10
    size_t partial_len;
11
    size_t partial_cap;
12
} line_buffer_ctx_t;
13

14
static enum bufferevent_filter_result line_buffer_filter(
15
    struct evbuffer *src, struct evbuffer *dst,
16
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx) {
17

18
    line_buffer_ctx_t *lb = ctx;
19
    char buf[1024];
20
    size_t n;
21

22
    while ((n = evbuffer_remove(src, buf, sizeof(buf))) > 0) {
23
        for (size_t i = 0; i < n; i++) {
24
            if (buf[i] == '\n') {
25
                // 找到换行符，输出完整行
26
                if (lb->partial_len > 0) {
27
                    evbuffer_add(dst, lb->partial_line, lb->partial_len);
28
                    lb->partial_len = 0;
29
                }
30
                evbuffer_add(dst, "\n", 1);
31
            } else {
32
                // 累积字符
33
                if (lb->partial_len >= lb->partial_cap) {
34
                    lb->partial_cap = lb->partial_cap ? lb->partial_cap * 2 : 256;
35
                    lb->partial_line = realloc(lb->partial_line, lb->partial_cap);
36
                }
37
                lb->partial_line[lb->partial_len++] = buf[i];
38
            }
39
        }
40
    }
41

42
    // 刷新时输出剩余数据
43
    if (mode == BEV_FLUSH && lb->partial_len > 0) {
44
        evbuffer_add(dst, lb->partial_line, lb->partial_len);
45
        lb->partial_len = 0;
46
    }
47

48
    return BEV_OK;
49
}
50

51
static void free_line_buffer_ctx(void *ctx) {
52
    line_buffer_ctx_t *lb = ctx;
53
    free(lb->partial_line);
54
    free(lb);
55
}

四、链式过滤器#

4.1 多层过滤#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <ctype.h>
5
#include <event2/event.h>
6
#include <event2/bufferevent.h>
7

8
static enum bufferevent_filter_result trim_filter(
9
    struct evbuffer *src, struct evbuffer *dst,
10
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx) {
11

12
    char buf[1024];
13
    size_t n;
14

15
    while ((n = evbuffer_remove(src, buf, sizeof(buf))) > 0) {
16
        size_t start = 0, end = n;
17

18
        // 去除前导空白
19
        while (start < n && isspace((unsigned char)buf[start])) start++;
20

21
        // 去除尾部空白
22
        while (end > start && isspace((unsigned char)buf[end - 1])) end--;
23

24
        if (start < end) {
25
            evbuffer_add(dst, buf + start, end - start);
26
        }
27
    }
28

29
    return BEV_OK;
30
}
31

32
static enum bufferevent_filter_result uppercase_filter(
33
    struct evbuffer *src, struct evbuffer *dst,
34
    ev_ssize_t dst_limit, enum bufferevent_flush_mode mode, void *ctx) {
35

36
    char buf[1024];
37
    size_t n;
38

39
    while ((n = evbuffer_remove(src, buf, sizeof(buf))) > 0) {
40
        for (size_t i = 0; i < n; i++) {
41
            buf[i] = toupper((unsigned char)buf[i]);
42
        }
43
        evbuffer_add(dst, buf, n);
44
    }
45

46
    return BEV_OK;
47
}
48

49
int main() {
50
    struct event_base *base = event_base_new();
51
    struct bufferevent *pair[2];
52

53
    bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair);
54

55
    // 第一层：去除空白
56
    struct bufferevent *filter1 = bufferevent_filter_new(
57
        base, pair[1],
58
        trim_filter,
59
        NULL,
60
        BEV_OPT_CLOSE_ON_FREE,
61
        NULL, NULL);
62

63
    // 第二层：转大写
64
    struct bufferevent *filter2 = bufferevent_filter_new(
65
        base, filter1,
66
        uppercase_filter,
67
        NULL,
68
        BEV_OPT_CLOSE_ON_FREE,
69
        NULL, NULL);
70

71
    char buf[1024];
72
    bufferevent_setcb(filter2,
73
        [](struct bufferevent *bev, void *arg) {
74
            char b[1024];
75
            size_t n;
76
            while ((n = bufferevent_read(bev, b, sizeof(b) - 1)) > 0) {
77
                b[n] = '\0';
78
                printf("Result: '%s'\n", b);
79
            }
80
        }, NULL, NULL, NULL);
81
    bufferevent_enable(filter2, EV_READ);
82

83
    const char *msg = "  hello world  \n";
84
    printf("Original: '%s'\n", msg);
85
    bufferevent_write(pair[0], msg, strlen(msg));
86

87
    event_base_loop(base, EVLOOP_ONCE);
88

89
    bufferevent_free(pair[0]);
90
    bufferevent_free(filter2);
91
    event_base_free(base);
92

93
    return 0;
94
}

五、SSL过滤器#

5.1 SSL作为过滤器#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <event2/event.h>
5
#include <event2/bufferevent.h>
6
#include <event2/bufferevent_ssl.h>
7
#include <openssl/ssl.h>
8

9
int main() {
10
    SSL_library_init();
11
    SSL_load_error_strings();
12

13
    struct event_base *base = event_base_new();
14

15
    // 创建SSL上下文
16
    SSL_CTX *ssl_ctx = SSL_CTX_new(TLS_method());
17

18
    // 加载证书和私钥（服务器端）
19
    SSL_CTX_use_certificate_file(ssl_ctx, "server.crt", SSL_FILETYPE_PEM);
20
    SSL_CTX_use_PrivateKey_file(ssl_ctx, "server.key", SSL_FILETYPE_PEM);
21

22
    // 创建底层连接
23
    struct bufferevent *pair[2];
24
    bufferevent_pair_new(base, BEV_OPT_CLOSE_ON_FREE, pair);
25

26
    // 在pair[0]上创建SSL客户端
27
    SSL *ssl_client = SSL_new(ssl_ctx);
28
    SSL_set_connect_state(ssl_client);
29
    struct bufferevent *ssl_bev_client = bufferevent_openssl_filter_new(
30
        base, pair[0], ssl_client, BUFFEREVENT_SSL_CONNECTING,
31
        BEV_OPT_CLOSE_ON_FREE);
32

33
    // 在pair[1]上创建SSL服务器
34
    SSL *ssl_server = SSL_new(ssl_ctx);
35
    SSL_set_accept_state(ssl_server);
36
    struct bufferevent *ssl_bev_server = bufferevent_openssl_filter_new(
37
        base, pair[1], ssl_server, BUFFEREVENT_SSL_ACCEPTING,
38
        BEV_OPT_CLOSE_ON_FREE);
39

40
    // 设置回调
41
    bufferevent_setcb(ssl_bev_server,
42
        [](struct bufferevent *bev, void *arg) {
43
            char buf[1024];
44
            size_t n;
45
            while ((n = bufferevent_read(bev, buf, sizeof(buf) - 1)) > 0) {
46
                buf[n] = '\0';
47
                printf("Server received: %s\n", buf);
48
                bufferevent_write(bev, buf, n);  // 回显
49
            }
50
        }, NULL, NULL, NULL);
51
    bufferevent_enable(ssl_bev_server, EV_READ | EV_WRITE);
52

53
    // 客户端发送数据
54
    const char *msg = "Hello, SSL!";
55
    bufferevent_write(ssl_bev_client, msg, strlen(msg));
56

57
    event_base_loop(base, EVLOOP_NONBLOCK);
58

59
    bufferevent_free(ssl_bev_client);
60
    bufferevent_free(ssl_bev_server);
61
    SSL_CTX_free(ssl_ctx);
62
    event_base_free(base);
63

64
    return 0;
65
}

六、完整示例：代理服务器#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <signal.h>
5
#include <event2/event.h>
6
#include <event2/listener.h>
7
#include <event2/bufferevent.h>
8

9
static struct event_base *g_base = NULL;
10

11
typedef struct {
12
    struct bufferevent *client_bev;
13
    struct bufferevent *server_bev;
14
} proxy_conn_t;
15

16
static void client_read_cb(struct bufferevent *bev, void *arg);
17
static void server_read_cb(struct bufferevent *bev, void *arg);
18
static void event_cb(struct bufferevent *bev, short events, void *arg);
19

20
static void client_read_cb(struct bufferevent *bev, void *arg) {
21
    proxy_conn_t *conn = arg;
22
    char buf[4096];
23
    size_t n;
24

25
    while ((n = bufferevent_read(bev, buf, sizeof(buf))) > 0) {
26
        printf("Client -> Server: %zu bytes\n", n);
27
        bufferevent_write(conn->server_bev, buf, n);
28
    }
29
}
30

31
static void server_read_cb(struct bufferevent *bev, void *arg) {
32
    proxy_conn_t *conn = arg;
33
    char buf[4096];
34
    size_t n;
35

36
    while ((n = bufferevent_read(bev, buf, sizeof(buf))) > 0) {
37
        printf("Server -> Client: %zu bytes\n", n);
38
        bufferevent_write(conn->client_bev, buf, n);
39
    }
40
}
41

42
static void event_cb(struct bufferevent *bev, short events, void *arg) {
43
    proxy_conn_t *conn = arg;
44

45
    if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
46
        printf("Connection closed\n");
47

48
        if (conn->client_bev) {
49
            bufferevent_free(conn->client_bev);
50
        }
51
        if (conn->server_bev) {
52
            bufferevent_free(conn->server_bev);
53
        }
54
        free(conn);
55
    } else if (events & BEV_EVENT_CONNECTED) {
56
        printf("Connected to upstream server\n");
57
    }
58
}
59

60
static void accept_cb(struct evconnlistener *listener, evutil_socket_t fd,
61
                      struct sockaddr *addr, int len, void *arg) {
62
    printf("New client connection\n");
63

64
    proxy_conn_t *conn = calloc(1, sizeof(proxy_conn_t));
65

66
    // 客户端连接
67
    conn->client_bev = bufferevent_socket_new(g_base, fd, BEV_OPT_CLOSE_ON_FREE);
68
    bufferevent_setcb(conn->client_bev, client_read_cb, NULL, event_cb, conn);
69
    bufferevent_enable(conn->client_bev, EV_READ | EV_WRITE);
70

71
    // 连接上游服务器
72
    conn->server_bev = bufferevent_socket_new(g_base, -1, BEV_OPT_CLOSE_ON_FREE);
73
    bufferevent_setcb(conn->server_bev, server_read_cb, NULL, event_cb, conn);
74
    bufferevent_enable(conn->server_bev, EV_READ | EV_WRITE);
75

76
    struct sockaddr_in server_addr;
77
    memset(&server_addr, 0, sizeof(server_addr));
78
    server_addr.sin_family = AF_INET;
79
    server_addr.sin_port = htons(80);  // 代理到HTTP服务器
80
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
81

82
    bufferevent_socket_connect(conn->server_bev,
83
                               (struct sockaddr *)&server_addr,
84
                               sizeof(server_addr));
85
}
86

87
static void signal_cb(evutil_socket_t fd, short events, void *arg) {
88
    printf("\nShutting down...\n");
89
    event_base_loopbreak(g_base);
90
}
91

92
int main() {
93
    g_base = event_base_new();
94

95
    struct event *sigint = evsignal_new(g_base, SIGINT, signal_cb, NULL);
96
    event_add(sigint, NULL);
97

98
    struct sockaddr_in listen_addr;
99
    memset(&listen_addr, 0, sizeof(listen_addr));
100
    listen_addr.sin_family = AF_INET;
101
    listen_addr.sin_port = htons(8080);
102
    listen_addr.sin_addr.s_addr = INADDR_ANY;
103

104
    struct evconnlistener *listener = evconnlistener_new_bind(
105
        g_base, accept_cb, NULL,
106
        LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
107
        -1, (struct sockaddr *)&listen_addr, sizeof(listen_addr));
108

109
    printf("Proxy server listening on port 8080\n");
110
    printf("Forwarding to 127.0.0.1:80\n");
111

112
    event_base_dispatch(g_base);
113

114
    evconnlistener_free(listener);
115
    event_free(sigint);
116
    event_base_free(g_base);
117

118
    return 0;
119
}

七、最佳实践#

特性	用途	建议
pair	进程内通信、测试	适合单元测试和管道构建
filter	数据转换	保持过滤器简单高效
链式过滤	多层处理	注意性能开销
SSL过滤	安全通信	使用filter模式更灵活
代理	数据转发	合理管理连接生命周期

其他相关资料请移步到个人主页

🔗 bufferevent高级特性 - libevent源码深度解析系列（二十四）