Bug fix on holepunch over layered local networks

Author: ReferenceType

Benchmarks/RelayBenchmark/Program.cs

@@ -180,7 +180,7 @@ private static void SerializerTest()
         static Stopwatch sw = new Stopwatch();
         private static void RelayTest()
         {
-            //string ip = "79.19.128.177";
+            //string ip = "79.52.134.220";
             string ip = "127.0.0.1";
 
 
@@ -190,13 +190,14 @@ private static void RelayTest()
             server.StartServer();
             //Task.Run(async () => { while (true) { await Task.Delay(10000); server.GetTcpStatistics(out var generalStats, out _); Console.WriteLine(generalStats.ToString()); } });
             var clients = new List<RelayClient>();
-            int numclients = 20;
+            int numclients = 2;
             var pending = new Task[numclients];
             // Parallel.For(0, numclients, (i) =>
             for (int i = 0; i < numclients; i++)
 
             {
                 var client = new RelayClient(cert);
+                client.MaxUdpPackageSize = 2000;
                 client.OnMessageReceived += (reply) => ClientMsgReceived(client, reply);
                 client.OnUdpMessageReceived += (reply) => ClientUdpReceived(client, reply);
                 //client.OnPeerRegistered += (id) => { /*if (client.sessionId.CompareTo(id) > 0)*/ client.RequestHolePunchAsync(id, 10000, false); };
@@ -219,17 +220,17 @@ private static void RelayTest()
             List<Task<bool>> pndg = new List<Task<bool>>();
             foreach (var client in clients)
             {
-                if (client.sessionId == Guid.Empty)
+                if (client.SessionId == Guid.Empty)
                     throw new Exception();
                 // Console.WriteLine("--- -- - | "+client.sessionId+" count: " + client.Peers.Count);
                 foreach (var peer in client.Peers)
                 {
-                    if (client.sessionId.CompareTo(peer.Key) > 0)
+                    if (client.SessionId.CompareTo(peer.Key) > 0)
                     {
                         if (peer.Key == Guid.Empty)
                             throw new Exception();
 
-                        //var a = client.RequestHolePunchAsync(peer.Key, 10000, false);
+                        var a = client.RequestHolePunchAsync(peer.Key, 10000, false);
                         //pndg.Add(a);
                         //client.TestHP(peer.Key, 10000, false);
                         //  Console.WriteLine(peer.Key+" cnt=> "+ ++cc);
@@ -248,7 +249,7 @@ private static void RelayTest()
                 var testMessage = new MessageEnvelope()
                 {
                     Header = "Test",
-                    Payload = new byte[12600]
+                    Payload = new byte[126000]
                 };
                 for (int i = 0; i < testMessage.PayloadCount; i++)
                 {

Json/JsonNetwork/JsonNetwork.csproj

@@ -5,7 +5,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>Json.Network.Library</PackageId>
     <Title>Json Network Library</Title>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
     <Authors>ReferenceType</Authors>
     <Description>Message passing and P2P network library using System.Text.Json</Description>
     <Copyright>Apache-2.0</Copyright>

MessagePack/MessagePackNetwork/MessagePackNetwork.csproj

@@ -5,7 +5,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>MessagePack.Network.Library</PackageId>
     <Title>MessagePack Network Library</Title>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
     <Authors>ReferenceType</Authors>
     <Description>Message passing and P2P network library using MessagePack Serialization</Description>
     <Copyright>Apache-2.0</Copyright>

NetSerializer/NetSerializerNetwork/NetSerializerNetwork.csproj

@@ -5,7 +5,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>NetSerializer.Network.Library</PackageId>
     <Title>NetSerializer Network Library</Title>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
     <Description>Message passing and P2P network library using .NetSerializer</Description>
     <Copyright>Apache-2.0</Copyright>
     <RepositoryUrl>https://github.com/ReferenceType/StandardNetworkLibrary</RepositoryUrl>

NetworkLibrary/NetworkLibrary.csproj

@@ -12,7 +12,7 @@
     <RepositoryUrl>https://github.com/ReferenceType/StandardNetworkLibrary</RepositoryUrl>
     <Authors>RefrenceType</Authors>
     <Copyright>Apache 2.0</Copyright>
-    <Version>2.0.1</Version>
+    <Version>2.0.2</Version>
     <AssemblyVersion>2.0.1</AssemblyVersion>
     <FileVersion>2.0.1</FileVersion>
     <PackageReleaseNotes>Relay and room server are no longer generic but directly implemented on NetworkLibrary.P2P.

NetworkLibrary/P2P/Components/HolePunch/IPUtils.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Text;
+
+namespace NetworkLibrary
+{
+    internal class IPUtils
+    {
+        //10.0.0.0 - 10.255.255.255
+        //172.16.0.0 - 172.31.255.255
+        //192.168.0.0 - 192.168.255.255
+        public static bool IsPrivate(byte[] ipBytes)
+        {
+            if (ipBytes[0]== 192 && ipBytes[1] == 168)
+            {
+                return true;
+            }
+            else if (ipBytes[0] == 10)
+            {
+                return true;
+            }
+            else if (ipBytes[0] ==172 && (ipBytes[1]>15 && ipBytes[1] < 31))
+            {
+                return true;
+            }
+            else { return false;}
+        }
+
+        public static bool IsLoopback(byte[] ipBtyes)
+        {
+            var addr = new IPAddress(ipBtyes);
+            if (IPAddress.IsLoopback(addr))
+            {
+                return true;
+            }
+            return false;
+        }
+    }
+}

NetworkLibrary/P2P/Components/Modules/ClientUdpModule.cs

@@ -18,7 +18,7 @@ namespace NetworkLibrary.P2P.Components.Modules
         private GenericMessageSerializer<S> serialiser = new GenericMessageSerializer<S>();
 
         public ClientUdpModule(int port) : base(port) { }
-
+        public int MaxUdpPackageSize = 62400;
         private static void GetTLSStream()
         {
             if (TLSSerialisationStream == null)
@@ -39,7 +39,7 @@ public bool TrySendAsync(IPEndPoint endpoint, MessageEnvelope message, out Poole
 
             serialiser.EnvelopeMessageWithBytes(TLSSerialisationStream,
                 message, message.Payload, message.PayloadOffset, message.PayloadCount);
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 streamWithLargeMessage = TLSSerialisationStream;
                 return false;
@@ -58,7 +58,7 @@ public bool TrySendAsync<T>(IPEndPoint endpoint, MessageEnvelope message, T inne
             serialiser.EnvelopeMessageWithInnerMessage(TLSSerialisationStream,
                 message, innerMessage);
 
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 excessStream = TLSSerialisationStream;
                 return false;
@@ -77,7 +77,7 @@ public bool TrySendAsync(IPEndPoint endpoint, MessageEnvelope message, Action<Po
                 message, SerializationCallback);
 
             excessStream = null;
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 excessStream = TLSSerialisationStream;
                 return false;
@@ -98,7 +98,7 @@ public bool TrySendAsync(IPEndPoint endpoint, MessageEnvelope message, Concurren
             serialiser.EnvelopeMessageWithBytes(TLSSerialisationStream,
                 message, message.Payload, message.PayloadOffset, message.PayloadCount);
 
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 largeMessageStream = TLSSerialisationStream;
                 return false;
@@ -120,7 +120,7 @@ public bool TrySendAsync(IPEndPoint endpoint, MessageEnvelope message, Action<Po
                 message, SerializationCallback);
 
             excessStream = null;
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 excessStream = TLSSerialisationStream;
                 return false;
@@ -142,7 +142,7 @@ public bool TrySendAsync<T>(IPEndPoint endpoint, MessageEnvelope message, T inne
 
             serialiser.EnvelopeMessageWithInnerMessage(TLSSerialisationStream,
                 message, innerMessage);
-            if (TLSSerialisationStream.Position32 > 64500)
+            if (TLSSerialisationStream.Position32 > MaxUdpPackageSize)
             {
                 excessStream = TLSSerialisationStream;
                 return false;

NetworkLibrary/P2P/Components/StateManagemet/Client/ClientHolepunchState.cs

@@ -2,9 +2,11 @@
 using NetworkLibrary.P2P.Components.HolePunch;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Transactions;
 
 namespace NetworkLibrary.P2P.Components.StateManagemet.Client
 {
@@ -16,6 +18,7 @@ internal class ClientHolepunchState : IState
         internal Guid destinationId;
         internal IPEndPoint succesfulEpToReceive;
         internal IPEndPoint succesfullEpToSend;
+        internal IPEndPoint relayServerEndpoint;
         internal Action Success;
         internal Action<byte[], List<EndpointData>> KeyReceived;
         internal EndpointTransferMessage targetEndpoints;
@@ -29,11 +32,12 @@ internal class ClientHolepunchState : IState
         private StateManager client;
         private int totalPunchRoutines = 0;
         private CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-        public ClientHolepunchState(Guid destinationId, Guid stateId, StateManager client)
+        public ClientHolepunchState(Guid destinationId, Guid stateId, StateManager client, IPEndPoint relayServerEndpoint)
         {
             this.destinationId = destinationId;
             StateId = stateId;
             this.client = client;
+            this.relayServerEndpoint = relayServerEndpoint;
         }
         // A asks B
         public void Initiate()
@@ -46,7 +50,7 @@ public void InitiateByRemote(MessageEnvelope message)
             HandleEndpointMessage(message);
         }
         // get remote ep then punch
-        private void RetrieveRemoteEndpoint(Guid destinatioinId)
+        private void RetrieveRemoteEndpoint(Guid destinationId)
         {
             var message = new MessageEnvelope
             {
@@ -56,28 +60,59 @@ private void RetrieveRemoteEndpoint(Guid destinatioinId)
             };
             if (encypted)
                 message.KeyValuePairs = new Dictionary<string, string>() { { "Encrypted", null } };
-            client.SendAsyncMessage(destinatioinId, message);
+            client.SendAsyncMessage(destinationId, message);
             // reply will be handled on HandleEndpointMessage
         }
 
         private void HandleEndpointMessage(MessageEnvelope message)
         {
             targetEndpoints = KnownTypeSerializer.DeserializeEndpointTransferMessage(message.Payload, message.PayloadOffset);
-            cryptoKey = targetEndpoints.IpRemote;
+
+            // the remote ip on relay is local means relay server and remote client is in same local network
+            var ipToVerify = targetEndpoints.LocalEndpoints.Last().Ip;
+            if (IPUtils.IsLoopback(ipToVerify) || IPUtils.IsPrivate(ipToVerify))
+            {
+                // (localhost client + relay) vs remote client
+                //if im not also local, i should try the internet address of the relay.
+                var relayIp = relayServerEndpoint.Address.GetAddressBytes();
+                if (!IPUtils.IsLoopback(relayIp) && !IPUtils.IsPrivate(relayIp))
+                    targetEndpoints.LocalEndpoints.Add(new EndpointData(new IPEndPoint(relayServerEndpoint.Address, targetEndpoints.LocalEndpoints[0].Port)));
+            }
+
+            // Here we need to remove loopback because i might send messages to myself if we share the same port..
+            List<EndpointData> toRemove = new List<EndpointData>();
+            foreach (var endpoint in targetEndpoints.LocalEndpoints)
+            {
+                if (IPUtils.IsLoopback(endpoint.Ip))
+                {
+                    toRemove.Add(endpoint);
+                }
+
+            }
+            foreach (var item in toRemove)
+            {
+                targetEndpoints.LocalEndpoints.Remove(item);
+            }
+
+            cryptoKey = targetEndpoints.IpRemote;// yea, didnt wanna change the type
             KeyReceived?.Invoke(cryptoKey, targetEndpoints.LocalEndpoints);
             if (cryptoKey != null)
             {
                 aesAlgorithm = new ConcurrentAesAlgorithm(cryptoKey, cryptoKey);
             }
+           
             var count = targetEndpoints.LocalEndpoints.Count;
             Interlocked.Exchange(ref totalPunchRoutines, count);
             for (int i = 0; i < count; i++)
             {
+                var Ip = targetEndpoints.LocalEndpoints[i].Ip;
                 var ep = targetEndpoints.LocalEndpoints[i].ToIpEndpoint();
 
-                // last one is remote end point, we need to try locals first.
-                if (i == count - 1)
+                // first handle the local ips, start remote later, because if we are on local why go through internet..
+                if (!IPUtils.IsPrivate(Ip))
+                {
                     PunchRoutine(ep, delay: true);
+                }
                 else
                     PunchRoutine(ep);
             }
@@ -95,7 +130,7 @@ private async void PunchRoutine(IPEndPoint ep, bool delay = false)
 
                 if (delay)
                 {
-                    await Task.Delay(1500, cancellationTokenSource.Token).ConfigureAwait(false);
+                    await Task.Delay(1000, cancellationTokenSource.Token).ConfigureAwait(false);
                 }
                // Console.WriteLine("Punching towards: " + ep.ToString());
 
@@ -131,7 +166,7 @@ private async void PunchRoutine(IPEndPoint ep, bool delay = false)
         // inside of this message i must put the endpoint i shot at
         public void HandleMessage(IPEndPoint remoteEndpoint, MessageEnvelope message)
         {
-
+            // here i would like to receive all, then rank the ips select nearest.
             if (Interlocked.CompareExchange(ref succesfulEpToReceive, remoteEndpoint, null) == null)
             {
                 //Console.WriteLine("Received Sucess: " + remoteEndpoint.ToString());
@@ -168,9 +203,10 @@ public void HandleMessage(MessageEnvelope message)
                 if (Interlocked.Exchange(ref stop, 1) == 0)
                 {
                     cancellationTokenSource.Cancel();
-                    Consensus();
                     // get the sucessfull ep
                     succesfullEpToSend = KnownTypeSerializer.DeserializeEndpointData(message.Payload, message.PayloadOffset).ToIpEndpoint();
+                    Consensus();
+
                 }
             }
             else if (message.Header == Constants.HolpunchMessagesSent)
@@ -220,7 +256,7 @@ public void Release(bool isCompletedSuccessfully)
         {
             if (Interlocked.CompareExchange(ref isReleased, 1, 0) == 0)
             {
-                if (isCompletedSuccessfully)
+                if (isCompletedSuccessfully && succesfullEpToSend != null && succesfulEpToReceive != null)
                     currentStatus = StateStatus.Completed;
                 else
                     currentStatus = StateStatus.Failed;

NetworkLibrary/P2P/Components/StateManagemet/Client/ClientStateManager.cs

@@ -2,13 +2,14 @@
 using NetworkLibrary.P2P.Generic;
 using System;
 using System.Collections.Concurrent;
+using System.Net;
 using System.Threading;
 
 namespace NetworkLibrary.P2P.Components.StateManagemet.Client
 {
     internal class ClientStateManager<S> : StateManager where S : ISerializer, new()
     {
-        private RelayClientBase<S> client;
+        internal RelayClientBase<S> client;
         private ConcurrentDictionary<Guid, string> pendingHolepunchStates = new ConcurrentDictionary<Guid, string>();
         private ClientConnectionState pendingState;
         public ClientStateManager(RelayClientBase<S> client) : base(client)
@@ -39,7 +40,7 @@ private IState CreateHolepunchState(MessageEnvelope message)
                 return null;
             }
 
-            var state = new ClientHolepunchState(message.From, message.MessageId, this);
+            var state = new ClientHolepunchState(message.From, message.MessageId, this, client.relayServerEndpoint);
             state.Completed += (x) => { OnHolepunchComplete(state); };
             state.KeyReceived += (key, associatedEndpoints) => client.RegisterCrypto(key, associatedEndpoints);
             state.InitiateByRemote(message);
@@ -50,7 +51,7 @@ public ClientHolepunchState CreateHolePunchState(Guid clientId, Guid stateId)
         {
             pendingHolepunchStates.TryAdd(clientId, null);
 
-            var state = new ClientHolepunchState(clientId, stateId, this);
+            var state = new ClientHolepunchState(clientId, stateId, this, client.relayServerEndpoint);
             state.Completed += (x) => { OnHolepunchComplete(state); };
             state.KeyReceived += (key, associatedEndpoints) => client.RegisterCrypto(key, associatedEndpoints);
             AddState(state);

NetworkLibrary/P2P/Components/StateManagemet/StateManager.cs

@@ -8,6 +8,7 @@ namespace NetworkLibrary.P2P.Components.StateManagemet
 {
     internal interface INetworkNode
     {
+        
         void SendUdpAsync(IPEndPoint ep, MessageEnvelope message, Action<PooledMemoryStream> callback, ConcurrentAesAlgorithm aesAlgorithm);
         void SendUdpAsync(IPEndPoint ep, MessageEnvelope message, Action<PooledMemoryStream> callback);
         void SendAsyncMessage(Guid destinatioinId, MessageEnvelope message);