這個標題用了兩個頓號三個名稱，其實說得是同一個東西，只是網上有不同的說法罷了，另外好像還有人叫TCP打孔（我的朋友小妞聽說後問“要打孔啊，要不要我幫你去借個電鑽過來啊？”“~！·￥%……·！”）。
閒話少說，我們先看一下技術背景：
Internet的迅速發展以及IPv4 地址數量的限制使得網絡地址翻譯(NAT,Network Address Trans2lation)設備得到廣泛應用。NAT設備允許處於同一NAT後的多台主機共享一個公網(本文將處於同一NAT後的網絡稱為私網,處於NAT前的網絡稱為公網) IP 地址。一個私網IP 地址通過NAT設備與公網的其他主機通信。公網和私網IP地址域，如下圖所示：
廣域網與私網示意圖
一般來說都是由私網內主機（例如上圖中“電腦A-01”）主動發起連接，數據包經過NAT地址轉換後送給公網上的服務器（例如上圖中的“Server”），連接建立以後可雙向傳送數據，NAT設備允許私網內主機主動向公網內主機發送數據,但卻禁止反方向的主動傳遞，但在一些特殊的場合需要不同私網內的主機進行互聯（例如P2P軟件、網絡會議、視頻傳輸等），TCP穿越NAT的問題必須解決。網上關於UDP穿越NAT的文章很多，而且還有配套源代碼，但是我個人認為UDP數據雖然速度快，但是沒有保障，而且NAT為UDP准備的臨時端口號有生命周期的限制，使用起來不夠方便，在需要保證傳輸質量的應用上TCP連接還是首選（例如：文件傳輸）。
網上也有不少關於TCP穿越NAT（即TCP打洞）的介紹文章，但不幸我還沒找到相關的源代碼可以參考，我利用空余時間寫了一個可以實現TCP穿越NAT，讓不同的私網內主機建立直接的TCP通信的源代碼。
這裡需要介紹一下NAT的類型：
NAT設備的類型對於TCP穿越NAT,有著十分重要的影響,根據端口映射方式,NAT可分為如下4類,前3種NAT類型可統稱為cone類型。
(1)全克隆( Full Cone) : NAT把所有來自相同內部IP地址和端口的請求映射到相同的外部IP地址和端口。任何一個外部主機均可通過該映射發送IP包到該內部主機。
(2)限制性克隆(Restricted Cone) : NAT把所有來自相同內部IP地址和端口的請求映射到相同的外部IP地址和端口。但是,只有當內部主機先給IP地址為X的外部主機發送IP包,該外部主機才能向該內部主機發送IP包。
(3)端口限制性克隆( Port Restricted Cone) :端口限制性克隆與限制性克隆類似,只是多了端口號的限制,即只有內部主機先向IP地址為X,端口號為P的外部主機發送1個IP包,該外部主機才能夠把源端口號為P的IP包發送給該內部主機。
(4)對稱式NAT ( Symmetric NAT) :這種類型的NAT與上述3種類型的不同,在於當同一內部主機使用相同的端口與不同地址的外部主機進行通信時, NAT對該內部主機的映射會有所不同。對稱式NAT不保證所有會話中的私有地址和公開IP之間綁定的一致性。相反,它為每個新的會話分配一個新的端口號。
我們先假設一下：有一個服務器S在公網上有一個IP，兩個私網分別由NAT-A和NAT-B連接到公網，NAT-A後面有一台客戶端A，NAT-B後面有一台客戶端B，現在，我們需要借助S將A和B建立直接的TCP連接，即由B向A打一個洞，讓A可以沿這個洞直接連接到B主機，就好像NAT-B不存在一樣。
實現過程如下（請參照源代碼）：
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連接建立起來了。
整個實現過程靠文字恐怕很難講清楚，再加上我的語言表達能力很差（高考語文才考75分，總分150分，慚愧），所以只好用代碼來說明問題了。
// 服務器地址和端口號定義這兩個端口是固定的，服務器S啟動時就開始偵聽這兩個端口了。
#define SRV_TCP_MAIN_PORT 4000 // 服務器主連接的端口號
#define SRV_TCP_HOLE_PORT 8000 // 服務器響應客戶端打洞申請的端口號//
// 將新客戶端登錄信息發送給所有已登錄的客戶端，但不發送給自己
//
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\n", 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\n", hwFormatMessage(GetLastError()) );
goto finished;
}
UINT nOptValue = 1;
if ( !Sock.SetSockOpt ( SO_REUSEADDR, &nOptValue , sizeof(UINT) ) )
{
printf ( "SetSockOpt socket failed : %s\n", hwFormatMessage(GetLastError()) );
goto finished;
}
if ( !Sock.Bind ( 0 ) )
{
printf ( "Bind socket failed : %s\n", hwFormatMessage(GetLastError()) );
goto finished;
}
if ( !Sock.Connect ( g_pServerAddess, SRV_TCP_HOLE_PORT ) )
{
printf ( "Connect to [%s:%d] failed : %s\n", 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\n", 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\n" );
}
// 對方斷開連接了
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\n", 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\n", hwFormatMessage(GetLastError()) );
return FALSE;
}
if ( !Sock.Connect ( g_pServerAddess, SRV_TCP_HOLE_PORT ) )
{
printf ( "Connect to [%s:%d] failed : %s\n", 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\n", 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\n",
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 )\n", pSrvReqDirectConnectPkt->szInvitedIP,
pSrvReqDirectConnectPkt->nInvitedPort, pSrvReqDirectConnectPkt->dwInvitedID );
// 直接與客戶端B建立TCP連接，如果連接成功說明TCP打洞已經成功了。
CSocket Sock;
try
{
if ( !Sock.Socket () )
{
printf ( "Create socket failed : %s\n", hwFormatMessage(GetLastError()) );
return FALSE;
}
UINT nOptValue = 1;
if ( !Sock.SetSockOpt ( SO_REUSEADDR, &nOptValue , sizeof(UINT) ) )
{
printf ( "SetSockOpt socket failed : %s\n", hwFormatMessage(GetLastError()) );
return FALSE;
}
if ( !Sock.Bind ( g_nHolePort ) )
{
printf ( "Bind socket failed : %s\n", 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\n", hwFormatMessage(GetLastError()) );
}
if ( !Sock.Connect ( pSrvReqDirectConnectPkt->szInvitedIP, pSrvReqDirectConnectPkt->nInvitedPort ) )
{
printf ( "Connect to [%s:%d] failed : %s\n",
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 !!!\n",
pSrvReqDirectConnectPkt->szInvitedIP, pSrvReqDirectConnectPkt->nInvitedPort );
// 接收測試數據
printf ( "Receiving data ...\n" );
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\n", 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\n", szError );
return FALSE;
}
return TRUE;
}
在客戶端B打洞和偵聽准備好以後，服務器S回復客戶端A，客戶端A便直接與客戶端B的公網IP和端口進行連接，收發數據可以正常進行，為了測試是否真正地直接TCP連接，在數據收發過程中可以將服務器S強行終止，看是否數據收發還正常進行著。
程序執行步驟和方法：
要准備好環境，如果要真實測試的話需要用2個連到公網上的局域網，1台具有公網地址的電腦（為了協助我測試，小曹、小妞可費了不少心，我還霸占了他們家的電腦，在此表示感謝）。如果不是這樣的環境，程序執行可能會不正常，因為我暫時未做相同局域網的處理。
在具有公網地址的電腦上執行“TcpHoleSrv.exe”程序，假設這台電腦的公網IP地址是“129.208.12.38”。
在局域網A中的一台電腦上執行“TcpHoleClt-A.exe 129.208.12.38”
在局域網B中的一台電腦上執行“TcpHoleClt-B.exe 129.208.12.38”
程序執行成功後的界面：客戶端出現“Send Data”或者“Received Data”表示穿越NAT的TCP連接已經建立起來，數據收發已經OK。
服務器S
客戶端A
客戶端B
本代碼在Windows XP、一個天威局域網、一個電信局域網、一個電話撥號網絡中測試通過。
由於時間和水平的關系，代碼和文章寫得都不咋的，但願能起到拋磚引玉的作用。代碼部分只是實現了不同局域網之間的客戶端相互連接的問題，至於相同局域網內的主機或者其中一台客戶端本身就具有公網IP的問題這裡暫時未做考慮（因為那些處理實在太簡單了，比較一下掩碼或者公網IP就能判斷出來的）；另外程序的防錯性代碼重用性也做得不好，只是實現了功能，我想
本文配套源碼
