分类: LINUX
2011-01-17 21:17:00
闲话少说,我们先看一下技术背景:
Internet的迅速发展以及IPv4 地址数量的限制使得网络地址翻译(NAT,Network Address
Trans2lation)设备得到广泛应用。NAT设备允许处于同一NAT后的多台主机共享一个公网(本文将处于同一NAT后的网络称为私网,处于
NAT前的网络称为公网) IP 地址。一个私网IP 地址通过NAT设备与公网的其他主机
广域网与私网示意图
一般来说都是由私网内主机(例如上图中“电脑A-01”)主动发起连接,数据包经过NAT地址转换后送给公网上的
网上也有不少关于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种类型的不同,在于当同一内部主机使用相同的端口与不同地址的外部主机进行
我们先假设一下:有一个
实现过程如下(请参照源代码):
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 // 服务器响应客户端打洞申请的端口号//
当
有新的客户端连接到服务器时,服务器负责将该客户端的信息(IP地址、端口号)发送给其他客户端。
// 将新客户端登录信息发送给所有已登录的客户端,但不发送给自己
//
BOOL
SendNewUserLoginNotifyToAll ( LPCTSTR lpszClientIP, UINT nClientPort,
DWORD dwID )
{
ASSERT ( lpszClientIP && nClientPort >
0 );
g_CSFor_PtrAry_SockClient.Lock();
for ( int i=0;
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;
}//
这
里假设客户端A先启动,当客户端B启动后客户端A将收到服务器S的新客户端登录的通知,并得到客户端B的公网IP和端口,客户端A启动线程连接S的【协助
打洞】端口(本地端口号可以用GetSocketName()函数取得,假设为M),请求S协助TCP打洞,然后启动线程侦听该本地端口(前面假设的M)
上的连接请求,然后等待服务器的回应。
// 执行者:客户端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;
}//
服务器S收到客户端A的协助打洞请求后通知客户端B,要求客户端B向客户端A打洞,即
让客户端B尝试与客户端A的公网IP和端口进行connect。
// 客户端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;
}//
客户端B收到服务器S的打洞通知后,先连接S的【协助打洞】端口号(本地端口号可以用
GetSocketName()函数取得,假设为X),启动线程尝试连接客户端A的公网IP和端口号,根据路由器不同,连接情况各异,如果运气好直接连接
就成功了,即使连接失败,但打洞便完成了。同时还要启动线程在相同的端口(即与S的【协助打洞】端口号建立连接的本地端口号X)上侦听到来的连接,等待客
户端A直接连接该端口号。
// 执行者:客户端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;
}//
// 执行者:客户端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强行终止,看是否数据收发还正常进行着。
程序执行步骤和方法:
要准备好环境,如果要真实测试的话需要用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。
客户端A
客户端B
本代码在Windows XP、一个天威局域网、一个电信局域网、一个电话拨号网络中测试通过。
由于时间和水平的关系,代码和文章写得都不咋的,但愿能起到抛砖引玉的作用。代码部分只是实现了不同局域网之间的客户端相互连接的问题,至于相 同局域网内的主机或者其中一台客户端本身就具有公网IP的问题这里暂时未做考虑(因为那些处理实在太简单了,比较一下掩码或者公网IP就能判断出来的); 另外程序的防错性代码重用性也做得不好,只是实现了功能,我想....
|