码迷，mamicode.com
首页 > 其他好文 > 详细

libevent学习，从3个例子开始

时间：2017-10-27 23:08:21      阅读：332      评论：0      收藏：0      [点我收藏+]

标签：mem   pen   params   tin   else   gcc编译   回调函数   源代码   oid   

最近一直在ubuntu下研究c++开源代码，本文的内容是大名鼎鼎的libevent库。

本文将从3个例子着手，从简单到复杂，分别包含了client与server。

文章参考该文，并对其中的代码进行重新梳理。本文代码均在ubuntu下通过程序验证。http://blog.csdn.net/luotuo44/article/details/39670221

 

1.初级版

>gcc -o client client.c -levent

>gcc -o server server.c -levent

上述两句命令能够编译出2个可执行文件。-levent在这里起到的作用是，链接libevent库到程序中。

此程序中server默认使用9999端口，且client运行时需要指定ip和port，如>./client 127.0.0.1 9999

 

client.c如下：

#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;
	}

	//2 params, IP, port
	int sockfd=tcp_connect_server(argv[1],atoi(argv[2]));
	if(sockfd==-1){
		perror("tcp_connect error\n");
		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;
}

/*
 * callback,
 */
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\n");
		exit(1);
	}
	msg[len]=‘\0‘;
	printf("recv %s from server\n",msg);
}

/*
 * callback,send msg to server
 */
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\n");
		exit(1);
	}

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

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

int tcp_connect_server(const char* server_ip,int port){
	int sockfd,status,save_erro;
	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){
		errno=EINVAL;
		return -1;
	}

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

	status=connect(sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
	if(status==-1){
		int save_errno=errno;
		close(sockfd);
		errno=save_errno;
		return -1;
	}

	evutil_make_socket_nonblocking(sockfd);
	return sockfd;

}

　

server.c如下：

#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 (-1==listener) {
		perror("tcp_server_init error\n");
		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 = (struct 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(%d) msg: %s\n",fd, msg);

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

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

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, (struct sockaddr*) &sin, sizeof(sin)) < 0) {
		errno_save = errno;
		evutil_closesocket(listener);
		errno = errno_save;
		return -1;
	}
	if (listen(listener, listen_num) < 0) {
		errno_save = errno;
		evutil_closesocket(listener);
		errno = errno_save;
		return -1;
	}
	evutil_make_socket_nonblocking(listener);
	return listener;
}

　　

2.中级版

和上述版本类似，编译过程相同。

 

 client.c

#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;
	}

	//2 param
	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");
	}

	//会自动关闭套接字和清空读写缓冲区
	bufferevent_free(bev);
	//因此，socket没有了，event也就没有存在必要了
	struct event*ev = (struct event*) arg;
	event_free(ev);
}

int tcp_connect_server(const char*server_ip, int port) {
	int sockfd, status, 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)
	{
		errno=EINVAL;
		return -1;
	}

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

	status=connect(sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
	if(status==-1)
	{
		int save_errno=errno;
		close(sockfd);
		errno=save_errno;
		return -1;
	}

	evutil_make_socket_nonblocking(sockfd);
	return sockfd;
}

　　

server.c

#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(struct 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 = (struct event_base*) arg;

	struct 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(struct 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\n", msg);

	char reply_msg[4096] = "I have received 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");
	}
	//这自动关闭套接字和清空读写缓冲区
	bufferevent_free(bev);
}

int tcp_server_init(int port, int listen_num) {
	int errno;
	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,(struct sockaddr*)&sin,sizeof(sin))<0) {
		int errno_save=errno;
		evutil_closesocket(listener);
		errno=errno_save;
		return -1;
	}

	if(listen(listener,listen_num)<0)
	{
		int errno_save=errno;
		evutil_closesocket(listener);
		errno=errno_save;
		return -1;
	}

	evutil_make_socket_nonblocking(listener);
	return listener;
}

　　

 3.高级版

在第三部分的代码中，有很多地方存在错误。主要存在与server的头文件引用和内部struct调用上。

目前所有的文档资料中，第三部分代码均很类似，且无法编译成功，本人也是修改了部分代码，可正常通过gcc编译和运行。

代码如下所示：

 

client.c

#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) {
		//2param
		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;
	}
	//自动关闭套接字和清空缓冲区
	bufferevent_free(bev);

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

　　

server.c

 

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

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

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

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

void socket_read_cb(struct bufferevent*bev, void*arg);
void socket_event_cb(struct 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);

	struct event_base*base = event_base_new();
	struct 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(struct evconnlistener*listener, evutil_socket_t fd,
		struct sockaddr*sock, int socklen, void*arg) {
	printf("accept a client %d\n", fd);

	struct event_base*base = (struct event_base*) arg;
	//为此客户端分配一个bufferevent
	struct 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(struct 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 have read your data";
	bufferevent_write(bev, reply, strlen(reply));
}

void socket_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);
}

　　

 

libevent学习，从3个例子开始

标签：mem   pen   params   tin   else   gcc编译   回调函数   源代码   oid   

原文地址：http://www.cnblogs.com/secondwatch/p/7745067.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！