Add Lockless DTLS

Hazel.UnitTests/TestHelper.cs

@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Diagnostics;
 using Hazel.Udp.FewerThreads;
+using System.Collections.Generic;
 
 namespace Hazel.UnitTests
 {
@@ -82,25 +83,19 @@ internal static void RunServerToClientTest(NetworkConnectionListener listener, C
             listener.Start();
 
             DataReceivedEventArgs? result = null;
-            //Setup conneciton
             connection.DataReceived += delegate (DataReceivedEventArgs a)
             {
                 Trace.WriteLine("Data was received correctly.");
-
-                try
-                {
-                    result = a;
-                }
-                finally
-                {
-                    mutex.Set();
-                }
+                result = a;
+                mutex.Set();
             };
 
             connection.Connect();
 
             //Wait until data is received
-            mutex.WaitOne();
+            mutex.WaitOne(1000);
+
+            Assert.IsNotNull(result, "Data never received");
 
             var dataReader = ConvertToMessageReader(data);
             Assert.AreEqual(dataReader.Length, result.Value.Message.Length);
@@ -333,5 +328,17 @@ static MessageWriter BuildData(SendOption sendOption, int dataSize)
 
             return output;
         }
+
+        public static void WaitAll(IEnumerable<ManualResetEventSlim> events, TimeSpan MaxWait)
+        {
+            DateTime timeStart = DateTime.UtcNow;
+            foreach (var evt in events)
+            {
+                var timeSpent = DateTime.UtcNow - timeStart;
+                if (timeSpent > MaxWait) break;
+
+                evt.Wait(MaxWait - timeSpent);
+            }
+        }
     }
 }

Hazel.UnitTests/ThreadLimitedUdpConnectionTests.cs

@@ -422,7 +422,7 @@ public void ClientDisconnectTest()
                 connection.Disconnect("Testing");
 
                 mutex2.WaitOne(1000);
-                Assert.AreEqual(ConnectionState.NotConnected, connection.State);
+                Assert.AreEqual(ConnectionState.Disconnected, connection.State);
             }
         }
 
@@ -465,7 +465,7 @@ public void ServerDisconnectTest()
                 serverMutex.Set();
 
                 mutex.Wait(500);
-                Assert.AreEqual(ConnectionState.NotConnected, connection.State);
+                Assert.AreEqual(ConnectionState.Disconnected, connection.State);
             }
         }
 

Hazel.UnitTests/UdpConnectionTestHarness.cs

@@ -37,7 +37,7 @@ protected override bool SendDisconnect(MessageWriter writer)
                     return false;
                 }
 
-                this.State = ConnectionState.NotConnected;
+                this.State = ConnectionState.Disconnected;
             }
 
             return true;

Hazel.UnitTests/UdpConnectionTests.cs

@@ -359,7 +359,7 @@ public void PingDisconnectClientTest()
 
                 Thread.Sleep(1050);    //Enough time for ~10 keep alive packets
 
-                Assert.AreEqual(ConnectionState.NotConnected, connection.State);
+                Assert.AreEqual(ConnectionState.Disconnected, connection.State);
                 Assert.AreEqual(3 * connection.MissingPingsUntilDisconnect + 4, connection.Statistics.TotalBytesSent); // + 4 for connecting overhead
             }
 #else

Hazel/ConnectionState.cs

@@ -11,7 +11,7 @@ namespace Hazel
     public enum ConnectionState
     {
         /// <summary>
-        ///     The Connection has either not been established yet or has been disconnected.
+        ///     The Connection has not been established yet.
         /// </summary>
         NotConnected,
 
@@ -24,5 +24,10 @@ public enum ConnectionState
         ///     The Connection is connected and data can be transfered.
         /// </summary>
         Connected,
+
+        /// <summary>
+        ///     The Connection was established, but is no longer.
+        /// </summary>
+        Disconnected
     }
 }

Hazel/ConnectionStatistics.cs

@@ -319,6 +319,27 @@ public int PingMessagesReceived
         /// </summary>
         int pingMessagesReceived;
 
+
+        /// <summary>
+        ///     The number of ping messages sent.
+        /// </summary>
+        /// <remarks>
+        ///     This is the number of hello messages that were sent by the <see cref="Connection"/>, incremented
+        ///     each time that SendPing is called by the Connection. Messages are counted before the bytes go on the wire.
+        /// </remarks>
+        public int PingMessagesSent
+        {
+            get
+            {
+                return pingMessagesSent;
+            }
+        }
+
+        /// <summary>
+        ///     The number of hello messages received.
+        /// </summary>
+        int pingMessagesSent;
+
         /// <summary>
         ///     The number of hello messages received.
         /// </summary>
@@ -542,6 +563,14 @@ internal void LogPingReceive(int totalLength)
             Interlocked.Add(ref totalBytesReceived, totalLength);
         }
 
+        /// <summary>
+        ///     Logs the sending of a hello data packet in the statistics.
+        /// </summary>
+        internal void LogPingSent()
+        {
+            Interlocked.Increment(ref pingMessagesSent);
+        }
+
         /// <summary>
         ///     Logs the receiving of a hello data packet in the statistics.
         /// </summary>

Hazel/Dtls/DtlsConnectionListener.cs

@@ -1405,7 +1405,10 @@ protected void MarkConnectionAsStale(ConnectionId connectionId)
         /// <inheritdoc />
         internal override void RemovePeerRecord(ConnectionId connectionId)
         {
-            this.existingPeers.TryRemove(connectionId.EndPoint, out _);
+            if (this.existingPeers.TryRemove(connectionId.EndPoint, out var peer))
+            {
+                peer.Dispose();
+            }
         }
 
         /// <summary>