libevent的使用_libevent使用

---

libevent封装的框架思想

libevent框架：
	1. 创建 event_base		(乐高底座)
	2. 创建 事件evnet	
	3. 将事件 添加到 base上	
	4. 循环监听事件满足
	5. 释放 event_base


1. 创建 event_base		(乐高底座)

		struct event_base *event_base_new(void);

		struct event_base *base = event_base_new();

2. 创建 事件evnet	

		常规事件 event	--> event_new(); 

		bufferevent --> bufferevent_socket_new();

3. 将事件 添加到 base上	

		int event_add(struct event *ev, const struct timeval *tv)

4. 循环监听事件满足

		int event_base_dispatch(struct event_base *base);

			event_base_dispatch(base);

5. 释放 event_base

		event_base_free(base);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

常用函数分析

创建事件event：

	struct event *ev；

	struct event *event_new(struct event_base *base，evutil_socket_t fd，short what，event_callback_fn cb;  void *arg);

		base： event_base_new()返回值。

		 fd： 绑定到 event 上的 文件描述符

		what：对应的事件（r、w、e）

	在		EV_READ		一次 读事件

			EV_WRTIE	一次 写事件

			EV_PERSIST	持续触发。 结合 event_base_dispatch 函数使用，生效。

		cb：一旦事件满足监听条件，回调的函数。

		typedef void (*event_callback_fn)(evutil_socket_t fd,  short,  void *)	

		arg： 回调的函数的参数。

		返回值：成功创建的 event
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

事件event操作：

添加事件到 event_base

	int event_add(struct event *ev, const struct timeval *tv);

		ev: event_new() 的返回值。

		tv：为NULL，不会超时。意为：一直等到事件被触发，回调函数会被调用。
			为非0，等待期间，检查事件没有被触发，时间到，回调函数依旧会被调用。

将事件从base上拿下
	int event_del(struct event *ev);
		ev: event_new() 的返回值。


释放事件
	int event_free(struct event *ev);
		ev: event_new() 的返回值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用fifo的读写

read.c

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <string.h>  
#include <fcntl.h>  
#include <event2/event.h>  
  
// 对操作处理函数  
void read_cb(evutil_socket_t fd, short what, void *arg)  
{  
    // 读管道  
    char buf[1024] = {0};  
      
    int len = read(fd, buf, sizeof(buf));  
      
    printf("read event: %s \n", what & EV_READ ? "Yes" : "No");  
    printf("data len = %d, buf = %s\n", len, buf);  
      
    sleep(1);  
}  
  
  
// 读管道  
int main(int argc, const char* argv[])  
{  
    unlink("myfifo");  
  
    //创建有名管道  
    mkfifo("myfifo", 0664);  
  
    // open file  
    //int fd = open("myfifo", O_RDONLY | O_NONBLOCK);  
    int fd = open("myfifo", O_RDONLY);  
    if(fd == -1)  
    {  
        perror("open error");  
        exit(1);  
    }  
  
    // 创建个event_base  
    struct event_base* base = NULL;  
    base = event_base_new();  
  
    // 创建事件  
    struct event* ev = NULL;  
    ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, NULL);  
  
    // 添加事件  
    event_add(ev, NULL);  
  
    // 事件循环  
    event_base_dispatch(base);  // while（1） { epoll();}  
  
    // 释放资源  
    event_free(ev);  
    event_base_free(base);  
    close(fd);  
      
    return 0;  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

write.c

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <string.h>  
#include <fcntl.h>  
#include <event2/event.h>  
  
// 对操作处理函数  
void write_cb(evutil_socket_t fd, short what, void *arg)  
{  
    // write管道  
    char buf[1024] = {0};  
      
    static int num = 0;  
    sprintf(buf, "hello,world-%d\n", num++);  
    write(fd, buf, strlen(buf)+1);  
      
    sleep(1);  
}  
  
  
// 写管道  
int main(int argc, const char* argv[])  
{  
    // open file  
    //int fd = open("myfifo", O_WRONLY | O_NONBLOCK);  
    int fd = open("myfifo", O_WRONLY);  
    if(fd == -1)  
    {  
        perror("open error");  
        exit(1);  
    }  
  
    // 写管道  
    struct event_base* base = NULL;  
    base = event_base_new();  
  
    // 创建事件  
    struct event* ev = NULL;  
    // 检测的写缓冲区是否有空间写  
    //ev = event_new(base, fd, EV_WRITE , write_cb, NULL);  
    ev = event_new(base, fd, EV_WRITE | EV_PERSIST, write_cb, NULL);  
  
    // 添加事件  
    event_add(ev, NULL);  
  
    // 事件循环  
    event_base_dispatch(base);  
  
    // 释放资源  
    event_free(ev);  
    event_base_free(base);  
    close(fd);  
      
    return 0;  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

未决和非未决

非未决: 没有资格被处理

未决： 有资格被处理，但尚未被处理

event_new --> event ---> 非未决 --> event_add --> 未决 --> dispatch() && 监听事件被触发 --> 激活态 

--> 执行回调函数 --> 处理态 --> 非未决 event_add && EV_PERSIST --> 未决 --> event_del --> 非未决
1
2
3

bufferevent特性

带缓冲区的事件 bufferevent

#include <event2/bufferevent.h> 
读：有数据-->读回调函数被调用-->bufferevent_read()-->读数据
写：使用bufferevent_write()-->向写缓冲中写数据-->该缓冲区有数据自动写出-->写完，回调函数被调用
1
2
3
4
5

bufferevent函数

创建、销毁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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

给bufferevent设置回调：
	对比event：	event_new( fd, callback );  	event_add() -- 挂到 event_base 上。

			bufferevent_socket_new（base,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
		events： BEV_EVENT_CONNECTED

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

event回调函数类型
		typedef void (*bufferevent_event_cb)(struct bufferevent *bev,  short events, void *ctx);

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

	
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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

启动、关闭 bufferevent的 缓冲区：

默认：新建的bufferevent的写缓冲是 enable、读缓冲是 disable

void bufferevent_enable(struct bufferevent *bufev, short events);   启动	
	通常用来启动bufferevent的read缓冲

void bufferevent_disable(struct bufferevent *bufev, short events); 禁用

	events： EV_READ、EV_WRITE、EV_READ|EV_WRITE

void bufferevent_get_enabled(struct bufferevent *bufev);
	获取缓冲区的禁用状态，需要借助&来得到
1
2
3
4
5
6
7
8
9
10
11
12
13

客户端和服务器连接和监听

客户端：

	socket();connect(fd,addr,addr_len);

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

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

		address、addresslen：等同于 connect() 的第二个参数和第三个参数


创建监听服务器：

	#include<event2/listener.h>

	//这个函数相当于socket、bind、listen、accept的作用
	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：释放bufferevent时关闭底层传输端口。
		这将关闭底层套接字、释放底层bufferevent等
		LEV_OPT_REUSEABLE：端口服用

	backlog： listen()的第2个参数。 -1 表最大值

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

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

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

	回调函数类型：
	typedef void(*evconnlistner_cb)(
	struct evconnlistener *listener, 
	evutil_socket_t sock,
	struct sockaddr* addr, 
	int len, 
	void *ptr);
	
	listener: evconnlistener_new_bind函数返回值
	sock: 用于通信的文件描述符
	addr: 客户端的IP+端口
	len: addr的len
	ptr: 外部ptr传递进来的值


释放监听服务器:

	void evconnlistener_free(struct evconnlistener *lev);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

libevent实现socket通信

服务器端

server.c

#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;  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

客户端

#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;  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99