P2P之UDP穿透NAT的原理與實現(實現部分)

1. // P2P程序服務端 
2. // 文件名：P2PServer.cpp
4. #include <windows.h>
5. #include "proto.h"
6. #include "Exception.h"
8. #pragma comment(lib, "ws2_32.lib")
10. UserList ClientList;
12. void InitWinSock()
13. {
14.     WSADATA wsaData;
16.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
17.     {
18.         printf("Windows sockets 2.2 startup") ;
19.         throw Exception("") ;
20.     }
21.     else
22.     {
23.         printf("Using %s (Status: %s)/n",
24.                 wsaData.szDescription, wsaData.szSystemStatus) ;
25.         printf("with API versions %d.%d to %d.%d/n/n",
26.                 LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion),
27.                 LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion)) ;
28.     }
29. }
31. SOCKET mksock(int type)
32. {
33.     SOCKET sock = socket(AF_INET, type, 0) ;
34.     if (sock < 0)
35.     {
36.         printf("create socket error") ;
37.         throw Exception("") ;
38.     }
39.     return sock;
40. }
42. stUserListNode GetUser(char *username)
43. {
44.     for(UserList::iterator UserIterator=ClientList.begin();
45.             UserIterator!=ClientList.end(); ++UserIterator)
46.     {
47.         if( strcmp( ((*UserIterator)->userName), username) == 0 )
48.             return *(*UserIterator) ;
49.     }
50.     throw Exception("not find this user") ;
51. }
53. int main(int argc, char* argv[])
54. {
55.     try
56.     {
57.         InitWinSock();
58.   
59.         SOCKET PrimaryUDP;
60.         PrimaryUDP = mksock(SOCK_DGRAM);
62.         sockaddr_in local;
63.         local.sin_family=AF_INET;
64.         local.sin_port = htons(SERVER_PORT); 
65.         local.sin_addr.s_addr = htonl(INADDR_ANY);
66.         int nResult = bind(PrimaryUDP, (sockaddr*)&local, sizeof(sockaddr)) ;
67.         if(nResult == SOCKET_ERROR)
68.             throw Exception("bind error");
70.         sockaddr_in sender;
71.         stMessage recvbuf;
72.         memset(&recvbuf, 0, sizeof(stMessage)) ;
74.   // 開始主循環.
75.   // 主循環負責下面幾件事情:
76.   // 一:讀取客戶端登陸和登出消息,記錄客戶列表
77.   // 二:轉發客戶p2p請求
78.         for(; ;)
79.         {
80.             int dwSender = sizeof(sender);
81.             int ret = recvfrom(PrimaryUDP, (char *)&recvbuf, sizeof(stMessage),
82.                     0, (sockaddr *)&sender, &dwSender) ;
83.             if(ret <= 0)
84.             {
85.                 printf("recv error");
86.                 continue;
87.             }
88.             else
89.             {
90.                 int messageType = recvbuf.iMessageType ;
91.                 switch(messageType)
92.                 {
93.                 case LOGIN:
94.                 {
95.                     //  將這個用戶的信息記錄到用戶列表中
96.                     printf("has a user login : %s/n", recvbuf.message.loginmember.userName);
97.                     stUserListNode *currentuser = new stUserListNode();
98.                     strcpy(currentuser->userName, recvbuf.message.loginmember.userName);
99.                     currentuser->ip = ntohl(sender.sin_addr.S_un.S_addr);
100.                     currentuser->port = ntohs(sender.sin_port);
101.       
102.                     ClientList.push_back(currentuser);
104.                     // 發送已經登陸的客戶信息
105.                     int nodecount = (int)ClientList.size();
106.                     sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0,
107.                             (const sockaddr*)&sender, sizeof(sender)) ;
108.                     for(UserList::iterator UserIterator=ClientList.begin();
109.                             UserIterator!=ClientList.end(); ++UserIterator)
110.                     {
111.                         sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode),
112.                                 0, (const sockaddr*)&sender, sizeof(sender)) ; 
113.                     }
115.                     break;
116.                 }
118.                 case LOGOUT:
119.                 {
120.                     // 將此客戶信息刪除
121.                     printf("has a user logout : %s/n", recvbuf.message.logoutmember.userName);
122.                     UserList::iterator removeiterator = NULL;
123.                     for(UserList::iterator UserIterator=ClientList.begin();
124.                             UserIterator!=ClientList.end(); ++UserIterator)
125.                     {
126.                         if( strcmp( ((*UserIterator)->userName),
127.                                 recvbuf.message.logoutmember.userName) == 0 )
128.                         {
129.                             removeiterator = UserIterator;
130.                             break;
131.                         }
132.                     }
133.                     if(removeiterator != NULL)
134.                         ClientList.remove(*removeiterator);
135.                     break;
136.                 }
138.                 case P2PTRANS:
139.                 {
140.                     // 某個客戶希望服務端向另外一個客戶發送一個打洞消息
141.                     printf("%s wants to p2p %s/n",inet_ntoa(sender.sin_addr),
142.                             recvbuf.message.translatemessage.userName);
143.                     stUserListNode node = GetUser(recvbuf.message.translatemessage.userName);
144.                     sockaddr_in remote;
145.                     remote.sin_family=AF_INET;
146.                     remote.sin_port= htons(node.port); 
147.                     remote.sin_addr.s_addr = htonl(node.ip);
149.                     in_addr tmp;
150.                     tmp.S_un.S_addr = htonl(node.ip);
151.                     printf("the address is %s,and port is %d/n",inet_ntoa(tmp), node.port);
153.                     stP2PMessage transMessage;
154.                     transMessage.iMessageType = P2PSOMEONEWANTTOCALLYOU;
155.                     transMessage.iStringLen = ntohl(sender.sin_addr.S_un.S_addr);
156.                     transMessage.Port = ntohs(sender.sin_port);
157.                         
158.                     sendto(PrimaryUDP,(const char*)&transMessage, sizeof(transMessage), 0,
159.                             (const sockaddr *)&remote, sizeof(remote)) ;
161.                     break;
162.                 }
163.     
164.                 case GETALLUSER:
165.                 {
166.                     int command = GETALLUSER;
167.                     sendto(PrimaryUDP, (const char*)&command, sizeof(int), 0,
168.                             (const sockaddr*)&sender, sizeof(sender)) ;
170.                     int nodecount = (int)ClientList.size();
171.                     sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0,
172.                             (const sockaddr*)&sender, sizeof(sender)) ;
174.                     for(UserList::iterator UserIterator=ClientList.begin();
175.                             UserIterator!=ClientList.end(); ++UserIterator)
176.                     {
177.                         sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode),
178.                                 0, (const sockaddr*)&sender, sizeof(sender)); 
179.                     }
180.                     break;
181.                 }
182.                 } //end switch
183.             } //end else
184.         } //end for
185.     } //end try
187.     catch(Exception &e)
188.     {
189.         printf(e.GetMessage()) ;
190.         return 1 ;
191.     }
193.     return 0;
194. }

 

1. // P2P 程序客戶端
2. // 文件名：P2PClient.c
4. #include <windows.h>
5. #include "proto.h"
6. #include "Exception.h"
7. #include <iostream>
9. #define COMMANDMAXC 256
10. #define MAXRETRY    5
12. #pragma comment(lib,"ws2_32.lib")
14. using namespace std;
16. UserList ClientList;
17. SOCKET PrimaryUDP;
18. char UserName[10];
19. char ServerIP[20];
20. bool RecvedACK;
22. void InitWinSock()
23. {
24.     WSADATA wsaData ;
26.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
27.     {
28.         printf("Windows sockets 2.2 startup");
29.         throw Exception("");
30.     }
31.     else
32.     {
33.         printf("Using %s (Status: %s)/n",
34.                 wsaData.szDescription, wsaData.szSystemStatus);
35.         printf("with API versions %d.%d to %d.%d/n/n",
36.                 LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion),
37.                 LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion));
38.     }
39. }
41. SOCKET mksock(int type)
42. {
43.     SOCKET sock = socket(AF_INET, type, 0);
44.     if (sock < 0)
45.     {
46.         printf("create socket error");
47.         throw Exception("");
48.     }
49.     return sock;
50. }
52. stUserListNode GetUser(char *username)
53. {
54.     for(UserList::iterator UserIterator=ClientList.begin();
55.             UserIterator!=ClientList.end(); ++UserIterator)
56.     {
57.         if( strcmp( ((*UserIterator)->userName), username) == 0 )
58.             return *(*UserIterator);
59.     }
60.     throw Exception("not find this user");
61. }
63. void BindSock(SOCKET sock)
64. {
65.     sockaddr_in sin;
66.     sin.sin_addr.S_un.S_addr = INADDR_ANY;
67.     sin.sin_family = AF_INET;
68.     sin.sin_port = 0;
70.     if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0)
71.         throw Exception("bind error") ;
72. }
74. void ConnectToServer(SOCKET sock,char *username, char *serverip)
75. {
76.     sockaddr_in remote;
77.     remote.sin_addr.S_un.S_addr = inet_addr(serverip);
78.     remote.sin_family = AF_INET;
79.     remote.sin_port = htons(SERVER_PORT);
81.     stMessage sendbuf;
82.     sendbuf.iMessageType = LOGIN;
83.     strncpy(sendbuf.message.loginmember.userName, username, 10);
85.     sendto(sock, (const char*)&sendbuf, sizeof(sendbuf), 0,
86.             (const sockaddr*)&remote, sizeof(remote)) ;
88.     int usercount;
89.     int fromlen = sizeof(remote);
90.     int iread = recvfrom(sock, (char *)&usercount, sizeof(int), 0,
91.             (sockaddr *)&remote, &fromlen);
92.     if(iread <= 0)
93.     {
94.         throw Exception("Login error/n");
95.     }
97.     // 登錄到服務端後，接收服務端發來的已經登錄的用戶的信息
98.     cout<<"Have "<<usercount<<" users logined server:"<<endl ;
99.     for(int i = 0;i<usercount;i++)
100.     {
101.         stUserListNode *node = new stUserListNode;
102.         recvfrom(sock, (char*)node, sizeof(stUserListNode), 0,
103.                 (sockaddr *)&remote, &fromlen);
104.         ClientList.push_back(node);
105.         cout<<"Username:"<<node->userName<<endl;
106.         in_addr tmp;
107.         tmp.S_un.S_addr = htonl(node->ip);
108.         cout<<"UserIP:"<<inet_ntoa(tmp)<<endl;
109.         cout<<"UserPort:"<<node->port<<endl;
110.         cout<<""<<endl;
111.     }
112. }
114. void OutputUsage()
115. {
116.     cout<<"You can input you command:/n"
117.         <<"Command Type:/"send/",/"exit/",/"getu/"/n"
118.         <<"Example : send Username Message/n"
119.         <<"          exit/n"
120.         <<"          getu/n"
121.         <<endl;
122. }
124. /* 這是主要的函數：發送一個消息給某個用戶(C)
125. *  流程：直接向某個用戶的外網IP發送消息，如果此前沒有聯繫過
126. *  那麼此消息將無法發送，發送端等待超時。
127. *  超時後，發送端將發送一個請求信息到服務端，
128. *  要求服務端發送給客戶C一個請求，請求C給本機發送打洞消息
129. *  以上流程將重複MAXRETRY次
130. */
131. bool SendMessageTo(char *UserName, char *Message)
132. {
133.     char realmessage[256];
134.     unsigned int UserIP;
135.     unsigned short UserPort;
136.     bool FindUser = false;
137.     for(UserList::iterator UserIterator=ClientList.begin();
138.             UserIterator!=ClientList.end(); ++UserIterator)
139.     {
140.         if( strcmp( ((*UserIterator)->userName), UserName) == 0 )
141.         {
142.             UserIP = (*UserIterator)->ip;
143.             UserPort = (*UserIterator)->port;
144.             FindUser = true;
145.         }
146.     }
148.     if(!FindUser)
149.         return false;
151.     strcpy(realmessage, Message) ;
152.     for(int i=0;i<MAXRETRY;i++)
153.     {
154.         RecvedACK = false;
156.         sockaddr_in remote;
157.         remote.sin_addr.S_un.S_addr = htonl(UserIP);
158.         remote.sin_family = AF_INET;
159.         remote.sin_port = htons(UserPort);
160.         stP2PMessage MessageHead;
161.         MessageHead.iMessageType = P2PMESSAGE;
162.         MessageHead.iStringLen = (int)strlen(realmessage)+1;
163.         int isend = sendto(PrimaryUDP, (const char *)&MessageHead,
164.                 sizeof(MessageHead), 0, (const sockaddr*)&remote,
165.                 sizeof(remote));
166.         isend = sendto(PrimaryUDP, (const char *)&realmessage,
167.                 MessageHead.iStringLen, 0, (const sockaddr*)&remote,
168.                 sizeof(remote));
169.   
170.         // 等待接收線程將此標記修改
171.         for(int j=0;j<10;j++)
172.         {
173.             if(RecvedACK)
174.                 return true;
175.             else
176.                 Sleep(300);
177.         }
179.   // 沒有接收到目標主機的迴應，認爲目標主機的端口映射沒有
180.   // 打開，那麼發送請求信息給服務器，要服務器告訴目標主機
181.   // 打開映射端口（UDP打洞）
182.         sockaddr_in server;
183.         server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
184.         server.sin_family = AF_INET;
185.         server.sin_port = htons(SERVER_PORT);
187.         stMessage transMessage;
188.         transMessage.iMessageType = P2PTRANS;
189.         strcpy(transMessage.message.translatemessage.userName, UserName);
191.         sendto(PrimaryUDP, (const char*)&transMessage, sizeof(transMessage),
192.                 0, (const sockaddr*)&server, sizeof(server)) ;
193.         Sleep(100);// 等待對方先發送信息。
194.     }
195.     return false ;
196. }
199. // 解析命令，暫時只有exit和send命令
200. // 新增getu命令，獲取當前服務器的所有用戶
201. void ParseCommand(char * CommandLine)
202. {
203.     if(strlen(CommandLine)<4)
204.         return;
205.     char Command[10];
206.     strncpy(Command, CommandLine, 4);
207.     Command[4]='/0';
209.     if(strcmp(Command,"exit")==0)
210.     {
211.         stMessage sendbuf;
212.         sendbuf.iMessageType = LOGOUT;
213.         strncpy(sendbuf.message.logoutmember.userName, UserName, 10);
214.         sockaddr_in server;
215.         server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
216.         server.sin_family = AF_INET;
217.         server.sin_port = htons(SERVER_PORT);
219.         sendto(PrimaryUDP,(const char*)&sendbuf, sizeof(sendbuf), 0,
220.                 (const sockaddr *)&server, sizeof(server)) ;
221.         shutdown(PrimaryUDP, 2);
222.         closesocket(PrimaryUDP);
223.         exit(0);
224.     }
225.     else if(strcmp(Command,"send")==0)
226.     {
227.         char sendname[20];
228.         char message[COMMANDMAXC];
229.         int i;
230.         for(i=5;;i++)
231.         {
232.             if(CommandLine[i]!=' ')
233.                 sendname[i-5]=CommandLine[i];
234.             else
235.             {
236.                 sendname[i-5]='/0';
237.                 break;
238.             }
239.         }
240.         strcpy(message, &(CommandLine[i+1]));
241.         if(SendMessageTo(sendname, message))
242.             printf("Send OK!/n");
243.         else 
244.             printf("Send Failure!/n");
245.     }
246.     else if(strcmp(Command,"getu")==0)
247.     {
248.         int command = GETALLUSER;
249.         sockaddr_in server;
250.         server.sin_addr.S_un.S_addr = inet_addr(ServerIP);
251.         server.sin_family = AF_INET;
252.         server.sin_port = htons(SERVER_PORT);
254.         sendto(PrimaryUDP,(const char*)&command, sizeof(command), 0,
255.                  (const sockaddr *)&server, sizeof(server)) ;
256.     }
257. }
259. // 接受消息線程
260. DWORD WINAPI RecvThreadProc(LPVOID lpParameter)
261. {
262.     sockaddr_in remote;
263.     int sinlen = sizeof(remote);
264.     stP2PMessage recvbuf;
265.     for(; ;)
266.     {
267.         int iread = recvfrom(PrimaryUDP, (char *)&recvbuf, sizeof(recvbuf),
268.                 0, (sockaddr *)&remote, &sinlen);
269.         if(iread<=0)
270.         {
271.             printf("recv error/n");
272.             continue;
273.         }
275.         switch(recvbuf.iMessageType)
276.         {
277.         case P2PMESSAGE:
278.         {
279.             // 接收到P2P的消息
280.             char *comemessage= new char[recvbuf.iStringLen];
281.             int iread1 = recvfrom(PrimaryUDP, comemessage, 256, 0,
282.                     (sockaddr *)&remote, &sinlen) ;
283.             comemessage[iread1-1] = '/0';
284.             if(iread1<=0)
285.                 throw Exception("Recv Message Error/n");
286.             else
287.             {
288.                 printf("Recv a Message:%s/n",comemessage);
289.      
290.                 stP2PMessage sendbuf;
291.                 sendbuf.iMessageType = P2PMESSAGEACK;
292.                 sendto(PrimaryUDP, (const char*)&sendbuf, sizeof(sendbuf), 0,
293.                         (const sockaddr*)&remote, sizeof(remote)) ;
294.             }
296.             delete []comemessage;
297.             break;
298.         }
300.         case P2PSOMEONEWANTTOCALLYOU:
301.         {
302.             // 接收到打洞命令，向指定的IP地址打洞
303.             printf("Recv p2someonewanttocallyou data/n");
304.             sockaddr_in remote;
305.             remote.sin_addr.S_un.S_addr = htonl(recvbuf.iStringLen);
306.             remote.sin_family = AF_INET;
307.             remote.sin_port = htons(recvbuf.Port);
309.             // UDP hole punching
310.             stP2PMessage message;
311.             message.iMessageType = P2PTRASH;
312.             sendto(PrimaryUDP, (const char *)&message, sizeof(message), 0,
313.                     (const sockaddr*)&remote, sizeof(remote));
314.                 
315.             break;
316.         }
318.         case P2PMESSAGEACK:
319.         {
320.             // 發送消息的應答
321.             RecvedACK = true;
322.             break;
323.         }
325.         case P2PTRASH:
326.         {
327.             // 對方發送的打洞消息，忽略掉。
328.             //do nothing ...
329.             printf("Recv p2ptrash data/n");
330.             break;
331.         }
333.         case GETALLUSER:
334.         {
335.             int usercount;
336.             int fromlen = sizeof(remote);
337.             int iread = recvfrom(PrimaryUDP, (char *)&usercount,
338.                     sizeof(int), 0, (sockaddr *)&remote, &fromlen);
339.             if(iread<=0)
340.             {
341.                 throw Exception("Login error/n");
342.             }
343.     
344.             ClientList.clear();
346.             cout<<"Have "<<usercount<<" users logined server:"<<endl;
347.             for(int i = 0;i<usercount;i++)
348.             {
349.                 stUserListNode *node = new stUserListNode;
350.                 recvfrom(PrimaryUDP, (char*)node, sizeof(stUserListNode),
351.                         0, (sockaddr *)&remote, &fromlen) ;
352.                 ClientList.push_back(node);
353.                 cout<<"Username:"<<node->userName<<endl;
354.                 in_addr tmp;
355.                 tmp.S_un.S_addr = htonl(node->ip);
356.                 cout<<"UserIP:"<<inet_ntoa(tmp)<<endl;
357.                 cout<<"UserPort:"<<node->port<<endl;
358.                 cout<<""<<endl;
359.             }
360.             break;
361.         }
362.         } //end switch
363.     } //end for
364. }
367. int main(int argc, char* argv[])
368. {
369.     try
370.     {
371.         InitWinSock();
372.   
373.         PrimaryUDP = mksock(SOCK_DGRAM);
374.         BindSock(PrimaryUDP);
376.         cout<<"Please input server ip:";
377.         cin>>ServerIP;
379.         cout<<"Please input your name:";
380.         cin>>UserName;
382.         ConnectToServer(PrimaryUDP, UserName, ServerIP);
384.         HANDLE threadhandle = CreateThread(NULL, 0, RecvThreadProc, NULL, NULL, NULL);
385.         CloseHandle(threadhandle);
386.         OutputUsage();
388.         for(; ;)
389.         {
390.             char Command[COMMANDMAXC];
391.             gets(Command);
392.             ParseCommand(Command);
393.         }
394.     }
395.     catch(Exception &e)
396.     {
397.         printf(e.GetMessage());
398.         return 1;
399.     }
400.     return 0;
401. }

 

1. // 異常類
2. // 文件名：Exception.h
4. #ifndef __HZH_Exception__
5. #define __HZH_Exception__
7. #define EXCEPTION_MESSAGE_MAXLEN 256
8. #include "string.h"
10. class Exception
11. {
12. private:
13.     char m_ExceptionMessage[EXCEPTION_MESSAGE_MAXLEN] ;
15. public:
16.     Exception(char *msg)
17.     {
18.         strncpy(m_ExceptionMessage, msg, EXCEPTION_MESSAGE_MAXLEN) ;
19.     }
21.     char *GetMessage()
22.     {
23.         return m_ExceptionMessage;
24.     }
25. };
27. #endif

 

1. // proto.h
2. // P2P 程序傳輸協議 
3. // 日期：2004-5-21
4. // 作者：shootingstars([email protected])
6. #pragma once
7. #include <list>
9. // 定義iMessageType的值
10. #define LOGIN 1
11. #define LOGOUT 2
12. #define P2PTRANS 3
13. #define GETALLUSER  4
15. // 服務器端口
16. #define SERVER_PORT 2280
18. // Client登錄時向服務器發送的消息
19. struct stLoginMessage
20. {
21.     char userName[10];
22.     char password[10];
23. } ;
25. // Client註銷時發送的消息
26. struct stLogoutMessage
27. {
28.     char userName[10];
29. };
31. // Client向服務器請求另外一個Client(userName)向自己方向發送UDP打洞消息
32. struct stP2PTranslate
33. {
34.     char userName[10];
35. };
37. // Client向服務器發送的消息格式
38. struct stMessage
39. {
40.     int iMessageType;
41.     union _message
42.     {
43.         stLoginMessage loginmember;
44.         stLogoutMessage logoutmember;
45.         stP2PTranslate translatemessage;
46.     }message ;
47. };
49. // 客戶節點信息
50. struct stUserListNode
51. {
52.     char userName[10];
53.     unsigned int ip;
54.     unsigned short port;
55. };
57. // Server向Client發送的消息
58. struct stServerToClient
59. {
60.     int iMessageType;
61.     union _message
62.     {
63.         stUserListNode user ;
64.     }message;
65. };
68. //======================================
69. // 下面的協議用於客戶端之間的通信
70. //======================================
71. #define P2PMESSAGE 100               // 發送消息
72. #define P2PMESSAGEACK 101            // 收到消息的應答
73. #define P2PSOMEONEWANTTOCALLYOU 102  // 服務器向客戶端發送的消息
74.                                      // 希望此客戶端發送一個UDP打洞包
75. #define P2PTRASH        103          // 客戶端發送的打洞包，接收端應該忽略此消息
77. // 客戶端之間發送消息格式
78. struct stP2PMessage
79. {
80.     int iMessageType;
81.     int iStringLen;         // or IP address
82.     unsigned short Port; 
83. };
85. using namespace std;
86. typedef list<stUserListNode *> UserList;