Libevent库基础(2)

带缓冲区的事件 bufferevent

　　#include <event2/bufferevent.h>

　　read/write 两个缓冲. 借助 队列.

创建、销毁bufferevent：

　　struct bufferevent *ev；

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

　　base： event_base

　　fd: 封装到bufferevent内的 fd

　　options：BEV_OPT_CLOSE_ON_FREE

　　返回： 成功创建的 bufferevent事件对象。

　　void bufferevent_socket_free(struct bufferevent *ev);

给bufferevent设置回调：

　　对比event： event_new( fd, callback ); event_add() -- 挂到 event_base 上。

　　bufferevent_socket_new（fd）  bufferevent_setcb（ callback ）

 

　　void bufferevent_setcb(struct bufferevent * bufev,

　　bufferevent_data_cb readcb,
　　bufferevent_data_cb writecb,
　　bufferevent_event_cb eventcb,
　　void *cbarg );

　　bufev： bufferevent_socket_new() 返回值

　　readcb： 设置 bufferevent 读缓冲，对应回调  read_cb{  bufferevent_read() 读数据  }

　　writecb： 设置 bufferevent 写缓冲，对应回调 write_cb {  } -- 给调用者，发送写成功通知。  可以 NULL

　　eventcb： 设置 事件回调。   也可传NULL

　　

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

　　void event_cb(struct bufferevent *bev, short events, void *ctx)
　　{

　　　　。。。。。
　　}

　　events： BEV_EVENT_CONNECTED

　　cbarg： 上述回调函数使用的 参数。

　　read 回调函数类型：

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

　　void read_cb(struct bufferevent *bev, void *cbarg )
　　{
　　　　.....
　　　　bufferevent_read(); --- read();
　　}

　　bufferevent_read()函数的原型：

　　　　size_t bufferevent_read(struct bufferevent *bev, void *buf, size_t bufsize);

　　write 回调函数类型：

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

 

启动、关闭 bufferevent的 缓冲区：

　　void bufferevent_enable(struct bufferevent *bufev, short events);   启动

　　events： EV_READ、EV_WRITE、EV_READ|EV_WRITE

　　默认、write 缓冲是 enable、read 缓冲是 disable

　　bufferevent_enable(evev, EV_READ); -- 开启读缓冲

 

连接客户端：

　　socket();connect();

　　int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *address, int addrlen);

　　bev: bufferevent 事件对象（封装了fd）

　　address、len：等同于 connect() 参2/3

创建监听服务器：

　　------ socket();bind();listen();accept();

　　struct evconnlistener * listner；

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

　　base： event_base

　　cb: 回调函数。 一旦被回调，说明在其内部应该与客户端完成， 数据读写操作，进行通信。

　　ptr： 回调函数的参数

　　flags： LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE

　　backlog： listen() 2参。 -1 表最大值

　　sa：服务器自己的地址结构体

　　socklen：服务器自己的地址结构体大小。

　　返回值：成功创建的监听器。

　　释放监听服务器:

　　　　void evconnlistener_free(struct evconnlistener *lev);

 

服务器端 libevent 创建TCP连接：

　　1. 创建event_base

　　2. 创建bufferevent事件对象。bufferevent_socket_new();　

　　3. 使用bufferevent_setcb() 函数给 bufferevent的 read、write、event 设置回调函数。

　　4. 当监听的 事件满足时，read_cb会被调用， 在其内部 bufferevent_read();读　

　　5. 使用 evconnlistener_new_bind 创建监听服务器， 设置其回调函数，当有客户端成功连接时，这个回调函数会被调用。

　　6. 封装 listner_cb() 在函数内部。完成与客户端通信

　　7. 设置读缓冲、写缓冲的 使能状态 enable、disable

　　8.启动循环 event_base_dispath();

　　9.释放连接

客户端端 libevent 创建TCP连接：

　　1、event_base

　　2. 创建bufferevent事件对象。bufferevent_socket_new();

　　3、bufferevent_socket_connect()连接服务器

　　4、使用bufferevent_setcb()函数给 bufferevent的 read、write、event 设置回调函数

　　5、设置读缓冲、写缓冲的 使能状态 enable、disable

　　6、接收和发送数据bufferevent_read()/bufferevent_write()

　　7、启动循环 event_base_dispath();

　　8、释放连接

 

libevent的服务器代码：

#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));
    printf("client say: %s\n", buf);

    char *p = "我是服务器, 已经成功收到你发送的数据!";
    // 发数据给客户端
    bufferevent_write(bev, p, strlen(p)+1);
    sleep(1);
}

// 写缓冲区回调
void write_cb(struct bufferevent *bev, void *arg)
{
    printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\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;
    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;
}

libevent客户端代码：

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

void read_cb(struct bufferevent *bev, void *arg)
{
    char buf[1024] = {0}; 
    bufferevent_read(bev, buf, sizeof(buf));

    printf("fwq say:%s\n", buf);

    bufferevent_write(bev, buf, strlen(buf)+1);
    sleep(1);
}

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");
    }
    else if(events & BEV_EVENT_CONNECTED)
    {
        printf("已经连接服务器...\\(^o^)/...\n");
        return;
    }
    
    // 释放资源
    bufferevent_free(bev);
}

// 客户端与用户交互，从终端读取数据写给服务器
void read_terminal(evutil_socket_t fd, short what, void *arg)
{
    // 读数据
    char buf[1024] = {0};
    int len = read(fd, buf, sizeof(buf));

    struct bufferevent* bev = (struct bufferevent*)arg;
    // 发送数据
    bufferevent_write(bev, buf, len+1);
}

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

    int fd = socket(AF_INET, SOCK_STREAM, 0);

    // 通信的fd放到bufferevent中
    struct bufferevent* bev = NULL;
    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

    // init server info
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(9876);
    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);

    // 创建事件
    struct event* ev = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST,
                                 read_terminal, bev);
    // 添加事件                     
    event_add(ev, NULL);

    event_base_dispatch(base);

    event_free(ev);
    
    event_base_free(base);

    return 0;
}