/*Linux下libevent主要API介绍
创建事件集
struct event_base *event_base_new(void);
创建事件
struct event event_new
(struct event_base ,evutil_socket_t ,short ,event_callback_fn, void*)
添加事件
int event_add(struct event * ev,const struct timeval* timeout)
删除事件
int event_del(struct event *)
事件循环
int event_base_loop(struct event_base *base, int flags)
int event_base_dispatch(struct event_base *event_base)*/
/*libevent使用步骤 编译加时 -levent
1.创建socket
2.创建事件集event_base
3.创建event(socket, EV_READ, callback1) / event(socket, EV_WRITE, callback2)
4.把event添加到事件集event_base
5.event_base_dispatch(evnet_base); event_base_loop();
注 意：
程序的最后调用event_base_dispatch(base);实现事件的循环处理
while（）
{
//调用多路复用
event_base_dispatch(base);
……
}*/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <assert.h>
typedef struct _ConnectStat ConnectStat;
#define BUFLEN 1024
struct _ConnectStat {
struct event* ev;//事件
int fd;
char send_buf[BUFLEN];
};
//echo 服务实现相关代码
ConnectStat * stat_init(int fd);
//void accept_connection(int fd, void *data);
void accept_connection(int fd, short events, void* arg);
void do_welcome_handler(int fd, short events, void* arg);
//void do_echo_handler(int fd, void *data);
void do_echo_handler(int fd, short events, void *arg);
void do_echo_response(int fd, short events, void *arg);
struct event_base * ev_base;
void usage(const char* argv)
{
printf("%s:[ip][port]\n", argv);
}
void set_nonblock(int fd)
{
int fl = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}
int startup(char* _ip, int _port) //创建一个套接字，绑定，检测服务器
{
//sock
//1.创建套接字
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror("sock");
exit(2);
}
int opt = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
//2.填充本地 sockaddr_in 结构体（设置本地的IP地址和端口）
struct sockaddr_in local;
local.sin_port = htons(_port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = inet_addr(_ip);
//3.bind（）绑定
if (bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
{
perror("bind");
exit(3);
}
//4.listen（）监听 检测服务器
if (listen(sock, 5) < 0)
{
perror("listen");
exit(4);
}
return sock; //这样的套接字返回
}
ConnectStat * stat_init(int fd) {
ConnectStat * temp = NULL;
temp = (ConnectStat *)malloc(sizeof(ConnectStat));
if (!temp) {
fprintf(stderr, "malloc failed. reason: %m\n");
return NULL;
}
memset(temp, '\0', sizeof(ConnectStat));
temp->fd = fd;
//temp->status = 0;
}
void do_welcome_handler(int fd, short events, void* arg)//处理客户端链接请求
{
const char * WELCOME= "Welcome.\n";
int wlen = strlen(WELCOME);
int n ;
ConnectStat * stat = (ConnectStat *)(arg);
if( (n = write(fd, "Welcome.\n",wlen)) != wlen )//欢迎客户端
{
if(n<=0){
fprintf(stderr, "write failed[len:%d], reason: %s\n",n,strerror(errno));
}else fprintf(stderr, "send %d bytes only ,need to send %d bytes.\n",n,wlen);
}else {
event_set(stat->ev, fd, EV_READ, do_echo_handler, (void *)stat);//设置服务端事件为读
stat->ev->ev_base = ev_base;//必须重置事件集合 服务端重新设置ev_base
event_add(stat->ev, NULL);//添加事件
}
}
void do_echo_handler(int fd, short events, void *arg) {
ConnectStat * stat = (ConnectStat *)(arg);
char * p = NULL;
assert(stat!=NULL);
p = stat->send_buf;
*p++ = '-';
*p++ = '>';
ssize_t _s = read(fd, p, BUFLEN-(p-stat->send_buf)-1); //2字节"->" +字符结束符.
if (_s > 0)
{
*(p+_s) = '\0';
printf("receive from client: %s\n", p);
//_s--;
//while( _s>=0 && ( stat->send_buf[_s]=='\r' || stat->send_buf[_s]=='\n' ) ) stat->send_buf[_s]='\0';
if(!strncasecmp(p, "quit", 4)){//退出.
//comm_close(fd);
event_free(stat->ev);//自动解除监听事件，释放event
close(fd);
free(stat);
return ;
}
event_set(stat->ev, fd, EV_WRITE, do_echo_response, (void *)stat);
stat->ev->ev_base = ev_base;//必须重置事件集合
event_add(stat->ev, NULL);
}else if (_s == 0) //client:close
{
fprintf(stderr,"Remote connection[fd: %d] has been closed\n", fd);
event_free(stat->ev);//自动解除监听事件，释放event
close(fd);
free(stat);
}
else //err occurred. 出错处理暂时忽略
{
fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\n",fd , strerror(errno), _s);
}
}
void do_echo_response(int fd, short events, void *arg) {
ConnectStat * stat = (ConnectStat *)(arg);
int len = strlen(stat->send_buf);
int _s = write(fd, stat->send_buf, len);
if(_s>0){
event_set(stat->ev, fd, EV_READ, do_echo_handler, (void *)stat);
stat->ev->ev_base = ev_base;//必须重置事件集合
event_add(stat->ev, NULL);
}else if(_s==0){
fprintf(stderr,"Remote connection[fd: %d] has been closed\n", fd);
event_free(stat->ev);//自动解除监听事件，释放event
close(fd);
free(stat);
}else {
fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\n",fd ,_s ,strerror(errno));
}
}
void accept_connection(int fd, short events, void* arg)//接受链接
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int new_fd = accept(fd, (struct sockaddr*)&peer, &len);
if (new_fd > 0)
{
ConnectStat *stat = stat_init(new_fd);//客户端的链接状态
set_nonblock(new_fd);
printf("new client: %s:%d\n", inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
struct event *ev = event_new(ev_base, new_fd, EV_WRITE, do_welcome_handler, (void *)stat);//新建客户端写事件
stat->ev = ev;//保存这个事件
event_add(ev, NULL);//添加事件
}
}
int main(int argc,char **argv){
if (argc != 3) //检测参数个数是否正确
{
usage(argv[0]);
exit(1);
}
int listen_sock = startup(argv[1], atoi(argv[2])); //创建一个绑定了本地 ip 和端口号的套接字描述符
ev_base = event_base_new();//创建event_base 创建事件集
ConnectStat * stat = stat_init(listen_sock);//服务器状态初始化
/*@1.事件集
@2.监听的fd
@3.监听的事件 EV_PERSIST表示一直读 服务端要一直读
@4.函数指针，接受链接
@5.回调函数传递的参数 */
struct event* ev_listen = event_new(ev_base, listen_sock, EV_READ|EV_PERSIST, accept_connection, NULL);//创建一个事件
event_add(ev_listen, NULL);//增加事件 超时不设置（超时断开链接）
event_base_dispatch(ev_base);//事件循环
//comm_select_shutdown();
return 0;
}
server1.c
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h>
#define BUFLEN 1024
typedef struct _ConnectStat {
struct event* ev;
char buf[BUFLEN];
}ConnectStat;
//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct event *ev);
void accept_connection(int fd, short events, void* arg);
void do_echo_request(int fd, short events, void *arg);
void do_echo_response(int fd, short events, void *arg);
int tcp_server_init(int port, int listen_num);//服务器初始化
struct event_base* base;
int main(int argc, char** argv)
{
int listener = tcp_server_init(9999, 10);//初始化服务端得tcp
if( listener == -1 )
{
perror(" tcp_server_init error ");
return -1;
}
base = event_base_new();//创建事件集
//添加监听客户端请求连接事件
struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
accept_connection, base);//创建事件如果有链接来执行函数指针 持续监听
event_add(ev_listen, NULL);
event_base_dispatch(base);
return 0;
}
ConnectStat * stat_init(int fd, struct event *ev) {
ConnectStat * temp = NULL;
temp = (ConnectStat *)malloc(sizeof(ConnectStat));
if (!temp) {
fprintf(stderr, "malloc failed. reason: %m\n");
return NULL;
}
memset(temp, '\0', sizeof(ConnectStat));
temp->ev = ev;
}
void accept_connection(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);//将客户端得sock设为非阻塞
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);//创建一个事件
ConnectStat *stat = stat_init(sockfd, ev);//客户端得sock绑定这个事件
//将动态创建的结构体作为event的回调参数
event_assign(ev, base, sockfd, EV_READ ,
do_echo_request, (void*)stat);//设置这个客户端得事件进行赋值
event_add(ev, NULL);//添加这个事件
}
void do_echo_request(int fd, short events, void *arg)
{
ConnectStat *stat = (ConnectStat *)arg;
struct event *ev = stat->ev;
char *msg = stat->buf;
printf("do echo request ...\n");
int len = read(fd, msg, BUFLEN - 1);
if( len <= 0 )
{
printf("connectin close or some error happen when read\n");
event_free(ev);
close(fd);
free(stat);
return ;
}
msg[len] = '\0';
printf("recv from client<<<< %s\n", msg);
event_set(ev, fd, EV_WRITE, do_echo_response, (void*)stat);
ev->ev_base = base;//这个时候里面得事件被清空了需要重新设置
event_add(ev, NULL);
}
void do_echo_response(int fd, short events, void *arg) {
ConnectStat * stat = (ConnectStat *)(arg);
struct event *ev = NULL;
assert(stat!=NULL);
ev = stat->ev;
int len = strlen(stat->buf);
printf("write to client>>>> %s\n", stat->buf);
int _s = write(fd, stat->buf, len);
if (_s > 0)
{
printf("write successfully.\n");
}else if (_s == 0) //client:close
{
fprintf(stderr,"Remote connection[fd: %d] has been closed\n", fd);
goto ERR_EXIT;
}
else //err occurred.
{
fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\n",fd , strerror(errno), _s);
goto ERR_EXIT;
}
event_set(ev, fd, EV_READ, do_echo_request, (void*)stat);
ev->ev_base = base;
event_add(ev, NULL);
return ;
ERR_EXIT:
event_free(ev);
close(fd);
free(stat);
}
typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{
int errno_save;
evutil_socket_t listener;// int listener;兼容其他平台就是类型定义
listener = socket(AF_INET, SOCK_STREAM, 0);
if( listener == -1 )
return -1;
//允许多次绑定同一个地址。要用在socket和bind之间
//等同于 int opt = 1;
//setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
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;
}
client1.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 connect_server(const char* server_ip, int port);
void cmd_read_data(int fd, short events, void* arg);
void socket_read_data(int fd, short events, void *arg);
int main(int argc, char** argv)
{
if( argc < 3 )
{
printf("please input 2 parameters\n");
return -1;
}
//两个参数依次是服务器端的IP地址、端口号
int sockfd = connect_server(argv[1], atoi(argv[2]));
if( sockfd == -1)
{
perror("tcp_connect error ");
return -1;
}
printf("connect to server successfully\n");
struct event_base* base = event_base_new();
struct event *ev_sockfd = event_new(base, sockfd,
EV_READ | EV_PERSIST,
socket_read_data, NULL);
event_add(ev_sockfd, NULL);
//监听终端输入事件
struct event* ev_cmd = event_new(base, STDIN_FILENO,
EV_READ | EV_PERSIST, cmd_read_data,
(void*)&sockfd);
event_add(ev_cmd, NULL);
event_base_dispatch(base);
printf("finished \n");
return 0;
}
void cmd_read_data(int fd, short events, void* arg)
{
char msg[1024];
int ret = read(fd, msg, sizeof(msg)-1);
if( ret <= 0 )
{
perror("read fail ");
exit(1);
}
int sockfd = *((int*)arg);
if(msg[ret - 1]=='\n') msg[ret - 1] = '\0';
else msg[ret] = '\0';
//把终端的消息发送给服务器端,客户端忽略性能考虑，直接利用阻塞方式发送
printf("write to server>>> [%s]\n", msg);
write(sockfd, msg, ret);
}
void socket_read_data(int fd, short events, void *arg)
{
char msg[1024];
//为了简单起见，不考虑读一半数据的情况
int len = read(fd, msg, sizeof(msg)-1);
if( len == 0 )
{
printf("connection close. exit~\n");
exit(1);
}else if(len < 0){
perror("read fail ");
return ;
}
msg[len] = '\0';
printf("recv from server<<<<< [%s] \n", msg);
}
typedef struct sockaddr SA;
int 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;
}
服务升级，使用缓冲事件 bufevent.c
//创建bufferevent
struct bufferevent* bev = bufferevent_socket_new(base, sockfd,
BEV_OPT_CLOSE_ON_FREE);
//当有数据可读或socket关闭时会调用回调函数
bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
//使bufferevent 生效
bufferevent_enable(bev, EV_READ | EV_PERSIST);
//读取数据
size_t len = bufferevent_read(bev, msg, sizeof(msg));
//写数据
bufferevent_write(bev, msg, size);
/*这个是写到缓冲中，从缓冲中读写数据*/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h>
#define BUFLEN 1024
typedef struct _ConnectStat {
struct bufferevent* bev;//buf事件缓冲
char buf[BUFLEN];
}ConnectStat;
//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct bufferevent *bev);//初始化链接状态
void accept_connection(int fd, short events, void* arg);//接受客户端得链接
void do_echo_request(struct bufferevent* bev, void* arg);//读取客户端来得数据
void event_cb(struct bufferevent *bev, short event, void *arg);//出错之后进行得回调
int tcp_server_init(int port, int listen_num);//服务端得tcp初始化
struct event_base* base;//事件集
int main(int argc, char** argv)
{
int listener = tcp_server_init(9999, 10);
if( listener == -1 )
{
perror(" tcp_server_init error ");
return -1;
}
base = event_base_new();
//添加监听客户端请求连接事件
struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
accept_connection, base);//服务器创建监听事件，设置回调函数
event_add(ev_listen, NULL);//添加这个监听事件
event_base_dispatch(base);//进入事件循环
return 0;
}
ConnectStat * stat_init(int fd, struct bufferevent *bev) //初始化链接状态
{
ConnectStat * temp = NULL;//链接状态指针
temp = (ConnectStat *)malloc(sizeof(ConnectStat));//分配内存
if (!temp)
{
fprintf(stderr, "malloc failed. reason: %m\n");
return NULL;
}
memset(temp, '\0', sizeof(ConnectStat));//清空内存
temp->bev = bev;//保存客户端得事件
}
void accept_connection(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);//创建客户端buf事件 关闭时释放资源
ConnectStat *stat = stat_init(sockfd, bev);//客户端链接初始化
bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat);//设置buf事件 读事件完了调用得函数 写事件调用得函数 出错会调用event_cb函数
bufferevent_enable(bev, EV_READ | EV_PERSIST);//事件生效 持续得读
}
void do_echo_request(struct bufferevent* bev, void* arg)//读取数据
{
ConnectStat *stat = (ConnectStat *)arg;//客户端得链接状态结构
char *msg = stat->buf;//客户端得结构中得buf
printf("do echo request ...\n");
size_t len = bufferevent_read(bev, msg, BUFLEN);//注这里不是从tcp里读数据，bufevent当数据来了会直接读到缓存，从缓存中读到buf
msg[len] = '\0';//字符串结束符
printf("recv from client<<<< %s\n", msg);
bufferevent_write(bev, msg, strlen(msg));//写入数据
}
void event_cb(struct bufferevent *bev, short event, void *arg)//遇到错误所执行得函数
{
ConnectStat *stat = (ConnectStat *)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);//释放内存
free(stat);//释放链接状态得结构
}
typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{
int errno_save;
evutil_socket_t listener;// int listener;
listener = socket(AF_INET, SOCK_STREAM, 0);
if( listener == -1 )
return -1;
//允许多次绑定同一个地址。要用在socket和bind之间
//等同于 int opt = 1;
//setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
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;
}
bufevent2.c
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include<event2/listener.h>
#include <assert.h>
#define BUFLEN 1024
typedef struct _ConnectStat {
//struct event* ev;
struct bufferevent* bev;
char buf[BUFLEN];
}ConnectStat;
//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct bufferevent *bev);
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *sock, int socklen, void *arg); //有接口进来就执行这个函数
void do_echo_request(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
int tcp_server_init(int port, int listen_num);
struct event_base* base;
int main(int argc, char** argv)
{
struct sockaddr_in sin;
memset(&sin, 0, sizeof(struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = htons(9999);
base = event_base_new(); //创建事件集
/*
功能创建套接字，并绑定 和监听
@1.创建得事件集
@2.函数指针，链接进来所需要执行得函数
@3.事件集
@4.内部宏，可重用性，关闭后释放内存
@5.等待进行3次握手得队列长度
@6.addr
@7.addr得长度
*/
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)); //这个方法连sock都不用创建 新建一个套接字得集合
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
ConnectStat * stat_init(int fd, struct bufferevent *bev) {
ConnectStat * temp = NULL;
temp = (ConnectStat *)malloc(sizeof(ConnectStat));
if (!temp) {
fprintf(stderr, "malloc failed. reason: %m\n");
return NULL;
}
memset(temp, '\0', sizeof(ConnectStat));
temp->bev = bev;
}
/*
一个新客户端连接上服务器此函数就会被调用,当此函数被调用时，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);
ConnectStat *stat = stat_init(fd, bev);
bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat); //设置buf事件 读事件完了调用得函数 写事件调用得函数 出错会调用event_cb函数
bufferevent_enable(bev, EV_READ | EV_PERSIST);//事件生效 持续得读
//超时处理函数
bufferevent_settimeout(bev, 10, 10);//设置超时数据 10sm 没读没写就超时断开链接
}
void do_echo_request(struct bufferevent* bev, void* arg)
{
ConnectStat *stat = (ConnectStat *)arg;
char *msg = stat->buf;
printf("do echo request ...\n");
size_t len = bufferevent_read(bev, msg, BUFLEN);
msg[len] = '\0';
printf("recv from client<<<< %s\n", msg);
bufferevent_write(bev, msg, strlen(msg));
}
void event_cb(struct bufferevent *bev, short event, void *arg)
{
ConnectStat *stat = (ConnectStat *)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);
free(stat);
}
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
