P2P技术基础: TCP打洞原理

落日映苍穹つ 2022-05-19 11:45 242阅读 0赞

原文链接：[https://blog.csdn.net/zhongguoren666/article/details/7489809][https_blog.csdn.net_zhongguoren666_article_details_7489809]

1. TCP协议通信：

现在有两台电脑A和B。在

假设A的地址为 192.168.0.100

假设B的地址为 192.168.0.102

A想给B发送一个字符串Hello,  如果A,B之间采用TCP协议，那么B收到Hello的过程是怎样的呢？

首先建立连接（3次握手成功之后，A和B的链接才算成功），然后A在给B发送数据。

如果A，B不在一个局域网内，A，B通信就需要打洞了。

假设A通过路由器S1上网。B通过路由器S2上网。

S1的外网IP:114.66.5.211          本地IP:192.168.0.1

S2的外网IP:14.153.27.47          本地IP:192.168.1.1

A的本地地址：192.168.0.100

B的本地地址：192.168.1.102

先暂时不说A和B的通信。我们来说一下A访问www.baidu.com

发送的源地址就是192.168.0.100  ，目标地址就是61.135.169.105（www.baidu.com经过DNS解析之后的地址）。

由于A的网内没有这个61.135.169.105地址，所以会把数据发给默认网关。这里的默认网关地址就是192.168.0.1（路由器S1的本地地址）

路由器S1拿到数据之后，会做什么事情呢？

他会做NAT映射，然后把之前的源地址192.168.0.100换成外网IP:114.66.5.211.

它是怎么映射的呢？

他会把192.168.0.1:22124转换成一个外网端口号。假设转换的端口号为1481。

22124为A电脑从哪个端口发出去的。1481为路由器计算出来的值，具体计算方法不需要知道，只需要知道这个值在NAT表中，是唯一的。

如下表：

![201544371156309.jpg][]

那么发给百度服务器的内容是 源IP为114.66.5.211:1481  目标IP为61.135.169.105:8080。 百度收到请求后，把源IP换成目标IP发送数据。

最终数据会传到路由器S1. 传到路由器之后，它开始根据端口号查NAT表。如果这个端口号在表中存在，那么就把src的值取出，并把数据中的目标地址

替换为src的值。这样A就收到了百度服务器的数据。

根据这个思路，可以得出，A,B要想通信，路由器S1必须知道，B在路由器S2中的映射。同样的，路由器S2必须知道A在S1中的映射。

平常做法是需要借助一台服务器T，A和B都去访问服务器T,那么T会得到A和B在各自路由器中的映射，然后把B在路由器S2中的映射发给S1。

把A在路由器S1中的映射发给S2.这样A和B就可以直接通信了。

2 关于TCP打洞技术  
  
建立穿越NAT设备的p2p的 TCP 连接只比UDP复杂一点点，TCP协议的“打洞”从协议层来看是与UDP  
的“打洞”过程非常相似的。尽管如此，基于TCP协议的打洞至今为止还没有被很好的理解，这也  
造成了对其提供支持的NAT设备不是很多。  
  
在NAT设备支持的前提下，基于TCP的“打洞”技术实际上与基于UDP的“打洞”技术一样快捷、可靠。实际上，只要NAT设备支持的话，基于TCP的p2p技术的健壮性将比基于UDP的技术的更强一些，因为TCP协议的状态机给出了一种标准的方法来精确的获取某个TCP session的生命期，而UDP协议则无法做到这一点。  
  
2.1 套接字和TCP端口的重用  
  
实现基于TCP协议的p2p“打洞”过程中，最主要的问题不是来自于TCP协议，而是来自于来自于应用程序的API接口。这是由于标准的伯克利(Berkeley)套接字的API是围绕着构建客户端/服务器程序而设计的，API允许TCP流套接字通过调用connect()函数来建立向外的连接，或者通过listen()和accept函数接受来自外部的连接。  
  
但是，TCP协议并没有象UDP那样的“同一个端口既可以向外连接，又能够接受来自外部的连接”的API。而且更糟的是，TCP的套接字通常仅允许建立1对1的响应，即应用程序在将一个套接字绑定到本地的一个端口以后，任何试图将第二个套接字绑定到该端口的操作都会失败。  
  
为了让TCP“打洞”能够顺利工作，我们需要使用一个本地的TCP端口来监听来自外部的TCP连接，同时建立多个向外的TCP连接。幸运的是，所有的主流操作系统都能够支持一个特殊的TCP套接字参数，通常叫做“SO\_REUSEADDR”，该参数允许应用程序将多个套接字绑定到本地的一个endpoint（只要所有要绑定的套接字都设置了SO\_REUSEADDR参数即可）。BSD系统引入了SO\_REUSEPORT参数,该参数用于区分  
端口重用还是地址重用，在这样的系统里面，上述所有的参数必须都设置才行。  
  
2.2 打开p2p的TCP流  
  
假定客户端A希望建立与B的TCP连接。我们像通常一样假定A和B已经与公网上的已知服务器S建立了TCP连接。服务器记录下来每个联入的客户端的公网和内网的endpoints，如同为UDP服务的时候一样从协议层来看，TCP“打洞”与UDP“打洞”是几乎完全相同的过程:  
  
1)、 S启动两个网络侦听，一个叫【主连接】侦听，一个叫【协助打洞】的侦听。

2)、 A和B分别与S的【主连接】保持联系。

3)、当A需要和B建立直接的TCP连接时，首先连接S的【协助打洞】端口，并发送协助连接申请。同时在该端口号上启动侦听。注意由于要在相同的网络终端上绑定到不同的套接字上，所以必须为这些套接字设置 SO\_REUSEADDR 属性（即允许重用），否则侦听会失败。

4)、 S的【协助打洞】连接收到A的申请后通过【主连接】通知B，并将A经过NAT-A转换后的公网IP地址和端口等信息告诉B。

5)、 B收到S的连接通知后首先与S的【协助打洞】端口连接，随便发送一些数据后立即断开，这样做的目的是让S能知道B经过NAT-B转换后的公网IP和端口号。

6)、 B尝试与A的经过NAT-A转换后的公网IP地址和端口进行connect，根据不同的路由器会有不同的结果，有些路由器在这个操作就能建立连接（例如我用的TPLink R402），大多数路由器对于不请自到的SYN请求包直接丢弃而导致connect失败，但NAT-A会纪录此次连接的源地址和端口号，为接下来真正的连接做好了准备，这就是所谓的打洞，即B向A打了一个洞，下次A就能直接连接到B刚才使用的端口号了。

7)、客户端B打洞的同时在相同的端口上启动侦听。B在一切准备就绪以后通过与S的【主连接】回复消息“我已经准备好”，S在收到以后将B经过NAT-B转换后的公网IP和端口号告诉给A。

8)、 A收到S回复的B的公网IP和端口号等信息以后，开始连接到B公网IP和端口号，由于在步骤6中B曾经尝试连接过A的公网IP地址和端口，NAT-A纪录了此次连接的信息，所以当A主动连接B时，NAT-B会认为是合法的SYN数据，并允许通过，从而直接的TCP连接建立起来了。

![080210075232.png][]

图7

**与UDP不同的是，使用UDP协议的每个客户端只需要一个套接字即可完成与服务器S通信，  
并同时与多个p2p客户端通信的任务；而TCP客户端必须处理多个套接字绑定到同一个本地  
TCP端口的问题，如图7所示。  
  
现在来看更加实际的一种情景：A与B分别位于不同的NAT设备后面。如同使用UDP协议进行“打洞”  
操作遇到的问题一样，TCP的“打洞”操作也会遇到内网的IP与“伪”公网IP重复造成连接失败或者错误连接之类的问题。  
  
客户端向彼此公网endpoint发起连接的操作，会使得各自的NAT设备打开新的“洞”以允许A与B的  
TCP数据通过。如果NAT设备支持TCP“打洞”操作的话，一个在客户端之间的基于TCP协议的流  
通道就会自动建立起来。如果A向B发送的第一个SYN包发到了B的NAT设备，而B在此前没有向  
A发送SYN包，B的NAT设备会丢弃这个包，这会引起A的“连接失败”或“无法连接”问题。而此时，由于A已经向B发送过SYN包，B发往A的SYN包将被看作是由A发往B的包的回应的一部分，  
所以B发往A的SYN包会顺利地通过A的NAT设备，到达A，从而建立起A与B的p2p连接。  
  
2.3 从应用程序的角度来看TCP“打洞”  
  
从应用程序的角度来看，在进行TCP“打洞”的时候都发生了什么呢？**

**假定A首先向B发出SYN包，该包发往B的公网endpoint，并且被B的NAT设备丢弃，但是B发往A的公网endpoint的SYN包则通过A的NAT到达了A，然后，会发生以下的两种结果中的一种，具体是哪一种取决于操作系统对TCP协议的实现：  
  
（1）A的TCP实现会发现收到的SYN包就是其发起连接并希望联入的B的SYN包，通俗一点来说  
就是“说曹操，曹操到”的意思，本来A要去找B，结果B自己找上门来了。A的TCP协议栈因此  
会把B做为A向B发起连接connect的一部分，并认为连接已经成功。程序A调用的异步connect()  
函数将成功返回，A的listen()等待从外部联入的函数将没有任何反映。此时，B联入A的操作  
在A程序的内部被理解为A联入B连接成功，并且A开始使用这个连接与B开始p2p通信。  
  
由于A收到的SYN包中不包含A需要的ACK数据，因此，A的TCP将用SYN-ACK包回应B的公网endpoint，  
并且将使用先前A发向B的SYN包一样的序列号。一旦B的TCP收到由A发来的SYN-ACK包，则把自己  
的ACK包发给A，然后两端建立起TCP连接。简单地说，第一种，就是即使A发往B的SYN包被B的NAT  
丢弃了，但是由于B发往A的包到达了A。结果是，A认为自己连接成功了，B也认为自己连接成功  
了，不管是谁成功了，总之连接是已经建立起来了。  
  
（2）另外一种结果是，A的TCP实现没有像（1）中所讲的那么“智能”，它没有发现现在联入的B  
就是自己希望联入的。就好比在机场接人，明明遇到了自己想要接的人却不认识，误认为是其它  
的人，安排别人给接走了，后来才知道是自己错过了机会，但是无论如何，人已经接到了任务  
已经完成了。然后，A通过常规的listen()函数和accept()函数得到与B的连接，而由A发起的向  
B的公网endpoint的连接会以失败告终。尽管A向B的连接失败，A仍然得到了B发起的向A的连接，  
等效于A与B之间已经联通，不管中间过程如何，A与B已经连接起来了，结果是A和B的基于TCP协议  
的p2p连接已经建立起来了。  
  
第一种结果适用于基于BSD的操作系统对于TCP的实现，而第二种结果更加普遍一些，多数linux和  
windows系统都会按照第二种结果来处理。**

**代码：**

`// 服务器地址和端口号定义 #define SRV_TCP_MAIN_PORT　　　　4000　　// 服务器主连接的端口号 #define SRV_TCP_HOLE_PORT　　　　8000　　// 服务器响应客户端打洞申请的端口号`

这两个端口是固定的，服务器S启动时就开始侦听这两个端口了。

`// // 将新客户端登录信息发送给所有已登录的客户端，但不发送给自己 // BOOL SendNewUserLoginNotifyToAll (LPCTSTR lpszClientIP, UINT nClientPort, DWORD dwID) { 　　ASSERT ( lpszClientIP && nClientPort > 0 ); 　　g_CSFor_PtrAry_SockClient.Lock(); 　　for ( int i=0; i<g_PtrAry_SockClient.GetSize(); i++ ) 　　{ 　　　　CSockClient *pSockClient = (CSockClient*)g_PtrAry_SockClient.GetAt(i); 　　　　if ( pSockClient && pSockClient->m_bMainConn && pSockClient->m_dwID > 0 && pSockClient->m_dwID != dwID ) 　 　　　{ 　　　　　　if (!pSockClient->SendNewUserLoginNotify (lpszClientIP, nClientPort, dwID)) 　　　　　　{ 　　　　　　　　g_CSFor_PtrAry_SockClient.Unlock(); 　　　　　　　　return FALSE; 　　　　　　} 　 　　　} 　　} 　　g_CSFor_PtrAry_SockClient.Unlock (); 　　return TRUE; }`

当有新的客户端连接到服务器时，服务器负责将该客户端的信息（IP地址、端口号）发送给其他客户端。

`// // 执行者：客户端A // 有新客户端B登录了，我（客户端A）连接服务器端口 SRV_TCP_HOLE_PORT ，申请与B建立直接的TCP连接 // BOOL Handle_NewUserLogin ( CSocket &MainSock, t_NewUserLoginPkt *pNewUserLoginPkt ) { 　　printf ( "New user ( %s:%u:%u ) login server", pNewUserLoginPkt->szClientIP, 　　　　 pNewUserLoginPkt->nClientPort, pNewUserLoginPkt->dwID ); 　　BOOL bRet = FALSE; 　　DWORD dwThreadID = 0; 　　t_ReqConnClientPkt ReqConnClientPkt; 　　CSocket Sock; 　　CString csSocketAddress; 　  char    szRecvBuffer[NET_BUFFER_SIZE] = {0}; 　　int     nRecvBytes = 0; 　　// 创建打洞Socket，连接服务器协助打洞的端口号 SRV_TCP_HOLE_PORT： 　　try 　　{ 　　　　if ( !Sock.Socket () ) 　　　　{ 　　　　　　printf ( "Create socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　goto finished; 　　　　}  　　　 UINT nOptValue = 1; 　　　　if ( !Sock.SetSockOpt ( SO_REUSEADDR, &nOptValue , sizeof(UINT) ) ) 　　　　{ 　　　　　　printf ( "SetSockOpt socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　 goto finished; 　　　　} 　　　　if ( !Sock.Bind ( 0 ) ) 　　　　{ 　　　　　  printf ( "Bind socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　goto finished; 　　　　} 　　　　if ( !Sock.Connect ( g_pServerAddess, SRV_TCP_HOLE_PORT ) ) 　　　　{ 　　　　　　printf ( "Connect to [%s:%d] failed : %s", g_pServerAddess, 　　　　　　　　 SRV_TCP_HOLE_PORT, hwFormatMessage(GetLastError()) ); 　　　　　　goto finished; 　　　　} 　　} 　　catch ( CException e ) 　　{ 　　　　char szError[255] = {0}; 　　　　e.GetErrorMessage( szError, sizeof(szError) ); 　　　　printf ( "Exception occur, %s", szError ); 　　　　goto finished; 　　} 　　g_pSock_MakeHole = &Sock; 　　ASSERT ( g_nHolePort == 0 ); 　　VERIFY ( Sock.GetSockName ( csSocketAddress, g_nHolePort ) ); 　　// 创建一个线程来侦听端口 g_nHolePort 的连接请求 　　dwThreadID = 0; 　　g_hThread_Listen = ::CreateThread ( NULL, 0, ::ThreadProc_Listen, LPVOID(NULL), 0, &dwThreadID ); 　　if (!HANDLE_IS_VALID(g_hThread_Listen) ) return FALSE; 　　Sleep ( 3000 ); 　 　// 我（客户端A）向服务器协助打洞的端口号 SRV_TCP_HOLE_PORT 发送申请，`

`    // 希望与新登录的客户端B建立连接 　　 // 服务器会将我的打洞用的外部IP和端口号告诉客户端B：  　　ASSERT ( g_WelcomePkt.dwID > 0 ); 　 　ReqConnClientPkt.dwInviterID = g_WelcomePkt.dwID; 　　 ReqConnClientPkt.dwInvitedID = pNewUserLoginPkt->dwID; 　 　if ( Sock.Send ( &ReqConnClientPkt, sizeof(t_ReqConnClientPkt) ) != sizeof(t_ReqConnClientPkt) ) 　　　　goto finished; 　　// 等待服务器回应，将客户端B的外部IP地址和端口号告诉我（客户端A）： 　　nRecvBytes = Sock.Receive ( szRecvBuffer, sizeof(szRecvBuffer) ); 　　if ( nRecvBytes > 0 ) 　 　{ 　　　　ASSERT ( nRecvBytes == sizeof(t_SrvReqDirectConnectPkt) ); 　  　　PACKET_TYPE *pePacketType = (PACKET_TYPE*)szRecvBuffer; 　　　　ASSERT ( pePacketType && *pePacketType == PACKET_TYPE_TCP_DIRECT_CONNECT ); 　　　　Sleep ( 1000 ); 　　　　Handle_SrvReqDirectConnect ( (t_SrvReqDirectConnectPkt*)szRecvBuffer ); 　 　　 printf ( "Handle_SrvReqDirectConnect end" ); 　　} 　　// 对方断开连接了 　　else 　　{ 　　　　goto finished; 　　} 　　 　　bRet = TRUE; finished: 　　g_pSock_MakeHole = NULL; 　　return bRet; }`

这里假设客户端A先启动，当客户端B启动后客户端A将收到服务器S的新客户端登录的通知，并得到客户端B的公网IP和端口，客户端A启动线程连接S的【协助打洞】端口(本地端口号可以用GetSocketName()函数取得，假设为M)，请求S协助TCP打洞，然后启动线程侦听该本地端口（前面假设的M）上的连接请求，然后等待服务器的回应。

`// // 客户端A请求我（服务器）协助连接客户端B，这个包应该在打洞Socket中收到 // BOOL CSockClient::Handle_ReqConnClientPkt(t_ReqConnClientPkt *pReqConnClientPkt) { 　　ASSERT ( !m_bMainConn ); 　　CSockClient *pSockClient_B = FindSocketClient ( pReqConnClientPkt->dwInvitedID );   　if ( !pSockClient_B ) return FALSE; 　　printf ( "%s:%u:%u invite %s:%u:%u connection",`

`        m_csPeerAddress, m_nPeerPort, m_dwID,`

`　　　　 pSockClient_B->m_csPeerAddress,`

`        pSockClient_B->m_nPeerPort,`

`        pSockClient_B->m_dwID ); 　　// 客户端A想要和客户端B建立直接的TCP连接，服务器负责将A的外部IP和端口号告诉给B: 　　t_SrvReqMakeHolePkt SrvReqMakeHolePkt; 　　SrvReqMakeHolePkt.dwInviterID = pReqConnClientPkt->dwInviterID;  　 SrvReqMakeHolePkt.dwInviterHoleID = m_dwID; 　  SrvReqMakeHolePkt.dwInvitedID = pReqConnClientPkt->dwInvitedID; 　　STRNCPY_CS ( SrvReqMakeHolePkt.szClientHoleIP, m_csPeerAddress ); 　　SrvReqMakeHolePkt.nClientHolePort = m_nPeerPort; 　　if ( pSockClient_B->SendChunk ( &SrvReqMakeHolePkt, sizeof(t_SrvReqMakeHolePkt), 0 ) != sizeof(t_SrvReqMakeHolePkt) ) 　　　 　return FALSE; 　　// 等待客户端B打洞完成，完成以后通知客户端A直接连接客户端外部IP和端口号 　　if ( !HANDLE_IS_VALID(m_hEvtWaitClientBHole) ) 　　　　return FALSE; 　　if ( WaitForSingleObject ( m_hEvtWaitClientBHole, 6000*1000 ) == WAIT_OBJECT_0 ) 　　{ 　　　　if ( SendChunk (&m_SrvReqDirectConnectPkt, sizeof(t_SrvReqDirectConnectPkt), 0) 　 　　　　　　　== sizeof(t_SrvReqDirectConnectPkt) ) 　　　　　　return TRUE; 　　 } 　　return FALSE; }`

服务器S收到客户端A的协助打洞请求后通知客户端B，要求客户端B向客户端A打洞，即让客户端B尝试与客户端A的公网IP和端口进行connect。

`// // 执行者：客户端B // 处理服务器要我（客户端B）向另外一个客户端（A）打洞，打洞操作在线程中进行。 // 先连接服务器协助打洞的端口号 SRV_TCP_HOLE_PORT ，通过服务器告诉客户端A我（客户端B）的外部IP地址和端口号，然后启动线程进行打洞， // 客户端A在收到这些信息以后会发起对我（客户端B）的外部IP地址和端口号的连接（这个连接在客户端B打洞完成以后进行，所以 // 客户端B的NAT不会丢弃这个SYN包，从而连接能建立） // BOOL Handle_SrvReqMakeHole(CSocket &MainSock, t_SrvReqMakeHolePkt *pSrvReqMakeHolePkt) { 　 　ASSERT ( pSrvReqMakeHolePkt ); 　　// 创建Socket，连接服务器协助打洞的端口号 SRV_TCP_HOLE_PORT，连接建立以后发送一个断开连接的请求给服务器，然后连接断开 　　// 这里连接的目的是让服务器知道我（客户端B）的外部IP地址和端口号，以通知客户端A 　　CSocket Sock; 　　try 　 　{ 　　　　if ( !Sock.Create () ) 　　　　{ 　　　　　　printf ( "Create socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　return FALSE; 　　　　} 　　　　if ( !Sock.Connect ( g_pServerAddess, SRV_TCP_HOLE_PORT ) ) 　　　　{ 　　　　　　printf ( "Connect to [%s:%d] failed : %s", g_pServerAddess, 　　　　　　　　SRV_TCP_HOLE_PORT, hwFormatMessage(GetLastError()) ); 　　　　　　return FALSE; 　　　　} 　　 } 　　catch ( CException e ) 　　{ 　　　　char szError[255] = {0};   　　　e.GetErrorMessage( szError, sizeof(szError) ); 　　　　printf ( "Exception occur, %s", szError ); 　　　　return FALSE; 　　} 　　CString csSocketAddress; 　　ASSERT ( g_nHolePort == 0 ); 　　VERIFY ( Sock.GetSockName ( csSocketAddress, g_nHolePort ) ); 　　// 连接服务器协助打洞的端口号 SRV_TCP_HOLE_PORT，发送一个断开连接的请求，然后将连接断开，服务器在收到这个包的时候也会将 　 　// 连接断开 　　 t_ReqSrvDisconnectPkt ReqSrvDisconnectPkt; 　　 ReqSrvDisconnectPkt.dwInviterID = pSrvReqMakeHolePkt->dwInvitedID; 　 　ReqSrvDisconnectPkt.dwInviterHoleID = pSrvReqMakeHolePkt->dwInviterHoleID; 　　 ReqSrvDisconnectPkt.dwInvitedID = pSrvReqMakeHolePkt->dwInvitedID; 　 　ASSERT ( ReqSrvDisconnectPkt.dwInvitedID == g_WelcomePkt.dwID ); 　　 if ( Sock.Send ( &ReqSrvDisconnectPkt, sizeof(t_ReqSrvDisconnectPkt) ) != sizeof(t_ReqSrvDisconnectPkt) ) 　　　　return FALSE; 　　 Sleep ( 100 ); 　　 Sock.Close (); 　　 // 创建一个线程来向客户端A的外部IP地址、端口号打洞 　　 t_SrvReqMakeHolePkt *pSrvReqMakeHolePkt_New = new t_SrvReqMakeHolePkt; 　 　if ( !pSrvReqMakeHolePkt_New ) return FALSE; 　　 memcpy (pSrvReqMakeHolePkt_New, pSrvReqMakeHolePkt, sizeof(t_SrvReqMakeHolePkt)); 　　 DWORD dwThreadID = 0; 　　 g_hThread_MakeHole = ::CreateThread ( NULL, 0, ::ThreadProc_MakeHole, 　　　　         LPVOID(pSrvReqMakeHolePkt_New), 0, &dwThreadID ); 　　 if (!HANDLE_IS_VALID(g_hThread_MakeHole) )`

`         return FALSE; 　　// 创建一个线程来侦听端口 g_nHolePort 的连接请求 　　 dwThreadID = 0; 　 　g_hThread_Listen = ::CreateThread ( NULL, 0, ::ThreadProc_Listen, LPVOID(NULL), 0, &dwThreadID ); 　　 if (!HANDLE_IS_VALID(g_hThread_Listen) )`

`         return FALSE; 　　`

`     // 等待打洞和侦听完成 　 　HANDLE hEvtAry[] = { g_hEvt_ListenFinished, g_hEvt_MakeHoleFinished }; 　 　if ( ::WaitForMultipleObjects ( LENGTH(hEvtAry), hEvtAry, TRUE, 30*1000 ) == WAIT_TIMEOUT ) 　　　　return FALSE; 　　 t_HoleListenReadyPkt HoleListenReadyPkt; 　　 HoleListenReadyPkt.dwInvitedID = pSrvReqMakeHolePkt->dwInvitedID; 　　 HoleListenReadyPkt.dwInviterHoleID = pSrvReqMakeHolePkt->dwInviterHoleID; 　　 HoleListenReadyPkt.dwInvitedID = pSrvReqMakeHolePkt->dwInvitedID; 　 　if ( MainSock.Send ( &HoleListenReadyPkt, sizeof(t_HoleListenReadyPkt) ) != sizeof(t_HoleListenReadyPkt) ) 　　{ 　 　　　printf ( "Send HoleListenReadyPkt to %s:%u failed : %s",     　　　　 g_WelcomePkt.szClientIP, g_WelcomePkt.nClientPort, 　　　　　　 hwFormatMessage(GetLastError()) ); 　　　　return FALSE; 　　} 　　 　 　return TRUE; }`

客户端B收到服务器S的打洞通知后，先连接S的【协助打洞】端口号（本地端口号可以用 GetSocketName()函数取得，假设为X），启动线程尝试连接客户端A的公网IP和端口号，根据路由器不同，连接情况各异，如果运气好直接连接就成功了，即使连接失败，但打洞便完成了。同时还要启动线程在相同的端口（即与S的【协助打洞】端口号建立连接的本地端口号X）上侦听到来的连接，等待客户端A直接连接该端口号。

`// // 执行者：客户端A // 服务器要求主动端（客户端A）直接连接被动端（客户端B）的外部IP和端口号 // BOOL Handle_SrvReqDirectConnect ( t_SrvReqDirectConnectPkt *pSrvReqDirectConnectPkt ) { 　　ASSERT ( pSrvReqDirectConnectPkt ); 　 　printf ( "You can connect direct to ( IP:%s　PORT:%d　ID:%u )",`

`        pSrvReqDirectConnectPkt->szInvitedIP, 　　　　 pSrvReqDirectConnectPkt->nInvitedPort, pSrvReqDirectConnectPkt->dwInvitedID ); 　　// 直接与客户端B建立TCP连接，如果连接成功说明TCP打洞已经成功了。 　　CSocket Sock; 　　try 　　{ 　 　　　if ( !Sock.Socket () ) 　　　　{ 　　　　　　printf ( "Create socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　return FALSE; 　　　　} 　　　　UINT nOptValue = 1; 　　　　if ( !Sock.SetSockOpt ( SO_REUSEADDR, &nOptValue , sizeof(UINT) ) ) 　　　　{ 　　　　　　 printf( "SetSockOpt socket failed : %s", hwFormatMessage(GetLastError())); 　　　　　　return FALSE; 　　　　} 　　 　 if ( !Sock.Bind ( g_nHolePort ) ) 　　　　{ 　　　　　　printf ( "Bind socket failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　return FALSE; 　　　　} 　　　　for ( int ii=0; ii<100; ii++ ) 　　　　{ 　 　　　　　if ( WaitForSingleObject ( g_hEvt_ConnectOK, 0 ) == WAIT_OBJECT_0 ) 　 　　　　　　　break; 　　　　　　DWORD dwArg = 1; 　　　　　　if ( !Sock.IOCtl ( FIONBIO, &dwArg ) ) 　　　　　　{ 　　　　　　　　printf ( "IOCtl failed : %s", hwFormatMessage(GetLastError()) ); 　　　　　　} 　　　　　　if ( !Sock.Connect ( pSrvReqDirectConnectPkt->szInvitedIP, pSrvReqDirectConnectPkt->nInvitedPort ) ) 　　　　　　{ 　　　　　　　　 printf ( "Connect to [%s:%d] failed : %s", 　　　　　　　　　　 pSrvReqDirectConnectPkt->szInvitedIP, 　　　　　　　　　　 pSrvReqDirectConnectPkt->nInvitedPort, 　　　　　　　　　　 hwFormatMessage(GetLastError()) ); 　　　　　　　　　Sleep (100); 　　　　　　} 　 　　　　 else`

`                break; 　　　　} 　　　　if ( WaitForSingleObject ( g_hEvt_ConnectOK, 0 ) != WAIT_OBJECT_0 ) 　　　　{ 　　　　　　if ( HANDLE_IS_VALID ( g_hEvt_ConnectOK ) )`

`              SetEvent ( g_hEvt_ConnectOK ); 　 　　　　 printf ( "Connect to [%s:%d] successfully !!!",     　　　　　　 pSrvReqDirectConnectPkt->szInvitedIP,`

`                pSrvReqDirectConnectPkt->nInvitedPort ); 　　　　　　 　　　　　　// 接收测试数据 　 　　　　　printf ( "Receiving data ..." ); 　　　　　　char szRecvBuffer[NET_BUFFER_SIZE] = {0}; 　　　　　　int nRecvBytes = 0; 　　　  　　for ( int i=0; i<1000; i++ ) 　　　　　　{ 　　　　　　　　nRecvBytes = Sock.Receive ( szRecvBuffer, sizeof(szRecvBuffer) ); 　　　　　　　　if ( nRecvBytes > 0 ) 　　　　　　　　{ 　　　　　　　　　　printf ( "-->>> Received Data : %s", szRecvBuffer ); 　　　　　　　　　　memset ( szRecvBuffer, 0, sizeof(szRecvBuffer) ); 　　　　　　　　　　SLEEP_BREAK ( 1 ); 　 　　　　　　　} 　　　　　　　　else 　　　　　　　　{ 　　　　　　　　　　SLEEP_BREAK ( 300 ); 　 　　　　　　　} 　　　　　　} 　　　　} 　　} 　　catch ( CException e ) 　　{ 　  　 char szError[255] = {0}; 　　　　e.GetErrorMessage( szError, sizeof(szError) ); 　　　　printf ( "Exception occur, %s", szError );   　　　return FALSE; 　　} 　　return TRUE; }`

在客户端B打洞和侦听准备好以后，服务器S回复客户端A，客户端A便直接与客户端B的公网IP和端口进行连接，收发数据可以正常进行，为了测试是否真正地直接TCP连接，在数据收发过程中可以将服务器S强行终止，看是否数据收发还正常进行着。

[https_blog.csdn.net_zhongguoren666_article_details_7489809]: https://blog.csdn.net/zhongguoren666/article/details/7489809
[201544371156309.jpg]: /images/20220519/76bf2b77b5314add8ca49ab3e757fe1d.png
[080210075232.png]: http://blogimg.chinaunix.net/blog/upfile2/080210075232.png