EPOLL 方式的 TCP 如何封装一个发送函数，任意文件中可以定义？

sasinop

网上找的代码，简单组织了下，发现发送函数，不能在主文件中调用，不能成功把临时加的值给发送给PC

后来发现是 “n”  变量这个值的问题，下面是在控制台上 打印  变量  n 的值结果：

in while n == 1
epoll nfds_tcp = 1   
for loop epoll nfds_tcp = 1   
in while n == 0
in while n == 0
n == 0
// 到主函数里后， 再次调用发送函数时，“n” 变量值改变了...
in while n == 1

请教这代码如何修改，才能封装一个函数，可以在任何文件中都可以调用？而且可以保证多个客户端 同时可以连接上来，且返回给每个客户端的数据正确（每个客户端发送内容可能不一样）


主文件：
[code]

#include "tcp.h"
int main(int argc, char * argv[])   
{

sasinop

1. 
   
2. 
   
3. #include "tcp.h"
   
4. int main(int argc, char * argv[])   
   
5. {
   
6.         unsigned char send_data_buffer_size[4];
   
7.         send_data_buffer_size[0]=0xAA;
   
8.         send_data_buffer_size[1]=0xAA;
   
9.         send_data_buffer_size[2]=0xAA;
   
10.         send_data_buffer_size[3]=0xAA;
    
11.        
    
12.                 tcp_initialize();
    
13.                 epoll_fd_tcp=create_epoll_tcp(MAX_EVENTS_TCP);         
    
14.           while(1)
    
15.           {
    
16.                    do_process_tcp_nowhile();
    
17.                    sleep(1);
    
18.                    set_tcp_event_out();
    
19.                    tcp_send_data_to_pc(4,send_data_buffer_size);
    
20.           }         
    
21. }  
    

复制代码

sasinop

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

复制代码

sasinop

1. 
   
2. #define BUFFER_SIZE_TCP 40
   
3. #define MAX_EVENTS_TCP 10
   
4. #define HOST_IP_ADDRESS_TCP "192.168.1.102"
   
5. #define HOST_PORT_TCP 4530
   
6. 
   
7. int n;
   
8. int epoll_fd_tcp;
   
9. int tcp_send_data_to_pc(int len,char* buffer);
   
10. void tcp_initialize();
    
11. int create_epoll_tcp(unsigned int event_num);
    
12. void do_process_tcp();
    
13. void do_process_tcp_nowhile();
    
14. void set_tcp_event_out();
    

复制代码

yulihua49

sasinop 发表于 2015-04-17 15:00

http://bbs.chinaunix.net/thread-4174032-1-2.html
看 3  楼那个，应用只需调用SendNet即可，epoll，AIO什么的都封装了。