libevent学习（二）bufferevent

1.数据缓冲区bufferevent

bufferevent可以看成有缓冲区的event，缓冲区内部用队列实现，头文件event2/bufferevent.h

bufferevent是libevent为IO缓冲区操作提供的一种通用机制。bufferevent 由一个底层的传输端口(如套接字 )，一个读取缓冲区和一个写入缓冲区组成。
与通常的事件在底层传输端口已经就绪,可以读取或者写入的时候执行回调不同的是, bufferevent在读取或者写入了足够量的数据之后调用用户提供的回调。

回调是缓冲区对应的操作，每个 bufferevent 有两个数据相关的回调
一个读取回调：从底层传输端口读取了任意量的数据之后会调用读取回调(默认)

二是写回调：输出缓冲区中足够量的数据被清空到底层传输端口后写入回调会被调用(默认)
 

2.服务器端的bufferevent

（1）创建基于套接字的bufferevent

可以使用 bufferevent_socket_new()创建基于套接字的 bufferevent

struct bufferevent *bufferevent_socket_new(
    struct event_base *base,
    evutil_socket_t fd,
    enum bufferevent_options options
);

options: BEV_OPT_CLOSE_ON_FREE //释放 bufferevent 时关闭底层传输端口。这将关闭底层套接字,释放底层 bufferevent 等

成功时函数返回一个 bufferevent, 失败则返回NULL

（2）bufferevent读写缓冲区回调操作

void bufferevent_setcb(
    struct bufferevent *bufev, 
    bufferevent_data_cb readcb, //在读回调中读数据, bufferevent_read()
    bufferevent_data_cb writecb,  
    bufferevent_event_cb eventcb,
    void *cbarg
);

typedef void (*bufferevent_data_cb)(
    struct bufferevent *bev,
    void *ctx
);
typedef void (*bufferevent_event_cb)(
    struct bufferevent *bev,
    short events,
    void *ctx
);

events参数:
EV_EVENT_READING：读取操作时发生某事件，具体是哪种事件请看其他标志
BEV_EVENT_WRITING：写入操作时发生某事件，具体是哪种事件请看其他标志
BEV_EVENT_ERROR：操作时发生错误。关于错误的更多信息，请调用EVUTIL_SOCKET_ERROR()
BEV_EVENT_TIMEOUT：发生超时
BEV_EVENT_EOF：遇到文件结束指示
BEV_EVENT_CONNECTED：请求的连接过程已经完成, 实现客户端的时候可以判断

void bufferevent_enable(
    struct bufferevent *bufev,
    short events
);
默认ev_write 是enable, ev_read是关闭的

（3）链接监听器 - evconnlistener

可以实现功能，创建监听socket，绑定，监听，等待并接收连接。

struct evconnlistener *evconnlistener_new_bind(
    struct event_base *base,
    evconnlistener_cb cb, //接受连接之后, 用户要做的操作
    void *ptr, // 给回调传参
    unsigned flags,
    int backlog, //最多监听的数量，-1使用默认的最大值
    const struct sockaddr *sa,  //服务器绑定的IP和端口信息
    int socklen
);

//回调函数
typedef void (*evconnlistener_cb)(
    struct evconnlistener *listener, 
    evutil_socket_t sock, //用于通信的文件描述符
    struct sockaddr *addr, //客户端的IP和端口信息
    int len,
    void *ptr; //外部传进来的数据
);
flags: LEV_OPT_CLOSE_ON_FREE; LEV_OPT_REUSEABLE

 evconnlistener函数返回一个新的连接监听器对象。连接监听器使 用 event_base 来得知什么时候在给定的监听套接字上有新的 TCP 连接。新连接到达时,监听器调用你给出的回调函数.

（4）释放，启用和禁用evconnlistener

void evconnlistener_free(struct evconnlistener *lev); //释放
int evconnlistener_disable(struct evconnlistener *lev);
int evconnlistener_enable(struct evconnlistener *lev); //暂时禁止或者重新允许监听新连接

（5）操作bufferevent中的数据

向bufferevent的输出缓冲区添加数据

int bufferevent_write(
    struct bufferevent *bufev,
    const void *data,
    size_t size
);

从bufferevent的输入缓冲区移除数据

size_t bufferevent_read(
    struct bufferevent *bufev,
    void *data,
    size_t size
);

（6）服务端bufferevent代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <event2/bufferevent.h>

// 读缓冲区回调
void read_cb(struct bufferevent *bev, void *arg)
{
    char buf[1024] = {0};   
    bufferevent_read(bev, buf, sizeof(buf));
    char* p = "我已经收到了你发送的数据!";
    printf("client say: %s\n", p);

    // 发数据给客户端
    bufferevent_write(bev, p, strlen(p)+1);
    printf("我发送了数据给客户端\n");
}

// 写缓冲区回调
void write_cb(struct bufferevent *bev, void *arg)
{
    printf("我是写缓冲区的回调函数...\n"); 
}

// 事件
void event_cb(struct bufferevent *bev, short events, void *arg)
{
    if (events & BEV_EVENT_EOF)
    {
        printf("connection closed\n");  
    }
    else if(events & BEV_EVENT_ERROR)   
    {
        printf("some other error\n");
    }
    
    bufferevent_free(bev);    
    printf("buffevent 资源已经被释放...\n"); 
}



void cb_listener(
        struct evconnlistener *listener, 
        evutil_socket_t fd, 
        struct sockaddr *addr, 
        int len, void *ptr)
{
   printf("connect new client\n");

   struct event_base* base = (struct event_base*)ptr;
   // 通信操作
   // 添加新事件
   struct bufferevent *bev;
   bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

   // 给bufferevent缓冲区设置回调
   bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
   bufferevent_enable(bev, EV_READ);
}


int main(int argc, const char* argv[])
{

    // init server 
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(9876);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);

    struct event_base* base;
    base = event_base_new();
    // 创建套接字
    // 绑定
    // 监听
    // 接收连接请求
    struct evconnlistener* listener;
    // 有新的连接请求，cb_listener被调用
    listener = evconnlistener_new_bind(base, cb_listener, base, 
                                  LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 
                                  36, (struct sockaddr*)&serv, sizeof(serv));

    event_base_dispatch(base);

    evconnlistener_free(listener);
    event_base_free(base);

    return 0;
}

3.客户端bufferevent

（1）在bufferevent上启动链接
 

int bufferevent_socket_connect(
    struct bufferevent *bev,
    struct sockaddr *address, //server ip和port
    int addrlen
);

（2）客户端程序

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <event2/event.h>
#include <event2/bufferevent.h>


void read_cb(struct bufferevent *bev, void *arg)
{
    char buf[1024] = {0}; 
    bufferevent_read(bev, buf, sizeof(buf));
    printf("Server say: %s\n", buf);
}

void write_cb(struct bufferevent *bev, void *arg)
{
    printf("I am Write_cb function....\n");
}

void event_cb(struct bufferevent *bev, short events, void *arg)
{
    if (events & BEV_EVENT_EOF)
    {
        printf("connection closed\n");  
    }
    else if(events & BEV_EVENT_ERROR)   
    {
        printf("some other error\n");
    }
    else if(events & BEV_EVENT_CONNECTED)
    {
        printf("成功连接到服务器, O(∩_∩)O哈哈~\n");
        return;
    }
    
    bufferevent_free(bev);
    printf("free bufferevent...\n");
}

void send_cb(evutil_socket_t fd, short what, void *arg)
{
    char buf[1024] = {0}; 
    struct bufferevent* bev = (struct bufferevent*)arg;
    printf("请输入要发送的数据: \n");
    read(fd, buf, sizeof(buf));
    bufferevent_write(bev, buf, strlen(buf)+1);
}


int main(int argc, const char* argv[])
{
    struct event_base* base;
    base = event_base_new();


    struct bufferevent* bev;
    bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);

    // 连接服务器
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(9876);
    evutil_inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));

    // 设置回调
    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    // 创建一个事件
    struct event* ev = event_new(base, STDIN_FILENO, 
                                 EV_READ | EV_PERSIST, 
                                 send_cb, bev);
    event_add(ev, NULL);
    
    event_base_dispatch(base);

    event_base_free(base);

    return 0;
}