[z]Libevent使用例子，从简单到复杂

[z]http://blog.csdn.net/luotuo44/article/details/39670221

本文从简单到复杂，展示如何使用libevent。网上的许多例子都是只有服务器端的，本文里面客户端和服务器端都有，以飨读者。

关于libevent编程时的一些疑问可以阅读《libevent编程疑难解答》。假如读者还想了解libevent的具体实现，可以阅读《libevent源码分析》系统文章。

不说这么多了，直接上代码。

初等：

客户端代码：

1. #include<sys/types.h>
2. #include<sys/socket.h>
3. #include<netinet/in.h>
4. #include<arpa/inet.h>
5. #include<errno.h>
6. #include<unistd.h>
7. #include<stdio.h>
8. #include<string.h>
9. #include<stdlib.h>
10. #include<event.h>
11. #include<event2/util.h>
12. int tcp_connect_server(const char* server_ip, int port);
13. void cmd_msg_cb(int fd, short events, void* arg);
14. void socket_read_cb(int fd, short events, void *arg);
15. int main(int argc, char** argv)
16. {
17. if( argc < 3 )
18. {
19. printf("please input 2 parameter\n");
20. return -1;
21. }
22. //两个参数依次是服务器端的IP地址、端口号
23. int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));
24. if( sockfd == -1)
25. {
26. perror("tcp_connect error ");
27. return -1;
28. }
29. printf("connect to server successful\n");
30. struct event_base* base = event_base_new();
31. struct event *ev_sockfd = event_new(base, sockfd,
32. EV_READ | EV_PERSIST,
33. socket_read_cb, NULL);
34. event_add(ev_sockfd, NULL);
35. //监听终端输入事件
36. struct event* ev_cmd = event_new(base, STDIN_FILENO,
37. EV_READ | EV_PERSIST, cmd_msg_cb,
38. (void*)&sockfd);
39. event_add(ev_cmd, NULL);
40. event_base_dispatch(base);
41. printf("finished \n");
42. return 0;
43. }
44. void cmd_msg_cb(int fd, short events, void* arg)
45. {
46. char msg[1024];
47. int ret = read(fd, msg, sizeof(msg));
48. if( ret <= 0 )
49. {
50. perror("read fail ");
51. exit(1);
52. }
53. int sockfd = *((int*)arg);
54. //把终端的消息发送给服务器端
55. //为了简单起见，不考虑写一半数据的情况
56. write(sockfd, msg, ret);
57. }
58. void socket_read_cb(int fd, short events, void *arg)
59. {
60. char msg[1024];
61. //为了简单起见，不考虑读一半数据的情况
62. int len = read(fd, msg, sizeof(msg)-1);
63. if( len <= 0 )
64. {
65. perror("read fail ");
66. exit(1);
67. }
68. msg[len] = '\0';
69. printf("recv %s from server\n", msg);
70. }
71. typedef struct sockaddr SA;
72. int tcp_connect_server(const char* server_ip, int port)
73. {
74. int sockfd, status, save_errno;
75. struct sockaddr_in server_addr;
76. memset(&server_addr, 0, sizeof(server_addr) );
77. server_addr.sin_family = AF_INET;
78. server_addr.sin_port = htons(port);
79. status = inet_aton(server_ip, &server_addr.sin_addr);
80. if( status == 0 ) //the server_ip is not valid value
81. {
82. errno = EINVAL;
83. return -1;
84. }
85. sockfd = ::socket(PF_INET, SOCK_STREAM, 0);
86. if( sockfd == -1 )
87. return sockfd;
88. status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );
89. if( status == -1 )
90. {
91. save_errno = errno;
92. ::close(sockfd);
93. errno = save_errno; //the close may be error
94. return -1;
95. }
96. evutil_make_socket_nonblocking(sockfd);
97. return sockfd;
98. }

服务器端代码：

1. #include<stdio.h>
2. #include<string.h>
3. #include<errno.h>
4. #include<unistd.h>
5. #include<event.h>
6. void accept_cb(int fd, short events, void* arg);
7. void socket_read_cb(int fd, short events, void *arg);
8. int tcp_server_init(int port, int listen_num);
9. int main(int argc, char** argv)
10. {
11. int listener = tcp_server_init(9999, 10);
12. if( listener == -1 )
13. {
14. perror(" tcp_server_init error ");
15. return -1;
16. }
17. struct event_base* base = event_base_new();
18. //添加监听客户端请求连接事件
19. struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
20. accept_cb, base);
21. event_add(ev_listen, NULL);
22. event_base_dispatch(base);
23. return 0;
24. }
25. void accept_cb(int fd, short events, void* arg)
26. {
27. evutil_socket_t sockfd;
28. struct sockaddr_in client;
29. socklen_t len = sizeof(client);
30. sockfd = ::accept(fd, (struct sockaddr*)&client, &len );
31. evutil_make_socket_nonblocking(sockfd);
32. printf("accept a client %d\n", sockfd);
33. struct event_base* base = (event_base*)arg;
34. //仅仅是为了动态创建一个event结构体
35. struct event *ev = event_new(NULL, -1, 0, NULL, NULL);
36. //将动态创建的结构体作为event的回调参数
37. event_assign(ev, base, sockfd, EV_READ | EV_PERSIST,
38. socket_read_cb, (void*)ev);
39. event_add(ev, NULL);
40. }
41. void socket_read_cb(int fd, short events, void *arg)
42. {
43. char msg[4096];
44. struct event *ev = (struct event*)arg;
45. int len = read(fd, msg, sizeof(msg) - 1);
46. if( len <= 0 )
47. {
48. printf("some error happen when read\n");
49. event_free(ev);
50. close(fd);
51. return ;
52. }
53. msg[len] = '\0';
54. printf("recv the client msg: %s", msg);
55. char reply_msg[4096] = "I have recvieced the msg: ";
56. strcat(reply_msg + strlen(reply_msg), msg);
57. write(fd, reply_msg, strlen(reply_msg) );
58. }
59. typedef struct sockaddr SA;
60. int tcp_server_init(int port, int listen_num)
61. {
62. int errno_save;
63. evutil_socket_t listener;
64. listener = ::socket(AF_INET, SOCK_STREAM, 0);
65. if( listener == -1 )
66. return -1;
67. //允许多次绑定同一个地址。要用在socket和bind之间
68. evutil_make_listen_socket_reuseable(listener);
69. struct sockaddr_in sin;
70. sin.sin_family = AF_INET;
71. sin.sin_addr.s_addr = 0;
72. sin.sin_port = htons(port);
73. if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
74. goto error;
75. if( ::listen(listener, listen_num) < 0)
76. goto error;
77. //跨平台统一接口，将套接字设置为非阻塞状态
78. evutil_make_socket_nonblocking(listener);
79. return listener;
80. error:
81. errno_save = errno;
82. evutil_closesocket(listener);
83. errno = errno_save;
84. return -1;
85. }

中等：

客户端代码：

1. #include<sys/types.h>
2. #include<sys/socket.h>
3. #include<netinet/in.h>
4. #include<arpa/inet.h>
5. #include<errno.h>
6. #include<unistd.h>
7. #include<stdio.h>
8. #include<string.h>
9. #include<stdlib.h>
10. #include<event.h>
11. #include<event2/bufferevent.h>
12. #include<event2/buffer.h>
13. #include<event2/util.h>
14. int tcp_connect_server(const char* server_ip, int port);
15. void cmd_msg_cb(int fd, short events, void* arg);
16. void server_msg_cb(struct bufferevent* bev, void* arg);
17. void event_cb(struct bufferevent *bev, short event, void *arg);
18. int main(int argc, char** argv)
19. {
20. if( argc < 3 )
21. {
22. printf("please input 2 parameter\n");
23. return -1;
24. }
25. //两个参数依次是服务器端的IP地址、端口号
26. int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));
27. if( sockfd == -1)
28. {
29. perror("tcp_connect error ");
30. return -1;
31. }
32. printf("connect to server successful\n");
33. struct event_base* base = event_base_new();
34. struct bufferevent* bev = bufferevent_socket_new(base, sockfd,
35. BEV_OPT_CLOSE_ON_FREE);
36. //监听终端输入事件
37. struct event* ev_cmd = event_new(base, STDIN_FILENO,
38. EV_READ | EV_PERSIST, cmd_msg_cb,
39. (void*)bev);
40. event_add(ev_cmd, NULL);
41. //当socket关闭时会用到回调参数
42. bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
43. bufferevent_enable(bev, EV_READ | EV_PERSIST);
44. event_base_dispatch(base);
45. printf("finished \n");
46. return 0;
47. }
48. void cmd_msg_cb(int fd, short events, void* arg)
49. {
50. char msg[1024];
51. int ret = read(fd, msg, sizeof(msg));
52. if( ret < 0 )
53. {
54. perror("read fail ");
55. exit(1);
56. }
57. struct bufferevent* bev = (struct bufferevent*)arg;
58. //把终端的消息发送给服务器端
59. bufferevent_write(bev, msg, ret);
60. }
61. void server_msg_cb(struct bufferevent* bev, void* arg)
62. {
63. char msg[1024];
64. size_t len = bufferevent_read(bev, msg, sizeof(msg));
65. msg[len] = '\0';
66. printf("recv %s from server\n", msg);
67. }
68. void event_cb(struct bufferevent *bev, short event, void *arg)
69. {
70. if (event & BEV_EVENT_EOF)
71. printf("connection closed\n");
72. else if (event & BEV_EVENT_ERROR)
73. printf("some other error\n");
74. //这将自动close套接字和free读写缓冲区
75. bufferevent_free(bev);
76. struct event *ev = (struct event*)arg;
77. //因为socket已经没有，所以这个event也没有存在的必要了
78. event_free(ev);
79. }
80. typedef struct sockaddr SA;
81. int tcp_connect_server(const char* server_ip, int port)
82. {
83. int sockfd, status, save_errno;
84. struct sockaddr_in server_addr;
85. memset(&server_addr, 0, sizeof(server_addr) );
86. server_addr.sin_family = AF_INET;
87. server_addr.sin_port = htons(port);
88. status = inet_aton(server_ip, &server_addr.sin_addr);
89. if( status == 0 ) //the server_ip is not valid value
90. {
91. errno = EINVAL;
92. return -1;
93. }
94. sockfd = ::socket(PF_INET, SOCK_STREAM, 0);
95. if( sockfd == -1 )
96. return sockfd;
97. status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );
98. if( status == -1 )
99. {
100. save_errno = errno;
101. ::close(sockfd);
102. errno = save_errno; //the close may be error
103. return -1;
104. }
105. evutil_make_socket_nonblocking(sockfd);
106. return sockfd;
107. }

服务器端代码：

1. #include<stdio.h>
2. #include<string.h>
3. #include<errno.h>
4. #include<event.h>
5. #include<event2/bufferevent.h>
6. void accept_cb(int fd, short events, void* arg);
7. void socket_read_cb(bufferevent* bev, void* arg);
8. void event_cb(struct bufferevent *bev, short event, void *arg);
9. int tcp_server_init(int port, int listen_num);
10. int main(int argc, char** argv)
11. {
12. int listener = tcp_server_init(9999, 10);
13. if( listener == -1 )
14. {
15. perror(" tcp_server_init error ");
16. return -1;
17. }
18. struct event_base* base = event_base_new();
19. //添加监听客户端请求连接事件
20. struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
21. accept_cb, base);
22. event_add(ev_listen, NULL);
23. event_base_dispatch(base);
24. event_base_free(base);
25. return 0;
26. }
27. void accept_cb(int fd, short events, void* arg)
28. {
29. evutil_socket_t sockfd;
30. struct sockaddr_in client;
31. socklen_t len = sizeof(client);
32. sockfd = ::accept(fd, (struct sockaddr*)&client, &len );
33. evutil_make_socket_nonblocking(sockfd);
34. printf("accept a client %d\n", sockfd);
35. struct event_base* base = (event_base*)arg;
36. bufferevent* bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);
37. bufferevent_setcb(bev, socket_read_cb, NULL, event_cb, arg);
38. bufferevent_enable(bev, EV_READ | EV_PERSIST);
39. }
40. void socket_read_cb(bufferevent* bev, void* arg)
41. {
42. char msg[4096];
43. size_t len = bufferevent_read(bev, msg, sizeof(msg));
44. msg[len] = '\0';
45. printf("recv the client msg: %s", msg);
46. char reply_msg[4096] = "I have recvieced the msg: ";
47. strcat(reply_msg + strlen(reply_msg), msg);
48. bufferevent_write(bev, reply_msg, strlen(reply_msg));
49. }
50. void event_cb(struct bufferevent *bev, short event, void *arg)
51. {
52. if (event & BEV_EVENT_EOF)
53. printf("connection closed\n");
54. else if (event & BEV_EVENT_ERROR)
55. printf("some other error\n");
56. //这将自动close套接字和free读写缓冲区
57. bufferevent_free(bev);
58. }
59. typedef struct sockaddr SA;
60. int tcp_server_init(int port, int listen_num)
61. {
62. int errno_save;
63. evutil_socket_t listener;
64. listener = ::socket(AF_INET, SOCK_STREAM, 0);
65. if( listener == -1 )
66. return -1;
67. //允许多次绑定同一个地址。要用在socket和bind之间
68. evutil_make_listen_socket_reuseable(listener);
69. struct sockaddr_in sin;
70. sin.sin_family = AF_INET;
71. sin.sin_addr.s_addr = 0;
72. sin.sin_port = htons(port);
73. if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
74. goto error;
75. if( ::listen(listener, listen_num) < 0)
76. goto error;
77. //跨平台统一接口，将套接字设置为非阻塞状态
78. evutil_make_socket_nonblocking(listener);
79. return listener;
80. error:
81. errno_save = errno;
82. evutil_closesocket(listener);
83. errno = errno_save;
84. return -1;
85. }

高等：

客户端代码：

1. #include<sys/types.h>
2. #include<sys/socket.h>
3. #include<netinet/in.h>
4. #include<arpa/inet.h>
5. #include<errno.h>
6. #include<unistd.h>
7. #include<stdio.h>
8. #include<string.h>
9. #include<stdlib.h>
10. #include<event.h>
11. #include<event2/bufferevent.h>
12. #include<event2/buffer.h>
13. #include<event2/util.h>
14. int tcp_connect_server(const char* server_ip, int port);
15. void cmd_msg_cb(int fd, short events, void* arg);
16. void server_msg_cb(struct bufferevent* bev, void* arg);
17. void event_cb(struct bufferevent *bev, short event, void *arg);
18. int main(int argc, char** argv)
19. {
20. if( argc < 3 )
21. {
22. //两个参数依次是服务器端的IP地址、端口号
23. printf("please input 2 parameter\n");
24. return -1;
25. }
26. struct event_base *base = event_base_new();
27. struct bufferevent* bev = bufferevent_socket_new(base, -1,
28. BEV_OPT_CLOSE_ON_FREE);
29. //监听终端输入事件
30. struct event* ev_cmd = event_new(base, STDIN_FILENO,
31. EV_READ | EV_PERSIST,
32. cmd_msg_cb, (void*)bev);
33. event_add(ev_cmd, NULL);
34. struct sockaddr_in server_addr;
35. memset(&server_addr, 0, sizeof(server_addr) );
36. server_addr.sin_family = AF_INET;
37. server_addr.sin_port = htons(atoi(argv[2]));
38. inet_aton(argv[1], &server_addr.sin_addr);
39. bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
40. sizeof(server_addr));
41. bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
42. bufferevent_enable(bev, EV_READ | EV_PERSIST);
43. event_base_dispatch(base);
44. printf("finished \n");
45. return 0;
46. }
47. void cmd_msg_cb(int fd, short events, void* arg)
48. {
49. char msg[1024];
50. int ret = read(fd, msg, sizeof(msg));
51. if( ret < 0 )
52. {
53. perror("read fail ");
54. exit(1);
55. }
56. struct bufferevent* bev = (struct bufferevent*)arg;
57. //把终端的消息发送给服务器端
58. bufferevent_write(bev, msg, ret);
59. }
60. void server_msg_cb(struct bufferevent* bev, void* arg)
61. {
62. char msg[1024];
63. size_t len = bufferevent_read(bev, msg, sizeof(msg));
64. msg[len] = '\0';
65. printf("recv %s from server\n", msg);
66. }
67. void event_cb(struct bufferevent *bev, short event, void *arg)
68. {
69. if (event & BEV_EVENT_EOF)
70. printf("connection closed\n");
71. else if (event & BEV_EVENT_ERROR)
72. printf("some other error\n");
73. else if( event & BEV_EVENT_CONNECTED)
74. {
75. printf("the client has connected to server\n");
76. return ;
77. }
78. //这将自动close套接字和free读写缓冲区
79. bufferevent_free(bev);
80. struct event *ev = (struct event*)arg;
81. event_free(ev);
82. }

服务器端代码：

1. #include<netinet/in.h>
2. #include<sys/socket.h>
3. #include<unistd.h>
4. #include<stdio.h>
5. #include<string.h>
6. #include<event.h>
7. #include<listener.h>
8. #include<bufferevent.h>
9. #include<thread.h>
10. void listener_cb(evconnlistener *listener, evutil_socket_t fd,
11. struct sockaddr *sock, int socklen, void *arg);
12. void socket_read_cb(bufferevent *bev, void *arg);
13. void socket_event_cb(bufferevent *bev, short events, void *arg);
14. int main()
15. {
16. //evthread_use_pthreads();//enable threads
17. struct sockaddr_in sin;
18. memset(&sin, 0, sizeof(struct sockaddr_in));
19. sin.sin_family = AF_INET;
20. sin.sin_port = htons(9999);
21. event_base *base = event_base_new();
22. evconnlistener *listener
23. = evconnlistener_new_bind(base, listener_cb, base,
24. LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
25. 10, (struct sockaddr*)&sin,
26. sizeof(struct sockaddr_in));
27. event_base_dispatch(base);
28. evconnlistener_free(listener);
29. event_base_free(base);
30. return 0;
31. }
32. //一个新客户端连接上服务器了
33. //当此函数被调用时，libevent已经帮我们accept了这个客户端。该客户端的
34. //文件描述符为fd
35. void listener_cb(evconnlistener *listener, evutil_socket_t fd,
36. struct sockaddr *sock, int socklen, void *arg)
37. {
38. printf("accept a client %d\n", fd);
39. event_base *base = (event_base*)arg;
40. //为这个客户端分配一个bufferevent
41. bufferevent *bev =  bufferevent_socket_new(base, fd,
42. BEV_OPT_CLOSE_ON_FREE);
43. bufferevent_setcb(bev, socket_read_cb, NULL, socket_event_cb, NULL);
44. bufferevent_enable(bev, EV_READ | EV_PERSIST);
45. }
46. void socket_read_cb(bufferevent *bev, void *arg)
47. {
48. char msg[4096];
49. size_t len = bufferevent_read(bev, msg, sizeof(msg)-1 );
50. msg[len] = '\0';
51. printf("server read the data %s\n", msg);
52. char reply[] = "I has read your data";
53. bufferevent_write(bev, reply, strlen(reply) );
54. }
55. void socket_event_cb(bufferevent *bev, short events, void *arg)
56. {
57. if (events & BEV_EVENT_EOF)
58. printf("connection closed\n");
59. else if (events & BEV_EVENT_ERROR)
60. printf("some other error\n");
61. //这将自动close套接字和free读写缓冲区
62. bufferevent_free(bev);
63. }