码迷,mamicode.com
首页 > 其他好文 > 详细

UDP穿洞技术,P2P一些原理

时间:2014-12-01 12:47:23      阅读:420      评论:0      收藏:0      [点我收藏+]

标签:http   io   ar   os   使用   sp   java   for   on   

因为当前 IPV4地址的缺乏 ,nat、防火墙的中介设备和不对称寻址建立起来的 p2p通信机制造成了地址访问的问题。 

在 internet最初体系结构中,每个节点都有全球唯一的 ip地址,能够直接通信。可是随着节点的增多, ip地址使用紧张,他们需要中介设备如 nat连在一起。 
私有网络中的节点可以直接连接到相同私有网络中的其他节点,也可以连接到全局地址空间中拥有全球唯一 ip地址的节点。。然而 nat通常只允许临时的向外连接申请,对于向内的申请会拒绝。这就造成了在 natA内网中的节点 A连接 natB内网中的节点 B时连接申请报到 natB时就被阻止了。此时我们需要的就是穿越技术。。。 
  
总体来说穿越技术是利用一个公共服务器中转,使节点 A、 B都连接到中转服务器 S之后,通过 S中转 A发送到 B的数据报或者是中转连接申请,,使 A、 B对于 natA和 natB来说都是向外申请。。。 
  
1、         中转数据报: A、 B都先向外与服务器 S建立接连,然后通过 S中转 A、 B之间的数据报。。 
2、         反向连接:当 A、 B都与 S建立了连接,并且只有一个节点在 nat之后(假设 A在 natA之后)。。当 B向 A申请连接时,申请背 natA拒绝。 B可以向 S提出申请要与 A建立连接,然后 S向 A发出指令,通知 A主动向 B申请建立连接。。 
【 UDP打洞】 
1、 A、 B在同一个 nat之后: 
bubuko.com,布布扣 
用户 A让 S做介绍人来与 B建立对话 
(1) A向 S发送一个消息请求与 B建立连接 
(2) S使用 B的公共终端( 155.99.25.11: 62005)和私有终端( 10.1.1.3)响应 A 
(3) 同时 S也想 B发送 A的公共终端( 155.99.25.11: 62000)和私有终端( 10.0.0.1),但是发送到公共终端的消息不一定能达到 B取决于 NAT是否支持“发夹”转化(回环转化) 
(4) 如果 nat支持发夹转化的话,应用程序就可以免除私有和共有终端都要试图连接的复杂性。。 

  
2、不同 NAT后面的节点 
bubuko.com,布布扣 
(1) 注册, A、 B都想服务器 S注册 natA安排了 62000端口用作 A和 S对话使用, natB安排了 31000端口用作 B和 S对话使用, A向 S的注册消息中报告了自己的私有终端 10.0.0.1: 4321这种情况下 A的公共终端是 155.99.25.11: 62000,同理 B的私有终端 10.1.1.3: 4321和公共终端 136.76.29.7: 31000 
(2) A发送请求消息到 S,请求与 B建立连接,作为响应 S向 A发送了 B的私有终端和公共终端也向 B发送了 A的私有和公共终端。 
(3) 既然 A、 B处在不同的子网中,那么 A、 B的私有终端是不能公共路由的,发送的消息肯能会发到自己子网中的 ip中(应为不同子网中的私有 ip可以相同) 
(4) 当从 A发向 B的第一个消息到达 natA时, natA注意到这是一个新的外出会话, natA看到源地址是子网中地址,而目的地址是外网地址,所以 natA将从私有终端 10.0.0.1: 4321的外出会话转化到对应公共终端 155.99.25.11: 62000,这样 A的第一个到 B的公共终端的外出会话消息就在 natA上“打了一个洞”。新的 UDP会话由 A的私有网络上的终端 10.0.0.1: 4321/138.76.29.7: 31000和 internet上的公共终端 155.99.25.11: 62000/138.76.29.7:31000标识,同理 B也建立了对 A的私有、公共连接标识。 
(5) 如果 A发向 B的公共终端的消息在 B发向 A的第一个消息穿过 B自己的 natB之前到达了 natB的话, natB会认为 A的内入消息是禁止的,丢弃 B的请求消息,但是 B的请求消息在 natB上为 A打了一洞,此时洞双向打开,通信可以进行下去了。。。 

3、多级 NAT后面的节点: 
bubuko.com,布布扣 
( 1) A、 B都建立与 S的向外连接 
( 2)最终连接目的: 
   Aà B    10.0.0.1à 10.0.1.2:55000 
   Bà A    10.0.0.3à 10.0.1.1:45000 
( 3)但是在此时 A、 B无法知道伪公众终端 10.0.1.2:55000和 10.0.1.1:45000。 S只看到了 155.99.25.11: 52000和 155.99.25.11: 62005。 
( 4)此时相应的 A、 B也只知道 155.99.25.11: 52000和 155.99.25.11: 62005 
( 5)只能依赖 natC的发夹转化。 
     当 A-à B,即 10.0.0.1—>155.99.25.11: 62005时 natA将数据报中源地址 10.0.0.1转化为 10.0.1.1然后发送到 natC,当 natC发现目的地址 ip是 155.99.25.11是自己转化过的 ip后, natC就会转化数据报中的源地址和目的地址,再发送到私有网络中。 155.99.25.11: 62000--à 10.0.1.2: 55000 
( 6)当数据报到 B私有网络时,同样方法进行转化。。 

另外,局域网内数据共享,可以采用组播方式。


UDPServer.java: 

Java代码  bubuko.com,布布扣
  1. package org.iaiai.test;  
  2.   
  3. import java.net.DatagramPacket;  
  4. import java.net.DatagramSocket;  
  5. import java.net.InetAddress;  
  6.   
  7. /** 
  8.  *  
  9.  * <br/> 
  10.  * Title: UDPServer.java<br/> 
  11.  * E-Mail: 176291935@qq.com<br/> 
  12.  * QQ: 176291935<br/> 
  13.  * Http: iaiai.iteye.com<br/> 
  14.  * Create time: 2013-1-29 上午11:11:56<br/> 
  15.  * <br/> 
  16.  * @author 丸子 
  17.  * @version 0.0.1 
  18.  */  
  19. public class UDPServer {  
  20.   
  21.     public static void main(String[] args) {  
  22.         try {  
  23.             DatagramSocket server = new DatagramSocket(2008);  
  24.             byte[] buf = new byte[1024];  
  25.             DatagramPacket packet = new DatagramPacket(buf, buf.length);  
  26.   
  27.             String sendMessage132 = "";  
  28.             String sendMessage129 = "";  
  29.             int port132 = 0;  
  30.             int port129 = 0;  
  31.             InetAddress address132 = null;  
  32.             InetAddress address129 = null;  
  33.             for (;;) {  
  34.                 server.receive(packet);  
  35.   
  36.                 String receiveMessage = new String(packet.getData(), 0, packet.getLength());  
  37.                 System.out.println(receiveMessage);  
  38.                 //接收到clientA  
  39.                 if (receiveMessage.contains("132")) {  
  40.                     port132 = packet.getPort();  
  41.                     address132 = packet.getAddress();  
  42.                     sendMessage132 = "host:" + address132.getHostAddress() + ",port:" + port132;  
  43.                 }  
  44.                 //接收到clientB  
  45.                 if (receiveMessage.contains("129")) {  
  46.                     port129 = packet.getPort();  
  47.                     address129 = packet.getAddress();  
  48.                     sendMessage129 = "host:" + address129.getHostAddress() + ",port:" + port129;  
  49.                 }  
  50.                 //两个都接收到后分别A、B址地交换互发  
  51.                 if (!sendMessage132.equals("") && !sendMessage129.equals("")) {  
  52.                     send132(sendMessage129, port132, address132, server);  
  53.                     send129(sendMessage132, port129, address129, server);  
  54.                     sendMessage132 = "";  
  55.                     sendMessage129 = "";  
  56.                 }  
  57.             }  
  58.         } catch (Exception e) {  
  59.             e.printStackTrace();  
  60.         }  
  61.     }  
  62.   
  63.     private static void send129(String sendMessage132, int port132, InetAddress address132, DatagramSocket server) {  
  64.         try {  
  65.             byte[] sendBuf = sendMessage132.getBytes();  
  66.             DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, address132, port132);  
  67.             server.send(sendPacket);  
  68.             System.out.println("消息发送成功!");  
  69.         } catch (Exception e) {  
  70.             e.printStackTrace();  
  71.         }  
  72.     }  
  73.   
  74.     private static void send132(String sendMessage129, int port129, InetAddress address129, DatagramSocket server) {  
  75.         try {  
  76.             byte[] sendBuf = sendMessage129.getBytes();  
  77.             DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, address129, port129);  
  78.             server.send(sendPacket);  
  79.             System.out.println("消息发送成功!");  
  80.         } catch (Exception e) {  
  81.             e.printStackTrace();  
  82.         }  
  83.     }  
  84. }  



UDPClientA.java: 

Java代码  bubuko.com,布布扣
  1. package org.iaiai.test;  
  2.   
  3. import java.net.DatagramPacket;  
  4. import java.net.DatagramSocket;  
  5. import java.net.InetAddress;  
  6. import java.net.InetSocketAddress;  
  7. import java.net.SocketAddress;  
  8.   
  9. /** 
  10.  *  
  11.  * <br/> 
  12.  * Title: UDPClientA.java<br/> 
  13.  * E-Mail: 176291935@qq.com<br/> 
  14.  * QQ: 176291935<br/> 
  15.  * Http: iaiai.iteye.com<br/> 
  16.  * Create time: 2013-1-29 上午11:11:56<br/> 
  17.  * <br/> 
  18.  * @author 丸子 
  19.  * @version 0.0.1 
  20.  */  
  21. public class UDPClientA {  
  22.   
  23.     public static void main(String[] args) {  
  24.         try {  
  25.             // 向server发起请求  
  26.             SocketAddress target = new InetSocketAddress("10.1.11.137", 2008);  
  27.             DatagramSocket client = new DatagramSocket();  
  28.             String message = "I am UPDClinetA 192.168.85.132";  
  29.             byte[] sendbuf = message.getBytes();  
  30.             DatagramPacket pack = new DatagramPacket(sendbuf, sendbuf.length, target);  
  31.             client.send(pack);  
  32.             // 接收请求的回复,可能不是server回复的,有可能来自UPDClientB的请求内  
  33.             receive(client);  
  34.         } catch (Exception e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.   
  39.     //接收请求内容  
  40.     private static void receive(DatagramSocket client) {  
  41.         try {  
  42.             for (;;) {  
  43.                 byte[] buf = new byte[1024];  
  44.                 DatagramPacket packet = new DatagramPacket(buf, buf.length);  
  45.                 client.receive(packet);  
  46.                 String receiveMessage = new String(packet.getData(), 0, packet.getLength());  
  47.                 System.out.println(receiveMessage);  
  48.                 int port = packet.getPort();  
  49.                 InetAddress address = packet.getAddress();  
  50.                 String reportMessage = "tks";  
  51.                 //获取接收到请问内容后并取到地址与端口,然后用获取到地址与端口回复内容  
  52.                 sendMessaage(reportMessage, port, address, client);  
  53.             }  
  54.         } catch (Exception e) {  
  55.             e.printStackTrace();  
  56.         }  
  57.     }  
  58.   
  59.     //回复内容  
  60.     private static void sendMessaage(String reportMessage, int port, InetAddress address, DatagramSocket client) {  
  61.         try {  
  62.             byte[] sendBuf = reportMessage.getBytes();  
  63.             DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, address, port);  
  64.             client.send(sendPacket);  
  65.             System.out.println("消息发送成功!");  
  66.         } catch (Exception e) {  
  67.             e.printStackTrace();  
  68.         }  
  69.     }  
  70. }  



UDPClientB.java 

Java代码  bubuko.com,布布扣
    1. package org.iaiai.test;  
    2.   
    3. import java.net.DatagramPacket;  
    4. import java.net.DatagramSocket;  
    5. import java.net.InetAddress;  
    6. import java.net.InetSocketAddress;  
    7. import java.net.SocketAddress;  
    8.   
    9. /** 
    10.  *  
    11.  * <br/> 
    12.  * Title: UDPClientB.java<br/> 
    13.  * E-Mail: 176291935@qq.com<br/> 
    14.  * QQ: 176291935<br/> 
    15.  * Http: iaiai.iteye.com<br/> 
    16.  * Create time: 2013-1-29 上午11:11:56<br/> 
    17.  * <br/> 
    18.  * @author 丸子 
    19.  * @version 0.0.1 
    20.  */  
    21. public class UDPClientB {  
    22.   
    23.     public static void main(String[] args) {  
    24.         try {  
    25.             //向server发起请求  
    26.             SocketAddress target = new InetSocketAddress("10.1.11.137", 2008);  
    27.             DatagramSocket client = new DatagramSocket();  
    28.             String message = "I am UDPClientB 192.168.85.129";  
    29.             byte[] sendbuf = message.getBytes();  
    30.             DatagramPacket pack = new DatagramPacket(sendbuf, sendbuf.length, target);  
    31.             client.send(pack);  
    32.             //接收server的回复内容  
    33.             byte[] buf = new byte[1024];  
    34.             DatagramPacket recpack = new DatagramPacket(buf, buf.length);  
    35.             client.receive(recpack);  
    36.             //处理server回复的内容,然后向内容中的地址与端口发起请求(打洞)  
    37.             String receiveMessage = new String(recpack.getData(), 0, recpack.getLength());  
    38.             String[] params = receiveMessage.split(",");  
    39.             String host = params[0].substring(5);  
    40.             String port = params[1].substring(5);  
    41.             System.out.println(host + ":" + port);  
    42.             sendMessage(host, port, client);  
    43.         } catch (Exception e) {  
    44.             e.printStackTrace();  
    45.         }  
    46.     }  
    47.   
    48.     //向UPDClientA发起请求(在NAT上打孔)  
    49.     private static void sendMessage(String host, String port, DatagramSocket client) {  
    50.         try {  
    51.             SocketAddress target = new InetSocketAddress(host, Integer.parseInt(port));  
    52.             for (;;) {  
    53.                 String message = "I am master 192.168.85.129 count test";  
    54.                 byte[] sendbuf = message.getBytes();  
    55.                 DatagramPacket pack = new DatagramPacket(sendbuf, sendbuf.length, target);  
    56.                 client.send(pack);  
    57.                 //接收UDPClientA回复的内容  
    58.                 receive(client);  
    59.             }  
    60.         } catch (Exception e) {  
    61.             e.printStackTrace();  
    62.         }  
    63.     }  
    64.   
    65.     //收到UDPClientA的回复内容,穿透已完成  
    66.     private static void receive(DatagramSocket client) {  
    67.         try {  
    68.             for (;;) {  
    69.                 //将接收到的内容打印  
    70.                 byte[] buf = new byte[1024];  
    71.                 DatagramPacket recpack = new DatagramPacket(buf, buf.length);  
    72.                 client.receive(recpack);  
    73.                 String receiveMessage = new String(recpack.getData(), 0, recpack.getLength());  
    74.                 System.out.println(receiveMessage);  
    75.   
    76.                 //记得重新收地址与端口,然后在以新地址发送内容到UPDClientA,就这样互发就可以了。  
    77.                 int port = recpack.getPort();  
    78.                 InetAddress address = recpack.getAddress();  
    79.                 String reportMessage = "I am master 192.168.85.129 count test";  
    80.   
    81.                 //发送消息  
    82.                 sendMessage(reportMessage, port, address, client);  
    83.             }  
    84.         } catch (Exception e) {  
    85.             e.printStackTrace();  
    86.         }  
    87.     }  
    88.   
    89.     private static void sendMessage(String reportMessage, int port, InetAddress address, DatagramSocket client) {  
    90.         try {  
    91.             byte[] sendBuf = reportMessage.getBytes();  
    92.             DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, address, port);  
    93.             client.send(sendPacket);  
    94.             System.out.println("send success");  
    95.         } catch (Exception e) {  
    96.             e.printStackTrace();  
    97.         }  
    98.     }  
    99. }  

UDP穿洞技术,P2P一些原理

标签:http   io   ar   os   使用   sp   java   for   on   

原文地址:http://www.cnblogs.com/liu-q/p/4134675.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!