最近公司要实如今各类网络环境下面的多屏互动（机顶盒、android phone、iphone及PC端）的需求；因为IP地址资源有限的缘由，目前咱们使用的各类终端设备都位于局域网后面也就是多台设备共享同一个公网IP；例如：若是位于局域网里面的一个终端Agent A要与互联网上的另外一个终端Agent B通讯，当A发送的data packet通过局域网出口处的NAT设备时，NAT会将data packet里面的source address字段替换成相应的公网IP和Port，而后再发送data packet到Agent B。Agent B看到的source address就是通过转换后的IP和Port并不知道Agent A的局域网地址；当Agent B的响应到达Agent A的NAT设备后，NAT设备查找内存中保存的和这个外网地址相对应的内网地址，若是找到后就将这个data packet转发到这个地址，这样就实现了通讯。html
然而因为目前存在着各类不一样类型的NAT设备对NAT有着不一样的实现方式（将内外地址映射成外网地址的时候有着不一样的行为方式），这就给NAT的穿透带来了麻烦；目前主要的NAT类型有以下几种：java
1)Full-cone NAT, also known as one-to-one NATandroid
- 一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将经过 eAddr:ePort 发送.
- 任何外部主机可以经过eAddr:ePort这个地址发送数据包到iAddr:iPort.
2)Address-restricted-cone NATapache
- 一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将经过 eAddr:ePort 发送.
- 仅只有接收到主机(iAddr:iPort)经过eAddr:ePort发送的数据包的外部主机经过该主机的任何端口发送到eAddr:ePort的数据包才可以被正确的转发到iAddr:iPort.也就是说主机有关端口无关.
3)Port-restricted cone NAT服务器
相似于address restricted cone NAT, 可是端口号有限制.网络
- 一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将经过 eAddr:ePort 发送.
- 仅只有接收到主机(iAddr:iPort)经过eAddr:ePort发送的数据包的外部主机经过该主机的相同端口发送到eAddr:ePort的数据包才可以被正确的转发到iAddr:iPort.
4)Symmetric NATapp
- 来自相同内部ip和port发送到相同目的地ip和port的请求被映射到惟一的外部ip和port地址；若是相同的内部主机采用相同的ip和port地址发送到不一样的目的地，那么从新分配映射地址。
- 只有先前收到内部主机发送的包的外部主机才可以发送返回包到内部主机。
针对前面三种NAT类型（即cone NAT）只要通讯双方彼此知道对方的内部地址和外部地址的映射关系，而后经过UDP打洞的方式就能够创建相互链接的通讯；可是第四种也就是Symmetric NAT的话因为每次向不一样目的地发送数据包时采用不一样的外部地址，也就没办法经过直接的方式创建P2P链接。iphone
1.各类网络环境下的P2P通讯解决方法：socket
（1）若是通讯双方在同一个局域网内，这种状况下能够不借助任何外力直接经过内网地址通讯便可；
（2）若是通讯双方都在有独立的公网地址，这种状况下固然能够不借助任何外力直接通讯便可；
（3）若是通讯双方一方拥有独立的公网地址另外一方在NAT后面，那么能够由位于NAT后面的一方主动发起通讯请求；ide
（4）若是通讯双方都位于NAT后面，且双方的NAT类型都是cone NAT，那么能够经过一个STUN服务器发现本身的NAT类型以及内网和外网传输地址映射信息，而后经过Signaling(信令服务器，实现了SIP协议的主机)交换彼此的NAT类型及内网和外网传输地址映射信息，而后经过UDP打洞的方式创建通讯链接；
（5）若是通讯双方有一方的NAT类型是Symmetric NAT，则没法直接创建P2P链接，这个时候就须要借助TURN(Traversal Using Relay NAT)即转发服务器来实现间接通讯；
2.协议及用到的相关技术介绍：
SDP(Session Description Protocol)
当初始化多媒体电视会议、IP电话、视频流等会话的时候，参与者之间会要求传送媒介的详细、传输地址和其余会话描述元数据等信息；SDP为这些信息提供一种和传输方式无关的标准的表现形式。也就是说SDP仅仅只是一种描述会话信息的格式。它主要被各类不一样的传输协议做为一种信息交换的格式使用列如：HTTP、RTSP、SIP、Email等各类协议。
如ICE里面的SDP内容为：
v=0 o=ice4j.org 0 0 IN IP4 192.168.106.215 s=- t=0 0 a=ice-options:trickle a=ice-ufrag:bc01a a=ice-pwd:1boove7ehnpo1lqho7unefni36 m=audio 3030 RTP/AVP 0 c=IN 192.168.106.215 IP4 a=mid:audio a=candidate:1 1 udp 2130706431 192.168.106.215 3030 typ host a=candidate:2 1 udp 1694498815 121.15.130.xxx 64923 typ srflx raddr 192.168.106.215 rport 3030
STUN(Session Traversal Utilities for NAT)
NAT会话穿透工具；STUN提供了一种方式使一个端点可以肯定NAT分配的和本地私有IP地址和端口相对应的公网IP地址和端口以及NAT的类型信息。它也为端点提供了一种方式保持一个NAT绑定不过时。NAT绑定过时则表示为相同的内网地址从新分配外网地址也就是端口号。
TURN(Traversal Using Relay NAT)
TURN是STUN协议的扩展，在实际应用中他也能够充当STUN的角色；若是一个位于NAT后面的设备想要和另一个位于NAT后面的设备创建通讯，当采用UDP打洞技术不能改实现的时候就必需要一台中间服务器扮演数据包转发的角色，这台TURN服务器须要拥有公网的IP地址；
SIP(Session Initiation Protocol)
是一种Signaling（信令）通讯协议；有许多互联网应用须要建立有多个参与者的会话和管理参与者之间相互的数据交换，然而若是这些工做让应用的参与者来实现是比较复杂的如：用户也许在端点之间移动、经过多个名称寻址和也许同时使用几种不一样的媒介通讯。有许多协议可以实现各类形式的多媒体会话进行数据传送例如声音、视频或者文本消息。SIP可以和这些协议一同合做，使一个客服端可以发现参与这个会话的其余客服端并共享同一会话。为了定位后面加入会话的参与者等功能，SIP可以为代理服务器建立基础设施，客服端能够经过这个代理服务器实现会话注册、邀请参与会话等功能。SIP是一个建立、修改和终止会话的灵活的多种用途的工具，不依赖于底层的传输协议而且不依赖于被建立的会话类型。
ICE(Interactive Connectivity Establishment)
是实现NAT穿透的一种技术方案；ICE是一种NAT穿透技术，经过offer/answer模型创建基于UDP的媒介流。ICE是offer/answer模型的扩展，经过在offer和answer的SDP里面包含多种IP地址和端口，而后对本地SDP和远程SDP里面的IP地址进行配对，而后经过P2P连通性检查进行连通性测试工做，若是测试经过即代表该传输地址对能够创建链接。其中IP地址和端口（也就是地址）有如下几种：本机地址、经过STUN服务器反射后获取的server-reflexive地址（内网地址被NAT映射后的地址）、relayed地址（和TURN转发服务器相对应的地址）及Peer reflexive地址等。
3.ICE进行NAT穿透的基本过程：
在一般的ICE部署环境中，咱们有两个客服端想要创建通讯链接，他们能够直接经过signaling服务器（如SIP服务器）执行offer/answer过程来交换SDP消息。
在ICE过程开始的时候，客服端忽略他们各自的网络拓扑结构，不论是不是在NAT设备后面或者多个NAT后面，ICE容许客服端发现他们的所在网络的拓扑结构的信息，而后找出一个或者更多的能够创建通讯链接的路径。
下图显示了一个典型的ICE部署环境，客服端L和R都在各自的NAT设备后面，下面简单描述下ICE创建通讯的过程：
（1）L和R先分别经过STUN和TURN服务器获取本身的host address,server-reflexive address、relayed address（和TURN转发服务器相对应的地址），其中server-reflexive address和relayed address经过定时刷新保证地址不过时。这些地址一般叫作candinate地址。
（2）给这些candinate地址分配优先级排序并格式化成SDP格式，经过SIP服务器交换彼此的SDP；
（3）交换完成后根据必定的原则把本地的候选和远程的候选进行配对，每一对都有本身的优先级并根据优先级进行排序后放入Check列表里面（两边都会有相同的Check列表）。
（4）而后进行链接性测试，测试前会选择一个客服端扮演Controlled角色和另外一个扮演Controling角色，连通性检查完成后扮演Controling角色的客服端负责在有效的Candinate对列表里面选择一个做为一个被选中的传输通道并通知Controlled的客服端。
（5）利用被选中的candinate地址对进行通讯。
4.ICE JAVA实现代码
我这里的样例代码采用ICE4J来实现，ICE4J的API文档能够参考http://bluejimp.com/jitsi/ice4j/javadoc/，在这个实现里面没有利用SIP服务器进行SDP信息的交换而是采用手动输入的方式，在生产环境中能够部署一台socket.io或者其余SIP服务器
1 /**
2 * Copyright (c) 2014 All Rights Reserved. 3 * TODO 4 */
5
6 import java.beans.PropertyChangeEvent; 7 import java.beans.PropertyChangeListener; 8 import java.io.BufferedReader; 9 import java.io.InputStreamReader; 10 import java.net.DatagramSocket; 11 import java.net.SocketAddress; 12 import java.util.List; 13
14 import org.apache.commons.lang3.StringUtils; 15 import org.apache.log4j.Logger; 16 import org.ice4j.Transport; 17 import org.ice4j.TransportAddress; 18 import org.ice4j.ice.Agent; 19 import org.ice4j.ice.Component; 20 import org.ice4j.ice.IceMediaStream; 21 import org.ice4j.ice.IceProcessingState; 22 import org.ice4j.ice.LocalCandidate; 23 import org.ice4j.ice.NominationStrategy; 24 import org.ice4j.ice.RemoteCandidate; 25 import org.ice4j.ice.harvest.StunCandidateHarvester; 26 import org.ice4j.ice.harvest.TurnCandidateHarvester; 27 import org.ice4j.security.LongTermCredential; 28
29 import test.SdpUtils; 30
31 public class IceClient { 32
33 private int port; 34
35 private String streamName; 36
37 private Agent agent; 38
39 private String localSdp; 40
41 private String remoteSdp; 42
43 private String[] turnServers = new String[] { "stun.jitsi.net:3478" }; 44
45 private String[] stunServers = new String[] { "stun.stunprotocol.org:3478" }; 46
47 private String username = "guest"; 48
49 private String password = "anonymouspower!!"; 50
51 private IceProcessingListener listener; 52
53 static Logger log = Logger.getLogger(IceClient.class); 54
55 public IceClient(int port, String streamName) { 56 this.port = port; 57 this.streamName = streamName; 58 this.listener = new IceProcessingListener(); 59 } 60
61 public void init() throws Throwable { 62
63 agent = createAgent(port, streamName); 64
65 agent.setNominationStrategy(NominationStrategy.NOMINATE_HIGHEST_PRIO); 66
67 agent.addStateChangeListener(listener); 68
69 agent.setControlling(false); 70
71 agent.setTa(10000); 72
73 localSdp = SdpUtils.createSDPDescription(agent); 74
75 log.info("=================== feed the following"
76 + " to the remote agent ==================="); 77
78 System.out.println(localSdp); 79
80 log.info("======================================"
81 + "========================================\n"); 82 } 83
84 public DatagramSocket getDatagramSocket() throws Throwable { 85
86 LocalCandidate localCandidate = agent 87 .getSelectedLocalCandidate(streamName); 88
89 IceMediaStream stream = agent.getStream(streamName); 90 List<Component> components = stream.getComponents(); 91 for (Component c : components) { 92 log.info(c); 93 } 94 log.info(localCandidate.toString()); 95 LocalCandidate candidate = (LocalCandidate) localCandidate; 96 return candidate.getDatagramSocket(); 97
98 } 99
100 public SocketAddress getRemotePeerSocketAddress() { 101 RemoteCandidate remoteCandidate = agent 102 .getSelectedRemoteCandidate(streamName); 103 log.info("Remote candinate transport address:"
104 + remoteCandidate.getTransportAddress()); 105 log.info("Remote candinate host address:"
106 + remoteCandidate.getHostAddress()); 107 log.info("Remote candinate mapped address:"
108 + remoteCandidate.getMappedAddress()); 109 log.info("Remote candinate relayed address:"
110 + remoteCandidate.getRelayedAddress()); 111 log.info("Remote candinate reflexive address:"
112 + remoteCandidate.getReflexiveAddress()); 113 return remoteCandidate.getTransportAddress(); 114 } 115
116 /**
117 * Reads an SDP description from the standard input.In production 118 * environment that we can exchange SDP with peer through signaling 119 * server(SIP server) 120 */
121 public void exchangeSdpWithPeer() throws Throwable { 122 log.info("Paste remote SDP here. Enter an empty line to proceed:"); 123 BufferedReader reader = new BufferedReader(new InputStreamReader( 124 System.in)); 125
126 StringBuilder buff = new StringBuilder(); 127 String line = new String(); 128
129 while ((line = reader.readLine()) != null) { 130 line = line.trim(); 131 if (line.length() == 0) { 132 break; 133 } 134 buff.append(line); 135 buff.append("\r\n"); 136 } 137
138 remoteSdp = buff.toString(); 139
140 SdpUtils.parseSDP(agent, remoteSdp); 141 } 142
143 public void startConnect() throws InterruptedException { 144
145 if (StringUtils.isBlank(remoteSdp)) { 146 throw new NullPointerException( 147 "Please exchange sdp information with peer before start connect! "); 148 } 149
150 agent.startConnectivityEstablishment(); 151
152 // agent.runInStunKeepAliveThread();
153
154 synchronized (listener) { 155 listener.wait(); 156 } 157
158 } 159
160 private Agent createAgent(int rtpPort, String streamName) throws Throwable { 161 return createAgent(rtpPort, streamName, false); 162 } 163
164 private Agent createAgent(int rtpPort, String streamName, 165 boolean isTrickling) throws Throwable { 166
167 long startTime = System.currentTimeMillis(); 168
169 Agent agent = new Agent(); 170
171 agent.setTrickling(isTrickling); 172
173 // STUN
174 for (String server : stunServers){ 175 String[] pair = server.split(":"); 176 agent.addCandidateHarvester(new StunCandidateHarvester( 177 new TransportAddress(pair[0], Integer.parseInt(pair[1]), 178 Transport.UDP))); 179 } 180
181 // TURN
182 LongTermCredential longTermCredential = new LongTermCredential(username, 183 password); 184
185 for (String server : turnServers){ 186 String[] pair = server.split(":"); 187 agent.addCandidateHarvester(new TurnCandidateHarvester( 188 new TransportAddress(pair[0], Integer.parseInt(pair[1]), Transport.UDP), 189 longTermCredential)); 190 } 191 // STREAMS
192 createStream(rtpPort, streamName, agent); 193
194 long endTime = System.currentTimeMillis(); 195 long total = endTime - startTime; 196
197 log.info("Total harvesting time: " + total + "ms."); 198
199 return agent; 200 } 201
202 private IceMediaStream createStream(int rtpPort, String streamName, 203 Agent agent) throws Throwable { 204 long startTime = System.currentTimeMillis(); 205 IceMediaStream stream = agent.createMediaStream(streamName); 206 // rtp
207 Component component = agent.createComponent(stream, Transport.UDP, 208 rtpPort, rtpPort, rtpPort + 100); 209
210 long endTime = System.currentTimeMillis(); 211 log.info("Component Name:" + component.getName()); 212 log.info("RTP Component created in " + (endTime - startTime) + " ms"); 213
214 return stream; 215 } 216
217 /**
218 * Receive notify event when ice processing state has changed. 219 */
220 public static final class IceProcessingListener implements
221 PropertyChangeListener { 222
223 private long startTime = System.currentTimeMillis(); 224
225 public void propertyChange(PropertyChangeEvent event) { 226
227 Object state = event.getNewValue(); 228
229 log.info("Agent entered the " + state + " state."); 230 if (state == IceProcessingState.COMPLETED) { 231 long processingEndTime = System.currentTimeMillis(); 232 log.info("Total ICE processing time: "
233 + (processingEndTime - startTime) + "ms"); 234 Agent agent = (Agent) event.getSource(); 235 List<IceMediaStream> streams = agent.getStreams(); 236
237 for (IceMediaStream stream : streams) { 238 log.info("Stream name: " + stream.getName()); 239 List<Component> components = stream.getComponents(); 240 for (Component c : components) { 241 log.info("------------------------------------------"); 242 log.info("Component of stream:" + c.getName() 243 + ",selected of pair:" + c.getSelectedPair()); 244 log.info("------------------------------------------"); 245 } 246 } 247
248 log.info("Printing the completed check lists:"); 249 for (IceMediaStream stream : streams) { 250
251 log.info("Check list for stream: " + stream.getName()); 252
253 log.info("nominated check list:" + stream.getCheckList()); 254 } 255 synchronized (this) { 256 this.notifyAll(); 257 } 258 } else if (state == IceProcessingState.TERMINATED) { 259 log.info("ice processing TERMINATED"); 260 } else if (state == IceProcessingState.FAILED) { 261 log.info("ice processing FAILED"); 262 ((Agent) event.getSource()).free(); 263 } 264 } 265 } 266 } 267
268 import java.io.IOException; 269 import java.net.DatagramPacket; 270 import java.net.DatagramSocket; 271 import java.net.SocketAddress; 272 import java.util.concurrent.TimeUnit; 273
274
275 public class PeerA { 276
277 public static void main(String[] args) throws Throwable { 278 try { 279 IceClient client = new IceClient(2020, "audio"); 280 client.init(); 281 client.exchangeSdpWithPeer(); 282 client.startConnect(); 283 final DatagramSocket socket = client.getDatagramSocket(); 284 final SocketAddress remoteAddress = client 285 .getRemotePeerSocketAddress(); 286 System.out.println(socket.toString()); 287 new Thread(new Runnable() { 288
289 public void run() { 290 while (true) { 291 try { 292 byte[] buf = new byte[1024]; 293 DatagramPacket packet = new DatagramPacket(buf, 294 buf.length); 295 socket.receive(packet); 296 System.out.println("receive:"
297 + new String(packet.getData(), 0, packet 298 .getLength())); 299 } catch (IOException e) { 300 // TODO Auto-generated catch block
301 e.printStackTrace(); 302 } 303
304 } 305 } 306 }).start(); 307
308 new Thread(new Runnable() { 309
310 public void run() { 311 int count = 1; 312 while (true) { 313 try { 314 byte[] buf = ("send msg " + count++ + "").getBytes(); 315 DatagramPacket packet = new DatagramPacket(buf, 316 buf.length); 317
318 packet.setSocketAddress(remoteAddress); 319 socket.send(packet); 320 System.out.println("send msg"); 321 TimeUnit.SECONDS.sleep(10); 322 } catch (Exception e) { 323 // TODO Auto-generated catch block
324 e.printStackTrace(); 325 } 326
327 } 328 } 329 }).start(); 330 } catch (Exception e) { 331 // TODO Auto-generated catch block
332 e.printStackTrace(); 333 } 334
335 } 336
337 }
5.参考资料