这个标题用了两个顿号三个名称，其实说得是同一个东西，只是网上有不同的说法罢了，另外好像还有人叫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分，惭愧），所以只好用代码来说明问题了。

// 服务器地址和端口号定义
#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\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强行终止，看是否数据收发还正常进行着。

程序执行步骤和方法：

  1. 要准备好环境，如果要真实测试的话需要用2个连到公网上的局域网，1台具有公网地址的电脑（为了协助我测试，小曹、小妞可费了不少心，我还霸占了他们家的电脑，在此表示感谢）。如果不是这样的环境，程序执行可能会不正常，因为我暂时未做相同局域网的处理。
  2. 在具有公网地址的电脑上执行“TcpHoleSrv.exe”程序，假设这台电脑的公网IP地址是“129.208.12.38”。
  3. 在局域网A中的一台电脑上执行“TcpHoleClt-A.exe 129.208.12.38”
  4. 在局域网B中的一台电脑上执行“TcpHoleClt-B.exe 129.208.12.38”

程序执行成功后的界面：客户端出现“Send Data”或者“Received Data”表示穿越NAT的TCP连接已经建立起来，数据收发已经OK。


服务器S

客户端A

客户端B

本代码在Windows XP、一个天威局域网、一个电信局域网、一个电话拨号网络中测试通过。
由于时间和水平的关系，代码和文章写得都不咋的，但愿能起到抛砖引玉的作用。代码部分只是实现了不同局域网之间的客户端相互连接的问题，至于相同局域网内的主机或者其中一台客户端本身就具有公网IP的问题这里暂时未做考虑（因为那些处理实在太简单了，比较一下掩码或者公网IP就能判断出来的）；另外程序的防错性代码重用性也做得不好，只是实现了功能