ＵＤＰ Ｐ２Ｐ通信

 http://bbs.bccn.net/thread-158657-1-1.html

 

网上很不错的一篇文章．介绍了Ｐ２Ｐ通信的原理，包括内外网打洞的原理。不光在ＵＤＰ上可以使用，在ＴＣＰ的两个内网间通信或Ｐ２Ｐ也有很大的参考价值。现转载文章并附上根据文章产生的源码。
值得提醒的是，在序列化与反序列化过程中需要明白程序集的概念。服务器端及客户端要求使用相同的程序集名，否则会出现unable to assembly ....的错误。

nat(network address translators)，网络地址转换：网络地址转换是在ip地址日益缺乏的情况下产生的，它的主要目的就是为了能够地址重用。nat分为两大类，基本的nat和napt(network address/port translator)。
最开始nat是运行在路由器上的一个功能模块。
最先提出的是基本的nat，它的产生基于如下事实：一个私有网络（域）中的节点中只有很少的节点需要与外网连接（呵呵，这是在上世纪90年代中期提出的）。那么这个子网中其实只有少数的节点需要全球唯一的ip地址，其他的节点的ip地址应该是可以重用的。
因此，基本的nat实现的功能很简单，在子网内使用一个保留的ip子网段，这些ip对外是不可见的。子网内只有少数一些ip地址可以对应到真正全球唯一的ip地址。如果这些节点需要访问外部网络，那么基本nat就负责将这个节点的子网内ip转化为一个全球唯一的ip然后发送出去。(基本的nat会改变ip包中的原ip地址，但是不会改变ip包中的端口)
关于基本的nat可以参看rfc 1631
另外一种nat叫做napt，从名称上我们也可以看得出，napt不但会改变经过这个nat设备的ip数据报的ip地址，还会改变ip数据报的tcp/udp端口。基本nat的设备可能我们见的不多（呵呵，我没有见到过），napt才是我们真正讨论的主角。看下图：
有一个私有网络10.*.*.*，client a是其中的一台计算机，这个网络的网关（一个nat设备）的外网ip是155.99.25.11(应该还有一个内网的ip地址，比如10.0.0.10)。如果client a中的某个进程（这个进程创建了一个udp socket,这个socket绑定1234端口）想访问外网主机18.181.0.31的1235端口，那么当数据包通过nat时会发生什么事情呢？
先nat会改变这个数据包的原ip地址，改为155.99.25.11。接着nat会为这个传输创建一个session（session是一个抽象的概念，如果是tcp，也许session是由一个syn包开始，以一个fin包结束。而udp呢，以这个ip的这个端口的第一个udp开始，结束呢，呵呵，也许是几分钟，也许是几小时，这要看具体的实现了）并且给这个session分配一个端口，比如62000，然后改变这个数据包的源端口为62000。所以本来是（10.0.0.1:1234->18.181.0.31:1235）的数据包到了互联网上变为了（155.99.25.11:62000->18.181.0.31:1235）。一旦nat创建了一个session后，nat会记住62000端口对应的是10.0.0.1的1234端口，以后从18.181.0.31发送到62000端口的数据会被nat自动的转发到10.0.0.1上。（注意：这里是说18.181.0.31发送到62000端口的数据会被转发，其他的ip发送到这个端口的数据将被nat抛弃）这样client a就与server s1建立以了一个连接。
呵呵，上面的基础知识可能很多人都知道了，那么下面是关键的部分了。
看看下面的情况：
接上面的例子，如果client a的原来那个socket(绑定了1234端口的那个udp socket)又接着向另外一个server s2发送了一个udp包，那么这个udp包在通过nat时会怎么样呢？
这时可能会有两种情况发生，一种是nat再次创建一个session，并且再次为这个session分配一个端口号（比如：62001）。另外一种是nat再次创建一个session，但是不会新分配一个端口号，而是用原来分配的端口号62000。前一种nat叫做symmetric nat，后一种叫做cone nat。我们期望我们的nat是第二种，呵呵，如果你的nat刚好是第一种，那么很可能会有很多p2p软件失灵。（可以庆幸的是，现在绝大多数的nat属于后者，即cone nat）
好了，我们看到，通过nat,子网内的计算机向外连结是很容易的（nat相当于透明的，子网内的和外网的计算机不用知道nat的情况）。
但是如果外部的计算机想访问子网内的计算机就比较困难了（而这正是p2p所需要的）。
那么我们如果想从外部发送一个数据报给内网的计算机有什么办法呢？首先，我们必须在内网的nat上打上一个“洞”（也就是前面我们说的在nat上建立一个session），这个洞不能由外部来打，只能由内网内的主机来打。而且这个洞是有方向的，比如从内部某台主机（比如：192.168.0.10）向外部的某个ip(比如：219.237.60.1)发送一个udp包，那么就在这个内网的nat设备上打了一个方向为219.237.60.1的“洞”，（这就是称为udp hole punching的技术）以后219.237.60.1就可以通过这个洞与内网的192.168.0.10联系了。（但是其他的ip不能利用这个洞）。
呵呵，现在该轮到我们的正题p2p了。有了上面的理论，实现两个内网的主机通讯就差最后一步了：那就是鸡生蛋还是蛋生鸡的问题了，两边都无法主动发出连接请求，谁也不知道谁的公网地址，那我们如何来打这个洞呢？我们需要一个中间人来联系这两个内网主机。
现在我们来看看一个p2p软件的流程，以下图为例：
首先，client a登录服务器，nat a为这次的session分配了一个端口60000，那么server s收到的client a的地址是202.187.45.3:60000，这就是client a的外网地址了。同样，client b登录server s，nat b给此次session分配的端口是40000，那么server s收到的b的地址是187.34.1.56:40000。此时，client a与client b都可以与server s通信了。如果client a此时想直接发送信息给client b，那么他可以从server s那儿获得b的公网地址187.34.1.56:40000，是不是client a向这个地址发送信息client b就能收到了呢？答案是不行，因为如果这样发送信息，nat b会将这个信息丢弃（因为这样的信息是不请自来的，为了安全，大多数nat都会执行丢弃动作）。现在我们需要的是在nat b上打一个方向为202.187.45.3（即client a的外网地址）的洞，那么client a发送到187.34.1.56:40000的信息,client b就能收到了。这个打洞命令由谁来发呢，呵呵，当然是server s。
总结一下这个过程：如果client a想向client b发送信息，那么client a发送命令给server s，请求server s命令client b向client a方向打洞。呵呵，是不是很绕口，不过没关系，想一想就很清楚了，何况还有源代码呢（侯老师说过：在源代码面前没有秘密 8）），然后client a就可以通过client b的外网地址与client b通信了。
注意：以上过程只适合于cone nat的情况，如果是symmetric nat，那么当client b向client a打洞的端口已经重新分配了，client b将无法知道这个端口（如果symmetric nat的端口是顺序分配的，那么我们或许可以猜测这个端口号，可是由于可能导致失败的因素太多，我们不推荐这种猜测端口的方法）。
下面是一个模拟p2p聊天的过程的源代码，过程很简单，p2pserver运行在一个拥有公网ip的计算机上，p2pclient运行在两个不同的nat后（注意，如果两个客户端运行在一个nat后，本程序很可能不能运行正常，这取决于你的nat是否支持loopback translation，详见http://midcom-p2p.sourceforge.net/draft-ford-midcom-p2p-01.txt，当然，此问题可以通过双方先尝试连接对方的内网ip来解决，但是这个代码只是为了验证原理，并没有处理这些问题），后登录的计算机可以获得先登录计算机的用户名，后登录的计算机通过send username message的格式来发送消息。如果发送成功，说明你已取得了直接与对方连接的成功。

1.公共库：WellKnown
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Net;
using System.Net.Sockets;
using System.Collections;

namespace WellKnown
{
/// <summary>
/// P2PConsts 的摘要说明。
/// </summary>
public class P2PConsts
{
/// <summary>
/// 服务器侦听端口号
/// </summary>
public const int SRV_PORT = 2280;

}

/// <summary>
/// User 的摘要说明。
/// </summary>
[Serializable]
public class User
{
protected string userName;
protected IPEndPoint netPoint;

public User(string UserName, IPEndPoint NetPoint)
{
this.userName = UserName;
this.netPoint = NetPoint;
}

public string UserName
{
get { return userName;}
set { userName = value;}
}

public IPEndPoint NetPoint
{
get { return netPoint; }
set { netPoint = value;}
}
}

/// <summary>
/// UserCollection 的摘要说明。
/// </summary>
[Serializable]
public class UserCollection : CollectionBase
{
public void Add(User user)
{
InnerList.Add(user);
}

public void Remove(User user)
{
InnerList.Remove(user);
}

public User this[int index]
{
get { return (User)InnerList[index]; }
}

public User Find(string userName)
{
foreach(User user in this)
{
if (string.Compare(userName, user.UserName, true) == 0)
{
return user;
}
}
return null;
}
}

/// <summary>
/// FormatterHelper 序列化，反序列化消息的帮助类
/// </summary>
///
[Serializable]
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>
/// Message base class
/// </summary>
[System.Serializable]
public abstract class MessageBase
{
}

// Message from Client to Server
namespace C2S
{
/// <summary>
/// 客户端发送到服务器的消息基类
/// </summary>
[Serializable]
public abstract class CSMessage : MessageBase
{
private string userName;
protected CSMessage(string anUserName)
{
userName = anUserName;
}

public string UserName
{
get { return userName; }
}
}

/// <summary>
/// 用户登录消息
/// </summary>
///
[Serializable]
public class LoginMessage : CSMessage
{

private string password;
public LoginMessage(string userName, string password) : base(userName)
{
this.password = password;
}
public string Password
{
get { return password; }
}
}

/// <summary>
/// 用户登出消息
/// </summary>
[Serializable]
public class LogoutMessage : CSMessage
{
public LogoutMessage(string userName) : base(userName)
{}
}

/// <summary>
/// 请求用户列表消息
/// </summary>
[Serializable]
public class GetUsersMessage : CSMessage
{
public GetUsersMessage(string userName) : base(userName)
{}
}

/// <summary>
/// 请求Purch Hole消息
/// </summary>
[Serializable]
public class TranslateMessage : CSMessage
{
protected string toUserName;
public TranslateMessage(string userName, string toUserName) : base(userName)
{
this.toUserName = toUserName;
}
public string ToUserName
{
get { return this.toUserName; }
}
}
}

// Message from server to the client
namespace S2C
{
/// <summary>
/// 服务器发送到客户端消息基类
/// </summary>
[Serializable]
public abstract class SCMessage : MessageBase
{}

/// <summary>
/// 请求用户列表应答消息
/// </summary>
[Serializable]
public class GetUsersResponseMessage : SCMessage
{
private UserCollection userList;
public GetUsersResponseMessage(UserCollection users)
{
this.userList = users;
}

public UserCollection UserList
{
get { return userList; }
}
}

/// <summary>
/// 转发请求Purch Hole消息
/// </summary>
[Serializable]
public class SomeOneCallYouMessage : SCMessage
{
protected System.Net.IPEndPoint remotePoint;
public SomeOneCallYouMessage(System.Net.IPEndPoint point)
{
this.remotePoint = point;
}

public System.Net.IPEndPoint RemotePoint
{
get { return remotePoint; }
}
}
}

// Message from peer to the peer
namespace P2P
{
/// <summary>
/// 点对点消息基类
/// </summary>
[Serializable]
public abstract class PPMessage : MessageBase
{}

/// <summary>
/// 测试消息
/// </summary>
[Serializable]
public class WorkMessage : PPMessage
{
private string message;
public WorkMessage(string msg)
{
message = msg;
}

public string Message
{
get { return message; }
}
}

/// <summary>
/// 测试应答消息
/// </summary>
[Serializable]
public class ACKMessage : PPMessage
{

}

/// <summary>
/// P2P Purch Hole Message
/// </summary>
public class TrashMessage : PPMessage
{}

}
}

2. Server
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using WellKnown;

namespace P2PServer
{
/// <summary>
/// Class1 的摘要说明。
/// </summary>
class Class1
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
Server server = new Server();
try
{
server.Start();
Console.ReadLine();
server.Stop();
}
catch
{}
}
}

/// <summary>
/// Server 的摘要说明。
/// </summary>
public class Server
{
private UdpClient server;
private UserCollection userList;
private Thread serverThread;
private IPEndPoint remotePoint;

public Server()
{
userList = new UserCollection();
remotePoint = new IPEndPoint(IPAddress.Any, 0);
serverThread = new Thread(new ThreadStart(Run));
}

public void Start()
{
try
{
server = new UdpClient(P2PConsts.SRV_PORT);
serverThread.Start();
Console.WriteLine("P2P Server started, waiting client connect...");
}
catch(Exception exp)
{
Console.WriteLine("Start P2P Server error: " + exp.Message);
throw exp;
}
}

public void Stop()
{
Console.WriteLine("P2P Server stopping...");
try
{
serverThread.Abort();
server.Close();
Console.WriteLine("Stop OK.");
}
catch(Exception exp)
{
Console.WriteLine("Stop error: " + exp.Message);
throw exp;
}
}

private void Run()
{
byte[] buffer = null;
while (true)
{
byte[] msgBuffer = server.Receive(ref remotePoint);
try
{
object msgObj = FormatterHelper.Deserialize(msgBuffer);
Type msgType = msgObj.GetType();
if (msgType == typeof(WellKnown.C2S.LoginMessage))
{
// 转换接受的消息
WellKnown.C2S.LoginMessage lginMsg = (WellKnown.C2S.LoginMessage)msgObj;
Console.WriteLine("has an user login: {0}", lginMsg.UserName);

// 添加用户到列表
IPEndPoint userEndPoint = new IPEndPoint(remotePoint.Address, remotePoint.Port);
User user = new User(lginMsg.UserName, userEndPoint);
userList.Add(user);

// 发送应答消息
WellKnown.S2C.GetUsersResponseMessage usersMsg = new WellKnown.S2C.GetUsersResponseMessage(userList);
buffer = FormatterHelper.Serialize(usersMsg);
server.Send(buffer, buffer.Length, remotePoint);
}
else if (msgType == typeof(WellKnown.C2S.LogoutMessage))
{
// 转换接受的消息
WellKnown.C2S.LogoutMessage lgoutMsg = (WellKnown.C2S.LogoutMessage)msgObj;
Console.WriteLine("has an user logout: {0}", lgoutMsg.UserName);

// 从列表中删除用户
User lgoutUser = userList.Find(lgoutMsg.UserName);
if (lgoutUser != null)
{
userList.Remove(lgoutUser);
}
}
else if (msgType == typeof(WellKnown.C2S.TranslateMessage))
{
// 转换接受的消息
WellKnown.C2S.TranslateMessage transMsg = (WellKnown.C2S.TranslateMessage)msgObj;
Console.WriteLine("{0}(1) wants to p2p {2}", remotePoint.Address.ToString(), transMsg.UserName, transMsg.ToUserName);

// 获取目标用户
User toUser = userList.Find(transMsg.ToUserName);

// 转发Purch Hole请求消息
if (toUser == null)
{
Console.WriteLine("Remote host {0} cannot be found at index server", transMsg.ToUserName);
}
else
{
WellKnown.S2C.SomeOneCallYouMessage transMsg2 = new WellKnown.S2C.SomeOneCallYouMessage(remotePoint);
buffer = FormatterHelper.Serialize(transMsg);
server.Send(buffer, buffer.Length, toUser.NetPoint);
}
}
else if (msgType == typeof(WellKnown.C2S.GetUsersMessage))
{
// 发送当前用户信息到所有登录客户
WellKnown.S2C.GetUsersResponseMessage srvResMsg = new WellKnown.S2C.GetUsersResponseMessage(userList);
buffer = FormatterHelper.Serialize(srvResMsg);
foreach(User user in userList)
{
server.Send(buffer, buffer.Length, user.NetPoint);
}
}
Thread.Sleep(500);
}
catch(Exception exp)
{
Console.WriteLine("error: " + exp.Message);
throw exp;
}
}
}
}
}

 

//////////////////////////

3. Client
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using WellKnown;

namespace P2PClient
{
/// <summary>
/// Class1 的摘要说明。
/// </summary>
class Class1
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
Client client = new Client("192.168.1.141");
client.ConnectToServer("myname2", "mypassword");
client.Start();
Console.WriteLine("test arguments");
while (true)
{
string str = Console.ReadLine();
client.PaserCommand(str);
}
}
}

/// <summary>
/// Client 的摘要说明。
/// </summary>
public class Client : IDisposable
{
private const int MAXRETRY = 10;
// private UdpClient client;
private UdpClient client;
private IPEndPoint hostPoint;
private IPEndPoint remotePoint;
private UserCollection userList;
private string myName;
private bool ReceivedACK;
private Thread listenThread;

public Client(string serverIP)
{
ReceivedACK = false;
remotePoint = new IPEndPoint(IPAddress.Any, 0);
hostPoint = new IPEndPoint(IPAddress.Parse(serverIP), P2PConsts.SRV_PORT);
client = new UdpClient();
userList = new UserCollection();
listenThread = new Thread(new ThreadStart(Run));
}

public void Start()
{
if (this.listenThread.ThreadState==ThreadState.Unstarted)
{
this.listenThread.Start();
Console.WriteLine("You can input you command:\n");
Console.WriteLine("Command Type:\"send\",\"exit\",\"getu\"");
Console.WriteLine("Example : send Username Message");
Console.WriteLine(" exit");
Console.WriteLine(" getu");
}
}

public void ConnectToServer(string userName, string password)
{
myName = userName;
// 发送登录消息到服务器
WellKnown.C2S.LoginMessage lginMsg = new WellKnown.C2S.LoginMessage(userName, password);
byte[] buffer = FormatterHelper.Serialize(lginMsg);
client.Send(buffer, buffer.Length, hostPoint);
// 接受服务器的登录应答消息
buffer = client.Receive(ref remotePoint);
WellKnown.S2C.GetUsersResponseMessage srvResMsg = (WellKnown.S2C.GetUsersResponseMessage)FormatterHelper.Deserialize(buffer);
// 更新用户列表
userList.Clear();
foreach(User user in srvResMsg.UserList)
{
userList.Add(user);
}
this.DisplayUsers(userList);
}

/// <summary>
/// 这是主要的函数：发送一个消息给某个用户(C)
/// 流程：直接向某个用户的外网IP发送消息，如果此前没有联系过
/// 那么此消息将无法发送，发送端等待超时。
/// 超时后，发送端将发送一个请求信息到服务端，要求服务端发送
/// 给客户C一个请求，请求C给本机发送打洞消息
/// *以上流程将重复MAXRETRY次
/// </summary>
/// <param name="toUserName">对方用户名</param>
/// <param name="message">待发送的消息</param>
/// <returns></returns>

private bool SendMessageTo(string toUserName, string message)
{
User toUser = userList.Find(toUserName);
if (toUser == null)
{
return false;
}
for (int i=0; i<MAXRETRY; i++)
{
WellKnown.P2P.WorkMessage workMsg = new WellKnown.P2P.WorkMessage(message);
byte[] buffer = FormatterHelper.Serialize(workMsg);
client.Send(buffer, buffer.Length, toUser.NetPoint);

// 等待接收线程将标记修改
for (int j=0; j<10; j++)
{
if (this.ReceivedACK)
{
this.ReceivedACK = false;
return true;
}
else
{
Thread.Sleep(300);
}
}
// 没有接收到目标主机的回应，认为目标主机的端口映射没有
// 打开，那么发送请求信息给服务器，要服务器告诉目标主机
// 打开映射端口（UDP打洞）
WellKnown.C2S.TranslateMessage transMsg = new WellKnown.C2S.TranslateMessage(myName, toUserName);
buffer = FormatterHelper.Serialize(transMsg);
client.Send(buffer, buffer.Length, hostPoint);
// 等待对方先发送信息
Thread.Sleep(100);
}
return false;
}

public void PaserCommand(string cmdstring)
{
cmdstring = cmdstring.Trim();
string[] args = cmdstring.Split(new char[]{' '});
if (args.Length > 0)
{
if (string.Compare(args[0], "exit", true) == 0)
{
WellKnown.C2S.LogoutMessage lgoutMsg = new WellKnown.C2S.LogoutMessage(myName);
byte[] buffer = FormatterHelper.Serialize(lgoutMsg);
client.Send(buffer, buffer.Length, hostPoint);
// do clear something here
Dispose();
System.Environment.Exit(0);
}
else if (string.Compare(args[0], "send", true) == 0)
{
if (args.Length > 2)
{
string toUserName = args[1];
string message = "";
for(int i=2; i<args.Length; i++)
{
if (args[i] == "") message += " ";
else message += args[i];
}
if (this.SendMessageTo(toUserName, message))
{
Console.WriteLine("Send OK!");
}
else
Console.WriteLine("Send Failed!");
}
}
else if (string.Compare(args[0], "getu", true) == 0)
{
WellKnown.C2S.GetUsersMessage getUserMsg = new WellKnown.C2S.GetUsersMessage(myName);
byte[] buffer = FormatterHelper.Serialize(getUserMsg);
client.Send(buffer, buffer.Length, hostPoint);
}
else
{
Console.WriteLine("Unknown command {0}", cmdstring);
}
}
}

private void DisplayUsers(UserCollection users)
{
foreach (User user in users)
{
Console.WriteLine("Username: {0}, IP:{1}, Port:{2}", user.UserName, user.NetPoint.Address.ToString(), user.NetPoint.Port);
}
}

private void Run()
{
byte[] buffer;
while (true)
{
buffer = client.Receive(ref remotePoint);
object msgObj = FormatterHelper.Deserialize(buffer);
Type msgType = msgObj.GetType();
if (msgType == typeof(WellKnown.S2C.GetUsersResponseMessage))
{
// 转换消息
WellKnown.S2C.GetUsersResponseMessage usersMsg = (WellKnown.S2C.GetUsersResponseMessage)msgObj;
// 更新用户列表
userList.Clear();
foreach(User user in usersMsg.UserList)
{
userList.Add(user);
}
this.DisplayUsers(userList);
}
else if (msgType == typeof(WellKnown.S2C.SomeOneCallYouMessage))
{
// 转换消息
WellKnown.S2C.SomeOneCallYouMessage purchReqMsg = (WellKnown.S2C.SomeOneCallYouMessage)msgObj;
// 发送打洞消息到远程主机
WellKnown.P2P.TrashMessage trashMsg = new WellKnown.P2P.TrashMessage();
buffer = FormatterHelper.Serialize(trashMsg);
client.Send(buffer, buffer.Length, purchReqMsg.RemotePoint);
}
else if (msgType == typeof(WellKnown.P2P.WorkMessage))
{
// 转换消息
WellKnown.P2P.WorkMessage workMsg = (WellKnown.P2P.WorkMessage)msgObj;
Console.WriteLine("Receive a message: {0}", workMsg.Message);
// 发送应答消息
WellKnown.P2P.ACKMessage ackMsg = new WellKnown.P2P.ACKMessage();
buffer = FormatterHelper.Serialize(ackMsg);
client.Send(buffer, buffer.Length, remotePoint);
}
else if (msgType == typeof(WellKnown.P2P.ACKMessage))
{
this.ReceivedACK = true;
}
else if (msgType == typeof(WellKnown.P2P.TrashMessage))
{
Console.WriteLine("Recieve a trash message");
}
Thread.Sleep(100);
}
}

#region IDisposable 成员
public void Dispose()
{
try
{
this.listenThread.Abort();
this.client.Close();
}
catch
{}
}
#endregion
}
}