UDP穿越NAT的原理和实现

最新推荐文章于 2021-07-27 17:24:57 发布
最新推荐文章于 2021-07-27 17:24:57 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： .Net 文章标签： buffer string server user class session
坛上经常有对P2P原理的讨论，但是讨论归讨论，很少有实质的东西产生（源代码）。呵呵，在这里我就用自己实现的一个源代码来说明UDP穿越NAT的原理。
首先先介绍一些基本概念：
    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的格式来发送消息。如果发送成功，说明你已取得了直接与对方连接的成功。
    程序现在支持三个命令：send , getu , exit
   
    send格式：send username message
   功能：发送信息给username
   
    getu格式：getu
    功能：获得当前服务器用户列表
   
    exit格式：exit
功能：注销与服务器的连接（服务器不会自动监测客户是否吊线）
 
源代码
注：原文代码是用C++写的，这里仅附上C#代码
1．  WellKnown公用库
namespace P2P.WellKnown
{
    using System;
    using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
    ///<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; }
        }
 
        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>
    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>
        public abstract class CSMessage : MessageBase
        {
            private string userName;
            protected CSMessage(string anUserName)
            {
                userName = anUserName;
            }
            public string UserName
            {
                get { return userName; }
            }
        }
        ///<summary>
        /// 用户登录消息
        ///</summary>
        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>
        public class LogoutMessage : CSMessage
        {
            public LogoutMessage(string userName) : base(userName)
            {}
        }
        ///<summary>
        /// 请求用户列表消息
        ///</summary>
        public class GetUsersMessage : CSMessage
        {
            public GetUsersMessage(string userName) : base(userName)
            {}
        }
        ///<summary>
        /// 请求Purch Hole消息
        ///</summary>
        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>
        public abstract class SCMessage : MessageBase
        {}
        ///<summary>
        /// 请求用户列表应答消息
        ///</summary>
        public class GetUsersResponseMessage : SCMessage
        {
            private UserCollection userList;
            public GetUsersResponseMessage(UserCollection users)
            {
                this.userList = users;
            }
            public UserCollection UserList
            {
                get { return userList; }
            }
        }
        ///<summary>
        /// 转发请求Purch Hole消息
        ///</summary>
        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>
        public abstract class PPMessage : MessageBase
        {}
        ///<summary>
        /// 测试消息
        ///</summary>
        public class WorkMessage : PPMessage
        {
            private string message;
            public WorkMessage(string msg)
            {
                message = msg;
            }
            public string Message
            {
                get { return message; }
            }
        }
        ///<summary>
        /// 测试应答消息
        ///</summary>
        public class ACKMessage : PPMessage
        {
        }
        ///<summary>
        /// P2P Purch Hole Message
        ///</summary>
        public class TrashMessage : PPMessage
        {}
    }  
}
 
 
2． P2Pserver
namespace P2P.P2PServer
{
    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using P2P.WellKnown;
    ///<summary>
    /// AppClass 的摘要说明。
    ///</summary>
    public class AppClass
    {
        public static void Main()
        {
            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(P2P.WellKnown.C2S.LoginMessage))
                    {
                        // 转换接受的消息
                        P2P.WellKnown.C2S.LoginMessage lginMsg = (P2P.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);
                        // 发送应答消息
                        P2P.WellKnown.S2C.GetUsersResponseMessage usersMsg = new P2P.WellKnown.S2C.GetUsersResponseMessage(userList);
                        buffer = FormatterHelper.Serialize(usersMsg);
                        server.Send(buffer, buffer.Length, remotePoint);
                    }
                    else if (msgType == typeof(P2P.WellKnown.C2S.LogoutMessage))
                    {
                        // 转换接受的消息
                        P2P.WellKnown.C2S.LogoutMessage lgoutMsg = (P2P.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(P2P.WellKnown.C2S.TranslateMessage))
                    {
                        // 转换接受的消息
                        P2P.WellKnown.C2S.TranslateMessage transMsg = (P2P.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
                        {
                            P2P.WellKnown.S2C.SomeOneCallYouMessage transMsg2 = new P2P.WellKnown.S2C.SomeOneCallYouMessage(remotePoint);
                            buffer = FormatterHelper.Serialize(transMsg);
                            server.Send(buffer, buffer.Length, toUser.NetPoint);                           
                        }
                    }
                    else if (msgType == typeof(P2P.WellKnown.C2S.GetUsersMessage))
                    {
                        // 发送当前用户信息到所有登录客户
                        P2P.WellKnown.S2C.GetUsersResponseMessage srvResMsg = new P2P.WellKnown.S2C.GetUsersResponseMessage(userList);                       
                        buffer = FormatterHelper.Serialize(srvResMsg);
                        foreach(User user in userList)
                        {
                            server.Send(buffer, buffer.Length, user.NetPoint);
                        }
                    }
                    Thread.Sleep(500);
                }
                catch{}
            }
        }
    }
}
 
 
3． P2Pclient
namespace P2P.P2PClient
{
    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using P2P.WellKnown;
    ///<summary>
    /// AppClass 的摘要说明。
    ///</summary>
    public class AppClass
    {
        public static void Main()
        {
            Client client = new Client("202.96.134.103");
            client.ConnectToServer("myname", "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 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;
            // 发送登录消息到服务器
            P2P.WellKnown.C2S.LoginMessage lginMsg = new P2P.WellKnown.C2S.LoginMessage(userName, password);
            byte[] buffer = FormatterHelper.Serialize(lginMsg);
            client.Send(buffer, buffer.Length, hostPoint);
            // 接受服务器的登录应答消息
            buffer = client.Receive(ref remotePoint);
            P2P.WellKnown.S2C.GetUsersResponseMessage srvResMsg = (P2P.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++)
            {
                P2P.WellKnown.P2P.WorkMessage workMsg = new P2P.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打洞）
                P2P.WellKnown.C2S.TranslateMessage transMsg = new P2P.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)
                {
                    P2P.WellKnown.C2S.LogoutMessage lgoutMsg = new P2P.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)
                {
                    P2P.WellKnown.C2S.GetUsersMessage getUserMsg = new P2P.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(P2P.WellKnown.S2C.GetUsersResponseMessage))
                {
                    // 转换消息
                    P2P.WellKnown.S2C.GetUsersResponseMessage usersMsg = (P2P.WellKnown.S2C.GetUsersResponseMessage)msgObj;
                    // 更新用户列表
                    userList.Clear();
                    foreach(User user in usersMsg.UserList)
                    {
                        userList.Add(user);
                    }
                    this.DisplayUsers(userList);
                }
                else if (msgType == typeof(P2P.WellKnown.S2C.SomeOneCallYouMessage))
                {
                    // 转换消息
                    P2P.WellKnown.S2C.SomeOneCallYouMessage purchReqMsg = (P2P.WellKnown.S2C.SomeOneCallYouMessage)msgObj;
                    // 发送打洞消息到远程主机
                    P2P.WellKnown.P2P.TrashMessage trashMsg = new P2P.WellKnown.P2P.TrashMessage();
                    buffer = FormatterHelper.Serialize(trashMsg);
                    client.Send(buffer, buffer.Length, purchReqMsg.RemotePoint);
                }
                else if (msgType == typeof(P2P.WellKnown.P2P.WorkMessage))
                {
                    // 转换消息
                    P2P.WellKnown.P2P.WorkMessage workMsg = (P2P.WellKnown.P2P.WorkMessage)msgObj;
                    Console.WriteLine("Receive a message: {0}", workMsg.Message);
                    // 发送应答消息
                    P2P.WellKnown.P2P.ACKMessage ackMsg = new P2P.WellKnown.P2P.ACKMessage();
                    buffer = FormatterHelper.Serialize(ackMsg);
                    client.Send(buffer, buffer.Length, remotePoint);
                }
                else if (msgType == typeof(P2P.WellKnown.P2P.ACKMessage))
                {
                    this.ReceivedACK = true;
                }
                else if (msgType == typeof(P2P.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
    }
}
 
LeoMaya
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实现UDP穿透NAT技术
05-07
用Java实现的UDP穿透NAT技术，内有详细的注释，完全可以自己看懂的
P2P 之 UDP穿透NAT的原理与实现（附源代码）
杂八杂七
03-29 1456
原创：shootingstars参考：http://midcom-p2p.sourceforge.net/draft-ford-midcom-p2p-01.txt论坛上经常有对P2P原理的讨论，但是讨论归讨论，很少有实质的东西产生（源代码）。呵呵，在这里我就用自己实现的一个源代码来说明UDP穿越NAT的原理。首先先介绍一些基本概念： NAT(Network Addre
入门级科普：RUDP传输那些事儿
机器之心
11-01 1789
袁荣喜，学霸君资深架构师，16年的C程序员，Golang爱好者，好求甚解，善于构建高性能服务系统和系统性能调优，喜好解决系统的疑难杂症和debug技术。早年痴迷于P2P通信网络、TCP/IP通信协议栈和鉴权加密技术，曾基于P2P super node技术实现了视频实时传输系统。2015年加入学霸君，负责构建学霸君的智能路由实时音视频传输系统和网络，解决音视频通信的实时性的问题。专注于存储系统和并发
P2P技术是如何将直播带宽降低75%的
zerok的专栏
01-04 1万+
实时直播经过去年的千播大战后已经成为互联网应用的标配技术，但直播平台的成本却一直居高不下，各个平台除了挖主播、挖网红以外，其背后高额的带宽费用也是他们最大的一块成本。现阶段直播技术在传输方面分为两块：CDN和连麦系统，CDN负责流媒体的分发传输，连麦系统负责解决同时多个主播间互动的实时通信传输问题。我们始终认为基于CDN+连麦系统的直播技术是一个高成本高消耗的技术，从各大直播平台纷纷亏损就验证了这
基于UDP实现NAT穿透
emm
08-17 1166
目标场景   有两个分别处于不同内网的客户端（客户端1:10.168.1.103、客户端2:14.10.12.155）分别通过各自的NAT网关（NAT网关A：172.128.58.1、NAT网关B：172.168.56.2）进行转换以访问外网。我们的目的是希望实现客户端1和客户端2的P2P通信。 技术方法 译自论文 Autonomous NAT Traversal.   使服务器了解客户端IP地址的关键思想是，服务器定期向一个固定的、已知的IP地址发送消息。最简单的方法是使用ICMP将请求消息ECHO到
论文研究-UDP穿越NAT原理及实现 .pdf
08-15
UDP穿越NAT原理及实现，马金韬，，本文是针对于基于P2P协议的网络传输方面的研究，主要为了解决对等端交互信息时发生的网关拒收数据的问题，包括了外网端同外网端、
UDP穿越Symmetric NAT(对称型NAT)的端口猜测方法
07-22
标题中的“UDP穿越Symmetric NAT(对称型NAT)的端口猜测方法”涉及到的是互联网通信中的一个关键问题，即如何在对称型网络地址转换（Symmetric NAT）环境中实现用户数据报协议（UDP）的数据传输。Symmetric NAT是一种...
UDP穿越NAT,UDP打洞
11-23
用C# 实现 UDP 穿越NAT UDP打洞 有全部源码和原理阐述
TCP和UDP穿越NAT技术及其代码
05-19
在提供的压缩包文件中，"P2P.doc"可能是关于TCP和UDP穿越NAT的理论文档，详细解释了这些概念和技术。而"P2P_TCP_Software.rar"和"P2P_by_shootingstars.rar"可能是包含C++实现的源代码库，其中"P2P_TCP_Software...
UDP穿越NAT通信
10-14
UDP穿越NAT（Network Address Translation）通信是一种在互联网上实现两个位于不同内网且被NAT设备隔离的设备之间直接通信的技术。NAT通常用于公网和私网之间的地址转换，使得内部网络的设备可以通过单一的公网IP...
P2P通信原理与实现(C++)
weixin_34130269的博客
09-11 3957
1.简介 　　当今互联网到处存在着一些中间件(MIddleBoxes)，如NAT和防火墙，导致两个(不在同一内网)中的客户端无法直接通信。这些问题即便是到了IPV6时代也会存在，因为即使不需要NAT，但还有其他中间件如防火墙阻挡了链接的建立。 　　当今部署的中间件大多都是在C/S架构上设计的，其中相对隐匿的客户机主动向周知的服务端(拥有静态IP地址和DNS名称)发起链接请求。大多数中间件实现了...
RUDP传输那些事儿
老吉
07-27 295
RUDP的价值在于根据不同的传输场景进行不同的技术选型，可能选择宽松的拥塞方式也可能选择特定的重传模式，但都是基于Expense(成本)、Latency（时延）、Quality（质量）三者之间来权衡，通过结合场景和权衡三角平衡关系RUDP或许能帮助开发者找到一个比较好的方案。 最近和很多实时音视频领域的朋友交流中都有谈论到RUDP(Reliable UDP)，这其实是个老生常谈的问题，RUDP在很多著名的项目上都有使用，例如google的QUIC和webRTC。在UDP之上做一层可靠，很多朋友认为这是很不
[zz] 视频解码优化
linux嵌入式驱动软件开发
05-13 2万+
以下通过剖析一些经验来了解视频解码优化1. 在嵌入式系统中实现MPEG4的视频解码有两种方法可行(1)采用ffmpeg(mplayer 的核心就是采用ffmpeg)，然后对ffmpeg mp4解码优化1).对IDCT汇编化,并优化VLD的实现   ->inline&汇编化2).根据ARM9 cache&cache line的大小做MB的分组,使得每次可以同时处理多个MB  即对多个MB在一个循环内
UDP打洞（成功打洞）
热门推荐
HotIce0
04-30 4万+
个人博客：www.saoguang.top​​​​​​​ UDP打洞   本篇文章由zg51747708曾广 原创，未经允许不可以转载 注：本文章内的程序代码全部是在Window 10 CreaterUpdata  VS2017 上测试 &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&amp
TCP打洞和UDP打洞的区别
az44yao的专栏
04-11 1332
为什么网上讲到的P2P打洞基本上都是基于UDP协议的打洞？难道TCP不可能打洞？还是TCP打洞难于实现？      假设现在有内网客户端A和内网客户端B，有公网服务端S。      如果A和B想要进行UDP通信，则必须穿透双方的NAT路由。假设为NAT-A和NAT-B。           A发送数据包到公网S,B发送数据包到公网S,则S分别得到了A和B的公网IP，  S也和A B 分别
NAT穿透技术详解（udp打洞精髓附代码）
lyztyycode的博客
06-30 2万+
以前自己写的代码都只是在本地进行c/s通信，今天想写一个可以跨越外网的c/s通信，这里我就用udp实现一个点对点的不同外网的通信。用到的技术就是nat穿透技术，这里最直接使用的就是udp打洞技术。文中如有表述不清楚，欢迎提问。如果你需要nat穿透技术的详解点这里：nat穿透浅析需要的设备：一个已知的外网服务器S（ip+port），两个位于不同外网的客户端A， B首先要知道udp打洞的流程：1.A客...
P2P UPD打洞原理
shuixin536的专栏
10-15 1037
http://blog.csdn.net/qinlicang/article/details/4422086 首先先介绍一些基本概念：             NAT(Network Address              Translators)，网络地址转换：网络地址转换是在IP地址日益缺乏的情况下产生的，它的主要目的就是为了能够地址重用。NAT分为两大类，基本的NAT
UDP打洞原理总结
学而时习之
08-17 5317
一直听人家说UDP打洞，或者你想实现两个局域网之间进行通信，那么，看一下UDP打洞原理吧，也许能帮到你。
UDP打洞
02-20 1815
UDP打洞，换句话说就是在两台位于NAT之后的主机之间建立直接的UDP会话。NAT的应用破坏了互联网的连通性，NAT之后的主机要连接公网主机，这没有问题。但是公网的主机（或一台私网主机）要连接一台位于NAT之后的私网主机，就不能直接实现，这就涉及到UDP打洞。 涉及UDP打洞的最常见应用是P2P软件，通过内网穿透可以加快下载速度。   公网主机无法连接内网主机，有两方面的原因： 1. 无法
NAT穿越的工作原理
最新发布
07-29
NAT（网络地址转换）穿越是一种技术，用于在经过NAT设备的网络中建立点对点的直接连接。它的工作原理如下： 1. 穿越请求发起：当两个位于不同NAT后面的设备（称为内部主机）希望建立直接连接时，其中一个设备（称为发起者）会发送一个穿越请求，通常是通过一个中介服务器或者STUN（Simple Traversal of UDP through NATs）服务器。 2. 中介服务器：中介服务器是一个位于公共互联网上的服务器，它帮助内部主机进行穿越。发起者会向中介服务器发送一个穿越请求，包括自己的外部IP地址和端口号。 3. 中介服务器回应：中介服务器收到穿越请求后，会将发起者的外部IP地址和端口号转发给目标设备。目标设备可以通过这些信息知道如何与发起者建立直接连接。 4. 连接建立：目标设备会使用发起者提供的外部IP地址和端口号，直接向发起者发送连接请求。由于目标设备使用了发起者的外部地址，因此该请求可以成功穿越NAT并到达发起者。 5. 数据传输：一旦连接建立，发起者和目标设备之间就可以直接进行数据传输，而无需通过NAT设备进行转发。 需要注意的是，NAT穿越可能需要使用其他技术来实现，例如端口映射（Port Mapping），UPnP（Universal Plug and Play）或者ICE（Interactive Connectivity Establishment）等。这些技术可以帮助内部主机和NAT设备之间进行通信，并确定如何建立直接连接。 总结起来，NAT穿越通过中介服务器或其他辅助手段，使位于不同NAT后面的设备能够建立点对点的直接连接，从而实现端到端的通信。这种技术在点对点应用、实时通信和文件传输等场景中非常有用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值