文章目录
解决安装libevent找不到动态库
获取libevent支持的方法和当前系统使用的方法
event.c
//获取libevent支持的方法和当前系统使用的方法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <event2/event.h>
int main()
{
//获取当前系统支持的方法有哪些
//const char **event_get_supported_methods(void);
const char **p = event_get_supported_methods();
int i = 0;
while(p[i]!=NULL)
{
printf("[%s] ", p[i++]);
}
printf("\n");
//创建event_base结构体
struct event_base *base = event_base_new();
if(base==NULL)
{
printf("event_base_new error\n");
return -1;
}
//const char * event_base_get_method(const struct event_base *base);
printf("[%s]\n", event_base_get_method(base));
//释放event_base节点
event_base_free(base);
return 0;
}
libevent开发流程
编写一个基于event实现的tcp服务器
- 创建socket—socket()
- 设置端口复用—setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int))
- 绑定–bind()
- 设置监听–listen()
- 创建地基
struct event_base *base = event_base_new() - 创建lfd对应的事件
struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base); - 上event_base地基
event_add(ev, NULL); - 进入事件循环
event_base_dispatch(base); - 释放资源
event_base_free(base);
event_free(ev);
libevent服务端实现核心思路
typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
//监听文件描述符对应的事件回调函数
void conncb(evutil_socket_t fd, short events, void *arg)
{
struct event_base *base = (struct event_base *)arg;
//接受新的连接
int cfd = accept(fd, NULL, NULL);
if(cfd>0)
{
//创建一个新的事件
struct event *ev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
event_add(ev, NULL);
}
}
//读客户端数据对应的回调函数
void readcb(evutil_socket_t fd, short events, void *arg)
{
//读数据
n = read(fd, buf, sizeof(buf));
if(n<=0)
{
//从base地基上删除该事件
close(fd);
event_del(ev);
event_free(ev);
}
//发送数据给对方
write(fd, buf, n);
}
libevent服务端代码实现
//编写libevent服务端
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <event2/event.h>
struct event *connev = NULL;
//typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
void readcb(evutil_socket_t fd, short events, void *arg)
{
int n;
char buf[1024];
memset(buf, 0x00, sizeof(buf));
n = read(fd, buf, sizeof(buf));
if(n<=0)
{
close(fd);
//将通信文件描述符对应的事件从base地基上删除
event_del(connev);
}
else
{
write(fd, buf, n);
}
}
void conncb(evutil_socket_t fd, short events, void *arg)
{
struct event_base *base = (struct event_base *)arg;
//接受新的客户端连接
int cfd = accept(fd, NULL, NULL);
if(cfd>0)
{
//创建通信文件描述符对应的事件并设置回调函数为readcb
connev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
if(connev==NULL)
{
//退出循环
event_base_loopexit(base, NULL);
}
//将通信文件描述符对应的事件上event_base地基
event_add(connev, NULL);
}
}
int main()
{
//创建socket
int lfd = socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
//绑定
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_addr.s_addr = htonl(INADDR_ANY);
serv.sin_port = htons(8888);
serv.sin_family = AF_INET;
bind(lfd, (struct sockaddr*)&serv, sizeof(serv));
//监听
listen(lfd, 120);
//创建地基
struct event_base *base = event_base_new();
if(base==NULL)
{
printf("event_base_new error\n");
return -1;
}
//创建监听文件描述符对应的事件
//struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
if(ev==NULL)
{
printf("event_new error\n");
return -1;
}
//将新的事件节点上base地基
event_add(ev, NULL);
//进入事件循环等待
event_base_dispatch(base);
//释放资源
event_base_free(base);
event_free(ev);
close(lfd);
return 0;
}
需改进:将文件描述符和事件封装为结构体(否则connev指针保存的永远是最后一个)
//编写libevent服务端
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <event2/event.h>
#include <ctype.h>
#define MAX 1000
struct event_fd
{
evutil_socket_t fd;
struct event *ev;
}event[MAX];
void init_ev_fd()
{
int i = 0;
for(i = 0; i < MAX; ++i)
{
event[i].fd = -1;
event[i].ev = NULL;
}
}
void setEventFd(evutil_socket_t fd, struct event *ev)
{
int i = 0;
//查找存放的位置
for(i = 0; i < MAX; ++i)
{
if(event[i].fd == -1)
{
break;
}
}
//若找不到合适的位置,直接退出进程
if(i == MAX)
{
exit(1);
}
event[i].fd = fd;
event[i].ev = ev;
}
int findEv(int fd)
{
int i = 0;
for(i = 0; i < MAX; ++i)
{
if(event[i].fd == fd)
{
break;
}
}
if(i == MAX)
{
printf("not find fd\n");
exit(1);
}
return i;
}
//typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
void readcb(evutil_socket_t fd, short events, void *arg)
{
int n;
char buf[1024];
memset(buf, 0x00, sizeof(buf));
int num = findEv(fd);
n = read(fd, buf, sizeof(buf));
if(n < 0)
{
perror("read error");
close(fd);
//将通信文件描述符对应的事件从base地基上删除
event_del(event[num].ev);
event[num].fd = -1;
event[num].ev = NULL;
}
else if(n == 0)
{
printf("client close\n");
close(fd);
event_del(event[num].ev);
printf("[%p], [%d]\n", event[num].ev, num);
event[num].fd = -1;
event[num].ev = NULL;
}
else
{
int i = 0;
for(i = 0; i < n; ++i)
{
buf[i] = toupper(buf[i]);
}
write(fd, buf, strlen(buf));
}
}
void conncb(evutil_socket_t fd, short events, void *arg)
{
struct event_base *base = (struct event_base *)arg;
//接受新的客户端连接
struct sockaddr_in cliaddr;
socklen_t addrlen = sizeof(struct sockaddr_in);
int cfd = accept(fd, (struct sockaddr*)&cliaddr, &addrlen);
if(cfd < 0)
{
perror("accept error");
exit(1);
}
//打印客户端IP和PORT
char sIP[128];
memset(sIP, 0x00, sizeof(sIP));
printf("received from %s at port %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, sIP, sizeof(sIP)), ntohs(cliaddr.sin_port));
//创建通信文件描述符对应的事件并设置回调函数为readcb
struct event *readev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, base);
event_add(readev, NULL);
setEventFd(cfd, readev);
}
int main()
{
//创建socket
int lfd = socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
//绑定
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_addr.s_addr = htonl(INADDR_ANY);
serv.sin_port = htons(8888);
serv.sin_family = AF_INET;
bind(lfd, (struct sockaddr*)&serv, sizeof(serv));
//监听
listen(lfd, 120);
//创建地基
struct event_base *base = event_base_new();
if(base==NULL)
{
printf("event_base_new error\n");
return -1;
}
//创建监听文件描述符对应的事件
//struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
if(ev==NULL)
{
printf("event_new error\n");
return -1;
}
//将新的事件节点上base地基
event_add(ev, NULL);
//进入事件循环等待
event_base_dispatch(base);
//释放资源
event_base_free(base);
event_free(ev);
close(lfd);
return 0;
}
bufferevent
bufferevent的读事件回调触发时机:
当数据由内核的读缓冲区到bufferevent的读缓冲区的时候, 会触发bufferevent的读事件回调.
需要注意的是: 数据由内核到bufferevent的过程不是用户程序执行的, 而是是由bufferevent内部操作的.
bufferevent的写事件回调触发时机:
当用户程序将数据写到bufferevent的写缓冲区之后, bufferevent会自动将数据写到内核的写缓冲区,最终有内核程序将数据发送出去.
事件回调:
当bufferevent绑定的socket连接, 断开或者异常的时候触发事件回调.
链接监听器
bufferevent服务端代码
hello-world.c
/*
This exmple program provides a trivial server program that listens for TCP
connections on port 9995. When they arrive, it writes a short message to
each client connection, and closes each connection once it is flushed.
Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
*/
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#ifndef WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
# include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>
static const char MESSAGE[] = "Hello, World!\n";
static const int PORT = 9995;
static void listener_cb(struct evconnlistener *, evutil_socket_t,
struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);
int
main(int argc, char **argv)
{
struct event_base *base; //定义了指向地基节点的指针
struct evconnlistener *listener; //定义了链接监听器的指针
struct event *signal_event; //定义了信号事件指针
struct sockaddr_in sin;
#ifdef WIN32
WSADATA wsa_data;
WSAStartup(0x0201, &wsa_data);
#endif
//创建地基节点--相当于epoll的树根
base = event_base_new();
if (!base) {
fprintf(stderr, "Could not initialize libevent!\n");
return 1;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
//创建链接监听器--socket bind listen accept
//listener_cb--回调函数
//LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE: 端口复用|释放连接监听器的时候关闭文件描述符
listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
(struct sockaddr*)&sin,
sizeof(sin));
if (!listener) {
fprintf(stderr, "Could not create a listener!\n");
return 1;
}
//#define evsignal_new(b, x, cb, arg) \
//event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
if (!signal_event || event_add(signal_event, NULL)<0) {
fprintf(stderr, "Could not create/add a signal event!\n");
return 1;
}
//进入事件循环---相当于while(1)
event_base_dispatch(base);
//释放连接监听器
evconnlistener_free(listener);
//释放信号事件节点
event_free(signal_event);
//释放地基节点
event_base_free(base);
printf("done\n");
return 0;
}
//listener: 链接监听器指针
//fd: 通信文件描述符
//sa和socklen: 客户端地址信息和长度
//user_data: 具体是地基节点指针
static void
listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *sa, int socklen, void *user_data)
{
printf("--call--%s--\n", __FUNCTION__);
struct event_base *base = user_data;
struct bufferevent *bev;//指向bufferevent的指针
//创建bufferevent
//BEV_OPT_CLOSE_ON_FREE: 当释放bufferevent的时候关闭连接
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!bev) {
fprintf(stderr, "Error constructing bufferevent!");
event_base_loopbreak(base);
return;
}
//设置回调函数---写事件和异常事件回调函数
bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL);
//使写事件回调生效
bufferevent_enable(bev, EV_WRITE);
//使读事件回调失效
bufferevent_disable(bev, EV_READ);
//将数据写到bufferevent的写缓冲区
bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}
static void
conn_writecb(struct bufferevent *bev, void *user_data)
{
printf("--call--%s--\n", __FUNCTION__);
//获取bufferevent的写缓冲区的指针
struct evbuffer *output = bufferevent_get_output(bev);
//查看缓冲区还有没有数据
if (evbuffer_get_length(output) == 0) {
printf("flushed answer\n");
//释放bufferevent,关闭通信文件 描述符
bufferevent_free(bev);
}
}
static void
conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
printf("--call--%s--\n", __FUNCTION__);
if (events & BEV_EVENT_EOF) {
printf("Connection closed.\n");
} else if (events & BEV_EVENT_ERROR) {
printf("Got an error on the connection: %s\n",
strerror(errno));/*XXX win32*/
}
/* None of the other events can happen here, since we haven't enabled
* timeouts */
bufferevent_free(bev);
}
static void
signal_cb(evutil_socket_t sig, short events, void *user_data)
{
printf("--call--%s--\n", __FUNCTION__);
struct event_base *base = user_data;
struct timeval delay = { 2, 0 };
printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");
//事件回调函数执行完后, 再过2秒, 跳出循环, 程序结束
event_base_loopexit(base, &delay);
}
bufferevent客户端代码
bufferevent_client.c
//bufferevent建立客户端的过程
#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();
//创建并且初始化buffer缓冲区
struct bufferevent* bev = bufferevent_socket_new(base, -1,
BEV_OPT_CLOSE_ON_FREE);
//监听终端输入事件 设置标准输入的监控,设置回调是 cmd_msg_cb
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]));
//将ip地址转换为网络字节序
inet_aton(argv[1], &server_addr.sin_addr);
//连接到 服务器ip地址和端口 初始化了 socket文件描述符 socket+connect
bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
sizeof(server_addr));
//设置buffer的回调函数 主要设置了读回调 server_msg_cb ,传入参数是标准输入的读事件
bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
bufferevent_enable(bev, EV_READ | EV_PERSIST);
event_base_dispatch(base);//循环等待
event_free(ev_cmd);
bufferevent_free(bev);
event_base_free(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);
}
//得到bufferevent指针,目的是为了写到bufferevent的写缓冲区
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);
//释放event事件 监控读终端
struct event *ev = (struct event*)arg;
event_free(ev);
}