LIBENENT
#cnclude<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet/h>
#include<errno.h>
#include<unistd.h>// 是 C 和 C++ 程序设计语言中提供对 POSIX 操作系统 API 的访问功能的头文件的名称。该头文件由 POSIX.1 标准（单一UNIX规范的基础）提出，故所有遵循该标准的操作系统和编译器均应提供该头文件（如 Unix 的所有官方版本，包括 Mac OS X、Linux 等）。
#include<stdio.h>
#include<string.h>
#inlcude<stdlib.h>
#include<event2/util.h>
type struct socketaddr SA;
int tcp_connect_to_server(const char * server_ip,int port )
{
int sockfd,save_error;
struct socketaddr_in,server_addr;
truct sockaddr_in
{
struct sockaddr_in
{
short sin_family;/*Address family一般来说AF_INET（地址族）PF_INET（协议族）*/
unsigned short sin_port;/*Port number(必须要采用网络数据格式,普通数字可以用htons()函数转换成网络数据格式的数字)*/
struct in_addr sin_addr;/*IP address in network byte order（Internet address）*/
unsigned char sin_zero[8];/*Same size as struct sockaddr没有实际意义,只是为了 跟SOCKADDR结构在内存中对齐*/
}
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);inet_aton是一个计算机函数，功能是将一个字符串IP地址转换为一个32位的网络序列IP地址。如果这个函数成功，函数的返回值非零，如果输入地址不正确则会返回零。使用这个函数并没有错误码存放在errno中，所以它的值会被忽略。
if( status == 0 ) //the server_ip is not valid value
{
errno = EINVAL;
return -1;
}
sockfd=::socket(PF_INET,SOCK_STREAM,0);//参数一表示地址类型，参数而表示面向连接还是面向无连接的套接字，参数三是表示TCP还是udp
if(sockfd==-1)
return sockfd;
其中流式套接字使用SOCKET_STREAM表示
SOCK_STREAM 是一种可靠的、双向的通信数据流，数据可以准确无误地到达另一台计算机，如果损坏或丢失，可以重新发送
流时套接字有自己的纠错机制
特点有
数据在传输过程中不会丢失，数据按照顺序传输的，数据的发送和接受不是同步的
只要传送带本身没有问题（不会断网），就能保证数据不丢失；同时，较晚传送的数据不会先到达，较早传送的数据不会晚到达，这就保证了数据是按照顺序传递的。
为什么流格式套接字可以达到高质量的数据传输呢？这是因为它使用了 TCP 协议（The Transmission Control Protocol，传输控制协议），TCP 协议会控制你的数据按照顺序到达并且没有错误。
你也许见过 TCP，是因为你经常听说“TCP/IP”。TCP 用来确保数据的正确性，IP（Internet Protocol，网络协议）用来控制数据如何从源头到达目的地，也就是常说的“路由”。
数据报格式套接字（Datagram Sockets）也叫“无连接的套接字”，在代码中使用 SOCK_DGRAM 表示。
计算机只管传输数据，不作数据校验，如果数据在传输中损坏，或者没有到达另一台计算机，是没有办法补救的。也就是说，数据错了就错了，无法重传。
因为数据报套接字所做的校验工作少，所以在传输效率方面比流格式套接字要高。
有了地址类型和数据传输方式，还不足以决定采用哪种协议吗？为什么还需要第三个参数呢？
正如大家所想，一般情况下有了 af 和 type 两个参数就可以创建套接字了，操作系统会自动推演出协议类型，除非遇到这样的情况：有两种不同的协议支持同一种地址类型和数据传输类型。如果我们不指明使用哪种协议，操作系统是没办法自动推演的。
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;
}
void server_msg_cb(struct bufferevent* bev, void* arg)
{
char msg[1024];
msg[len];
size_t len=bufferevent_read(bev,msg,sizeof(msg));
msg[len]='\0';
printf("recv%s from server\n",msg);
}
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);
｝
int main()
{
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);
//eventbase是libevent处理事物的框架负责事件的注册，删除，属于reactor模式中的reactor
//创建一个event_base event_base_new(void)
struct event_base *
event_base_new(void)
{
struct event_base *base = NULL;
struct event_config *cfg = event_config_new();
if (cfg) {
base = event_base_new_with_config(cfg);
event_config_free(cfg);
}
return base;
}
由上边程序知道，event_base创建的关键所在是event_base_new_config函数，而次函数有用过调用多路复用的机制来初始化event_base实例
event_new创建事件，涉及内存操作
event_add
event_del
event_free释放由new创建的内存
struct event_base *
event_init(void)
{
struct event_base *base = event_base_new(); //event_init()调用event_base_new()
if (base != NULL)
current_base = base;
return (base);
}
struct event_base *
event_base_new(void) //初始化libevent的event_base
{
int i;
struct event_base *base;
if ((base = calloc(1, sizeof(struct event_base))) == NULL) //在堆上分配内存存储event_base，所有字段初始化为0
event_err(1, "%s: calloc", __func__);
event_sigcb = NULL;
event_gotsig = 0;
detect_monotonic(); //设置use_monotonic变量
gettime(base, &base->event_tv); //base->tv_cache.tv_sec非0，则赋给base->event_tv
min_heap_ctor(&base->timeheap); //初始化定时事件的小根堆base->timeheap min_heap.h
TAILQ_INIT(&base->eventqueue); //初始化注册事件链表base->eventqueue sys/queue.h
base->sig.ev_signal_pair[0] = -1; //初始化信号base->sig
base->sig.ev_signal_pair[1] = -1;
base->evbase = NULL; //初始化I/O多路复用 base->evbase
//遍历全局数组eventops[]，初始化libevent的I/O多路复用机制
for (i = 0; eventops[i] && !base->evbase; i++) { //以NULL标志数组结尾，只选取一个I/O多路复用机制
base->evsel = eventops[i]; //初始化base->evsel
base->evbase = base->evsel->init(base); //初始化base->evbase
}
if (base->evbase == NULL) //没有I/O多路复用
event_errx(1, "%s: no event mechanism available", __func__);
if (evutil_getenv("EVENT_SHOW_METHOD")) //调用getenv()获取环境变量EVENT_SHOW_METHOD evutil.c
event_msgx("libevent using: %s\n",
base->evsel->name);
/* allocate a single active event queue */
//event_base_new()内调用event_base_priority_init()
event_base_priority_init(base, 1); //设置优先级base->nactivequeues；分配数组base->activequeues。数组大小和优先级相同
return (base);
}
先是初始化event_base然后初始化event，通过初始化event_set()函数实现。
void
event_set(struct event *ev, int fd, short events,
void (*callback)(int, short, void *), void *arg)
{
/* Take the current base - caller needs to set the real base later */
ev->ev_base = current_base; //设置event属于当前base；current_base通过event_init()设置
ev->ev_callback = callback; //设置回调函数
ev->ev_arg = arg; //设置回调函数的3个参数
ev->ev_fd = fd;
ev->ev_events = events;
ev->ev_res = 0;
ev->ev_flags = EVLIST_INIT; //设置event状态
ev->ev_ncalls = 0;
ev->ev_pncalls = NULL;
min_heap_elem_init(ev); //初始化event在小根堆中索引为-1 min_heap.h
/* by default, we put new events into the middle priority */
if(current_base)
ev->ev_pri = current_base->nactivequeues/2; //设置event优先级
}
event_base()初始化event_base
event_set()初始化event
event_base_set()将event绑定到指定的event_base上
event_add()将event添加到事件链表上，注册事件
event_base_dispatch()循环、检测、分发事件
写一个测试程序
struct event ev;
struct timeval tv;
void time(int fd,short event,void *arg)
{
printf("amck");
event_add(&ev,&tv);
}
int main()
{
struct event_base *base=event_init();
tv.tv_sec=1;
tv.tv_usec=0;
event_set(&ev, -1, 0, timer_cb, NULL); //初始化event结构中成员
event_base_set(base, &ev);
event_add(&ev, &tv); //将event添加到events事件链表，注册事件
event_base_dispatch(base); //循环、分发事件
return 0;
}
服务端代码：
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<unistd.h>
#include<event.h>
void accept_cb(int fd, short events, void* arg)
｛
evutil_socket_t sockfd;//int
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专门为封装成带有缓冲区的socket套接字。当有数据到来时，我们只需要在回调函数里面通过封装函数bufferevent_read读取数据即可，根本不需要自己处理一些细节，以及缓存的问题。
bufferevent其实也就是在event_base的基础上再进行一层封装，其本质还是离不开event和event_base，从bufferevent的结构体就可以看到这一点。
bufferevent_setcb(bev,socket_read_cb,NULL,event_cb,arg);
bufferevent_ebable(bev,EV_READ|EV_PERSIST);
｝
void socket_read_cb(int fd, short events, void *arg);
typedef struct aockaddr SA
int tcp_server_init(int port, int listen_num)
{
int errno_save;
evutil_sock_t listener;
if(listener==-1)
return =-1;
evutil_make_listen_socket_reuseable(listen);//允许多次绑定同一地址
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 err;
evutil_make_socket_nonblocking(listener);//跨平台统一接口，将套接字设置为非阻塞
return listener;
error:
errno_save = errno;
evutil_closesocket(listener);
errno = errno_save;
return -1;
}
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_PRESIST,accept__cb,base);
}
网友评论