开发者社区> double2li> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

用TCP穿透NAT(TCP打洞)的实现

简介: 1. TCP穿透原理:     我们假设在两个不同的局域网后面分别有2台客户机A和 B,AB所在的局域网都分别通过一个路由器接入互联网。互联网上有一台服务器S。     现在AB是无法直接和对方发送信息的,AB都不知道对方在互联网上真正的IP和端口, AB所在的局域网的路由器只允许内部向外主动发送的信息通过。
+关注继续查看

1. TCP穿透原理:

    我们假设在两个不同的局域网后面分别有2台客户机A和 B,AB所在的局域网都分别通过一个路由器接入互联网。互联网上有一台服务器S。 
    现在AB是无法直接和对方发送信息的,AB都不知道对方在互联网上真正的IP和端口, AB所在的局域网的路由器只允许内部向外主动发送的信息通过。对于B直接发送给A的路由器的消息,路由会认为其“不被信任”而直接丢弃。 
    要实现 AB直接的通讯,就必须进行以下3步:A首先连接互联网上的服务器S并发送一条消息(对于UDP这种无连接的协议其实直接初始会话发送消息即可),这样S就获取了A在互联网上的实际终端(发送消息的IP和端口号)。接着 B也进行同样的步骤,S就知道了AB在互联网上的终端(这就是“打洞”)。接着S分别告诉A和B对方客户端在互联网上的实际终端,也即S告诉A客户B的会话终端,S告诉B客户A的会话终端。这样,在AB都知道了对方的实际终端之后,就可以直接通过实际终端发送消息了(因为先前双方都向外发送过消息,路由上已经有允许数据进出的消息通道)。

2. 程序思路:

1:启动服务器,监听端口8877
2:第一次启动客户端(称为client1),连上服务器,服务器将返回字符串first,标识这个是client1,同时,服务器将记录下这个客户端的(经过转换之后的)IP和端口。
3:第二次启动客户端(称为client2),连上服务器,服务器将向其返回自身的发送端口(称为port2),以及client1的(经过转换之后的)IP和端口。
4:然后服务器再发client1返回client2(经过转换之后的)IP和端口,然后断开与这两个客户端的连接(此时,服务器的工作已经全部完成了)
5:client2尝试连接client1,这次肯定会失败,但它会在路由器上留下记录,以帮忙client1成功穿透,连接上自己,然后设置port2端口为可重用端口,并监听端口port2。
6:client1尝试去连接client2,前几次可能会失败,因为穿透还没成功,如果连接10次都失败,就证明穿透失败了(可能是硬件不支持),如果成功,则每秒向client2发送一次hello, world
7:如果client1不断出现send message: Hello, world,client2不断出现recv message: Hello, world,则证明实验成功了,否则就是失败了。

3. 声明

1:这个程序只是一个DEMO,所以肯定有很多不完善的地方,请大家多多见谅。
2:在很多网络中,这个程序并不能打洞成功,可能是硬件的问题(毕竟不是每种路由器都支持穿透),也可能是我程序的问题,如果大家有意见或建议,欢迎留言或给我发邮件(邮箱是:aa1080711@163.com)

4. 上代码:

服务器端:

Cpp代码  收藏代码
  1. /* 
  2. 文件:server.c 
  3. PS:第一个连接上服务器的客户端,称为client1,第二个连接上服务器的客户端称为client2 
  4. 这个服务器的功能是: 
  5. 1:对于client1,它返回"first",并在client2连接上之后,将client2经过转换后的IP和port发给client1; 
  6. 2:对于client2,它返回client1经过转换后的IP和port和自身的port,并在随后断开与他们的连接。 
  7. */  
  8.   
  9. #include <stdio.h>  
  10. #include <unistd.h>  
  11. #include <signal.h>  
  12. #include <sys/socket.h>  
  13. #include <fcntl.h>  
  14. #include <stdlib.h>  
  15. #include <errno.h>  
  16. #include <string.h>  
  17. #include <arpa/inet.h>  
  18.   
  19. #define MAXLINE 128  
  20. #define SERV_PORT 8877  
  21.   
  22. //发生了致命错误,退出程序  
  23. void error_quit(const char *str)      
  24. {      
  25.     fprintf(stderr, "%s", str);    
  26.     //如果设置了错误号,就输入出错原因  
  27.     if( errno != 0 )  
  28.         fprintf(stderr, " : %s", strerror(errno));  
  29.     printf("\n");  
  30.     exit(1);      
  31. }     
  32.   
  33. int main(void)        
  34. {            
  35.     int i, res, cur_port;   
  36.     int connfd, firstfd, listenfd;     
  37.     int count = 0;  
  38.     char str_ip[MAXLINE];    //缓存IP地址  
  39.     char cur_inf[MAXLINE];   //当前的连接信息[IP+port]  
  40.     char first_inf[MAXLINE];    //第一个链接的信息[IP+port]  
  41.     char buffer[MAXLINE];    //临时发送缓冲区  
  42.     socklen_t clilen;        
  43.     struct sockaddr_in cliaddr;        
  44.     struct sockaddr_in servaddr;  
  45.   
  46.     //创建用于监听TCP协议套接字          
  47.     listenfd = socket(AF_INET, SOCK_STREAM, 0);        
  48.     memset(&servaddr, 0, sizeof(servaddr));        
  49.     servaddr.sin_family = AF_INET;        
  50.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);        
  51.     servaddr.sin_port = htons(SERV_PORT);        
  52.   
  53.     //把socket和socket地址结构联系起来         
  54.     res = bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));      
  55.     if( -1 == res )  
  56.         error_quit("bind error");  
  57.   
  58.     //开始监听端口         
  59.     res = listen(listenfd, INADDR_ANY);      
  60.     if( -1 == res )  
  61.         error_quit("listen error");  
  62.   
  63.     while( 1 )  
  64.     {  
  65.         //接收来自客户端的连接  
  66.         connfd = accept(listenfd,(struct sockaddr *)&cliaddr, &clilen);    
  67.         if( -1 == connfd )  
  68.             error_quit("accept error");  
  69.         inet_ntop(AF_INET, (void*)&cliaddr.sin_addr, str_ip, sizeof(str_ip));  
  70.   
  71.         count++;  
  72.         //对于第一个链接,将其的IP+port存储到first_inf中,  
  73.         //并和它建立长链接,然后向它发送字符串'first',  
  74.         if( count == 1 )  
  75.         {  
  76.             firstfd = connfd;  
  77.             cur_port = ntohs(cliaddr.sin_port);  
  78.             snprintf(first_inf, MAXLINE, "%s %d", str_ip, cur_port);     
  79.             strcpy(cur_inf, "first\n");  
  80.             write(connfd, cur_inf, strlen(cur_inf)+1);  
  81.         }  
  82.         //对于第二个链接,将其的IP+port发送给第一个链接,  
  83.         //将第一个链接的信息和他自身的port返回给它自己,  
  84.         //然后断开两个链接,并重置计数器  
  85.         else if( count == 2 )  
  86.         {  
  87.             cur_port = ntohs(cliaddr.sin_port);  
  88.             snprintf(cur_inf, MAXLINE, "%s %d\n", str_ip, cur_port);  
  89.             snprintf(buffer, MAXLINE, "%s %d\n", first_inf, cur_port);  
  90.             write(connfd, buffer, strlen(buffer)+1);  
  91.             write(firstfd, cur_inf, strlen(cur_inf)+1);   
  92.             close(connfd);  
  93.             close(firstfd);  
  94.             count = 0;  
  95.         }  
  96.         //如果程序运行到这里,那肯定是出错了  
  97.         else  
  98.             error_quit("Bad required");  
  99.     }  
  100.     return 0;  
  101. }  

 客户端:

Cpp代码  收藏代码
  1. /* 
  2. 文件:client.c 
  3. PS:第一个连接上服务器的客户端,称为client1,第二个连接上服务器的客户端称为client2 
  4. 这个程序的功能是:先连接上服务器,根据服务器的返回决定它是client1还是client2, 
  5. 若是client1,它就从服务器上得到client2的IP和Port,连接上client2, 
  6. 若是client2,它就从服务器上得到client1的IP和Port和自身经转换后的port, 
  7. 在尝试连接了一下client1后(这个操作会失败),然后根据服务器返回的port进行监听。 
  8. 这样以后,就能在两个客户端之间进行点对点通信了。 
  9. */  
  10.   
  11. #include <stdio.h>  
  12. #include <unistd.h>  
  13. #include <signal.h>  
  14. #include <sys/socket.h>  
  15. #include <fcntl.h>  
  16. #include <stdlib.h>  
  17. #include <errno.h>  
  18. #include <string.h>  
  19. #include <arpa/inet.h>  
  20.   
  21. #define MAXLINE 128  
  22. #define SERV_PORT 8877  
  23.   
  24. typedef struct  
  25. {  
  26.     char ip[32];  
  27.     int port;  
  28. }server;  
  29.   
  30. //发生了致命错误,退出程序  
  31. void error_quit(const char *str)      
  32. {      
  33.     fprintf(stderr, "%s", str);   
  34.     //如果设置了错误号,就输入出错原因  
  35.     if( errno != 0 )  
  36.         fprintf(stderr, " : %s", strerror(errno));  
  37.     printf("\n");  
  38.     exit(1);      
  39. }     
  40.   
  41. int main(int argc, char **argv)       
  42. {            
  43.     int i, res, port;  
  44.     int connfd, sockfd, listenfd;   
  45.     unsigned int value = 1;  
  46.     char buffer[MAXLINE];        
  47.     socklen_t clilen;          
  48.     struct sockaddr_in servaddr, sockaddr, connaddr;    
  49.     server other;  
  50.   
  51.     if( argc != 2 )  
  52.         error_quit("Using: ./client <IP Address>");  
  53.   
  54.     //创建用于链接(主服务器)的套接字          
  55.     sockfd = socket(AF_INET, SOCK_STREAM, 0);   
  56.     memset(&sockaddr, 0, sizeof(sockaddr));        
  57.     sockaddr.sin_family = AF_INET;        
  58.     sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);        
  59.     sockaddr.sin_port = htons(SERV_PORT);        
  60.     inet_pton(AF_INET, argv[1], &sockaddr.sin_addr);  
  61.     //设置端口可以被重用  
  62.     setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value));  
  63.   
  64.     //连接主服务器  
  65.     res = connect(sockfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));   
  66.     if( res < 0 )  
  67.         error_quit("connect error");  
  68.   
  69.     //从主服务器中读取出信息  
  70.     res = read(sockfd, buffer, MAXLINE);  
  71.     if( res < 0 )  
  72.         error_quit("read error");  
  73.     printf("Get: %s", buffer);  
  74.   
  75.     //若服务器返回的是first,则证明是第一个客户端  
  76.     if( 'f' == buffer[0] )  
  77.     {  
  78.         //从服务器中读取第二个客户端的IP+port  
  79.         res = read(sockfd, buffer, MAXLINE);  
  80.         sscanf(buffer, "%s %d", other.ip, &other.port);  
  81.         printf("ff: %s %d\n", other.ip, other.port);  
  82.   
  83.         //创建用于的套接字          
  84.         connfd = socket(AF_INET, SOCK_STREAM, 0);   
  85.         memset(&connaddr, 0, sizeof(connaddr));        
  86.         connaddr.sin_family = AF_INET;        
  87.         connaddr.sin_addr.s_addr = htonl(INADDR_ANY);        
  88.         connaddr.sin_port = htons(other.port);      
  89.         inet_pton(AF_INET, other.ip, &connaddr.sin_addr);  
  90.   
  91.         //尝试去连接第二个客户端,前几次可能会失败,因为穿透还没成功,  
  92.         //如果连接10次都失败,就证明穿透失败了(可能是硬件不支持)  
  93.         while( 1 )  
  94.         {  
  95.             static int j = 1;  
  96.             res = connect(connfd, (struct sockaddr *)&connaddr, sizeof(connaddr));   
  97.             if( res == -1 )  
  98.             {  
  99.                 if( j >= 10 )  
  100.                     error_quit("can't connect to the other client\n");  
  101.                 printf("connect error, try again. %d\n", j++);  
  102.                 sleep(1);  
  103.             }  
  104.             else   
  105.                 break;  
  106.         }  
  107.   
  108.         strcpy(buffer, "Hello, world\n");  
  109.         //连接成功后,每隔一秒钟向对方(客户端2)发送一句hello, world  
  110.         while( 1 )  
  111.         {  
  112.             res = write(connfd, buffer, strlen(buffer)+1);  
  113.             if( res <= 0 )  
  114.                 error_quit("write error");  
  115.             printf("send message: %s", buffer);  
  116.             sleep(1);  
  117.         }  
  118.     }  
  119.     //第二个客户端的行为  
  120.     else  
  121.     {  
  122.         //从主服务器返回的信息中取出客户端1的IP+port和自己公网映射后的port  
  123.         sscanf(buffer, "%s %d %d", other.ip, &other.port, &port);  
  124.   
  125.         //创建用于TCP协议的套接字          
  126.         sockfd = socket(AF_INET, SOCK_STREAM, 0);   
  127.         memset(&connaddr, 0, sizeof(connaddr));        
  128.         connaddr.sin_family = AF_INET;        
  129.         connaddr.sin_addr.s_addr = htonl(INADDR_ANY);        
  130.         connaddr.sin_port = htons(other.port);        
  131.         inet_pton(AF_INET, other.ip, &connaddr.sin_addr);  
  132.         //设置端口重用  
  133.         setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value));  
  134.   
  135.         //尝试连接客户端1,肯定会失败,但它会在路由器上留下记录,  
  136.         //以帮忙客户端1成功穿透,连接上自己   
  137.         res = connect(sockfd, (struct sockaddr *)&connaddr, sizeof(connaddr));   
  138.         if( res < 0 )  
  139.             printf("connect error\n");  
  140.   
  141.         //创建用于监听的套接字          
  142.         listenfd = socket(AF_INET, SOCK_STREAM, 0);   
  143.         memset(&servaddr, 0, sizeof(servaddr));        
  144.         servaddr.sin_family = AF_INET;        
  145.         servaddr.sin_addr.s_addr = htonl(INADDR_ANY);        
  146.         servaddr.sin_port = htons(port);  
  147.         //设置端口重用  
  148.         setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value));  
  149.   
  150.         //把socket和socket地址结构联系起来   
  151.         res = bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));      
  152.         if( -1 == res )  
  153.             error_quit("bind error");  
  154.   
  155.         //开始监听端口         
  156.         res = listen(listenfd, INADDR_ANY);      
  157.         if( -1 == res )  
  158.             error_quit("listen error");  
  159.   
  160.         while( 1 )  
  161.         {  
  162.             //接收来自客户端1的连接  
  163.             connfd = accept(listenfd,(struct sockaddr *)&sockaddr, &clilen);    
  164.             if( -1 == connfd )  
  165.                 error_quit("accept error");  
  166.   
  167.             while( 1 )  
  168.             {  
  169.                 //循环读取来自于客户端1的信息  
  170.                 res = read(connfd, buffer, MAXLINE);  
  171.                 if( res <= 0 )  
  172.                     error_quit("read error");  
  173.                 printf("recv message: %s", buffer);  
  174.             }  
  175.             close(connfd);  
  176.         }  
  177.     }  
  178.   
  179.     return 0;  
  180. }  

 

5. 运行示例:

(第一个终端)
qch@qch ~/program/tcode $ gcc server.c -o server
qch@qch ~/program/tcode $ ./server &
[1] 4688
qch@qch ~/program/tcode $ gcc client.c -o client
qch@qch ~/program/tcode $ ./client localhost
Get: first
ff: 127.0.0.1 38052
send message: Hello, world
send message: Hello, world
send message: Hello, world
.................


第二个终端:
qch@qch ~/program/tcode $ ./client localhost
Get: 127.0.0.1 38073 38074
connect error
recv message: Hello, world
recv message: Hello, world
recv message: Hello, world
..................

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
一文讲透TCP三次握手到底怎么实现的(上)
一文讲透TCP三次握手到底怎么实现的
46 0
如何在 SAP BTP 上通过 CDS view 快速创建 Fiori Elements 应用
如何在 SAP BTP 上通过 CDS view 快速创建 Fiori Elements 应用
34 0
使用abapGit在ABAP On-Premises系统和SAP云平台ABAP环境之间进行代码传输
使用abapGit在ABAP On-Premises系统和SAP云平台ABAP环境之间进行代码传输
36 0
使用abapGit在ABAP On-Premises系统和SAP云平台ABAP环境之间进行代码传输
SAP ABAP顾问朋友们,应该都使用过SAPLink这个工具。如果两个ABAP Netweaver系统没有建立起传输路径时,我们无法使用标准的SE10事务码创建传输请求的方式进行这两个系统间的代码传输。此时,SAPLink就有了用武之地。
48 0
自定义View仿TabHost的实现(一)
Activity1如下: package cn.com; import android.app.Activity; import android.
476 0
+关注
double2li
一个在IT行业摸爬滚打的老司机
2869
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载