求教libevent用法

故哈

服务端逻辑：
              使用本地sock(绑定文件的，STREAM)， 接收字符串， 返回字符串， 关闭连接

客户端逻辑：
              主动连接服务端，发送字符串，接收字符串，关闭连接， 重新连接服务端，无限循环

问题：
       accept只能触发一次。 就是当客户端第一次建立连接时，accept事件和read事件都能正常返回。 当客户端第二次连接时，accept事件就不会返回了

问：
     accept事件需要每次用完，再重新添加进base吗？ 怎样重新添加呢？ 先event_free或者event_del，然后再add吗？

服务端

1. #include "task.h"
   
2. 
   
3. struct event_base *TaskReadEvBase;
   
4. void TaskReadEvFun(int sd, short event, void *arg);
   
5. 
   
6. void *ReadTaskEvThead(void *arg){
   
7.         TaskListenPort *ListenPort=(TaskListenPort *)arg;
   
8.         struct event *TaskReadEv=NULL;
   
9. 
   
10.         TaskReadEvBase=event_base_new();
    
11.         TaskReadEv=event_new(TaskReadEvBase, ListenPort->sd, EV_READ|EV_PERSIST, TaskAcceptEvFun, (void *)TaskReadEv);
    
12.         if(TaskReadEv==NULL){
    
13.                 perror("event_new");
    
14.                 pthread_exit(NULL);
    
15.         }       
    
16.         event_add(TaskReadEv, NULL);
    
17.         event_base_dispatch(TaskReadEvBase);
    
18.         printf("event_base_dispatch over");
    
19.         pthread_exit(NULL);
    
20. }
    
21. 
    
22. void TaskReadEvFun(int sd, short event, void *arg){
    
23.         int len=0;
    
24.         char buf[256];
    
25.         struct event *TaskReadEv=(struct event *)arg;
    
26.        
    
27. 
    
28.         printf("==================\n");
    
29.         printf("sd=%d\n", sd);
    
30.         bzero(buf, 256);
    
31.         len=recv(sd, buf, 256, 0);
    
32.         printf("recvbuf=%s\n", buf);
    
33.         write(sd, "over\n", 5);
    
34.         perror("write");
    
35.         printf("sd=%d\n", event_get_fd(TaskReadEv));
    
36.         close(event_get_fd(TaskReadEv));
    
37.         event_free(TaskReadEv);
    
38.         return;
    
39. }
    
40. 
    
41. void TaskAcceptEvFun(int sd, short event, void *arg){
    
42.         int newsd=0;
    
43.         struct sockaddr_un addr;
    
44.         socklen_t isinsize=0;
    
45.         struct event *TaskReadEv=NULL;
    
46.         struct event *TaskAcceptEv=(struct event *)arg;
    
47.        
    
48.         printf("accept event\n");
    
49.         newsd = accept(sd, (struct sockaddr *)&addr, &isinsize);
    
50.         if(newsd==-1){
    
51.                 printf("TaskAcceptEvFun error\n");
    
52.                 perror("accept");
    
53.                 return;
    
54.         }
    
55.         evutil_make_socket_nonblocking(newsd);
    
56.         TaskReadEv=event_new(TaskReadEvBase, newsd, EV_READ|EV_PERSIST, TaskReadEvFun, (void *)TaskReadEv);
    
57.         if(TaskReadEv==NULL){
    
58.                 perror("event_new error\n");
    
59.                 return;
    
60.         }
    
61.         event_add(TaskReadEv, NULL);
    
62.         //event_add(TaskAcceptEv, NULL);
    
63. }
    
64. 
    
65. int init_task_listen(TaskListenPort *port){
    
66.         int sd=0, ret=0;
    
67.         struct sockaddr_un addr;
    
68. 
    
69.         sd=socket(PF_UNIX, SOCK_STREAM, 0);
    
70.         if(sd==-1){
    
71.                 perror("socket");
    
72.                 remove(port->portfile);
    
73.                 return ERR;
    
74.         }
    
75.        
    
76.         evutil_make_socket_nonblocking(sd);
    
77.        
    
78.         addr.sun_family=AF_UNIX;
    
79.         strncpy(addr.sun_path, port->portfile, sizeof(addr.sun_path)-1);
    
80.         ret=bind(sd, (struct sockaddr *)&addr, sizeof(addr));
    
81.         if(ret==-1){
    
82.                 perror("bind");
    
83.                 close(sd);
    
84.                 return ERR;
    
85.         }
    
86.         ret=listen(sd, 256);
    
87.         if(ret==-1){
    
88.                 perror("listen");
    
89.                 close(sd);
    
90.                 return ERR;
    
91.         }
    
92. 
    
93.         return sd;
    
94. }
    

复制代码

客户端

1. //c_unix.c
   
2. #include <stdio.h>
   
3. #include <sys/types.h>
   
4. #include <sys/socket.h>
   
5. #include <sys/un.h>
   
6. #define UNIX_DOMAIN "/tmp/dataswsmb.port"
   
7. int main(void)
   
8. {
   
9.         int connect_fd;
   
10.         int ret;
    
11.         char snd_buf[128];
    
12.         int i;
    
13.         while(1)
    
14.         {
    
15.                 static struct sockaddr_un srv_addr;
    
16.                 connect_fd=socket(PF_UNIX,SOCK_STREAM,0);
    
17.                 if(connect_fd<0)
    
18.                 {
    
19.                         perror("cannot create communication socket");
    
20.                         return 1;
    
21.                 }   
    
22.                 srv_addr.sun_family=AF_UNIX;
    
23.                 strcpy(srv_addr.sun_path,UNIX_DOMAIN);
    
24.                 ret=connect(connect_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));
    
25.                 if(ret==-1)
    
26.                 {
    
27.                         perror("cannot connect to the server");
    
28.                         close(connect_fd);
    
29.                         return 1;
    
30.                 }
    
31.                 perror("connect");
    
32.                 memset(snd_buf,0x00,128);
    
33.                 strcpy(snd_buf,"message from client");
    
34. 
    
35.                 ret = write(connect_fd,snd_buf,sizeof(snd_buf));
    
36.                 if (ret <= 0)
    
37.                 {
    
38.                         perror("write");
    
39.                 }
    
40.                 perror("write");
    
41.                 memset(snd_buf,0x00,128);
    
42.                 ret = read(connect_fd,snd_buf,sizeof(snd_buf));
    
43.                 if (ret <= 0)
    
44.                 {
    
45.                         perror("read");
    
46.                 }
    
47.                 perror("read");
    
48.                 printf("server returned : %s\n", snd_buf);
    
49.                 close(connect_fd);
    
50.                 printf("=================================\n");
    
51.         }
    
52.         return 0;
    
53. }
    

复制代码

MeRcy_PM

event_new的时候应该已经指定了base了，触发一次以后libevent应该会把他从关注的列表里面去掉，如果还要关注这个事件就重新event_add就可以了，但是不管监听不监听，他都在你初始化分配的base中。不过我对PERSIST理解还不太够

故哈

回复 2# MeRcy_PM


   
重新ADD也不行 我试了。

MeRcy_PM

回复 3# 故哈
是不是原来的fd已经close了，accept另一个fd，event_assign一下试试？

   

故哈

回复 4# MeRcy_PM


    我这个不是网络socket，是本地sock， PF_UNIX的。


用来accept的sd应该是没有关闭 通过netstat看 还是LISTENING状态

故哈

回复 4# MeRcy_PM


    应该是我哪里用的不对 第一次用

MeRcy_PM

回复 5# 故哈
不好意思，刚没细看代码。在Accept之后添加了一个TaskReadEvFun的事件，但是在TaskReadEvFun这里面没有事件添加吧，所以到最后base里面都是空的事件吧？

   

故哈

回复 7# MeRcy_PM


    TaskReadEvFun里边是没有添加事件的。

     因为我在TaskAcceptEvFun里边调用accept的时候，每次新建的socket都重新加了read事件， 那我在TaskReadEvFun里边是不是不需要重新添加read事件了？

故哈

回复 7# MeRcy_PM


    在read事件里边的socket其实每次recv之后就是要关闭的。

MeRcy_PM

回复 8# 故哈
应该是添加accept事件吧。
我个人理解的服务器调用应该是listen->add_accept_ev->[accept->add_read_ev->deal_read_ev]->add_accept_ev]->[......