Libevent源码分析-----连接监听器evconnlistener

最新推荐文章于 2024-09-06 16:46:31 发布

一介丶草民

最新推荐文章于 2024-09-06 16:46:31 发布

阅读量4k

点赞数

分类专栏：基本库相关

基本库相关专栏收录该内容

27 篇文章 0 订阅

订阅专栏

使用evconnlistener：

基于event和event_base已经可以写一个CS模型了。但是对于服务器端来说，仍然需要用户自行调用socket、bind、listen、accept等步骤。这个过程有点繁琐，为此在2.0.2-alpha版本的Libevent推出了一些对应的封装函数。

用户只需初始化struct sockaddr_in结构体变量，然后把它作为参数传给函数evconnlistener_new_bind即可。该函数会完成上面说到的那4个过程。下面的代码是一个使用例子。

[cpp]view plaincopy 
    
 #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_error_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(8989);  
   
     event_base *base = event_base_new();  
     evconnlistener *listener  
             = evconnlistener_new_bind(base, listener_cb, base,  
                                       LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE | LEV_OPT_THREADSAFE,  
                                       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)  
 {  
     event_base *base = (event_base*)arg;  
   
     //下面代码是为这个fd创建一个bufferevent  
     bufferevent *bev =  bufferevent_socket_new(base, fd,  
                                                BEV_OPT_CLOSE_ON_FREE);  
   
     bufferevent_setcb(bev, socket_read_cb, NULL, socket_error_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_error_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);  
 }  

上面的代码是一个服务器端的例子，客户端代码可以使用《Libevent使用例子，从简单到复杂》博文中的客户端。这里就不贴客户端代码了。

从上面代码可以看到，当服务器端监听到一个客户端的连接请求后，就会调用listener_cb这个回调函数。这个回调函数是在evconnlistener_new_bind函数中设置的。现在来看一下这个函数的参数有哪些，下面是其函数原型。

[cpp]view plaincopy 
    
 //listener.h文件  
 typedef void (*evconnlistener_cb)(struct evconnlistener *, evutil_socket_t, struct sockaddr *, int socklen, void *);  
   
 struct evconnlistener *evconnlistener_new_bind(struct event_base *base,  
     evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,  
     const struct sockaddr *sa, int socklen);  

第一个参数是很熟悉的event_base，无论怎么样都是离不开event_base这个发动机的。

第二个参数是一个函数指针，该函数指针的格式如代码所示。当有新的客户端请求连接时，该函数就会调用。要注意的是：当这个回调函数被调用时，Libevent已经帮我们accept了这个客户端。所以，该回调函数有一个参数是文件描述符fd。我们直接使用这个fd即可。真是方便。这个参数是可以为NULL的，此时用户并不能接收到客户端。当用户调用evconnlistener_set_cb函数设置回调函数后，就可以了。

第三个参数是传给回调函数的用户参数，作用就像event_new函数的最后一个参数。

参数flags是一些标志值，有下面这些：

LEV_OPT_LEAVE_SOCKETS_BLOCKING：默认情况下，当连接监听器接收到新的客户端socket连接后，会把该socket设置为非阻塞的。如果设置该选项，那么就把之客户端socket保留为阻塞的
LEV_OPT_CLOSE_ON_FREE：当连接监听器释放时，会自动关闭底层的socket
LEV_OPT_CLOSE_ON_EXEC：为底层的socket设置close-on-exec标志
LEV_OPT_REUSEABLE: 在某些平台，默认情况下当一个监听socket被关闭时，其他socket不能马上绑定到同一个端口，要等一会儿才行。设置该标志后，Libevent会把该socket设置成reuseable。这样，关闭该socket后，其他socket就能马上使用同一个端口
LEV_OPT_THREADSAFE：为连接监听器分配锁。这样可以确保线程安全

参数backlog是系统调用listen的第二个参数。最后两个参数就不多说了。

evconnlistener的封装：

接下来看一下Libevent是怎么封装evconnlistener的。

用到的结构体：

[cpp]view plaincopy 
    
 //listener.c文件  
 struct evconnlistener_ops {//一系列的工作函数  
     int (*enable)(struct evconnlistener *);  
     int (*disable)(struct evconnlistener *);  
     void (*destroy)(struct evconnlistener *);  
     void (*shutdown)(struct evconnlistener *);  
     evutil_socket_t (*getfd)(struct evconnlistener *);  
     struct event_base *(*getbase)(struct evconnlistener *);  
 };  
   
 struct evconnlistener {  
     const struct evconnlistener_ops *ops;//操作函数  
     void *lock; //锁变量，用于线程安全  
     evconnlistener_cb cb;//用户的回调函数  
     evconnlistener_errorcb errorcb;//发生错误时的回调函数  
     void *user_data;//回调函数的参数  
     unsigned flags;//属性标志  
     short refcnt;//引用计数  
     unsigned enabled : 1;//位域为1.即只需一个比特位来存储这个成员  
 };  
   
 struct evconnlistener_event {  
     struct evconnlistener base;  
     struct event listener; //内部event,插入到event_base  
 };  

在evconnlistener_event结构体有一个event结构体。可以想象，在实现时必然是将服务器端的socket fd赋值给struct event 类型变量listener的fd成员。然后将listener加入到event_base，这样就完成了自动监听工作。这也回归到之前学过的内容。

下面看一下具体是怎么实现的。

初始化服务器socket：

[cpp]view plaincopy 
    
 //listener.c文件  
 struct evconnlistener *  
 evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb,  
     void *ptr, unsigned flags, int backlog, const struct sockaddr *sa,  
     int socklen)  
 {  
     struct evconnlistener *listener;  
     evutil_socket_t fd;  
     int on = 1;  
     int family = sa ? sa->sa_family : AF_UNSPEC;  
   
     //监听个数不能为0  
     if (backlog == 0)  
         return NULL;  
   
     fd = socket(family, SOCK_STREAM, 0);  
     if (fd == -1)  
         return NULL;  
   
     //LEV_OPT_LEAVE_SOCKETS_BLOCKING选项是应用于accept到的客户端socket  
     //所以对于服务器端的socket，直接将之设置为非阻塞的  
     if (evutil_make_socket_nonblocking(fd) < 0) {  
         evutil_closesocket(fd);  
         return NULL;  
     }  
   
     if (flags & LEV_OPT_CLOSE_ON_EXEC) {  
         if (evutil_make_socket_closeonexec(fd) < 0) {  
             evutil_closesocket(fd);  
             return NULL;  
         }  
     }  
   
     if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on))<0) {  
         evutil_closesocket(fd);  
         return NULL;  
     }  
     if (flags & LEV_OPT_REUSEABLE) {  
         if (evutil_make_listen_socket_reuseable(fd) < 0) {  
             evutil_closesocket(fd);  
             return NULL;  
         }  
     }  
   
     if (sa) {  
         if (bind(fd, sa, socklen)<0) {//绑定  
             evutil_closesocket(fd);  
             return NULL;  
         }  
     }  
   
     listener = evconnlistener_new(base, cb, ptr, flags, backlog, fd);  
     if (!listener) {  
         evutil_closesocket(fd);  
         return NULL;  
     }  
   
     return listener;  
 }  

evconnlistener_new_bind函数申请一个socket，然后对之进行一些有关非阻塞、重用、保持连接的处理、绑定到特定的IP和端口。最后把业务逻辑交给evconnlistener_new处理。

[cpp]view plaincopy 
    
 //listener.c文件  
 static const struct evconnlistener_ops evconnlistener_event_ops = {  
     event_listener_enable,  
     event_listener_disable,  
     event_listener_destroy,  
     NULL, /* shutdown */  
     event_listener_getfd,  
     event_listener_getbase  
 };  
   
   
 struct evconnlistener *  
 evconnlistener_new(struct event_base *base,  
     evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,  
     evutil_socket_t fd)  
 {  
     struct evconnlistener_event *lev;  
   
     if (backlog > 0) {  
         if (listen(fd, backlog) < 0)  
             return NULL;  
     } else if (backlog < 0) {  
         if (listen(fd, 128) < 0)  
             return NULL;  
     }  
   
     lev = mm_calloc(1, sizeof(struct evconnlistener_event));  
     if (!lev)  
         return NULL;  
   
     //赋值  
     lev->base.ops = &evconnlistener_event_ops;  
     lev->base.cb = cb;  
     lev->base.user_data = ptr;  
     lev->base.flags = flags;  
     lev->base.refcnt = 1;  
   
     if (flags & LEV_OPT_THREADSAFE) {//线程安全就需要分配锁  
         EVTHREAD_ALLOC_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);  
     }  
   
     //在多路IO复用函数中，新客户端的连接请求也被当作读事件  
     event_assign(&lev->listener, base, fd, EV_READ|EV_PERSIST,  
         listener_read_cb, lev);  
   
     //会调用event_add，把event加入到event_base中  
     evconnlistener_enable(&lev->base);  
   
     return &lev->base;  
 }  
   
 int  
 evconnlistener_enable(struct evconnlistener *lev)  
 {  
     int r;  
     LOCK(lev);  
     lev->enabled = 1;  
     if (lev->cb)  
         r = lev->ops->enable(lev);//实际上是调用下面的event_listener_enable函数  
     else  
         r = 0;  
     UNLOCK(lev);  
     return r;  
 }  
   
 static int  
 event_listener_enable(struct evconnlistener *lev)  
 {  
     struct evconnlistener_event *lev_e =  
         EVUTIL_UPCAST(lev, struct evconnlistener_event, base);  
   
     //加入到event_base，完成监听工作。  
     return event_add(&lev_e->listener, NULL);  
 }  

几个函数的一路调用，思路还是挺清晰的。就是申请一个socket，进行一些处理，然后用之赋值给event。最后把之add到event_base中。event_base会对新客户端的请求连接进行监听。

在evconnlistener_enable函数里面，如果用户没有设置回调函数，那么就不会调用event_listener_enable。也就是说并不会add到event_base中。

event_listener_enable函数里面的宏EVUTIL_UPCAST可以根据结构体成员变量的地址推算出结构体的起始地址。有关这个宏，可以查看”结构体偏移量”。

处理客户端的连接请求：

现在来看一下event的回调函数listener_read_cb。

[cpp]view plaincopy 
    
 //listener.c文件  
 static void  
 listener_read_cb(evutil_socket_t fd, short what, void *p)  
 {  
     struct evconnlistener *lev = p;  
     int err;  
     evconnlistener_cb cb;  
     evconnlistener_errorcb errorcb;  
     void *user_data;  
     LOCK(lev);  
     while (1) { //可能有多个客户端同时请求连接  
         struct sockaddr_storage ss;  
 #ifdef WIN32  
         int socklen = sizeof(ss);  
 #else  
         socklen_t socklen = sizeof(ss);  
 #endif  
         evutil_socket_t new_fd = accept(fd, (struct sockaddr*)&ss, &socklen);  
         if (new_fd < 0)  
             break;  
         if (socklen == 0) {  
             /* This can happen with some older linux kernels in 
              * response to nmap. */  
             evutil_closesocket(new_fd);  
             continue;  
         }  
   
         if (!(lev->flags & LEV_OPT_LEAVE_SOCKETS_BLOCKING))  
             evutil_make_socket_nonblocking(new_fd);  
   
         //用户还没设置连接监听器的回调函数  
         if (lev->cb == NULL) {  
             UNLOCK(lev);  
             return;  
         }  
   
         //由于refcnt被初始化为1.这里有++了，所以一般情况下并不会进入下面的  
         //if判断里面。但如果程在下面UNLOCK之后，第二个线调用evconnlistener_free  
         //释放这个evconnlistener时，就有可能使得refcnt为1了。即进入那个判断体里  
         //执行listener_decref_and_unlock。在下面会讨论这个问题。  
         ++lev->refcnt;  
         cb = lev->cb;  
         user_data = lev->user_data;  
         UNLOCK(lev);  
         cb(lev, new_fd, (struct sockaddr*)&ss, (int)socklen,  
             user_data);//调用用户设置的回调函数，让用户处理这个fd  
         LOCK(lev);  
         if (lev->refcnt == 1) {  
             int freed = listener_decref_and_unlock(lev);  
             EVUTIL_ASSERT(freed);  
             return;  
         }  
         --lev->refcnt;  
     }  
       
     err = evutil_socket_geterror(fd);  
     if (EVUTIL_ERR_ACCEPT_RETRIABLE(err)) {//还可以accept  
         UNLOCK(lev);  
         return;  
     }  
   
     //当有错误发生时才会运行到这里  
     if (lev->errorcb != NULL) {  
         ++lev->refcnt;  
         errorcb = lev->errorcb;  
         user_data = lev->user_data;  
         UNLOCK(lev);  
         errorcb(lev, user_data);//调用用户设置的错误回调函数  
         LOCK(lev);  
         listener_decref_and_unlock(lev);  
     }  
 }  

这个函数所做的工作也比较简单，就是accept客户端，然后调用用户设置的回调函数。所以，用户回调函数的参数fd是一个已经连接好了的socket。

上面函数说到了错误回调函数，可以通过下面的函数设置连接监听器的错误监听函数。

[cpp]view plaincopy 
    
 //listener.h文件  
 typedef void (*evconnlistener_errorcb)(struct evconnlistener *, void *);  
   
 //listener.c文件  
 void  
 evconnlistener_set_error_cb(struct evconnlistener *lev,  
     evconnlistener_errorcb errorcb)  
 {  
     LOCK(lev);  
     lev->errorcb = errorcb;  
     UNLOCK(lev);  
 }  

释放evconnlistener：

调用evconnlistener_free可以释放一个evconnlistener。由于evconnlistener拥有一些系统资源，在释放evconnlistener_free的时候会释放这些系统资源。

[cpp]view plaincopy 
    
 //listener.c文件  
 void  
 evconnlistener_free(struct evconnlistener *lev)  
 {  
     LOCK(lev);  
     lev->cb = NULL;  
     lev->errorcb = NULL;  
     if (lev->ops->shutdown)//这里的shutdown为NULL  
         lev->ops->shutdown(lev);  
   
     //引用次数减一，并解锁  
     listener_decref_and_unlock(lev);  
 }  
   
 static int  
 listener_decref_and_unlock(struct evconnlistener *listener)  
 {  
     int refcnt = --listener->refcnt;  
     if (refcnt == 0) {  
         //实际调用event_listener_destroy  
         listener->ops->destroy(listener);  
         UNLOCK(listener);  
         //释放锁  
         EVTHREAD_FREE_LOCK(listener->lock, EVTHREAD_LOCKTYPE_RECURSIVE);  
         mm_free(listener);  
         return 1;  
     } else {  
         UNLOCK(listener);  
         return 0;  
     }  
 }  
   
 static void  
 event_listener_destroy(struct evconnlistener *lev)  
 {  
     struct evconnlistener_event *lev_e =  
         EVUTIL_UPCAST(lev, struct evconnlistener_event, base);  
   
     //把event从event_base中删除  
     event_del(&lev_e->listener);  
     if (lev->flags & LEV_OPT_CLOSE_ON_FREE)//如果用户设置了这个选项，那么要关闭socket  
         evutil_closesocket(event_get_fd(&lev_e->listener));  
 }  

要注意一点，LEV_OPT_CLOSE_ON_FREE选项关闭的是服务器端的监听socket，而非那些连接客户端的socket。

现在来说一下那个listener_decref_and_unlock。前面注释说到，在函数listener_read_cb中，一般情况下是不会调用listener_decref_and_unlock，但在多线程的时候可能会调用。这种特殊情况是：当主线程accept到一个新客户端时，会解锁，并调用用户设置的回调函数。此时，引用计数等于2。就在这个时候，第二个线程执行evconnlistener_free函数。该函数会执行listener_decref_and_unlock。明显主线程还在用这个evconnlistener，肯定不能删除。此时引用计数也等于2也不会删除。但用户已经调用了evconnlistener_free。Libevent必须要响应。当第二个线程执行完后，主线程抢到CPU，此时引用计数就变成1了，也就进入到if判断里面了。在判断体里面执行函数listener_decref_and_unlock，并且完成删除工作。

总得来说，Libevent封装的这个evconnlistener和一系列操作函数，还是比较简单的。思路也比较清晰。

参考：

http://www.wangafu.net/~nickm/libevent-book/Ref8_listener.html