linux epoll 发送函数封装问题请教...

sasinop

大概流程就是：main.c 主文件运行后，接受客户端连接，当客户端发相应命令过来后，在tcp.c 文件中解析后，调用function.c文件中的处理函数：Receive_Process（）。
原来我的想法是，在function处理完成后，通过Receive_Process()函数再把结果返回，
[code=c]void Receive_Process(int conn_fd,unsigned char*  buff_r,unsigned char*  buff_w)[/code]
如果这样的话，就没这些问题了，处理的结果，我在tcp.c文件中，通过 “unsigned char*  buff_w” 可以拿到，送给PC就完事了。

现在同事要求不这么干，即不通过Receive_Process（）进、出方式，把结果返回。而是要在fuction.c中（当然也可能其他文件中可以调用发送函数，把结果送给PC）把结果直接送给PC端...


（在另个帖子里可能没描述清楚）

主文件：
主要就是网上找到一段代码，简单调整了一下。

1. 
   
2. #include "tcp.h"
   
3. int main(int argc, char * argv[])   
   
4. {       
   
5.                 tcp_initialize();
   
6.                 epoll_fd_tcp=create_epoll_tcp(MAX_EVENTS_TCP);         
   
7.           while(1)
   
8.           {
   
9.                    do_process_tcp_nowhile();
   
10.                    sleep(1);
    
11.           }         
    
12. }  
    

复制代码

处理文件：function.c

1. 
   
2. #include "function.h"
   
3. 
   
4. void Receive_Process(int conn_fd,unsigned char*  buff_r,unsigned char*  buff_w)
   
5. {
   
6.         unsigned char CmdKey;
   
7.         unsigned char length;
   
8.         int len,i;
   
9.   len = buff_r[1];
   
10.         CmdKey = buff_r[2];       
    
11.         printf("packet len is : %02X\n",buff_r[1]);
    
12.         printf("cmdkey is : %02X\n",buff_r[2]);
    
13.         for(i=0;i<len;i++)
    
14.                      buff_r[i]=buff_r[i+1];
    
15.              for(i=0;i<len;i++)
    
16.                      printf("%02X ",buff_r[i]);
    
17.   printf("\n");
    
18. switch(CmdKey)
    
19.         {                               
    
20.                 case 0x02:
    
21.                         //write_spi_arm_to_fpga_array(5,buff_r,buff_w);
    
22.                      [color=#FF0000]  // 根据命令，与FPGA交互后，将返回结果送给PC端，下面是模拟的数据。[/color]
    
23.                         buff_w[0]=0x08;
    
24.                         buff_w[1]=0x03;
    
25.                         buff_w[2]=0x8c;
    
26.                         buff_w[3]=0x00;
    
27.                         buff_w[4]=0x00;
    
28.                         //send to pc
    
29.                        [color=#FF0000] tcp_send_data_to_pc(5 buff_w);[/color]
    
30.                        // 无发完成发送任务，这个函数只能在tcp.c文件中能正常，出了tcp.c文件就不行了。
    
31.                         printf("CMD_GET_VERSION OK \n");               
    
32.                         break;
    
33.                 default:                                               
    
34.                         break;
    
35.         }               
    
36. }
    

复制代码

TCP文件： tcp.c

1. 
   
2. #include "tcp.h"
   
3. 
   
4. struct epoll_event events[MAX_EVENTS_TCP];// 事件监听队列
   
5. 
   
6. 
   
7. int server_sock_fd_tcp;// 服务器端套接字   
   
8. int client_sock_fd_tcp;// 客户端套接字      
   
9. int nfds_tcp;// epoll监听事件发生的个数
   
10. int len_recv_data_tcp;
    
11. struct sockaddr_in host_addr_tcp;   // 服务器网络地址结构体   
    
12. struct sockaddr_in remote_addr_tcp; // 客户端网络地址结构体   
    
13. int sin_size;   
    
14. unsigned char send_data_buffer_size_tcp[BUFFER_SIZE_TCP];  // 数据传送的缓冲区  
    
15. unsigned char retn_data_buffer_size_tcp[BUFFER_SIZE_TCP];   
    
16. int m=0;
    
17. int len;
    
18. //设置句柄为非阻塞方式
    
19. int setnonblocking(int sockfd)  
    
20. {  
    
21. if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  
    
22. {  
    
23.     return -1;  
    
24. }  
    
25.     return 0;  
    
26. }
    
27. 
    
28. int tcp_send_data_to_pc(int len,char* buffer)
    
29. {       
    
30.                 printf("in while n == %d \n",n);
    
31.                 send(events[n].data.fd,buffer,4,0);               
    
32.                 ev.events = EPOLLIN;
    
33.                 ev.data.fd = events[n].data.fd;
    
34.     epoll_ctl(epoll_fd_tcp, EPOLL_CTL_MOD, ev.data.fd, &ev);
    
35. }
    
36. 
    
37. void tcp_initialize()
    
38. {
    
39.     struct rlimit rt;
    
40.    
    
41.     /* 设置每个进程允许打开的最大文件数 */  
    
42.     rt.rlim_max = rt.rlim_cur = 1024;  
    
43.     if (setrlimit(RLIMIT_NOFILE, &rt) == -1)   
    
44.                 {  
    
45.         perror("setrlimit");  
    
46.         exit(1);  
    
47.     }  
    
48.     else   
    
49.     {  
    
50.         printf("setrlimit ok! \n");  
    
51.     }  
    
52.    
    
53.     // 创建服务器端套接字--IPv4协议，面向连接通信，TCP协议
    
54.     if((server_sock_fd_tcp=socket(PF_INET,SOCK_STREAM,0))<0)   
    
55.     {     
    
56.         perror("socket");   
    
57.         //return 1;   
    
58.     }
    
59.     else
    
60.     {
    
61.             printf("Tcp server socket ok...\n");
    
62.     }
    
63.            
    
64.             // 设置 socket属性，端口可以重用   
    
65.   
    
66.           int opt=SO_REUSEADDR;
    
67.           setsockopt(server_sock_fd_tcp,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    
68.           setnonblocking(server_sock_fd_tcp);
    
69.            
    
70.     memset(&host_addr_tcp,0,sizeof(host_addr_tcp)); // 数据初始化--清零      
    
71.     host_addr_tcp.sin_family=PF_INET; // 设置为IP通信   
    
72.     host_addr_tcp.sin_addr.s_addr=inet_addr(HOST_IP_ADDRESS_TCP);// 服务器IP地址--允许连接到所有本地地址上   
    
73.     host_addr_tcp.sin_port=htons(HOST_PORT_TCP); // 服务器端口号  
    
74.    
    
75.     // 将套接字绑定到服务器的网络地址上
    
76.     if (bind(server_sock_fd_tcp,(struct sockaddr *)&host_addr_tcp,sizeof(struct sockaddr))<0)   
    
77.     {   
    
78.         perror("bind");   
    
79.         //return 1;   
    
80.     }
    
81.     else
    
82.     {
    
83.             printf("Tcp server bind ok...\n");
    
84.             printf("IP  : %s   \n", inet_ntoa(host_addr_tcp.sin_addr));
    
85.             printf("port: %d \n",ntohs(host_addr_tcp.sin_port));
    
86.     }
    
87.     // 监听连接请求--监听队列长度为5
    
88.     listen(server_sock_fd_tcp,64);   
    
89.     sin_size=sizeof(struct sockaddr_in);
    
90.        
    
91. }
    
92. 
    
93. // 创建一个epoll句柄
    
94. int create_epoll_tcp(unsigned int event_num)
    
95.   {       
    
96.           int epoll_fd;
    
97.                 epoll_fd=epoll_create(event_num);
    
98.                 if(epoll_fd==-1)
    
99.                 {
    
100.                         perror("epoll_create failed");                       
     
101.                 }
     
102.                 ev.events=EPOLLIN | EPOLLET;
     
103.                 ev.data.fd=server_sock_fd_tcp;
     
104.                 // 向epoll注册server_sockfd监听事件
     
105.                 if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,server_sock_fd_tcp,&ev)==-1)
     
106.                 {
     
107.                         perror("epll_ctl:server_sock_fd_tcp register failed");                       
     
108.                 }
     
109.                 else
     
110.           {
     
111.             printf("socket adding in  epoll success! \n");
     
112.           }
     
113.                 return epoll_fd;
     
114. }
     
115. 
     
116. void do_process_tcp_nowhile()
     
117. {                         
     
118.                         // 等待事件发生
     
119.                         nfds_tcp=epoll_wait(epoll_fd_tcp,events,1024,-1);
     
120.                         if(nfds_tcp==-1)
     
121.                         {
     
122.                                 perror("start epoll_wait failed");
     
123.                                 //exit(EXIT_FAILURE);
     
124.                         }
     
125.                         else
     
126.                         {
     
127.                                         printf(" epoll nfds_tcp = %d   \n",nfds_tcp);
     
128.                         }
     
129.                        
     
130.                         for(n=0;n<nfds_tcp;++n)
     
131.                         {
     
132.                                 printf(" for loop epoll nfds_tcp = %d   \n",nfds_tcp);
     
133.                                 // 客户端有新的连接请求
     
134.                                 if(events[n].data.fd == server_sock_fd_tcp)
     
135.                                 {
     
136.                                         // 等待客户端连接请求到达
     
137.                       if((client_sock_fd_tcp=accept(server_sock_fd_tcp,(struct sockaddr *)&remote_addr_tcp,&sin_size))<0)
     
138.                                         {   
     
139.                                                 perror("accept client_sock_fd_tcp failed");   
     
140.                                                 exit(EXIT_FAILURE);
     
141.                                         }
     
142.                                         // 向epoll注册client_sockfd监听事件
     
143.                                         setnonblocking(client_sock_fd_tcp);
     
144.                                         ev.events=EPOLLIN | EPOLLET;
     
145.                                         ev.data.fd=client_sock_fd_tcp;
     
146.                                         if(epoll_ctl(epoll_fd_tcp,EPOLL_CTL_ADD,client_sock_fd_tcp,&ev)==-1)
     
147.                                         {
     
148.                                                 perror("epoll_ctl:client_sock_fd_tcp register failed");                                               
     
149.                                         }
     
150.                                         printf("accept client %s\n",inet_ntoa(remote_addr_tcp.sin_addr));                                               
     
151.                                 }
     
152.                                 else if(events[n].events & EPOLLIN)
     
153.                                 {
     
154.                                         // 客户端有数据发送过来
     
155.                                         sprintf(send_data_buffer_size_tcp,"");
     
156.                                         //sin_size=sizeof(remote_addr_tcp);
     
157.                                
     
158.                                         len_recv_data_tcp=recv(events[n].data.fd,send_data_buffer_size_tcp,BUFFER_SIZE_TCP,0);
     
159.                                         if(len_recv_data_tcp<=0)
     
160.                                         {
     
161.                                                 printf("close id is : %d \n",events[n].data.fd);                                       
     
162.                                                 if(epoll_ctl(epoll_fd_tcp,EPOLL_CTL_DEL,events[n].data.fd,&ev)==0)
     
163.                                                 {
     
164.                                                         printf("delete ok \n");
     
165.                                                         close(events[n].data.fd);
     
166.                                                 }
     
167.                                                 else
     
168.                                                 {
     
169.                                                         printf("delete error \n");
     
170.                                                 }
     
171.                                         }
     
172.                                         else
     
173.                                         {//[color=#FF0000]处理PC来的命令包，，调用fuction.c文件中的 Receive_Process（）函数[/color]
     
174.                                      Receive_Process(4,send_data_buffer_size_tcp,retn_data_buffer_size_tcp);
     
175.                                     
     
176.                                                 ev.data.fd = events[n].data.fd;
     
177.             ev.events = EPOLLOUT|EPOLLET;
     
178.             epoll_ctl(epoll_fd_tcp, EPOLL_CTL_MOD, events[n].data.fd, &ev);                                                       
     
179.                                         }
     
180.                                 }
     
181.                                 else if(events[n].events & EPOLLOUT)//发送
     
182.                                 {                                       
     
183.                                         tcp_send_data_to_pc(4,send_data_buffer_size_tcp);        [color=#FF0000]//这个地方就正常        [/color]                       
     
184.                                 }
     
185.                         }                       
     
186.                
     
187.                 if(server_sock_fd_tcp>0)
     
188.                 {
     
189.                         printf("socket close \n");
     
190.                         shutdown(server_sock_fd_tcp,SHUT_RDWR);
     
191.                         close(server_sock_fd_tcp);
     
192.                 }
     
193.                
     
194. }
     

复制代码

tcp.h头文件

1. 
   
2. #include <arpa/inet.h>  
   
3. #include <fcntl.h>  
   
4. #include <sys/epoll.h>  
   
5. #include <sys/time.h>  
   
6. #include <sys/resource.h>  
   
7. 
   
8. #define BUFFER_SIZE_TCP 40
   
9. #define MAX_EVENTS_TCP 10
   
10. #define HOST_IP_ADDRESS_TCP "192.168.1.200"
    
11. #define HOST_PORT_TCP 4530
    
12. 
    
13. int n;
    
14. struct epoll_event ev;// epoll事件结构体
    
15. 
    
16. int epoll_fd_tcp;
    
17. int tcp_send_data_to_pc(int len,char* buffer);
    
18. void tcp_initialize();
    
19. int create_epoll_tcp(unsigned int event_num);
    
20. void do_process_tcp_nowhile();
    
21. 
    

复制代码

yulihua49

sasinop 发表于 2015-04-18 10:00
大概流程就是：main.c 主文件运行后，接受客户端连接，当客户端发相应命令过来后，在tcp.c 文件中解析后， ...

这算是啥封装哦！
根据你的题目，就是要写一个函数，利用epoll进行异步操作，让应用可以使用这个函数发送任何信息，屏蔽epoll的一切特性。
为完成这个任务，可能需要一些初始化工作。
http://bbs.chinaunix.net/thread-4174032-1-2.html
看看3楼那个，才是“封装”，应用只要调用那个函数即可发送任意数据，异步操作，epoll，线程池，协程之类的细节完全屏蔽。
那是一个实际可以工作的程序，不是个demo或者作业什么的。没有给出初始化过程。

那个例子表示了什么是“封装”。怎样封装的，需要对do_event()进行逐层展开。
你的例子大量使用全局变量，无法支持多线程。

你同事的要求是对的，你要写一个通用的发送函数，供各种场合用。很可能还需要个接收函数。
你的那么多行程序没必要提供，自己留着用，只需对外提供：
初始化（构造函数），善后（析构函数），发送函数，接收函数即可。

人们不关心你的process，无数的应用逻辑，可以有无数的process，他们的共同需求是在网上收发数据。
他们希望唯一的线程（你那个是单线程的）不要耽误在等待IO上，又不希望复杂的异步逻辑把应用逻辑搅得一塌糊涂。
于是，AIO -- 协程就产生了。

你可以拿我那个程序问问同事，要的是不是这个东西，然后再说怎么做。

linux_c_py_php

封装性太差了，应该先将epoll细节封装起来，之后再封装tcp/udp，这样做业务才会变简单。

sasinop

回复 2# yulihua49

谢谢呀

没法测试你的哪个函数


不知道你那个封装的函数，是不是在一个工程里，有N多个文件时，随意在某个文件里都可以调用，都可以来发送数据给客户端？






   

sasinop

你同事的要求是对的，你要写一个通用的发送函数，供各种场合用。很可能还需要个接收函数。

这样好么？

一个函数比如，do (in,out) 这样， 命令和结果一个函数扎口不好在什么地方呢？

同事那种要求：do(in), 只进命令，，结果 send(out)，要在不同的文件，不同的命令分支调用，处理完成后，就直接把结果送出去了... 难道这样好？

不解，请赐教呀

yulihua49

sasinop 发表于 2015-04-21 16:57
回复 2# yulihua49

谢谢呀

那个函数仅供学习，它是交易中间件的一部分，整个系统太大了，要下载整个中间件的源码。
你用那个函数，看懂过程和概念即可，按这个思路写自己的东西。

yulihua49

sasinop 发表于 2015-04-21 17:03
这样好么？

一个函数比如，do (in,out) 这样， 命令和结果一个函数扎口不好在什么地方呢？

in和out还是要分开的，比如有时是一进一出，有时是几进一出，一进几出，只进不出。。。。
还有，正常出，错误（异常）出等等，业务逻辑什么需求都有。

所以，你只要提供 in，out就可以了，何时in，何时out，它们之前，之间，之后做了什么你就不必管了。

就像我那个程序，只管发送N字节到socket。之前，要填充包头，包体要压缩，加密，校验。。。
之后要归还资源（内存和连接池），写日志。。。。。。这些你管的着吗？

你写了个in，out，把AIO，epoll...都埋藏在这两个函数里，外边那些作业就容易多了。
看我的程序，知道怎么埋藏，这可是个大学问。

对了，那个windoze也很会埋，我还是跟他学的。不过他的代码很多，你也可以用他的那个fiberized .IO, C++  的。