Question

我现在已经尝试过TCP打孔一段时间了，而论坛在基于TCP的方法和C编程语言方面似乎没什么帮助。以下是互联网的主要参考资料，

一个。 http://www.brynosaurus.com/pub/net/p2pnat/
湾https://wuyongzheng.wordpress.com/2013/01/31/experiment-on-tcp-hole-punching/

我的设置是
客户端A - NAT-A - Internet - NAT-B - 客户端B.

假设客户端A知道B的公共和私有端点，并且B知道A端点（我已经写了一个服务器＆＃39; S＆＃39;它在对等端之间交换端点信息），以及鉴于两个NAT都不对称，如果两个客户端都反复尝试连接（）到彼此的公共端点（用于上述设置），那么它是否足够（实现TCP打孔）？

如果没有，为了实现tcp打孔，究竟需要做些什么？

我在每个客户端上有两个线程，一个对其他客户端重复进行连接调用，另一个用于侦听来自其他客户端的传入连接。我确保两个线程中的套接字都绑定到给对等端的本地端口。此外，我看到两个NAT都保留了端口映射，即本地和公共端口是相同的。然而，我的计划没有工作。

是否会使会合服务器＆＃39; S＆＃39;我上面提到过，它可以在打孔或创建允许SYN请求传递给对等点的NAT映射方面发挥作用。如果是的话，必须做些什么？

附上相关的代码部分 connect_with_peer（）是服务器＆＃39; S＆＃39;之后的入口点。提供对等体的公共ip：port tuple，它被赋予该功能以及完成绑定的本地端口。此函数生成一个线程（accept_handler（）），该线程还绑定到本地端口并侦听来自对等方的传入连接。 connect_with_peer（）返回一个套接字，如果connect（）[主线程]或accept（）[子线程]，则成功。

谢谢，
Dinkar

volatile int quit_connecting=0;

void *accept_handler(void *arg)
{
    int i,psock,cnt=0;
    int port = *((int *)arg);
    ssize_t len;
    int asock,opt,fdmax;
    char str[BUF_SIZE];
    struct sockaddr_in peer,local;
    socklen_t peer_len = sizeof(peer);
    fd_set master,read_fds;    // master file descriptor list
    struct timeval tv = {10, 0}; // 10 sec timeout
    int *ret_sock = NULL;
    struct linger lin;
    lin.l_onoff=1;
    lin.l_linger=0;

    opt=1;
    //Create socket
    asock = socket(AF_INET , SOCK_STREAM, IPPROTO_TCP);

    if (asock == -1)
    {
        fprintf(stderr,"Could not create socket");
        goto quit_ah;
    }
    else if (setsockopt(asock, SOL_SOCKET, SO_LINGER, &lin,
                        (socklen_t) sizeof lin) < 0)
    {
        fprintf(stderr,"\nTCP set linger socket options failure");
        goto quit_ah;
    }
    else if (setsockopt(asock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
                        (socklen_t) sizeof opt) < 0)
    {
        fprintf(stderr,"\nTCP set csock options failure");
        goto quit_ah;
    }


    local.sin_family = AF_INET;         /* host byte order */
    local.sin_port = htons(port);     /* short, network byte order */
    local.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
    bzero(&(local.sin_zero), 8);        /* zero the rest of the struct */

fprintf(stderr,"\naccept_handler: binding to port %d",port);

    if (bind(asock, (struct sockaddr *)&local, sizeof(struct sockaddr)) == -1) {
        perror("accept_handler bind error :");
        goto quit_ah;
    }

    if (listen(asock, 1) == -1) {
        perror(" accept_handler listen");
        goto quit_ah;
    }

    memset(&peer, 0, sizeof(peer));
    peer.sin_addr.s_addr = inet_addr(peer_global_address);
    peer.sin_family = AF_INET;
    peer.sin_port = htons( peer_global_port );

    FD_ZERO(&master);    // clear the master and temp sets
    FD_SET(asock, &master);
    fdmax = asock; // so far, it's this one

    // Try accept
    fprintf(stderr,"\n listen done; accepting next ... ");

    while(quit_connecting == 0){
        read_fds = master; // copy it
        if (select(fdmax+1, &read_fds, NULL, NULL, &tv) == -1) {
            perror("accept_handler select");
            break;
        }
        // run through the existing connections looking for data to read
        for(i = 0; i <= fdmax; i++) {
            if (FD_ISSET(i, &read_fds)) { // we got one!!
                if (i == asock) {
                    // handle new connections
                    psock = accept(asock, (struct sockaddr *)&peer, (socklen_t*)&peer_len);

                    if (psock == -1) {
                        perror("accept_handler accept");
                    } else {
                        fprintf(stderr,"\n Punch accept in thread succeeded soc=%d....",psock);
                        quit_connecting = 1;

                        ret_sock = malloc(sizeof(int));
                        if(ret_sock){
                            *ret_sock = psock;
                        }

                    }
                }
            }
        } // end for
    }


quit_ah:

    if(asock>=0) {
        shutdown(asock,2);
        close(asock);
    }
    pthread_exit((void *)ret_sock);

    return (NULL);
}



int connect_with_peer(char *ip, int port, int lport)
{
    int retval=-1, csock=-1;
    int *psock=NULL;
    int attempts=0, cnt=0;
    int rc=0, opt;
    ssize_t len=0;
    struct sockaddr_in peer, apeer;
    struct sockaddr_storage from;
    socklen_t peer_len = sizeof(peer);
    socklen_t fromLen = sizeof(from);
    char str[64];
    int connected = 0;
    pthread_t accept_thread;
    long arg;
    struct timeval tv;
    fd_set myset;
    int so_error;

    struct linger lin;
    lin.l_onoff=1;
    lin.l_linger=0;

    opt=1;

    //Create socket
    csock = socket(AF_INET , SOCK_STREAM, IPPROTO_TCP);

    if (csock == -1)
    {
        fprintf(stderr,"Could not create socket");
        return -1;
    }
    else if (setsockopt(csock, SOL_SOCKET, SO_LINGER, &lin,
                        (socklen_t) sizeof lin) < 0)
    {
        fprintf(stderr,"\nTCP set linger socket options failure");
    }

#if 1
    else if (setsockopt(csock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
                        (socklen_t) sizeof opt) < 0)
    {
        fprintf(stderr,"\nTCP set csock options failure");
    }
#endif

    quit_connecting = 0;

///////////

    if( pthread_create( &accept_thread , NULL ,  accept_handler , &lport) < 0)
    {
        perror("could not create thread");
        return 1;
    }
    sleep(2); // wait for listen/accept to begin in accept_thread.

///////////
    peer.sin_family = AF_INET;         /* host byte order */
    peer.sin_port = htons(lport);     /* short, network byte order */
    peer.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
    bzero(&(peer.sin_zero), 8);        /* zero the rest of the struct */

fprintf(stderr,"\n connect_with_peer: binding to port %d",lport);

    if (bind(csock, (struct sockaddr *)&peer, sizeof(struct sockaddr)) == -1) {
        perror("connect_with_peer bind error :");
        goto quit_connect_with_peer;
    }

    // Set non-blocking 
    arg = fcntl(csock, F_GETFL, NULL); 
    arg |= O_NONBLOCK; 
    fcntl(csock, F_SETFL, arg); 

    memset(&peer, 0, sizeof(peer));
    peer.sin_addr.s_addr = inet_addr(ip);
    peer.sin_family = AF_INET;
    peer.sin_port = htons( port );

    //Connect to remote server
    fprintf(stderr,"\n Attempting to connect/punch to %s; attempt=%d",ip,attempts);
    rc = connect(csock , (struct sockaddr *)&peer , peer_len);

    if(rc == 0){ //succeeded
        fprintf(stderr,"\n Punch Connect succeeded first time....");
    } else { 
        if (errno == EINPROGRESS) { 


            while((attempts<5) && (quit_connecting==0)){
            tv.tv_sec = 10; 
            tv.tv_usec = 0; 
            FD_ZERO(&myset); 
            FD_SET(csock, &myset); 
                if (select(csock+1, NULL, &myset, NULL, &tv) > 0) { 

                    len = sizeof(so_error);
                    getsockopt(csock, SOL_SOCKET, SO_ERROR, &so_error, (socklen_t *)&len);

                    if (so_error == 0) {
                        fprintf(stderr,"\n Punch Connect succeeded ....");
                        // Set it back to blocking mode
                        arg = fcntl(csock, F_GETFL, NULL); 
                        arg &= ~(O_NONBLOCK); 
                        fcntl(csock, F_SETFL, arg);

                        quit_connecting=1;
                        retval = csock;
                    } else { // error
                        fprintf(stderr,"\n Punch select error: %s\n", strerror(so_error));
                        goto quit_connect_with_peer;
                    }

                } else { 
                    fprintf(stderr,"\n Punch select timeout: %s\n", strerror(so_error));
                } 
                attempts++;
            }// end while

        } else { //errorno is not EINPROGRESS
            fprintf(stderr, "\n Punch connect error: %s\n", strerror(errno)); 
        } 
    } 

quit_connect_with_peer:

    quit_connecting=1;
    fprintf(stderr,"\n Waiting for accept_thread to close..");
    pthread_join(accept_thread,(void **)&psock);

    if(retval == -1 ) {
        if(psock && ((*psock) != -1)){
            retval = (*psock); // Success from accept socket
        }
    }

    fprintf(stderr,"\n After accept_thread psock = %d csock=%d, retval=%d",psock?(*psock):-1,csock,retval);

    if(psock) free(psock); // Free the socket pointer , not the socket.

    if((retval != csock) && (csock>=0)){ // close connect socket if accept succeeded
        shutdown(csock,2);
        close(csock);
    }

    return retval;
}

Answer 1

首先，阅读这个非常相似的问题：
TCP Hole Punching

阅读EDIT2之后的部分（此处摘录）。这可能是失败的原因。

第二个套接字成功绑定后，所有行为绑定到该端口的套接字是不确定的。

不要担心linux在socket（7）中有与SO_REUSEADDR类似的限制：

对于AF_INET套接字，这意味着套接字可以绑定，除非有一个绑定到该地址的活动侦听套接字。当。。。的时候侦听套接字绑定到具有特定端口的INADDR_ANY然后它无法绑定到此端口以获取任何本地地址

我认为不是之前的倾听会有所作为。

您不必尝试打开两次连接。

建立TCP连接的步骤摘要：左侧:(连接到服务器S的客户端C）是常见的情况，右侧是两个对等方A和B的同时连接（您正在尝试做的事情）：

C                           A       B
  \ (SYN)                     \   /
   \                      (SYN)\ /(SYN)
     > S                        X
    /                          / \
   /(SYN+ACK)                 /   \
  /                       A <       > B
C<                            \   /
  \                   (SYN+ACK)\ / (SYN+ACK)
   \(ACK)                       X
    \                          / \
     \                        /   \
      > S                  A <     > B 
 ESTABLISHED               ESTABLISHED

的引用：
https://tools.ietf.org/html/rfc793#section-3.4图8。 +校正图8第7行：
https://tools.ietf.org/html/rfc1122#page-87（第4.2.2.10节）

不同的是同时发送SYN * 2 / SYN + ACK * 2而不是SYN / SYN + ACK / ACK（在我的测试中有两个linux同行，通常只有SYN + ACK的“第一”答案，因为它永远不会同时。这并不重要。）

两个对等体都主动发起连接。他们最初并不是在等待连接，你根本不需要调用listen（）/ accept（）。您根本不必使用任何线程。

每个对等方应该（通过S）交换（通过S）其预期的本地端口供另一方使用（并且在S的帮助下，他们将交换他们的公共IP），并假设端口不会被翻译。

现在，您只需尝试连接您的4-uple信息。每个都将与（INADDR_ANY，lport）绑定并连接到（peer_global_address，peer_global_port），而同时B也会这样做。 最后在双方之间建立了一个独特的连接。

两个NAT框都会看到传出的数据包并准备一条反向路径。

现在可能出现什么问题？

NAT盒无法处理具有SYN而不是更常见的SYN + ACK的预期数据包。对不起，如果发生这种情况，你可能会失败。 TCP协议允许这种情况并且它是强制性的（rfc 1122上面的4.2.2.10节）。如果其他NAT盒正常，它仍然可以工作（一旦发回SYN + ACK）。
一个NAT设备（来自执行请求太晚的对等体，比如说B前面的NAT-B）用RST数据包回答，而不是像大多数NAT设备那样静默地丢弃仍然未知的数据包。 A接收RST并中止连接。然后B发送它并发生类似的命运。 ping往返越快，你就越容易得到它。为避免这种情况，请：
- 如果您可以控制其中一个NAT设备，请丢弃该数据包而不是发送RST。
- 实际上是同步的（使用NTP，通过S在对等体之间以毫秒为单位交换预定动作的精确日期，或者等待下一个5秒的多次开始）
- 在A和/或B上删除带有自定义（和临时）防火墙规则的传出RST数据包（优于丢弃传入的RST，因为NAT设备可以决定在看到它时关闭期望）

我可以告诉我，可以“手动”可靠地使用TCP打孔工作，只需在两个对等设置之间使用netcat就像你的情况一样。

例如在Linux上使用netcat：在NAT设备后面的私有LAN中同时键入两个对等体A和B上的那些。使用通常的NAT设备（丢弃未知数据包），不需要任何完美的同步，即使这两个命令之间的5秒也很好（当然第一个会等待）：

host-a$ nc -p 7777 public-ip-host-b 8888
host-b$ nc -p 8888 public-ip-host-a 7777

完成后，netcat都一起建立了SAME UNIQUE连接，没有建立两个连接。不需要重试（无循环）。当然程序将使用connect（），如果第二个命令（以及connect（））被延迟，OS可能在connect（）期间发送了多个SYN数据包作为自动重试机制。这是系统/内核级别，而不是您的级别。

我希望这有助于您简化程序并使其正常运行。记住，不需要listen（），accept（），不得不分叉，使用线程。你甚至不需要select（），只需要没有O_NONBLOCK的connect（）块。

基于TCP的打孔

1 个答案: