注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

淡忘邻人

二十七,始发愤

 
 
 

日志

 
 
 
 

UDP打洞原理及代码  

2010-05-24 17:20:01|  分类: C# |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

UDP"打洞"原理

 

1.       NAT分类

根据Stun协议(RFC3489),NAT大致分为下面四类

1)      Full Cone

这种NAT内部的机器A连接过外网机器C后,NAT会打开一个端口.然后外网的任何发到这个打开的端口的UDP数据报都可以到达A.不管是不是C发过来的.

例如 A:192.168.8.100 NAT:202.100.100.100 C:292.88.88.88
A(192.168.8.100:5000) -> NAT(202.100.100.100 : 8000) -> C(292.88.88.88:2000)
任何发送到 NAT(202.100.100.100:8000)的数据都可以到达A(192.168.8.100:5000)

2)      Restricted Cone

这种NAT内部的机器A连接过外网的机器C后,NAT打开一个端口.然后C可以用任何端口和A通信.其他的外网机器不行.

例如 A:192.168.8.100 NAT:202.100.100.100 C:292.88.88.88
A(192.168.8.100:5000) -> NAT(202.100.100.100 : 8000) -> C(292.88.88.88:2000)
任何从C发送到 NAT(202.100.100.100:8000)的数据都可以到达A(192.168.8.100:5000)

3)      Port Restricted Cone

这种NAT内部的机器A连接过外网的机器C后,NAT打开一个端口.然后C可以用原来的端口和A通信.其他的外网机器不行.

例如 A:192.168.8.100 NAT:202.100.100.100 C:292.88.88.88
A(192.168.8.100:5000) -> NAT(202.100.100.100 : 8000) -> C(292.88.88.88:2000)
C(202.88.88.88:2000)发送到 NAT(202.100.100.100:8000)的数据都可以到达A(192.168.8.100:5000)

以上三种NAT通称Cone NAT.我们只能用这种NAT进行UDP打洞.

4)      Symmetic

对于这种NAT.连接不同的外部目标.原来NAT打开的端口会变化.而Cone NAT不会.虽然可以用端口猜测.但是成功的概率很小.因此放弃这种NAT的UDP打洞.

2.       UDP hole punching

对于Cone NAT.要采用UDP打洞.需要一个公网机器C来充当”介绍人”.内网的A,B先分别和C通信.打开各自的NAT端口.C这个时候知道A,B的公网IP: Port. 现在A和B想直接连接.比如A给B发.除非B是Full Cone.否则不能通信.反之亦然.但是我们可以这样.

A要连接B.A给B发一个UDP包.同时.A让那个介绍人给B发一个命令,让B同时给A发一个UDP包.这样双方的NAT都会记录对方的IP,然后就会允许互相通信.

3.       同一个NAT后面的情况

如果A,B在同一个NAT后面.如果用上面的技术来进行互连.那么如果NAT支持loopback(就是本地到本地的转换),A,B可以连接,但是比较浪费带宽和NAT.有一种办法是,A,B和介绍人通信的时候,同时把自己的local IP也告诉服务器.A,B通信的时候,同时发local ip和公网IP.谁先到就用哪个IP.但是local ip就有可能不知道发到什么地方去了.比如A,B在不同的NAT后面但是他们各自的local ip段一样.A给B的local IP发的UDP就可能发给自己内部网里面的某某某了.

还有一个办法是服务器来判断A,B是否在一个NAT后面.(网络拓朴不同会不会有问题?)

 

WellKnown.cs

//WellKnown公用库
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Net;
using System.Net.Sockets;
using System.Collections;

namespace P2PWellKnown
{
/// <summary>
/// UDP用户登录事件委托
/// </summary>
/// <param name="sender">事件源对象</param>
/// <param name="e">事件实体</param>
public delegate void UdpUserLogInDelegate(object sender, UDPSockEventArgs e);

/// <summary>
/// 一般UDP消息事件委托
/// </summary>
/// <param name="sender">事件源对象</param>
/// <param name="e">事件实体</param>
public delegate void UdpMessageDelegate(object sender, UDPSockEventArgs e);

/// <summary>
/// 初始化一个新连接的事件委托
/// </summary>
/// <param name="sender">事件源对象</param>
/// <param name="e">事件实体</param>
public delegate void UdpNewConnectDelegate(object sender, UDPSockEventArgs e);

/// <summary>
/// P2P共享数据类
/// </summary>
public class P2PConsts
{
/// <summary>
/// UDP服务器监听端口
/// </summary>
public const int UDP_SRV_PORT = 2280;

/// <summary>
///TCP服务器监听端口
/// </summary>
public const int TCP_SRV_PORT = 2000;
}



/// <summary>
/// FormatterHelper 序列化,反序列化消息的帮助类
/// </summary>
public class FormatterHelper
{

public static byte[] Serialize(object obj)
{
BinaryFormatter binaryF
= new BinaryFormatter();
MemoryStream ms
= new MemoryStream(1024 * 10);
binaryF.Serialize(ms, obj);
ms.Seek(
0, SeekOrigin.Begin);
byte[] buffer = new byte[(int)ms.Length];
ms.Read(buffer,
0, buffer.Length);
ms.Close();
return buffer;
}



public static object Deserialize(byte[] buffer)
{
BinaryFormatter binaryF
= new BinaryFormatter();
MemoryStream ms
= new MemoryStream(buffer, 0, buffer.Length, false);
object obj = binaryF.Deserialize(ms);
ms.Close();
return obj;
}

}



/// <summary>
/// 用于承载UDPSock信息的事件类
/// </summary>
public class UDPSockEventArgs : EventArgs
{
/// <summary>
/// 要承载的消息
/// </summary>
private string m_strMsg;

/// <summary>
/// 用户信息
/// </summary>
private string m_strUserName;


/// <summary>
/// 触发该事件的公共终端
/// </summary>
private IPEndPoint m_EndPoint;


/// <summary>
/// 初始化UDPSock事件
/// </summary>
/// <param name="sMsg">用户发送的信息</param>
public UDPSockEventArgs(string sMsg)
:
base()
{
this.m_strMsg = sMsg;
}

/// <summary>
/// 远端用户名
/// </summary>
public string RemoteUserName
{
get
{
return m_strUserName;
}
set
{
m_strUserName
= value;
}
}


/// <summary>
/// 一般套接字消息
/// </summary>
public string SockMessage
{
get
{
return m_strMsg;
}
set
{
m_strMsg
= value;
}
}


/// <summary>
/// 公共远端节点
/// </summary>
public IPEndPoint RemoteEndPoint
{
get
{
return m_EndPoint;
}
set
{
m_EndPoint
= value;
}
}
}
}

 

 

 

 

 

 

 

 

UDPP2PSock.cs

 

//UDPP2PSock.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

using P2PWellKnown;

namespace UDPP
{
/// <summary>
/// UDPP2P套接字管理类
/// </summary>
public class UDPP2PSock
{
/// <summary>
/// 用户登录事件
/// </summary>
public event UdpUserLogInDelegate OnUserLogInU;

/// <summary>
/// 一般UDP消息事件
/// </summary>
public event UdpMessageDelegate OnSockMessageU;

/// <summary>
/// 初始化一个新连接事件
/// </summary>
public event UdpNewConnectDelegate OnNewConnectU;

/// <summary>
/// UDP服务器
/// </summary>
private UdpClient m_udpServer;

/// <summary>
/// UDP客户端
/// </summary>
private UdpClient m_udpClient;

/// <summary>
/// 服务器实际上在本地机器上监听的
/// 端口,用于当一台计算机上同时启
/// 动两个可两以上服务器进程时,标
/// 识不同的服务器进程
/// </summary>
private int m_iMyServerPort;

/// <summary>
/// 客户端在本地机器上实际使用的端口,
/// 用于当一台计算机上同时有两个或两
/// 个以上客户端进程在运行时,标识不
/// 同的客户端进程
/// </summary>
private int m_iMyClientPort;

/// <summary>
/// 标识是否已成功创服务器
/// </summary>
private bool m_bServerCreated;

/// <summary>
/// 标识是否已成功创建客户端
/// </summary>
private bool m_bClientCreated;

/// <summary>
/// 服务器使用的线程
/// </summary>
private Thread m_serverThread;

/// <summary>
/// 客户端使用的线程
/// </summary>
private Thread m_clientThread;

/// <summary>
/// 打洞线程
/// </summary>
//private Thread m_burrowThread;

/// <summary>
/// 远端节点
/// </summary>
private IPEndPoint m_remotePoint;

/// <summary>
/// 当前进程作为客户端的公共终端
/// </summary>
private string m_strMyPublicEndPoint;

/// <summary>
/// 当前进程作为客户端的私有终端
/// </summary>
private string m_strMyPrivateEndPoint;

/// <summary>
/// 用于接受信息的 StringBuilder实例
/// </summary>
private StringBuilder m_sbResponse = new StringBuilder();

/// <summary>
/// P2P打洞时标识是否收到回应消息
/// </summary>
private bool m_bRecvAck = false;

/// <summary>
/// 请求向其方向打洞的私有终端
/// </summary>
private IPEndPoint m_requestPrivateEndPoint;

/// <summary>
/// 请求向其方向打洞的公共终端
/// </summary>
private IPEndPoint m_requestPublicEndPoint;

/// <summary>
/// 打洞消息要发向的节点
/// </summary>
private ToEndPoint m_toEndPoint;

/// <summary>
/// 用于标识是否已经和请求客户端建立点对连接
/// </summary>
//private bool m_bHasConnected=false ;

/// <summary>
/// 创建服务器或客户端的最大尝试
/// 次数,为(65536-60000),防止
/// 因不能创建而限入死循环或使用
/// 无效端口
/// </summary>
private const int MAX_CREATE_TRY = 5536;

/// <summary>
/// 打洞时尝试连接的最大尝试次数
/// </summary>
private const int MAX_CONNECT_TRY = 10;


/// <summary>
/// 构造函数,初始化UDPP2P实例
/// </summary>
public UDPP2PSock()
{
m_iMyServerPort
= P2PConsts.UDP_SRV_PORT;
m_iMyClientPort
= 60000;
m_bClientCreated
= false;
m_bServerCreated
= false;
m_toEndPoint
= new ToEndPoint();
m_serverThread
= new Thread(new ThreadStart(RunUDPServer));
m_clientThread
= new Thread(new ThreadStart(RunUDPClient));
//m_burrowThread = new Thread(new ThreadStart(BurrowProc));
}

/// <summary>
/// 创建UDP 服务器
/// </summary>
public void CreateUDPSever()
{
int iTryNum = 0;

//开始尝试创建服务器
while (!m_bServerCreated && iTryNum < MAX_CREATE_TRY)
{
try
{
m_udpServer
= new UdpClient(m_iMyServerPort);
m_bServerCreated
= true;
}
catch
{
m_iMyServerPort
++;
iTryNum
++;
}
}

//创建失败,抛出异常
if (!m_bServerCreated && iTryNum == MAX_CREATE_TRY)
{
throw new Exception("创建服务器尝试失败!");
}
m_serverThread.Start();

}

/// <summary>
/// 创建UDP客户端
/// </summary>
/// <param name="strServerIP"& gt;服务器IP</param>
/// <param name="iServerPort"& gt;服务器端口</param>
public void CreateUDPClient(string strServerIP, int iServerPort)
{
int iTryNum = 0;

//开始尝试创建服务器
while (!m_bClientCreated && iTryNum < MAX_CREATE_TRY)
{
try
{
m_udpClient
= new UdpClient(m_iMyClientPort);
m_bClientCreated
= true;
string strIPAddress = (System.Net.Dns.GetHostAddresses("localhost")[0]).ToString();
m_strMyPrivateEndPoint
= strIPAddress + ":" + m_iMyClientPort.ToString();
}
catch
{
m_iMyClientPort
++;
iTryNum
++;
}
}

//创建失败,抛出异常
if (!m_bClientCreated && iTryNum == MAX_CREATE_TRY)
{
throw new Exception("创建客户端尝试失败!");
}

IPEndPoint hostPoint
= new IPEndPoint(IPAddress.Parse(strServerIP), iServerPort);
string strLocalIP = (System.Net.Dns.GetHostAddresses("localhost"))[0].ToString();
SendLocalPoint(strLocalIP, m_iMyClientPort, hostPoint);
m_clientThread.Start();
}


/// <summary>
/// 运行UDP 服务器
/// </summary>
private void RunUDPServer()
{
while (true)
{
byte[] msgBuffer = m_udpServer.Receive(ref m_remotePoint);
m_sbResponse.Append(System.Text.Encoding.Default.GetString(msgBuffer));
CheckCommand();
Thread.Sleep(
10);
}
}


/// <summary>
/// 运行UDP客户端
/// </summary>
private void RunUDPClient()
{
while (true)
{
byte[] msgBuffer = m_udpClient.Receive(ref m_remotePoint);
m_sbResponse.Append(System.Text.Encoding.Default.GetString(msgBuffer));
CheckCommand();
Thread.Sleep(
10);
}
}


/// <summary>
/// 销毁UDP 服务器
/// </summary>
public void DisposeUDPServer()
{
m_serverThread.Abort();
m_udpServer.Close();
}

/// <summary>
/// 销毁UDP客房端
/// </summary>
public void DisposeUDPClient()
{
m_clientThread.Abort();
m_udpClient.Close();
}

/// <summary>
/// 发送消息
/// </summary>
/// <param name="strMsg"& gt;消息内容</param>
/// <param name="REP"& gt;接收节点</param>
public void SendData(string strMsg, IPEndPoint REP)
{
byte[] byMsg = System.Text.Encoding.Default.GetBytes(strMsg.ToCharArray());
m_udpClient.Send(byMsg, byMsg.Length, REP);
}


/// <summary>
/// 发送消息,服务器专用
/// </summary>
/// <param name="strMsg"& gt;消息内容</param>
/// <param name="REP"& gt;接收节点</param>
private void ServerSendData(string strMsg, IPEndPoint REP)
{
byte[] byMsg = System.Text.Encoding.Default.GetBytes(strMsg.ToCharArray());
m_udpServer.Send(byMsg, byMsg.Length, REP);
}


/// <summary>
/// 发送本地节点信息
/// </summary>
/// <param name="strLocalIP"& gt;本地IP</param>
/// <param name="iLocalPort"& gt;本地端口</param>
public void SendLocalPoint(string strLocalIP, int iLocalPort, IPEndPoint REP)
{
string strLocalPoint = "\x01\x02" + strLocalIP + ":" + iLocalPort.ToString() + "\x02\x01";
SendData(strLocalPoint, REP);
}


/// <summary>
/// 同时向指定的终端(包括公共终端和私有终端)打洞
/// </summary>
/// <param name="pubEndPoint"& gt;公共终端</param>
/// <param name="prEndPoint"& gt;私有终端</param>
/// <returns>打洞成功返回true,否则返回false</returns>
public void StartBurrowTo(IPEndPoint pubEndPoint, IPEndPoint prEndPoint)
{
Thread burrowThread
= new Thread(new ThreadStart(BurrowProc));
m_toEndPoint.m_privateEndPoint
= prEndPoint;
m_toEndPoint.m_publicEndPoint
= pubEndPoint;
burrowThread.Start();
}


/// <summary>
/// 打洞线程
/// </summary>
private void BurrowProc()
{
IPEndPoint prEndPoint
= m_toEndPoint.m_privateEndPoint;
IPEndPoint pubEndPoint
= m_toEndPoint.m_publicEndPoint;
int j = 0;
for (int i = 0; i < MAX_CONNECT_TRY; i++)
{
SendData(
"\x01\x07\x07\x01", prEndPoint);
SendData(
"\x01\x07\x07\x01", pubEndPoint);

// 等待接收线程标记修改
for (j = 0; j < MAX_CONNECT_TRY; j++)
{
if (m_bRecvAck)
{
m_bRecvAck
= false;
SendData(
"\x01\x07\x07\x01", prEndPoint);
Thread.Sleep(
50);
SendData(
"\x01\x07\x07\x01", pubEndPoint);

UDPSockEventArgs args
= new UDPSockEventArgs("");
args.RemoteEndPoint
= pubEndPoint;
if (OnNewConnectU != null)
{
OnNewConnectU(
this, args);
}
//Thread .Sleep (System .Threading.Timeout .Infinite );
return;
}
else
{
Thread.Sleep(
100);
}
}

//如果没有收到目标主机的回应,表明本次打
// 洞尝试失败,等待100毫秒后尝试下一次打洞
Thread.Sleep(100);
}

//MAX_CONNECT_TRY 尝试都失败,表明打洞失败,抛出异常
//throw new Exception(" 打洞失败!");
System.Windows.Forms.MessageBox.Show("打洞失败!");////////////
}


/// <summary>
/// 转发打洞请求消息,在服务器端使用
/// </summary>
/// <param name="strSrcPrEndpoint"& gt;请求转发的源私有终端</param>
/// <param name="strSrcPubEndPoint"& gt;请求转发的源公共终端</param>
/// <param name="REP"& gt;转发消息到达的目的终端</param>
public void SendBurrowRequest(string strSrcPrEndpoint, string strSrcPubEndPoint, IPEndPoint REP)
{
string strBurrowMsg = "\x04\x07" + strSrcPrEndpoint + " " + strSrcPubEndPoint + "\x07\x04";
ServerSendData(strBurrowMsg, REP);
}


/// <summary>
/// 检查字符串中的命令
/// </summary>
private void CheckCommand()
{
int nPos;
string strCmd = m_sbResponse.ToString();

//如果接收远端用户名
if ((nPos = strCmd.IndexOf("\x01\x02")) > -1)
{
ReceiveName(strCmd, nPos);

// 反馈公共终给端远端主机
string strPubEPMsg = "\x03\x07" + m_remotePoint.ToString() + "\x07\x03";
SendData(strPubEPMsg, m_remotePoint);

return;
}

//如果接收我的公共终端
if ((nPos = strCmd.IndexOf("\x03\x07")) > -1)
{
ReceiveMyPublicEndPoint(strCmd, nPos);
return;
}

//如果是打洞请求消息
if ((nPos = strCmd.IndexOf("\x04\x07")) > -1)
{
ReceiveAndSendAck(strCmd, nPos);
return;
}

//如果是打洞回应消息
if ((nPos = strCmd.IndexOf("\x01\x07")) > -1)
{
m_bRecvAck
= true;
int nPos2 = strCmd.IndexOf("\x07\x01");
if (nPos2 > -1)
{
m_sbResponse.Remove(nPos, nPos2
- nPos + 2);
}



return;
}

//一般聊天消息
m_sbResponse.Remove(0, strCmd.Length);
RaiseMessageEvent(strCmd);
}


/// <summary>
/// 接收远端用户名
/// </summary>
/// <param name="strCmd"& gt;包含用户名的控制信息</param>
/// <param name="nPos"></param>
private void ReceiveName(string strCmd, int nPos)
{
int nPos2 = strCmd.IndexOf("\x02\x01");
if (nPos2 == -1)
{
return;
}
m_sbResponse.Remove(nPos, nPos2
- nPos + 2);

string strUserName = strCmd.Substring(nPos + 2, nPos2 - nPos - 2);
UDPSockEventArgs e
= new UDPSockEventArgs("");
e.RemoteUserName
= strUserName;
e.RemoteEndPoint
= m_remotePoint;

//触发用户登录事件
if (OnUserLogInU != null)
{
OnUserLogInU(
this, e);
}
}


/// <summary>
/// 接收打洞请求的消息并发送回应
/// </summary>
/// <param name="strCmd"></param>
/// <param name="nPos"></param>
private void ReceiveAndSendAck(string strCmd, int nPos)
{
int nPos2 = strCmd.IndexOf("\x07\x04");
if (nPos2 == -1)
{
return;
}
m_sbResponse.Remove(nPos, nPos2
- nPos + 2);

string strBurrowMsg = strCmd.Substring(nPos + 2, nPos2 - nPos - 2);

string[] strSrcPoint = strBurrowMsg.Split(' ');

//分析控制字符串包含的节点信息
string[] strPrEndPoint = strSrcPoint[0].Split(':');
string[] strPubEndPoint = strSrcPoint[1].Split(':');
m_requestPrivateEndPoint
= new IPEndPoint(IPAddress.Parse(strPrEndPoint[0]), int.Parse(strPrEndPoint[1]));
m_requestPublicEndPoint
= new IPEndPoint(IPAddress.Parse(strPubEndPoint[0]), int.Parse(strPubEndPoint[1]));

//向请求打洞终端的方向打洞
StartBurrowTo(m_requestPublicEndPoint, m_requestPrivateEndPoint);
}


/// <summary>
/// 接收我的公共终端
/// </summary>
/// <param name="strCmd"& gt;包含公共终端的控制信息</param>
/// <param name="nPos"& gt;控制字符串的起始位置</param>
private void ReceiveMyPublicEndPoint(string strCmd, int nPos)
{
int nPos2 = strCmd.IndexOf("\x07\x03");
if (nPos2 == -1)
{
return;
}
m_sbResponse.Remove(nPos, nPos2
- nPos + 2);

m_strMyPublicEndPoint
= strCmd.Substring(nPos + 2, nPos2 - nPos - 2);
}


/// <summary>
/// 触发一般UDP消息事件
/// </summary>
/// <param name="strMsg"& gt;消息内容</param>
private void RaiseMessageEvent(string strMsg)
{
UDPSockEventArgs args
= new UDPSockEventArgs("");
args.SockMessage
= strMsg;
args.RemoteEndPoint
= m_remotePoint;
if (OnSockMessageU != null)
{
OnSockMessageU(
this, args);
}
}


/// <summary>
/// 获取当前进程作为客户端的公共终端
/// </summary>
public string MyPublicEndPoint
{
get
{
return m_strMyPublicEndPoint;
}
}


/// <summary>
/// 获取当前进程作为客户端的私有终端
/// </summary>
public string MyPrivateEndPoint
{
get
{
return m_strMyPrivateEndPoint;
}
}
}


/// <summary>
/// 保存打洞消息要发向的节点信息
/// </summary>
class ToEndPoint
{
/// <summary>
/// 私有节点
/// </summary>
public IPEndPoint m_privateEndPoint;

/// <summary>
/// 公共节点
/// </summary>
public IPEndPoint m_publicEndPoint;
}
}

 

 

 

 

 

关于如何使用上述程序包的一些说明:
主要程序的初始化,参考代码如下:

 

using UDPP;
using P2PWellKnown;


//创建UDP服务器和客户端
try
{
string strServerIP = "127.0.0.1";
UDPP2PSock udpSock
= new UDPP2PSock();
udpSock.OnUserLogInU
+= new UdpUserLogInDelegate(OnUserLogInU);
udpSock.OnNewConnectU
+= new UdpNewConnectDelegate(OnNewConnectU);
udpSock.CreateUDPSever();
udpSock.CreateUDPClient(strServerIP, P2PConsts.UDP_SRV_PORT);
}
catch (Exception ex)
{

}

经上面的初始化后,就可以使用类UDPP2PSock中的方法了。

 

注:

udpSock.OnUserLogInU += new UdpUserLogInDelegate(OnUserLogInU);
udpSock.OnNewConnectU
+= new UdpNewConnectDelegate(OnNewConnectU);
中的
OnUserLogInU和OnNewConnectU是事件名称

private void test(object sender, UDPSockEventArgs e)
{
MessageBox.Show("ok");
}
  评论这张
 
阅读(1640)| 评论(1)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017