求助，一个UDP数据转发问题！

zhanglong71

一个转发网络数据包的程序，想不通问题出在哪里！请高人指点。

实现的原理如下：
１.使用UDP协议。
登录过程如下：
２.客户端(Client)向转发服务器(Server)发送登录数据包。登录数据包中包括客户自己的ID号。
３.转发服务器(Server)将收到的登录数据包中的客户ID号及源ip+port记录下来。
客户端1向客户端2发送数据的过程如下：
４.客户端1向转发服务器发数据包,包内有源客户端ID1及目的客户端ID2。
５.转发服务器(Server)将从客户端收到的数据包中提取目的客户端ID2，以目的客户端ID2查找客户端登录时的ip+port。再将数据包发往此ip+port对应的客户端2。

执行一次数据传输后服务器端的数据如下：
[start.c-213]receiving ...
[start.c-219]received !
[start.c-290]Client Node[22345678901-192.168.1.112:9655] created ok!
[start.c-324]send login ACK ok
[start.c-333]Client [22345678901: 192.168.1.112: 9655] login
[start.c-213]receiving ...
[start.c-219]received !
[start.c-290]Client Node[12345678901-192.168.1.103:7100] created ok!
[start.c-324]send login ACK ok
[start.c-333]Client [12345678901: 192.168.1.103: 7100] login
[start.c-213]receiving ...
[start.c-219]received !
[start.c-236]received data !
[start.c-242]ready to forward data !
[start.c-258]forward data from [12345678901-192.168.1.103:7100] to [22345678901-192.168.1.103:9655]!
[start.c-213]receiving ...
[start.c-219]received !
[start.c-236]received data !
[start.c-242]ready to forward data !
[start.c-258]forward data from [22345678901-192.168.1.112:9655] to [12345678901-192.168.1.112:7100]!
[start.c-213]receiving ...

其中：start.c-333表示客户端登录时的ID号及ip:port。
　　　start.c-258表示数据从客户端1发往客户端2时的ID号:ip:port

问题：
　　１.比较[start.c-333]与[start.c-258]的信息后发现，登录时的ip地址与需要转发数据时找到的ip地址不同：
登录时的节点信息是“22345678901: 192.168.1.112: 9655”。而转发需要数据时，找到的节点信息却是“22345678901-192.168.1.103:9655”，两者的ip地址不同
似乎[start.c-258]处错打印了源端的ip地址信息。但找不到哪里有问题。
    ２.这种数据转发及从recvfrom()中取得数据包的源ip+port的方式是否可行？

附代码如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <sys/types.h>
   
5. #include <sys/socket.h>
   
6. #include <netinet/in.h>
   
7. #include <arpa/inet.h>
   
8. #include <unistd.h>
   
9. 
   
10. #if 1
    
11. #include "ptype.h"
    
12. #include "rbtree.h"
    
13. //#include "read.h"
    
14. #include "parse.h"
    
15. #endif
    
16. 
    
17. /*
    
18. *receive data as recv port
    
19. */
    
20. 
    
21. int insertImsi(struct rb_root *root, struct clientNode_s *__clientNode, charsCmp_t cmp)
    
22. {
    
23.     struct rb_node **new = &(root->rb_node), *parent = NULL;
    
24. 
    
25.     /* Figure out where to put new node */
    
26.     while (*new)
    
27.     {
    
28.         //struct mytype *this = container_of(*new, struct mytype, node);
    
29.         struct clientNode_s *clientNode = container_of(*new, struct clientNode_s, node);
    
30.         int result = cmp(__clientNode->clientImsi, clientNode->clientImsi);
    
31. 
    
32.         parent = *new;
    
33.         if (result < 0)
    
34.             new = &((*new)->rb_left);
    
35.         else if (result > 0)
    
36.             new = &((*new)->rb_right);
    
37.         else
    
38.             return 0;
    
39.     }
    
40. 
    
41.     /* Add new node and rebalance tree. */
    
42.     rb_link_node(&(__clientNode->node), parent, new);
    
43.     rb_insert_color(&(__clientNode->node), root);
    
44. 
    
45.     return 1;
    
46. }
    
47. 
    
48. int insertClientId(struct rb_root *root, struct clientNode_s *__clientNode, cmp_t cmp)
    
49. {
    
50.     struct rb_node **new = &(root->rb_node), *parent = NULL;
    
51. 
    
52.     /* Figure out where to put new node */
    
53.     while (*new)
    
54.     {
    
55.         //struct mytype *this = container_of(*new, struct mytype, node);
    
56.         struct clientNode_s *clientNode = container_of(*new, struct clientNode_s, node);
    
57.         int result = cmp(__clientNode->clientId, clientNode->clientId);
    
58. 
    
59.         parent = *new;
    
60.         if (result < 0)
    
61.             new = &((*new)->rb_left);
    
62.         else if (result > 0)
    
63.             new = &((*new)->rb_right);
    
64.         else
    
65.             return 0;
    
66.     }
    
67. 
    
68.     /* Add new node and rebalance tree. */
    
69.     rb_link_node(&(__clientNode->node), parent, new);
    
70.     rb_insert_color(&(__clientNode->node), root);
    
71. 
    
72.     return 1;
    
73. }
    
74. 
    
75. 
    
76. struct clientNode_s *searchClientId(struct rb_root *root, unsigned  int __clientId, cmp_t cmp)
    
77. {
    
78.     struct rb_node *node = root->rb_node;
    
79.     while (node)
    
80.     {
    
81.         struct clientNode_s *clientNode = container_of(node, struct clientNode_s, node);
    
82.         int result = cmp(__clientId, clientNode->clientId);
    
83.         if (result < 0)
    
84.             node = node->rb_left;
    
85.         else if (result > 0)
    
86.             node = node->rb_right;
    
87.         else
    
88.             return clientNode;
    
89.     }   
    
90.     return NULL;
    
91. }
    
92. 
    
93. struct clientNode_s *searchImsi(struct rb_root *root, char* __imsi, charsCmp_t cmp)
    
94. {
    
95.     struct rb_node *node = root->rb_node;
    
96.     while (node)
    
97.     {
    
98.         struct clientNode_s *clientNode = container_of(node, struct clientNode_s, node);
    
99.         int result = cmp(__imsi, clientNode->clientImsi);
    
100.         if (result < 0)
     
101.             node = node->rb_left;
     
102.         else if (result > 0)
     
103.             node = node->rb_right;
     
104.         else
     
105.             return clientNode;
     
106.     }   
     
107.     return NULL;
     
108. }
     
109. 
     
110. unsigned int uicmp(const unsigned int __arg1, const unsigned int __arg2)
     
111. {
     
112.     return (__arg1 - __arg2);
     
113. }
     
114. 
     
115. #if 1
     
116. #if 1
     
117. int charsCmp(const char* __arg1, const char* __arg2)
     
118. {
     
119.     int i;
     
120.     for(i = 0; ((i < __arg1[0]) && (i < CIMSI_LEN)); i++)     /** Note: arg1[0] is the length of string **/
     
121.     {
     
122.         if(__arg1[i] != __arg2[i])
     
123.         {
     
124.             return  __arg1[i] - __arg2[i];
     
125.         }
     
126.     }
     
127.     return 0;
     
128. }
     
129. #else
     
130. unsigned int charsCmp(const char* __arg1, const char* __arg2, int __len)
     
131. {
     
132.     for(int i = 0; (i < CIMSI_LEN) && (i < __len); i++)
     
133.     {
     
134.         if(__arg1[i] != __arg2[i])
     
135.         {
     
136.             return  __arg1[i] - __arg2[i];
     
137.         }
     
138.     }
     
139.     return 0;
     
140. }
     
141. #endif
     
142. 
     
143. #else
     
144. unsigned int charsCmp(const char* __arg1, const char* __arg2)
     
145. {
     
146.     int i;
     
147. 
     
148.     if(__arg1[0] != __arg2[0])      /** 先比较长度 **/
     
149.     {
     
150.         return  __arg1[0] - __arg2[0];
     
151.     }
     
152.    
     
153.     for(i = 1; (i < CIMSI_LEN) && (i < __arg1[0]); i++)
     
154.     {
     
155.         if(__arg1[i] != __arg2[i])
     
156.         {
     
157.             return  __arg1[i] - __arg2[i];
     
158.         }
     
159.     }
     
160.     return 0;
     
161. }
     
162. #endif
     
163. 
     
164. int        main(int argc, char *argv[])
     
165. {
     
166.         //int i;
     
167.         int sock_fd;
     
168.         //int iLen = 0;
     
169.         struct sockaddr_in myaddr;
     
170.         struct sockaddr_in src_addr;
     
171.         struct sockaddr_in dst_addr;
     
172. 
     
173.     struct clientNode_s *dstNode;
     
174.     struct clientNode_s *srcNode;
     
175. 
     
176.     char dstImsi[CIMSI_LEN];
     
177.     char srcImsi[CIMSI_LEN];
     
178.         char format[CFMAT_LEN];
     
179.     //unsigned int dstClientId = 0;
     
180.     //unsigned int srcClientId = 0;
     
181. 
     
182.     struct rb_root root = RB_ROOT;
     
183.         char buf[BUF_LEN];
     
184.         char value[BUF_LEN];
     
185.         int iStrLen = 0;
     
186.         int        recv_num;
     
187.         int        recvlen;
     
188. 
     
189.         if(2 > argc)
     
190.         {
     
191.                 printf("argc\n");
     
192.                 exit(1);
     
193.         }
     
194. 
     
195.         if(-1 == (sock_fd = socket(PF_INET, SOCK_DGRAM, 0)))
     
196.         {
     
197.                 printf("socket\n");
     
198.                 exit(2);
     
199.         }
     
200. 
     
201.         myaddr.sin_family = AF_INET;
     
202.         myaddr.sin_port = htons(atoi(argv[1]));
     
203.         myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     
204. 
     
205.         if(-1 == bind(sock_fd, (struct sockaddr *)&myaddr, sizeof(struct sockaddr_in)))
     
206.         {
     
207.                 perror("bind");
     
208.                 exit(1);
     
209.         }
     
210. 
     
211.     while(1)
     
212.     {
     
213.         fprintf(stderr, "[%s-%d]receiving ... \n", __FILE__, __LINE__);
     
214.         recvlen = sizeof(struct sockaddr_in);
     
215.         bzero(buf, BUF_LEN);
     
216.         recv_num = recvfrom(sock_fd, (char *)buf, sizeof(buf), 0,
     
217.                 (struct sockaddr *)&src_addr, (socklen_t *)&recvlen);  
     
218. 
     
219.         fprintf(stderr, "[%s-%d]received ! \n", __FILE__, __LINE__);
     
220.         if(recv_num != -1)
     
221.         {
     
222.             iStrLen = strlen(buf);
     
223.             iStrLen = iStrLen > recv_num? iStrLen:recv_num;
     
224. 
     
225.             memcpy(value, buf, iStrLen);
     
226.             parsePacketFormatId(value, format);
     
227. 
     
228.             memcpy(value, buf, iStrLen);
     
229.             parseSrcImsi(value, srcImsi);
     
230. 
     
231.             memcpy(value, buf, iStrLen);
     
232.             parseDstImsi(value, dstImsi);
     
233. 
     
234.             if((strcmp(format, "data-send") == 0) || (strcmp(format, "data-ACK") == 0))
     
235.             {
     
236.                 fprintf(stderr, "[%s-%d]received data !\n", __FILE__, __LINE__);
     
237.                 //dstNode = searchImsi(&root, srcImsi, strcmp);
     
238.                 dstNode = searchImsi(&root, dstImsi, strcmp);
     
239.                 if(NULL != dstNode)
     
240.                 {
     
241.                     /** received data and find the destination node, forward data **/
     
242.                     fprintf(stderr, "[%s-%d]ready to forward data !\n", __FILE__, __LINE__);
     
243. 
     
244.                     dst_addr.sin_family = AF_INET;
     
245.                     dst_addr.sin_port = dstNode->port;
     
246.                     dst_addr.sin_addr.s_addr = inet_addr(dstNode->loginAddr);
     
247.                     //memcpy(&dst_addr, dstNode->ipAddr, sizeof(dst_addr));
     
248. 
     
249.                     //int ret = sendto(sock_fd, buf, BUF_LEN, 0, (struct sockaddr *)dstNode->ipAddr, sizeof(struct sockaddr_in));
     
250.                     int ret = sendto(sock_fd, buf, BUF_LEN, 0, (struct sockaddr *)&dst_addr, sizeof(struct sockaddr_in));
     
251.                     if(-1 == ret)
     
252.                     {
     
253.                         fprintf(stderr, "[%s-%d]send data error !\n", __FILE__, __LINE__);
     
254.                         exit(2);
     
255.                     }
     
256.                 #if 1
     
257.                     fprintf(stderr, "[%s-%d]forward data from [%s-%s:%u] to [%s-%s:%u]!\n",
     
258.                             __FILE__, __LINE__,
     
259.                             srcImsi,
     
260.                             inet_ntoa(src_addr.sin_addr),
     
261.                             src_addr.sin_port,
     
262.                             dstImsi,
     
263.                             inet_ntoa(dst_addr.sin_addr),
     
264.                             dst_addr.sin_port);
     
265.                 #endif                     
     
266.                 }
     
267.                 else
     
268.                 {
     
269.                     fprintf(stderr, "[%s-%d]destination[%s] is not on line!\n", __FILE__, __LINE__, dstImsi);
     
270.                 }
     
271.             }
     
272.             else if(strcmp(format, "login-request") == 0)       /** 登录请求，记录信息 **/
     
273.             {
     
274.                 /** received login message **/
     
275.                 srcNode = searchImsi(&root, srcImsi, strcmp);
     
276.                 if(NULL == srcNode)
     
277.                 {
     
278.                     /** create new node **/
     
279.                     srcNode = malloc(sizeof(struct clientNode_s));
     
280.                     if(NULL != srcNode)
     
281.                     {
     
282.                         bzero(srcNode, sizeof(struct clientNode_s));
     
283.                         memcpy(srcNode->clientImsi, srcImsi, CIMSI_LEN);
     
284.                         memcpy(srcNode->ipAddr, &src_addr, sizeof(src_addr));
     
285.                         srcNode->clientStatus = STATUS_LGINSUC;  /** 进入登录状态 **/
     
286. 
     
287.                         insertImsi(&root, srcNode, strcmp);
     
288. 
     
289.                         fprintf(stderr, "[%s-%d]Client Node[%s-%s:%u] created ok!\n",
     
290.                                 __FILE__, __LINE__,
     
291.                                 srcImsi,
     
292.                                 inet_ntoa(src_addr.sin_addr),
     
293.                                 src_addr.sin_port);
     
294. 
     
295.                     }
     
296.                     else
     
297.                     {
     
298.                         fprintf(stderr, "[%s-%d]malloc error. Client Node[%s] created failed!\n", __FILE__, __LINE__, srcImsi);
     
299.                     }
     
300.                 }
     
301.                 else
     
302.                 {   
     
303.                     srcNode->clientStatus = STATUS_LGINSUC;  /** 进入登录状态 **/
     
304. 
     
305.                     memcpy(srcNode->clientImsi, srcImsi, CIMSI_LEN);
     
306.                     memcpy(srcNode->ipAddr, &src_addr, sizeof(src_addr));
     
307.                     fprintf(stderr, "[%s-%d]Client[%s-%s:%u] login again !\n",
     
308.                             __FILE__, __LINE__,
     
309.                             srcImsi,
     
310.                             inet_ntoa(src_addr.sin_addr),
     
311.                             src_addr.sin_port);
     
312.                 }
     
313. 
     
314.                 setPacketFormat(buf, "login-ok");
     
315.                 int ret = sendto(sock_fd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&src_addr, sizeof(struct sockaddr_in));
     
316.                 if(-1 == ret)
     
317.                 {
     
318.                     perror("sendto");
     
319.                     fprintf(stderr, "[%s-%d]sendto error !!!!!!\n", __FILE__, __LINE__ );
     
320.                     //exit(2);
     
321.                 }
     
322.                 else
     
323.                 {
     
324.                     fprintf(stderr, "[%s-%d]send login ACK ok\n", __FILE__, __LINE__ );
     
325.                 }
     
326.                 /**
     
327.                  * store the client [IP:port]
     
328.                  **/
     
329.                 strcpy(srcNode->loginAddr, inet_ntoa(src_addr.sin_addr));
     
330.                 srcNode->port = src_addr.sin_port;
     
331.                            
     
332.                 fprintf(stderr, "[%s-%d]Client [%s: %s: %d] login \n",
     
333.                         __FILE__, __LINE__,
     
334.                         srcImsi,
     
335.                         inet_ntoa(((struct sockaddr_in *)(srcNode->ipAddr))->sin_addr),
     
336.                         ((struct sockaddr_in *)(srcNode->ipAddr))->sin_port);
     
337. 
     
338.             }
     
339.             else if(strcmp(format, "login-out") == 0)
     
340.             {
     
341.                 fprintf(stderr, "[%s-%d]Client[%s] logout!\n", __FILE__, __LINE__, srcImsi);
     
342.             }
     
343.             else
     
344.             {
     
345.                 fprintf(stderr, "[%s-%d]buf[%s] is unrecognized!!!\n", __FILE__, __LINE__, buf);
     
346.             }
     
347.         }
     
348.     }
     
349.         close(sock_fd);
     
350. 
     
351.     return  0;
     
352. }

复制代码

zhanglong71

在代码第257-264行之间加入打印节点信息的语句，两者显示的数据居然不一样！
显示结果如下：
[start.c-279]ready to forward data !
[22345678901-192.168.1.112:14228]
[start.c-293]forward data from [15343023711-175.1.95.93:25121] to [22345678901-175.1.95.93:14228]!
[22345678901-192.168.1.112:14228]

代码如下：

1.       
   
2. 　　　　　printNode(dstNode);
   
3.                     fprintf(stderr, "[%s-%d]forward data from [%s-%s:%u] to [%s-%s:%u]!\n",
   
4.                             __FILE__, __LINE__,
   
5.                             srcImsi,
   
6.                             inet_ntoa(src_addr.sin_addr),
   
7.                             src_addr.sin_port,
   
8.                             dstImsi,
   
9.                             inet_ntoa(((struct sockaddr_in *)(dstNode->ipAddr))->sin_addr),
   
10.                             ((struct sockaddr_in *)(dstNode->ipAddr))->sin_port);
    
11.                     printNode(dstNode);

复制代码

中间一次打印的dstNode的内容居然与前后两次的内容不一样！

其中的printNode如下：

1. void printNode(struct clientNode_s *clientNode)
   
2. {
   
3.     if(clientNode != NULL)
   
4.     {
   
5.         printf("[%s-%s:%u]\n",
   
6.                 clientNode->clientImsi,
   
7.                 inet_ntoa(((struct sockaddr_in *)(clientNode->ipAddr))->sin_addr),
   
8.                 ((struct sockaddr_in *)(clientNode->ipAddr))->sin_port);
   
9.     }
   
10.     else
    
11.     {
    
12.         printf("null\n");
    
13.     }
    
14. }
    

复制代码

---------------------------------------------------------------------------------
打印信息不同的问题已解决。很可能是这样的原因：不能在printf打印语句中两次调用inet_ntoa()。
原因是inet_ntoa()会将执行的结果保存在一个静态存贮区，并返回此存贮区的地址。两次调用inet_ntoa()后，inet_ntoa()可能返回的都是同一个地址，但其中的内容只是最后一次处理后的内容。
另一个问题作备忘：手机上的客户端收不到转发的数据。用wireshark抓包发现，转发往手机的数据包长度已经超过1500Bytes。实际的包内有用信息大小不超过200。通过计算包内字符串长度，并只发送该长度的数据，手机上可以正常显示收到的数据。具体修改L250的BUF_LEN改成strlen(buf) + 1。

jonas_mao

LZ good boy