【Libevent】Libevent使用例子，从简单到复杂

 

​​​​

 

 

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

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

    

初等：

客户端代码：

#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  

#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  

#include<event.h>  
#include<event2/util.h>  




int tcp_connect_server(const char* server_ip, int port);  


void cmd_msg_cb(int fd, short events, void* arg);  
void socket_read_cb(int fd, short events, void *arg);  

int main(int argc, char** argv)  
{  
if( argc < 3 )  
    {  
printf("please input 2 parameter\n");  
return -1;  
    }  


//两个参数依次是服务器端的IP地址、端口号  
int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));  
if( sockfd == -1)  
    {  
perror("tcp_connect error ");  
return -1;  
    }  

printf("connect to server successful\n");  

struct event_base* base = event_base_new();  

struct event *ev_sockfd = event_new(base, sockfd,  
EV_READ | EV_PERSIST,  
socket_read_cb, NULL);  
event_add(ev_sockfd, NULL);  

//监听终端输入事件  
struct event* ev_cmd = event_new(base, STDIN_FILENO,  
EV_READ | EV_PERSIST, cmd_msg_cb,  
                                      (void*)&sockfd);  


event_add(ev_cmd, NULL);  

event_base_dispatch(base);  

printf("finished \n");  
return 0;  
}  






void cmd_msg_cb(int fd, short events, void* arg)  
{  
char msg[1024];  

int ret = read(fd, msg, sizeof(msg));  
if( ret <= 0 )  
    {  
perror("read fail ");  
exit(1);  
    }  

int sockfd = *((int*)arg);  

//把终端的消息发送给服务器端  
//为了简单起见，不考虑写一半数据的情况  
write(sockfd, msg, ret);  
}  


void socket_read_cb(int fd, short events, void *arg)  
{  
char msg[1024];  

//为了简单起见，不考虑读一半数据的情况  
int len = read(fd, msg, sizeof(msg)-1);  
if( len <= 0 )  
    {  
perror("read fail ");  
exit(1);  
    }  

msg[len] = '\0';  

printf("recv %s from server\n", msg);  
}  



typedef struct sockaddr SA;  
int tcp_connect_server(const char* server_ip, int port)  
{  
int sockfd, status, save_errno;  
struct sockaddr_in server_addr;  

memset(&server_addr, 0, sizeof(server_addr) );  

server_addr.sin_family = AF_INET;  
server_addr.sin_port = htons(port);  
status = inet_aton(server_ip, &server_addr.sin_addr);  

if( status == 0 ) //the server_ip is not valid value  
    {  
errno = EINVAL;  
return -1;  
    }  

sockfd = ::socket(PF_INET, SOCK_STREAM, 0);  
if( sockfd == -1 )  
return sockfd;  


status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );  

if( status == -1 )  
    {  
save_errno = errno;  
        ::close(sockfd);  
errno = save_errno; //the close may be error  
return -1;  
    }  

evutil_make_socket_nonblocking(sockfd);  

return sockfd;  
}  

服务器端代码：

#include<stdio.h> 
#include<string.h> 
#include<errno.h> 

#include<unistd.h> 
#include<event.h> 



void accept_cb(int fd, short events, void* arg); 
void socket_read_cb(int fd, short events, void *arg); 

int tcp_server_init(int port, int listen_num); 

int main(int argc, char** argv) 
{ 

int listener = tcp_server_init(9999, 10); 
if( listener == -1 ) 
{ 
perror(" tcp_server_init error "); 
return -1; 
} 

struct event_base* base = event_base_new(); 

//添加监听客户端请求连接事件 
struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST, 
accept_cb, base); 
event_add(ev_listen, NULL); 


event_base_dispatch(base); 

return 0; 
} 



void accept_cb(int fd, short events, void* arg) 
{ 
evutil_socket_t sockfd; 

struct sockaddr_in client; 
socklen_t len = sizeof(client); 

sockfd = ::accept(fd, (struct sockaddr*)&client, &len ); 
evutil_make_socket_nonblocking(sockfd); 

printf("accept a client %d\n", sockfd); 

struct event_base* base = (event_base*)arg; 

//仅仅是为了动态创建一个event结构体 
struct event *ev = event_new(NULL, -1, 0, NULL, NULL); 
//将动态创建的结构体作为event的回调参数 
event_assign(ev, base, sockfd, EV_READ | EV_PERSIST, 
socket_read_cb, (void*)ev); 

event_add(ev, NULL); 
} 


void socket_read_cb(int fd, short events, void *arg) 
{ 
char msg[4096]; 
struct event *ev = (struct event*)arg; 
int len = read(fd, msg, sizeof(msg) - 1); 



if( len <= 0 ) 
{ 
printf("some error happen when read\n"); 
event_free(ev); 
close(fd); 
return ; 
} 

msg[len] = '\0'; 
printf("recv the client msg: %s", msg); 

char reply_msg[4096] = "I have recvieced the msg: "; 
strcat(reply_msg + strlen(reply_msg), msg); 

write(fd, reply_msg, strlen(reply_msg) ); 
} 



typedef struct sockaddr SA; 
int tcp_server_init(int port, int listen_num) 
{ 
int errno_save; 
evutil_socket_t listener; 

listener = ::socket(AF_INET, SOCK_STREAM, 0); 
if( listener == -1 ) 
return -1; 

//允许多次绑定同一个地址。要用在socket和bind之间 
evutil_make_listen_socket_reuseable(listener); 

struct sockaddr_in sin; 
sin.sin_family = AF_INET; 
sin.sin_addr.s_addr = 0; 
sin.sin_port = htons(port); 

if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 ) 
goto error; 

if( ::listen(listener, listen_num) < 0) 
goto error; 


//跨平台统一接口，将套接字设置为非阻塞状态 
evutil_make_socket_nonblocking(listener); 

return listener; 

error: 
errno_save = errno; 
evutil_closesocket(listener); 
errno = errno_save; 

return -1; 
}

 

 

中等：

客户端代码：

#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  

#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  

#include<event.h>  
#include<event2/bufferevent.h>  
#include<event2/buffer.h>  
#include<event2/util.h>  




int tcp_connect_server(const char* server_ip, int port);  


void cmd_msg_cb(int fd, short events, void* arg);  
void server_msg_cb(struct bufferevent* bev, void* arg);  
void event_cb(struct bufferevent *bev, short event, void *arg);  

int main(int argc, char** argv)  
{  
if( argc < 3 )  
    {  
printf("please input 2 parameter\n");  
return -1;  
    }  


//两个参数依次是服务器端的IP地址、端口号  
int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));  
if( sockfd == -1)  
    {  
perror("tcp_connect error ");  
return -1;  
    }  

printf("connect to server successful\n");  

struct event_base* base = event_base_new();  

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

//监听终端输入事件  
struct event* ev_cmd = event_new(base, STDIN_FILENO,  
EV_READ | EV_PERSIST, cmd_msg_cb,  
                                      (void*)bev);  
event_add(ev_cmd, NULL);  

//当socket关闭时会用到回调参数  
bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);  
bufferevent_enable(bev, EV_READ | EV_PERSIST);  


event_base_dispatch(base);  

printf("finished \n");  
return 0;  
}  






void cmd_msg_cb(int fd, short events, void* arg)  
{  
char msg[1024];  

int ret = read(fd, msg, sizeof(msg));  
if( ret < 0 )  
    {  
perror("read fail ");  
exit(1);  
    }  

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

//把终端的消息发送给服务器端  
bufferevent_write(bev, msg, ret);  
}  


void server_msg_cb(struct bufferevent* bev, void* arg)  
{  
char msg[1024];  

size_t len = bufferevent_read(bev, msg, sizeof(msg));  
msg[len] = '\0';  

printf("recv %s from server\n", msg);  
}  


void event_cb(struct bufferevent *bev, short event, void *arg)  
{  

if (event & BEV_EVENT_EOF)  
printf("connection closed\n");  
else if (event & BEV_EVENT_ERROR)  
printf("some other error\n");  

//这将自动close套接字和free读写缓冲区  
bufferevent_free(bev);  

struct event *ev = (struct event*)arg;  
//因为socket已经没有，所以这个event也没有存在的必要了  
event_free(ev);  
}  


typedef struct sockaddr SA;  
int tcp_connect_server(const char* server_ip, int port)  
{  
int sockfd, status, save_errno;  
struct sockaddr_in server_addr;  

memset(&server_addr, 0, sizeof(server_addr) );  

server_addr.sin_family = AF_INET;  
server_addr.sin_port = htons(port);  
status = inet_aton(server_ip, &server_addr.sin_addr);  

if( status == 0 ) //the server_ip is not valid value  
    {  
errno = EINVAL;  
return -1;  
    }  

sockfd = ::socket(PF_INET, SOCK_STREAM, 0);  
if( sockfd == -1 )  
return sockfd;  


status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );  

if( status == -1 )  
    {  
save_errno = errno;  
        ::close(sockfd);  
errno = save_errno; //the close may be error  
return -1;  
    }  

evutil_make_socket_nonblocking(sockfd);  

return sockfd;  
}  

服务器端代码：

#include<stdio.h>  
#include<string.h>  
#include<errno.h>  

#include<event.h>  
#include<event2/bufferevent.h>  



void accept_cb(int fd, short events, void* arg);  
void socket_read_cb(bufferevent* bev, void* arg);  
void event_cb(struct bufferevent *bev, short event, void *arg);  
int tcp_server_init(int port, int listen_num);  

int main(int argc, char** argv)  
{  

int listener = tcp_server_init(9999, 10);  
if( listener == -1 )  
    {  
perror(" tcp_server_init error ");  
return -1;  
    }  

struct event_base* base = event_base_new();  

//添加监听客户端请求连接事件  
struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,  
accept_cb, base);  
event_add(ev_listen, NULL);  


event_base_dispatch(base);  
event_base_free(base);  


return 0;  
}  



void accept_cb(int fd, short events, void* arg)  
{  
evutil_socket_t sockfd;  

struct sockaddr_in client;  
socklen_t len = sizeof(client);  

sockfd = ::accept(fd, (struct sockaddr*)&client, &len );  
evutil_make_socket_nonblocking(sockfd);  

printf("accept a client %d\n", sockfd);  

struct event_base* base = (event_base*)arg;  

bufferevent* bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);  
bufferevent_setcb(bev, socket_read_cb, NULL, event_cb, arg);  

bufferevent_enable(bev, EV_READ | EV_PERSIST);  
}  



void socket_read_cb(bufferevent* bev, void* arg)  
{  
char msg[4096];  

size_t len = bufferevent_read(bev, msg, sizeof(msg));  

msg[len] = '\0';  
printf("recv the client msg: %s", msg);  


char reply_msg[4096] = "I have recvieced the msg: ";  

strcat(reply_msg + strlen(reply_msg), msg);  
bufferevent_write(bev, reply_msg, strlen(reply_msg));  
}  



void event_cb(struct bufferevent *bev, short event, void *arg)  
{  

if (event & BEV_EVENT_EOF)  
printf("connection closed\n");  
else if (event & BEV_EVENT_ERROR)  
printf("some other error\n");  

//这将自动close套接字和free读写缓冲区  
bufferevent_free(bev);  
}  


typedef struct sockaddr SA;  
int tcp_server_init(int port, int listen_num)  
{  
int errno_save;  
evutil_socket_t listener;  

listener = ::socket(AF_INET, SOCK_STREAM, 0);  
if( listener == -1 )  
return -1;  

//允许多次绑定同一个地址。要用在socket和bind之间  
evutil_make_listen_socket_reuseable(listener);  

struct sockaddr_in sin;  
sin.sin_family = AF_INET;  
sin.sin_addr.s_addr = 0;  
sin.sin_port = htons(port);  

if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )  
goto error;  

if( ::listen(listener, listen_num) < 0)  
goto error;  


//跨平台统一接口，将套接字设置为非阻塞状态  
evutil_make_socket_nonblocking(listener);  

return listener;  

error:  
errno_save = errno;  
evutil_closesocket(listener);  
errno = errno_save;  

return -1;  
}  

高等：

客户端代码：

#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  

#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  

#include<event.h>  
#include<event2/bufferevent.h>  
#include<event2/buffer.h>  
#include<event2/util.h>  




int tcp_connect_server(const char* server_ip, int port);  


void cmd_msg_cb(int fd, short events, void* arg);  
void server_msg_cb(struct bufferevent* bev, void* arg);  
void event_cb(struct bufferevent *bev, short event, void *arg);  

int main(int argc, char** argv)  
{  
if( argc < 3 )  
    {  
//两个参数依次是服务器端的IP地址、端口号  
printf("please input 2 parameter\n");  
return -1;  
    }  

struct event_base *base = event_base_new();  

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

//监听终端输入事件  
struct event* ev_cmd = event_new(base, STDIN_FILENO,  
EV_READ | EV_PERSIST,  
cmd_msg_cb, (void*)bev);  


event_add(ev_cmd, NULL);  

struct sockaddr_in server_addr;  

memset(&server_addr, 0, sizeof(server_addr) );  

server_addr.sin_family = AF_INET;  
server_addr.sin_port = htons(atoi(argv[2]));  
inet_aton(argv[1], &server_addr.sin_addr);  

bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,  
sizeof(server_addr));  


bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);  
bufferevent_enable(bev, EV_READ | EV_PERSIST);  



event_base_dispatch(base);  

printf("finished \n");  
return 0;  
}  





void cmd_msg_cb(int fd, short events, void* arg)  
{  
char msg[1024];  

int ret = read(fd, msg, sizeof(msg));  
if( ret < 0 )  
    {  
perror("read fail ");  
exit(1);  
    }  

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

//把终端的消息发送给服务器端  
bufferevent_write(bev, msg, ret);  
}  


void server_msg_cb(struct bufferevent* bev, void* arg)  
{  
char msg[1024];  

size_t len = bufferevent_read(bev, msg, sizeof(msg));  
msg[len] = '\0';  

printf("recv %s from server\n", msg);  
}  


void event_cb(struct bufferevent *bev, short event, void *arg)  
{  

if (event & BEV_EVENT_EOF)  
printf("connection closed\n");  
else if (event & BEV_EVENT_ERROR)  
printf("some other error\n");  
else if( event & BEV_EVENT_CONNECTED)  
    {  
printf("the client has connected to server\n");  
return ;  
    }  

//这将自动close套接字和free读写缓冲区  
bufferevent_free(bev);  

struct event *ev = (struct event*)arg;  
event_free(ev);  
}  

 

服务器端代码：

 

#include<netinet/in.h>    
#include<sys/socket.h>    
#include<unistd.h>    

#include<stdio.h>    
#include<string.h>    

#include<event.h>    
#include<listener.h>    
#include<bufferevent.h>    
#include<thread.h>    


void listener_cb(evconnlistener *listener, evutil_socket_t fd,    
struct sockaddr *sock, int socklen, void *arg);    

void socket_read_cb(bufferevent *bev, void *arg);    
void socket_event_cb(bufferevent *bev, short events, void *arg);    

int main()    
{    
//evthread_use_pthreads();//enable threads    

struct sockaddr_in sin;    
memset(&sin, 0, sizeof(struct sockaddr_in));    
sin.sin_family = AF_INET;    
sin.sin_port = htons(9999);    

event_base *base = event_base_new();    
evconnlistener *listener    
= evconnlistener_new_bind(base, listener_cb, base,    
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,    
10, (struct sockaddr*)&sin,    
sizeof(struct sockaddr_in));    

event_base_dispatch(base);    

evconnlistener_free(listener);    
event_base_free(base);    

return 0;    
}    


//一个新客户端连接上服务器了    
//当此函数被调用时，libevent已经帮我们accept了这个客户端。该客户端的  
//文件描述符为fd  
void listener_cb(evconnlistener *listener, evutil_socket_t fd,    
struct sockaddr *sock, int socklen, void *arg)    
{    
printf("accept a client %d\n", fd);    

event_base *base = (event_base*)arg;    

//为这个客户端分配一个bufferevent    
bufferevent *bev =  bufferevent_socket_new(base, fd,    
BEV_OPT_CLOSE_ON_FREE);    

bufferevent_setcb(bev, socket_read_cb, NULL, socket_event_cb, NULL);    
bufferevent_enable(bev, EV_READ | EV_PERSIST);    
}    


void socket_read_cb(bufferevent *bev, void *arg)    
{    
char msg[4096];    

size_t len = bufferevent_read(bev, msg, sizeof(msg)-1 );    

msg[len] = '\0';    
printf("server read the data %s\n", msg);    

char reply[] = "I has read your data";    
bufferevent_write(bev, reply, strlen(reply) );    
}    


void socket_event_cb(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");    

//这将自动close套接字和free读写缓冲区    
bufferevent_free(bev);    
}