Unity compatibility patch (Aes to RijndaelManaged)

ReferenceType · ReferenceType · commit e9838fdcf9c5 · 2023-03-05T23:04:20.000+01:00
Cert. Validation callback fix
diff --git a/NetworkLibrary/Components/AesAlgorithm.cs b/NetworkLibrary/Components/AesAlgorithm.cs
@@ -8,7 +8,7 @@ namespace NetworkLibrary.Components
 {
     public class AesAlgorithm:IDisposable
     {
-        private readonly Aes algorithm;
+        private readonly SymmetricAlgorithm algorithm;
         private readonly ICryptoTransform encryptor;
         private readonly ICryptoTransform decryptor;
 
@@ -22,7 +22,8 @@ public AesAlgorithm(byte[] Key, byte[] IV,string algorithmName = null)
         {
             if(algorithmName == null)
             {
-                algorithm = Aes.Create();
+                // AES.create is not compatible with Unity... 
+                algorithm =  new System.Security.Cryptography.RijndaelManaged();//Aes.Create();
             }
             else
             {
diff --git a/NetworkLibrary/NetworkLibrary.csproj b/NetworkLibrary/NetworkLibrary.csproj
@@ -13,7 +13,9 @@
     <Authors>RefrenceType</Authors>
     <PackageLicenseFile>Licence.txt</PackageLicenseFile>
     <Copyright>Apache 2.0</Copyright>
-    <Version>1.0.3</Version>
+    <Version>1.0.6</Version>
+    <AssemblyVersion>1.0.5.0</AssemblyVersion>
+    <FileVersion>1.0.5.0</FileVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
diff --git a/NetworkLibrary/TCP/Base/AsyncTcpClient.cs b/NetworkLibrary/TCP/Base/AsyncTcpClient.cs
@@ -29,7 +29,7 @@ public AsyncTpcClient() {}
 
         public override void Connect(string IP, int port)
         {
-            ConnectAsyncAwaitable(IP, port).Wait();
+           _ =  ConnectAsyncAwaitable(IP, port).Result;
         }
 
         public override async Task<bool> ConnectAsyncAwaitable(string IP, int port)
diff --git a/NetworkLibrary/UDP/AsyncUdpClient.cs b/NetworkLibrary/UDP/AsyncUdpClient.cs
@@ -1,4 +1,5 @@
-﻿using System;
+﻿using NetworkLibrary.Utils;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -49,15 +50,15 @@ public int SocketSendBufferSize
         public AsyncUdpClient()
         {
             recieveBuffer = new byte[65500];
-            clientSocket = new Socket(SocketType.Dgram, ProtocolType.Udp);
+            clientSocket = new Socket(AddressFamily.InterNetwork,SocketType.Dgram, ProtocolType.Udp);
 
-            clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);
+            clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, true);
             //clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
-            clientSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true);
+            //clientSocket.SetSocketOption(SocketOptionLevel.Udp, SocketOptionName.PacketInformation, true);
 
             clientSocket.ReceiveBufferSize = ReceiveBufferSize;
             clientSocket.SendBufferSize = SocketSendBufferSize;
-            clientSocket.Blocking = false;
+            clientSocket.Blocking = true;
 
             RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
         }
@@ -85,7 +86,9 @@ public void SetRemoteEnd(string ip, int port, bool receive = true)
         {
             if (IPAddress.TryParse(ip, out var ipAdress))
             {
-                RemoteEndPoint = new IPEndPoint(ipAdress, port);
+                // IPV6 is not compatible with Unity..
+                var ep = new IPEndPoint(ipAdress.MapToIPv4(), port);
+                RemoteEndPoint = ep;
                 if (receive)
                     Receive();
             }
@@ -103,7 +106,7 @@ public void Connect(string IP, int port)
             RemoteEndPoint = new IPEndPoint(IPAddress.Parse(IP), port);
             clientSocket.Connect(RemoteEndPoint);
             Connected = true;
-            clientSocket.Blocking = false;
+            //clientSocket.Blocking = false;
             clientSocket.BeginReceive(recieveBuffer, 0, recieveBuffer.Length, SocketFlags.None, EndRecieve, null);
         }
 
@@ -146,7 +149,7 @@ private void EndRecieve(IAsyncResult ar)
             {
                 amount = clientSocket.EndReceive(ar);
             }
-            catch (SocketException e)
+            catch (Exception e)
             {
                 OnError?.Invoke(e);
                 return;
@@ -186,13 +189,22 @@ protected virtual void HandleBytesReceived(byte[] buffer, int offset, int count)
 
         public virtual void SendAsync(byte[] bytes, int offset, int count)
         {
+
             try
             {
-                clientSocket.SendTo(bytes, offset, count, SocketFlags.None, RemoteEndPoint);
+                if (Connected)
+                {
+                    clientSocket.Send(bytes, offset, count, SocketFlags.None);
+                }
+                else
+                {
+                    clientSocket.SendTo(bytes, offset, count, SocketFlags.None, RemoteEndPoint);
+                }
 
             }
             catch (Exception e)
             {
+                MiniLogger.Log(MiniLogger.LogLevel.Error, "Unable to send the Udp Datagram due to : "+e.Message);
             }
         }
 
diff --git a/NetworkLibrary/UDP/AsyncUdpServer.cs b/NetworkLibrary/UDP/AsyncUdpServer.cs
@@ -55,8 +55,12 @@ protected ConcurrentDictionary<IPEndPoint, UdpStatistics> Statistics
 
         public AsyncUdpServer(int port = 20008)
         {
-            ServerSocket = new Socket(SocketType.Dgram, ProtocolType.Udp);
+            // IPV6 is not compatible with Unity.
+            ServerSocket = new Socket(AddressFamily.InterNetwork,SocketType.Dgram, ProtocolType.Udp);
             ServerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, true);
+            // Not compatible with Unity..
+            //ServerSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true);
+
 
             ServerSocket.ReceiveBufferSize = SocketReceiveBufferSize;
             ServerSocket.SendBufferSize = SocketSendBufferSize;
diff --git a/NetworkLibrary/UDP/Secure/SecureUdpClient.cs b/NetworkLibrary/UDP/Secure/SecureUdpClient.cs
@@ -32,8 +32,16 @@ protected override void HandleBytesReceived(byte[] buffer, int offset, int count
             var decryptBuffer = BufferPool.RentBuffer(count+256);
             try
             {
-                var decriptedAmount = algorithm.DecryptInto(buffer, offset, count, decryptBuffer, 0);
-                HandleDecrypedBytes(decryptBuffer, 0, decriptedAmount);
+                if (algorithm != null)
+                {
+                    var decriptedAmount = algorithm.DecryptInto(buffer, offset, count, decryptBuffer, 0);
+                    HandleDecrypedBytes(decryptBuffer, 0, decriptedAmount);
+                }
+                else
+                {
+                    HandleDecrypedBytes(buffer, offset, count);
+                }
+                
             }
             catch (Exception e)
             {
@@ -55,8 +63,16 @@ public override void SendAsync(byte[] bytes, int offset, int count)
             var buffer = BufferPool.RentBuffer(count+256);
             try
             {
-                int amount = algorithm.EncryptInto(bytes, offset, count, buffer, 0);
-                base.SendAsync(buffer, 0, amount);
+                if (algorithm != null)
+                {
+                    int amount = algorithm.EncryptInto(bytes, offset, count, buffer, 0);
+                    base.SendAsync(buffer, 0, amount);
+                }
+                else
+                {
+                    base.SendAsync(bytes, offset, count);
+                }
+               
 
             }
             catch(Exception ex)
diff --git a/Protobuff/P2P/HolePunch/ClientHolepunchState.cs b/Protobuff/P2P/HolePunch/ClientHolepunchState.cs
@@ -32,7 +32,6 @@ public ClientHolepunchState(RelayClient client, Guid stateId, Guid To)
 
         public void HandleMessage(MessageEnvelope message)
         {
-            MiniLogger.Log(MiniLogger.LogLevel.Info, "ClientStateGotMsg");
             switch (message.Header)
             {
                 case HolepunchHeaders.CreateChannel:
@@ -143,8 +142,8 @@ private void HandleSuccess(MessageEnvelope message)
         {
             MiniLogger.Log(MiniLogger.LogLevel.Info, "success!!");
             message.LockBytes();
-            holepunchClient.SwapAlgorith(new ConcurrentAesAlgorithm(message.Payload, message.Payload));
-            //holepunchClient.Connect((IPEndPoint)holepunchClient.RemoteEndPoint);
+           holepunchClient.SwapAlgorith(new ConcurrentAesAlgorithm(message.Payload, message.Payload));
+           // holepunchClient.SwapAlgorith(null);
             Completion.TrySetResult(holepunchClient);
         }
 
diff --git a/Protobuff/P2P/RelayClient.cs b/Protobuff/P2P/RelayClient.cs
@@ -548,6 +548,7 @@ private void ResendUdpInitMessage(MessageEnvelope message)
             message.Payload = null;
             message.IsInternal = true;
 
+            MiniLogger.Log(MiniLogger.LogLevel.Info, "Resending Udp Init to " + udpRelayClient.RemoteEndPoint.ToString());
             udpRelayClient.SendAsyncMessage(message);
             protoClient.SendAsyncMessage(message);
         }
diff --git a/Protobuff/P2P/RelayServer.cs b/Protobuff/P2P/RelayServer.cs
@@ -328,13 +328,11 @@ private void SendEndpoint(Guid clientId, MessageEnvelope message)
 
         private void UdpClientAccepted(SocketAsyncEventArgs ClientSocket)
         {
-
         }
 
 
         private void HandleUdpBytesReceived(IPEndPoint adress, byte[] bytes, int offset, int count)
         {
-
             // Client is trying to register its Udp endpoint here
             if (!UdpCryptos.ContainsKey(adress))
             {
@@ -365,9 +363,9 @@ private void HandleUdpBytesReceived(IPEndPoint adress, byte[] bytes, int offset,
                     }
                 }
             }
-            catch
+            catch(Exception e)
             {
-                MiniLogger.Log(MiniLogger.LogLevel.Error, "Udp Relay failed to deserialise envelope message ");
+                MiniLogger.Log(MiniLogger.LogLevel.Error, "Udp Relay failed to deserialise envelope message "+e.Message);
                 return;
             }
             finally
diff --git a/Protobuff/ProtoServer.cs b/Protobuff/ProtoServer.cs
@@ -38,7 +38,6 @@ public class ProtoServer
         internal readonly ProtoServerInternal server;
         private ConcurrentProtoSerialiser serialiser = new ConcurrentProtoSerialiser();
         private MessageAwaiter awaiter;
-        private SharerdMemoryStreamPool streamPool = new SharerdMemoryStreamPool();
 
 
         public ProtoServer(int port)
@@ -89,8 +88,6 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse<T>(Guid clientId,
                 message.MessageId = Guid.NewGuid();
 
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
-            message.MessageId = Guid.NewGuid();
-
             SendAsyncMessage(clientId, message, buffer, offset, count);
             return await result;
         }
@@ -101,8 +98,6 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse<T>(Guid clientId,
                 message.MessageId = Guid.NewGuid();
 
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
-            message.MessageId = Guid.NewGuid();
-
             SendAsyncMessage(clientId, message, payload);
             return await result;
         }
@@ -112,9 +107,7 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse(Guid clientId, Mes
             if (message.MessageId == Guid.Empty)
                 message.MessageId = Guid.NewGuid();
 
-            message.MessageId = Guid.NewGuid();
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
-
             SendAsyncMessage(clientId, message);
             return await result;
         }
diff --git a/Protobuff/Protobuff.csproj b/Protobuff/Protobuff.csproj
@@ -11,8 +11,9 @@
     <Copyright>Apache-2.0</Copyright>
     <Product>ProtobufNetworkLibrary</Product>
     <PackageLicenseFile>Licence.txt</PackageLicenseFile>
-    <AssemblyVersion>1.0.1</AssemblyVersion>
-    <Version>1.0.2</Version>
+    <AssemblyVersion>1.0.4.0</AssemblyVersion>
+    <Version>1.0.5</Version>
+    <FileVersion>1.0.4.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/Protobuff/SecureProtoClient.cs b/Protobuff/SecureProtoClient.cs
@@ -23,7 +23,7 @@ public class SecureProtoClient
         private MessageAwaiter awaiter;
 
         // hook to override default cb.
-        public RemoteCertificateValidationCallback RemoteCertificateValidationCallback => client.RemoteCertificateValidationCallback;
+        public RemoteCertificateValidationCallback RemoteCertificateValidationCallback;
 
         public SecureProtoClient(X509Certificate2 certificate)
         {
@@ -41,6 +41,8 @@ public SecureProtoClient(X509Certificate2 certificate)
 
         private bool DefaultValidationCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
         {
+            if (RemoteCertificateValidationCallback != null)
+                return RemoteCertificateValidationCallback.Invoke(sender, certificate, chain, sslPolicyErrors);
             return true;
         }
       
diff --git a/Protobuff/SecureProtoServer.cs b/Protobuff/SecureProtoServer.cs
@@ -25,7 +25,7 @@ public class SecureProtoServer
         private ConcurrentProtoSerialiser serialiser = new ConcurrentProtoSerialiser();
         private MessageAwaiter awaiter;
 
-        public RemoteCertificateValidationCallback RemoteCertificateValidationCallback=>server.RemoteCertificateValidationCallback;
+        public RemoteCertificateValidationCallback RemoteCertificateValidationCallback;
 
         public SecureProtoServer(int port,X509Certificate2 cerificate)
         {
@@ -55,6 +55,8 @@ public IPEndPoint GetIPEndPoint(Guid cliendId)
 
         private bool DefaultValidationCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
         {
+            if (RemoteCertificateValidationCallback != null)
+                return RemoteCertificateValidationCallback.Invoke(sender,certificate,chain,sslPolicyErrors);
             return true;
         }
 
@@ -87,8 +89,6 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse<T>(Guid clientId,
                 message.MessageId= Guid.NewGuid();
 
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
-            message.MessageId = Guid.NewGuid();
-
             SendAsyncMessage(clientId, message, buffer, offset, count);
             return await result;
         }
@@ -99,7 +99,6 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse<T>(Guid clientId,
                 message.MessageId = Guid.NewGuid();
 
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
-            message.MessageId = Guid.NewGuid();
 
             SendAsyncMessage(clientId, message, payload);
             return await result;
@@ -110,7 +109,6 @@ public async Task<MessageEnvelope> SendMessageAndWaitResponse(Guid clientId, Mes
             if (message.MessageId == Guid.Empty)
                 message.MessageId = Guid.NewGuid();
 
-            message.MessageId = Guid.NewGuid();
             var result = awaiter.RegisterWait(message.MessageId, timeoutMs);
             
             SendAsyncMessage(clientId, message);

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace NetworkLibrary.Components`
`8`	`8`	`{`
`9`	`9`	`public class AesAlgorithm:IDisposable`
`10`	`10`	`{`
`11`		`- private readonly Aes algorithm;`
	`11`	`+ private readonly SymmetricAlgorithm algorithm;`
`12`	`12`	`private readonly ICryptoTransform encryptor;`
`13`	`13`	`private readonly ICryptoTransform decryptor;`
`14`	`14`
`@@ -22,7 +22,8 @@ public AesAlgorithm(byte[] Key, byte[] IV,string algorithmName = null)`
`22`	`22`	`{`
`23`	`23`	`if(algorithmName == null)`
`24`	`24`	`{`
`25`		`- algorithm = Aes.Create();`
	`25`	`+ // AES.create is not compatible with Unity...`
	`26`	`+ algorithm = new System.Security.Cryptography.RijndaelManaged();//Aes.Create();`
`26`	`27`	`}`
`27`	`28`	`else`
`28`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public AsyncTpcClient() {}`
`29`	`29`
`30`	`30`	`public override void Connect(string IP, int port)`
`31`	`31`	`{`
`32`		`- ConnectAsyncAwaitable(IP, port).Wait();`
	`32`	`+ _ = ConnectAsyncAwaitable(IP, port).Result;`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`public override async Task<bool> ConnectAsyncAwaitable(string IP, int port)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System;`
	`1`	`+using NetworkLibrary.Utils;`
	`2`	`+using System;`
`2`	`3`	`using System.Collections.Concurrent;`
`3`	`4`	`using System.Collections.Generic;`
`4`	`5`	`using System.Diagnostics;`
`@@ -49,15 +50,15 @@ public int SocketSendBufferSize`
`49`	`50`	`public AsyncUdpClient()`
`50`	`51`	`{`
`51`	`52`	`recieveBuffer = new byte[65500];`
`52`		`- clientSocket = new Socket(SocketType.Dgram, ProtocolType.Udp);`
	`53`	`+ clientSocket = new Socket(AddressFamily.InterNetwork,SocketType.Dgram, ProtocolType.Udp);`
`53`	`54`
`54`		`- clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);`
	`55`	`+ clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, true);`
`55`	`56`	`//clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);`
`56`		`- clientSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true);`
	`57`	`+ //clientSocket.SetSocketOption(SocketOptionLevel.Udp, SocketOptionName.PacketInformation, true);`
`57`	`58`
`58`	`59`	`clientSocket.ReceiveBufferSize = ReceiveBufferSize;`
`59`	`60`	`clientSocket.SendBufferSize = SocketSendBufferSize;`
`60`		`- clientSocket.Blocking = false;`
	`61`	`+ clientSocket.Blocking = true;`
`61`	`62`
`62`	`63`	`RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);`
`63`	`64`	`}`
`@@ -85,7 +86,9 @@ public void SetRemoteEnd(string ip, int port, bool receive = true)`
`85`	`86`	`{`
`86`	`87`	`if (IPAddress.TryParse(ip, out var ipAdress))`
`87`	`88`	`{`
`88`		`- RemoteEndPoint = new IPEndPoint(ipAdress, port);`
	`89`	`+ // IPV6 is not compatible with Unity..`
	`90`	`+ var ep = new IPEndPoint(ipAdress.MapToIPv4(), port);`
	`91`	`+ RemoteEndPoint = ep;`
`89`	`92`	`if (receive)`
`90`	`93`	`Receive();`
`91`	`94`	`}`
`@@ -103,7 +106,7 @@ public void Connect(string IP, int port)`
`103`	`106`	`RemoteEndPoint = new IPEndPoint(IPAddress.Parse(IP), port);`
`104`	`107`	`clientSocket.Connect(RemoteEndPoint);`
`105`	`108`	`Connected = true;`
`106`		`- clientSocket.Blocking = false;`
	`109`	`+ //clientSocket.Blocking = false;`
`107`	`110`	`clientSocket.BeginReceive(recieveBuffer, 0, recieveBuffer.Length, SocketFlags.None, EndRecieve, null);`
`108`	`111`	`}`
`109`	`112`
`@@ -146,7 +149,7 @@ private void EndRecieve(IAsyncResult ar)`
`146`	`149`	`{`
`147`	`150`	`amount = clientSocket.EndReceive(ar);`
`148`	`151`	`}`
`149`		`- catch (SocketException e)`
	`152`	`+ catch (Exception e)`
`150`	`153`	`{`
`151`	`154`	`OnError?.Invoke(e);`
`152`	`155`	`return;`
`@@ -186,13 +189,22 @@ protected virtual void HandleBytesReceived(byte[] buffer, int offset, int count)`
`186`	`189`
`187`	`190`	`public virtual void SendAsync(byte[] bytes, int offset, int count)`
`188`	`191`	`{`
	`192`	`+`
`189`	`193`	`try`
`190`	`194`	`{`
`191`		`- clientSocket.SendTo(bytes, offset, count, SocketFlags.None, RemoteEndPoint);`
	`195`	`+ if (Connected)`
	`196`	`+ {`
	`197`	`+ clientSocket.Send(bytes, offset, count, SocketFlags.None);`
	`198`	`+ }`
	`199`	`+ else`
	`200`	`+ {`
	`201`	`+ clientSocket.SendTo(bytes, offset, count, SocketFlags.None, RemoteEndPoint);`
	`202`	`+ }`
`192`	`203`
`193`	`204`	`}`
`194`	`205`	`catch (Exception e)`
`195`	`206`	`{`
	`207`	`+ MiniLogger.Log(MiniLogger.LogLevel.Error, "Unable to send the Udp Datagram due to : "+e.Message);`
`196`	`208`	`}`
`197`	`209`	`}`
`198`	`210`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@ public ClientHolepunchState(RelayClient client, Guid stateId, Guid To)`
`32`	`32`
`33`	`33`	`public void HandleMessage(MessageEnvelope message)`
`34`	`34`	`{`
`35`		`- MiniLogger.Log(MiniLogger.LogLevel.Info, "ClientStateGotMsg");`
`36`	`35`	`switch (message.Header)`
`37`	`36`	`{`
`38`	`37`	`case HolepunchHeaders.CreateChannel:`
`@@ -143,8 +142,8 @@ private void HandleSuccess(MessageEnvelope message)`
`143`	`142`	`{`
`144`	`143`	`MiniLogger.Log(MiniLogger.LogLevel.Info, "success!!");`
`145`	`144`	`message.LockBytes();`
`146`		`- holepunchClient.SwapAlgorith(new ConcurrentAesAlgorithm(message.Payload, message.Payload));`
`147`		`- //holepunchClient.Connect((IPEndPoint)holepunchClient.RemoteEndPoint);`
	`145`	`+ holepunchClient.SwapAlgorith(new ConcurrentAesAlgorithm(message.Payload, message.Payload));`
	`146`	`+ // holepunchClient.SwapAlgorith(null);`
`148`	`147`	`Completion.TrySetResult(holepunchClient);`
`149`	`148`	`}`
`150`	`149`
Original file line number	Diff line number	Diff line change
`@@ -548,6 +548,7 @@ private void ResendUdpInitMessage(MessageEnvelope message)`
`548`	`548`	`message.Payload = null;`
`549`	`549`	`message.IsInternal = true;`
`550`	`550`
	`551`	`+ MiniLogger.Log(MiniLogger.LogLevel.Info, "Resending Udp Init to " + udpRelayClient.RemoteEndPoint.ToString());`
`551`	`552`	`udpRelayClient.SendAsyncMessage(message);`
`552`	`553`	`protoClient.SendAsyncMessage(message);`
`553`	`554`	`}`
Original file line number	Diff line number	Diff line change
`@@ -328,13 +328,11 @@ private void SendEndpoint(Guid clientId, MessageEnvelope message)`
`328`	`328`
`329`	`329`	`private void UdpClientAccepted(SocketAsyncEventArgs ClientSocket)`
`330`	`330`	`{`
`331`		`-`
`332`	`331`	`}`
`333`	`332`
`334`	`333`
`335`	`334`	`private void HandleUdpBytesReceived(IPEndPoint adress, byte[] bytes, int offset, int count)`
`336`	`335`	`{`
`337`		`-`
`338`	`336`	`// Client is trying to register its Udp endpoint here`
`339`	`337`	`if (!UdpCryptos.ContainsKey(adress))`
`340`	`338`	`{`
`@@ -365,9 +363,9 @@ private void HandleUdpBytesReceived(IPEndPoint adress, byte[] bytes, int offset,`
`365`	`363`	`}`
`366`	`364`	`}`
`367`	`365`	`}`
`368`		`- catch`
	`366`	`+ catch(Exception e)`
`369`	`367`	`{`
`370`		`- MiniLogger.Log(MiniLogger.LogLevel.Error, "Udp Relay failed to deserialise envelope message ");`
	`368`	`+ MiniLogger.Log(MiniLogger.LogLevel.Error, "Udp Relay failed to deserialise envelope message "+e.Message);`
`371`	`369`	`return;`
`372`	`370`	`}`
`373`	`371`	`finally`