modernize hole punch. increase protocol to 11

Author: RevenantX

LibSample/HolePunchServerTest.cs

@@ -8,13 +8,13 @@ namespace LibSample
 {
     class WaitPeer
     {
-        public IPEndPoint InternalAddr { get; private set; }
-        public IPEndPoint ExternalAddr { get; private set; }
+        public IPEndPoint InternalAddr { get; }
+        public IPEndPoint ExternalAddr { get; }
         public DateTime RefreshTime { get; private set; }
 
         public void Refresh()
         {
-            RefreshTime = DateTime.Now;
+            RefreshTime = DateTime.UtcNow;
         }
 
         public WaitPeer(IPEndPoint internalAddr, IPEndPoint externalAddr)
@@ -39,8 +39,7 @@ class HolePunchServerTest : INatPunchListener
 
         void INatPunchListener.OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token)
         {
-            WaitPeer wpeer;
-            if (_waitingPeers.TryGetValue(token, out wpeer))
+            if (_waitingPeers.TryGetValue(token, out var wpeer))
             {
                 if (wpeer.InternalAddr.Equals(localEndPoint) &&
                     wpeer.ExternalAddr.Equals(remoteEndPoint))
@@ -168,7 +167,7 @@ public void Run()
                     }
                 }
 
-                DateTime nowTime = DateTime.Now;
+                DateTime nowTime = DateTime.UtcNow;
 
                 _c1.NatPunchModule.PollEvents();
                 _c2.NatPunchModule.PollEvents();

LibSample/Program.cs

@@ -20,10 +20,10 @@ static void Main(string[] args)
             ntpRequest.Send();
 
             //new EchoMessagesTest().Run();
-            //new HolePunchServerTest().Run();
+            new HolePunchServerTest().Run();
             //new BroadcastTest().Run();
             //new BenchmarkTest.TestHost().Run();
-            new SerializerBenchmark().Run();
+            //new SerializerBenchmark().Run();
             //new SpeedBench().Run();
             //new PacketProcessorExample().Run();
             //new AesEncryptionTest().Run();

LiteNetLib/NatPunchModule.cs

@@ -3,7 +3,6 @@
 using System.Net.Sockets;
 using LiteNetLib.Utils;
 
-//Some code parts taken from lidgren-network-gen3
 namespace LiteNetLib
 {
     public interface INatPunchListener
@@ -51,60 +50,87 @@ struct SuccessEventData
             public string Token;
         }
 
-        private readonly NetSocket _socket;
-        private readonly Queue<RequestEventData> _requestEvents;
-        private readonly Queue<SuccessEventData> _successEvents; 
-        private const byte HostByte = 1;
-        private const byte ClientByte = 0;
-        public const int MaxTokenLength = 256;
+        class NatIntroduceRequestPacket
+        {
+            public IPEndPoint Internal { get; set; }
+            public string Token { get; set; }
+        }
 
+        class NatIntroduceResponsePacket
+        {
+            public IPEndPoint Internal { get; set; }
+            public IPEndPoint External { get; set; }
+            public string Token { get; set; }
+        }
+
+        class NatPunchPacket
+        {
+            public string Token { get; set; }
+        }
+
+        private readonly NetSocket _socket;
+        private readonly Queue<RequestEventData> _requestEvents = new Queue<RequestEventData>();
+        private readonly Queue<SuccessEventData> _successEvents = new Queue<SuccessEventData>();
+        private readonly NetDataReader _cacheReader = new NetDataReader();
+        private readonly NetDataWriter _cacheWriter = new NetDataWriter();
+        private readonly NetPacketProcessor _netPacketProcessor = new NetPacketProcessor(MaxTokenLength);
         private INatPunchListener _natPunchListener;
+        public const int MaxTokenLength = 256;
 
         internal NatPunchModule(NetSocket socket)
         {
             _socket = socket;
-            _requestEvents = new Queue<RequestEventData>();
-            _successEvents = new Queue<SuccessEventData>();
+            _netPacketProcessor.SubscribeReusable<NatIntroduceResponsePacket>(OnNatIntroductionResponse);
+            _netPacketProcessor.SubscribeReusable<NatIntroduceRequestPacket, IPEndPoint>(OnNatIntroductionRequest);
+            _netPacketProcessor.SubscribeReusable<NatPunchPacket, IPEndPoint>(OnNatPunch);
+        }
+
+        internal void ProcessMessage(IPEndPoint senderEndPoint, NetPacket packet)
+        {
+            _cacheReader.SetSource(packet.RawData, NetConstants.HeaderSize, packet.Size);
+            _netPacketProcessor.ReadAllPackets(_cacheReader, senderEndPoint);
         }
 
         public void Init(INatPunchListener listener)
         {
             _natPunchListener = listener;
         }
 
+        private void Send<T>(T packet, IPEndPoint target) where T : class, new()
+        {
+            SocketError errorCode = 0;
+            _cacheWriter.Reset();
+            _cacheWriter.Put((byte)PacketProperty.NatMessage);
+            _netPacketProcessor.Write(_cacheWriter, packet);
+            _socket.SendTo(_cacheWriter.Data, 0, _cacheWriter.Length, target, ref errorCode);
+        }
+
         public void NatIntroduce(
             IPEndPoint hostInternal,
             IPEndPoint hostExternal,
             IPEndPoint clientInternal,
             IPEndPoint clientExternal,
             string additionalInfo)
         {
-            NetDataWriter dw = new NetDataWriter();
-
-            //First packet (server)
-            //send to client
-            dw.Put((byte)PacketProperty.NatIntroduction);
-            dw.Put(ClientByte);
-            dw.Put(hostInternal);
-            dw.Put(hostExternal);
-            dw.Put(additionalInfo, MaxTokenLength);
-            SocketError errorCode = 0;
-            _socket.SendTo(dw.Data, 0, dw.Length, clientExternal, ref errorCode);
-
-            //Second packet (client)
-            //send to server
-            dw.Reset();
-            dw.Put((byte)PacketProperty.NatIntroduction);
-            dw.Put(HostByte);
-            dw.Put(clientInternal);
-            dw.Put(clientExternal);
-            dw.Put(additionalInfo, MaxTokenLength);
-            _socket.SendTo(dw.Data, 0, dw.Length, hostExternal, ref errorCode);
+            var req = new NatIntroduceResponsePacket
+            {
+                Token = additionalInfo
+            };
+
+            //First packet (server) send to client
+            req.Internal = hostInternal;
+            req.External = hostExternal;
+            Send(req, clientExternal);
+
+            //Second packet (client) send to server
+            req.Internal = clientInternal;
+            req.External = clientExternal;
+            Send(req, hostExternal);
         }
 
         public void PollEvents()
         {
-            if (_natPunchListener == null)
+            if (_natPunchListener == null || (_successEvents.Count == 0 && _requestEvents.Count == 0))
                 return;
             lock (_successEvents)
             {
@@ -132,110 +158,68 @@ public void SendNatIntroduceRequest(string host, int port, string additionalInfo
         public void SendNatIntroduceRequest(IPEndPoint masterServerEndPoint, string additionalInfo)
         {
             //prepare outgoing data
-            NetDataWriter dw = new NetDataWriter();
             string networkIp = NetUtils.GetLocalIp(LocalAddrType.IPv4);
             if (string.IsNullOrEmpty(networkIp))
             {
                 networkIp = NetUtils.GetLocalIp(LocalAddrType.IPv6);
             }
-            IPEndPoint localEndPoint = NetUtils.MakeEndPoint(networkIp, _socket.LocalPort);
-            dw.Put((byte)PacketProperty.NatIntroductionRequest);
-            dw.Put(localEndPoint);
-            dw.Put(additionalInfo, MaxTokenLength);
 
-            //prepare packet
-            SocketError errorCode = 0;
-            _socket.SendTo(dw.Data, 0, dw.Length, masterServerEndPoint, ref errorCode);
+            Send(
+                new NatIntroduceRequestPacket
+                {
+                    Internal = NetUtils.MakeEndPoint(networkIp, _socket.LocalPort),
+                    Token = additionalInfo
+                }, 
+                masterServerEndPoint);
         }
 
-        private void HandleNatPunch(IPEndPoint senderEndPoint, NetDataReader dr)
+        //We got request and must introduce
+        private void OnNatIntroductionRequest(NatIntroduceRequestPacket req, IPEndPoint senderEndPoint)
         {
-            byte fromHostByte = dr.GetByte();
-            if (fromHostByte != HostByte && fromHostByte != ClientByte)
-            {
-                //garbage
-                return;
-            }
-
-            //Read info
-            string additionalInfo = dr.GetString(MaxTokenLength);
-            NetDebug.Write(NetLogLevel.Trace, "[NAT] punch received from {0} - additional info: {1}", senderEndPoint, additionalInfo);
-
-            //Release punch success to client; enabling him to Connect() to msg.Sender if token is ok
-            lock (_successEvents)
+            lock (_requestEvents)
             {
-                _successEvents.Enqueue(new SuccessEventData { TargetEndPoint = senderEndPoint, Token = additionalInfo });
+                _requestEvents.Enqueue(new RequestEventData
+                {
+                    LocalEndPoint = req.Internal,
+                    RemoteEndPoint = senderEndPoint,
+                    Token = req.Token
+                });
             }
         }
 
-        private void HandleNatIntroduction(NetDataReader dr)
+        //We got introduce and must punch
+        private void OnNatIntroductionResponse(NatIntroduceResponsePacket req)
         {
-            // read intro
-            byte hostByte = dr.GetByte();
-            IPEndPoint remoteInternal = dr.GetNetEndPoint();
-            IPEndPoint remoteExternal = dr.GetNetEndPoint();
-            string token = dr.GetString(MaxTokenLength);
-
-            NetDebug.Write(NetLogLevel.Trace, "[NAT] introduction received; we are designated " + (hostByte == HostByte ? "host" : "client"));
-            NetDataWriter writer = new NetDataWriter();
+            NetDebug.Write(NetLogLevel.Trace, "[NAT] introduction received");
 
             // send internal punch
-            writer.Put((byte)PacketProperty.NatPunchMessage);
-            writer.Put(hostByte);
-            writer.Put(token);
-            SocketError errorCode = 0;
-            _socket.SendTo(writer.Data, 0, writer.Length, remoteInternal, ref errorCode);
-            NetDebug.Write(NetLogLevel.Trace, "[NAT] internal punch sent to " + remoteInternal);
-
-            // send external punch
-            writer.Reset();
-            writer.Put((byte)PacketProperty.NatPunchMessage);
-            writer.Put(hostByte);
-            writer.Put(token);
+            var punchPacket = new NatPunchPacket {Token = req.Token};
+            Send(punchPacket, req.Internal);
+            NetDebug.Write(NetLogLevel.Trace, "[NAT] internal punch sent to " + req.Internal);
 
             // hack for some routers
+            SocketError errorCode = 0;
             _socket.Ttl = 2;
-            _socket.SendTo(new []{(byte)PacketProperty.Empty}, 0, 1, remoteExternal, ref errorCode);
+            _socket.SendTo(new[] { (byte)PacketProperty.Empty }, 0, 1, req.External, ref errorCode);
 
-            // actual send
+            // send external punch
             _socket.Ttl = NetConstants.SocketTTL;
-            _socket.SendTo(writer.Data, 0, writer.Length, remoteExternal, ref errorCode);
-
-            NetDebug.Write(NetLogLevel.Trace, "[NAT] external punch sent to " + remoteExternal);
+            Send(punchPacket, req.External);
+            NetDebug.Write(NetLogLevel.Trace, "[NAT] external punch sent to " + req.External);
         }
 
-        private void HandleNatIntroductionRequest(IPEndPoint senderEndPoint, NetDataReader dr)
+        //We got punch and can connect
+        private void OnNatPunch(NatPunchPacket req, IPEndPoint senderEndPoint)
         {
-            IPEndPoint localEp = dr.GetNetEndPoint();
-            string token = dr.GetString(MaxTokenLength);
-            lock (_requestEvents)
-            {
-                _requestEvents.Enqueue(new RequestEventData
-                {
-                    LocalEndPoint = localEp,
-                    RemoteEndPoint = senderEndPoint,
-                    Token = token
-                });
-            }
-        }
+            //Read info
+            NetDebug.Write(NetLogLevel.Trace, "[NAT] punch received from {0} - additional info: {1}",
+                senderEndPoint, req.Token);
 
-        internal void ProcessMessage(IPEndPoint senderEndPoint, NetPacket packet)
-        {
-            var dr = new NetDataReader(packet.RawData, NetConstants.HeaderSize, packet.Size);
-            switch (packet.Property)
+            //Release punch success to client; enabling him to Connect() to Sender if token is ok
+            lock (_successEvents)
             {
-                case PacketProperty.NatIntroductionRequest:
-                    //We got request and must introduce
-                    HandleNatIntroductionRequest(senderEndPoint, dr);
-                    break;
-                case PacketProperty.NatIntroduction:
-                    //We got introduce and must punch
-                    HandleNatIntroduction(dr);
-                    break;
-                case PacketProperty.NatPunchMessage:
-                    //We got punch and can connect
-                    HandleNatPunch(senderEndPoint, dr);
-                    break;
+                _successEvents.Enqueue(new SuccessEventData
+                    { TargetEndPoint = senderEndPoint, Token = req.Token });
             }
         }
     }

LiteNetLib/NetConstants.cs

@@ -49,7 +49,7 @@ public static class NetConstants
         public const ushort HalfMaxSequence = MaxSequence / 2;
 
         //protocol
-        internal const int ProtocolId = 10;
+        internal const int ProtocolId = 11;
         internal const int MaxUdpHeaderSize = 68;
 
         internal static readonly int[] PossibleMtu =

LiteNetLib/NetManager.cs

@@ -261,7 +261,6 @@ private struct IncomingData
         /// </summary>
         public bool EnableStatistics = false;
 
-        //modules
         /// <summary>
         /// NatPunchModule for NAT hole punching operations
         /// </summary>
@@ -966,9 +965,7 @@ private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEnd
                     CreateEvent(NetEvent.EType.ReceiveUnconnected, remoteEndPoint: remoteEndPoint, readerSource: packet);
                     break;
 
-                case PacketProperty.NatIntroduction:
-                case PacketProperty.NatIntroductionRequest:
-                case PacketProperty.NatPunchMessage:
+                case PacketProperty.NatMessage:
                     if (NatPunchEnabled)
                         NatPunchModule.ProcessMessage(remoteEndPoint, packet);
                     break;

LiteNetLib/NetPacket.cs

@@ -14,17 +14,15 @@ internal enum PacketProperty : byte
         ConnectAccept,
         Disconnect,
         UnconnectedMessage,
-        NatIntroductionRequest,
-        NatIntroduction,
-        NatPunchMessage,
         MtuCheck,
         MtuOk,
         Broadcast,
         Merged,
         ShutdownOk,
         PeerNotFound,
         InvalidProtocol,
-        Empty
+        NatMessage,
+        Empty,
     }
 
     internal sealed class NetPacket
@@ -121,8 +119,6 @@ public static int GetHeaderSize(PacketProperty property)
                     return NetConstants.HeaderSize + 8;
                 case PacketProperty.Pong:
                     return NetConstants.HeaderSize + 10;
-                case PacketProperty.Empty:
-                    return 1;
                 default:
                     return NetConstants.HeaderSize;
             }