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的服务器代码：

 1 #include <stdio.h>

 2 #include <unistd.h>

 3 #include <stdlib.h>

 4 #include <sys/types.h>

 5 #include <sys/stat.h>

 6 #include <string.h>

 7 #include <event2/event.h>

 8 #include <event2/listener.h>

 9 #include <event2/bufferevent.h>

10

11 // 读缓冲区回调

12 void read_cb(struct bufferevent *bev, void *arg)

13 {

14     char buf[1024] = {0};

15     bufferevent_read(bev, buf, sizeof(buf));

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

17

18     char *p = "我是服务器, 已经成功收到你发送的数据!";

19     // 发数据给客户端

20     bufferevent_write(bev, p, strlen(p)+1);

21     sleep(1);

22 }

23

24 // 写缓冲区回调

25 void write_cb(struct bufferevent *bev, void *arg)

26 {

27     printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\n");

28 }

29

30 // 事件

31 void event_cb(struct bufferevent *bev, short events, void *arg)

32 {

33     if (events & BEV_EVENT_EOF)

34     {

35         printf("connection closed\n");

36     }

37     else if(events & BEV_EVENT_ERROR)

38     {

39         printf("some other error\n");

40     }

41

42     bufferevent_free(bev);

43     printf("buffevent 资源已经被释放...\n");

44 }

45

46

47

48 void cb_listener(

49         struct evconnlistener *listener,

50         evutil_socket_t fd,

51         struct sockaddr *addr,

52         int len, void *ptr)

53 {

54    printf("connect new client\n");

55

56    struct event_base* base = (struct event_base*)ptr;

57    // 通信操作

58    // 添加新事件

59    struct bufferevent *bev;

60    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

61

62    // 给bufferevent缓冲区设置回调

63    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);

64    bufferevent_enable(bev, EV_READ);

65 }

66

67

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

69 {

70

71     // init server

72     struct sockaddr_in serv;

73

74     memset(&serv, 0, sizeof(serv));

75     serv.sin_family = AF_INET;

76     serv.sin_port = htons(9876);

77     serv.sin_addr.s_addr = htonl(INADDR_ANY);

78

79     struct event_base* base;

80     base = event_base_new();

81     // 创建套接字

82     // 绑定

83     // 接收连接请求

84     struct evconnlistener* listener;

85     listener = evconnlistener_new_bind(base, cb_listener, base,

86                                   LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,

87                                   36, (struct sockaddr*)&serv, sizeof(serv));

88

89     event_base_dispatch(base);

90

91     evconnlistener_free(listener);

92     event_base_free(base);

93

94     return 0;

95 }

libevent客户端代码：

 1 #include <stdio.h>

 2 #include <unistd.h>

 3 #include <stdlib.h>

 4 #include <sys/types.h>

 5 #include <sys/stat.h>

 6 #include <string.h>

 7 #include <event2/bufferevent.h>

 8 #include <event2/event.h>

 9 #include <arpa/inet.h>

10

11 void read_cb(struct bufferevent *bev, void *arg)

12 {

13     char buf[1024] = {0};

14     bufferevent_read(bev, buf, sizeof(buf));

15

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

17

18     bufferevent_write(bev, buf, strlen(buf)+1);

19     sleep(1);

20 }

21

22 void write_cb(struct bufferevent *bev, void *arg)

23 {

24     printf("----------我是客户端的写回调函数,没卵用\n");

25 }

26

27 void event_cb(struct bufferevent *bev, short events, void *arg)

28 {

29     if (events & BEV_EVENT_EOF)

30     {

31         printf("connection closed\n");

32     }

33     else if(events & BEV_EVENT_ERROR)

34     {

35         printf("some other error\n");

36     }

37     else if(events & BEV_EVENT_CONNECTED)

38     {

39         printf("已经连接服务器...\\(^o^)/...\n");

40         return;

41     }

42

43     // 释放资源

44     bufferevent_free(bev);

45 }

46

47 // 客户端与用户交互，从终端读取数据写给服务器

48 void read_terminal(evutil_socket_t fd, short what, void *arg)

49 {

50     // 读数据

51     char buf[1024] = {0};

52     int len = read(fd, buf, sizeof(buf));

53

54     struct bufferevent* bev = (struct bufferevent*)arg;

55     // 发送数据

56     bufferevent_write(bev, buf, len+1);

57 }

58

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

60 {

61     struct event_base* base = NULL;

62     base = event_base_new();

63

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

65

66     // 通信的fd放到bufferevent中

67     struct bufferevent* bev = NULL;

68     bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

69

70     // init server info

71     struct sockaddr_in serv;

72     memset(&serv, 0, sizeof(serv));

73     serv.sin_family = AF_INET;

74     serv.sin_port = htons(9876);

75     inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);

76

77     // 连接服务器

78     bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));

79

80     // 设置回调

81     bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);

82

83     // 设置读回调生效

84     // bufferevent_enable(bev, EV_READ);

85

86     // 创建事件

87     struct event* ev = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST,

88                                  read_terminal, bev);

89     // 添加事件

90     event_add(ev, NULL);

91

92     event_base_dispatch(base);

93

94     event_free(ev);

95

96     event_base_free(base);

97

98     return 0;

99 }

巴特西

Libevent库基础(2)

最新文章

热门文章