protected override ThreadLimitedUdpConnectionListener CreateListener(int numWorkers, IPEndPoint endPoint, ILogger logger, IPMode ipMode = IPMode.IPv4)
{
DtlsConnectionListener listener = new DtlsConnectionListener(2, endPoint, logger, ipMode);
listener.SetCertificate(GetCertificateForServer());
return(listener);
}
public void TestConnectionSuccessAfterClientKeyExchangeFlightDropped()
{
IPEndPoint captureEndPoint = new IPEndPoint(IPAddress.Loopback, 27511);
IPEndPoint listenerEndPoint = new IPEndPoint(IPAddress.Loopback, 27510);
bool serverConnected = false;
bool serverDisconnected = false;
bool clientDisconnected = false;
Semaphore signal = new Semaphore(0, int.MaxValue);
using (SocketCapture capture = new SocketCapture(captureEndPoint, listenerEndPoint))
using (DtlsConnectionListener listener = new DtlsConnectionListener(2, new IPEndPoint(IPAddress.Any, listenerEndPoint.Port), new TestLogger()))
using (TestDtlsHandshakeDropUnityConnection connection = new TestDtlsHandshakeDropUnityConnection(new TestLogger(), captureEndPoint))
{
connection.DropSendClientKeyExchangeFlightCount = 1;
listener.SetCertificate(GetCertificateForServer());
connection.SetValidServerCertificates(GetCertificateForClient());
listener.NewConnection += (evt) =>
{
serverConnected = true;
signal.Release();
evt.Connection.Disconnected += (o, et) => {
serverDisconnected = true;
};
};
connection.Disconnected += (o, evt) => {
clientDisconnected = true;
signal.Release();
};
listener.Start();
connection.Connect();
// wait for the client to connect
signal.WaitOne(10);
listener.Dispose();
// wait for the client to disconnect
signal.WaitOne(100);
Assert.IsTrue(serverConnected);
Assert.IsTrue(clientDisconnected);
Assert.IsFalse(serverDisconnected);
}
}
public void TestClientConnects()
{
IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 27510);
bool serverConnected = false;
bool serverDisconnected = false;
bool clientDisconnected = false;
Semaphore signal = new Semaphore(0, int.MaxValue);
using (DtlsConnectionListener listener = new DtlsConnectionListener(2, new IPEndPoint(IPAddress.Any, ep.Port), new TestLogger()))
using (DtlsUnityConnection connection = new DtlsUnityConnection(new TestLogger(), ep))
{
listener.SetCertificate(GetCertificateForServer());
connection.SetValidServerCertificates(GetCertificateForClient());
listener.NewConnection += (evt) =>
{
serverConnected = true;
signal.Release();
evt.Connection.Disconnected += (o, et) => {
serverDisconnected = true;
};
};
connection.Disconnected += (o, evt) => {
clientDisconnected = true;
signal.Release();
};
listener.Start();
connection.Connect();
// wait for the client to connect
signal.WaitOne(10);
listener.Dispose();
// wait for the client to disconnect
signal.WaitOne(100);
Assert.IsTrue(serverConnected);
Assert.IsTrue(clientDisconnected);
Assert.IsFalse(serverDisconnected);
}
}
public void PingDisconnectClientTest()
{
#if DEBUG
IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 27510);
using (DtlsConnectionListener listener = (DtlsConnectionListener)CreateListener(2, new IPEndPoint(IPAddress.Any, ep.Port), new TestLogger()))
{
// Adjust the ping rate to end the test faster
listener.NewConnection += (evt) =>
{
var conn = (ThreadLimitedUdpServerConnection)evt.Connection;
conn.KeepAliveInterval = 100;
conn.MissingPingsUntilDisconnect = 3;
};
listener.Start();
for (int i = 0; i < 5; ++i)
{
using (DtlsUnityConnection connection = (DtlsUnityConnection)CreateConnection(ep, new TestLogger()))
{
connection.KeepAliveInterval = 100;
connection.MissingPingsUntilDisconnect = 3;
connection.Connect();
Thread.Sleep(10);
// After connecting, quietly stop responding to all messages to fake connection loss.
connection.TestDropRate = 1;
Thread.Sleep(500); //Enough time for ~3 keep alive packets
Assert.AreEqual(ConnectionState.NotConnected, connection.State);
}
}
listener.DisconnectOldConnections(TimeSpan.FromMilliseconds(500), null);
Assert.AreEqual(0, listener.PeerCount, "All clients disconnected, peer count should be zero.");
}
#else
Assert.Inconclusive("Only works in DEBUG");
#endif
}
public void TestMalformedConnectionData()
{
IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 27510);
IPEndPoint connectionEndPoint = ep;
DtlsConnectionListener.ConnectionId connectionId = new ThreadLimitedUdpConnectionListener.ConnectionId();
Semaphore signal = new Semaphore(0, int.MaxValue);
using (DtlsConnectionListener listener = new DtlsConnectionListener(2, new IPEndPoint(IPAddress.Any, ep.Port), new TestLogger()))
using (MalformedDTLSClient connection = new MalformedDTLSClient(new TestLogger(), ep))
{
listener.SetCertificate(GetCertificateForServer());
connection.SetValidServerCertificates(GetCertificateForClient());
listener.NewConnection += (evt) =>
{
connectionEndPoint = evt.Connection.EndPoint;
connectionId = ((ThreadLimitedUdpServerConnection)evt.Connection).ConnectionId;
signal.Release();
evt.Connection.Disconnected += (o, et) => {
};
};
connection.Disconnected += (o, evt) => {
signal.Release();
};
listener.Start();
connection.Connect();
Assert.IsTrue(listener.ReceiveThreadRunning, "Listener should be able to handle a malformed hello packet");
Assert.AreEqual(ConnectionState.NotConnected, connection.State);
Assert.AreEqual(0, listener.PeerCount);
// wait for the client to disconnect
listener.Dispose();
signal.WaitOne(100);
}
}
public void HandshakeLikeAJerkTest()
{
using (DtlsConnectionListener listener = this.CreateListener(2, new IPEndPoint(IPAddress.Any, 4296), new TestLogger("Server")))
using (MultipleClientKeyExchangeFlightDtlsConnection client = new MultipleClientKeyExchangeFlightDtlsConnection(new TestLogger("Client "), new IPEndPoint(IPAddress.Loopback, 4296), IPMode.IPv4))
{
client.SetValidServerCertificates(GetCertificateForClient());
int connects = 0;
listener.NewConnection += (obj) =>
{
Interlocked.Increment(ref connects);
};
listener.Start();
client.Connect();
Thread.Sleep(500);
Assert.AreEqual(0, listener.ReceiveQueueLength);
Assert.IsTrue(connects <= 1, $"Too many connections: {connects}");
Assert.AreEqual(ConnectionState.Connected, client.State);
Assert.IsTrue(client.HandshakeComplete);
}
}
public void TestResentHandshakeConnects()
{
IPEndPoint captureEndPoint = new IPEndPoint(IPAddress.Loopback, 27511);
IPEndPoint listenerEndPoint = new IPEndPoint(IPAddress.Loopback, 27510);
bool serverConnected = false;
bool serverDisconnected = false;
bool clientDisconnected = false;
Semaphore signal = new Semaphore(0, int.MaxValue);
using (SocketCapture capture = new SocketCapture(captureEndPoint, listenerEndPoint))
using (DtlsConnectionListener listener = new DtlsConnectionListener(2, new IPEndPoint(IPAddress.Any, listenerEndPoint.Port), new TestLogger()))
using (DtlsUnityConnection connection = new DtlsUnityConnection(new TestLogger(), captureEndPoint))
{
Semaphore listenerToConnectionThrottle = new Semaphore(0, int.MaxValue);
capture.SendToLocalSemaphore = listenerToConnectionThrottle;
Thread throttleThread = new Thread(() => {
// HelloVerifyRequest
listenerToConnectionThrottle.Release(1);
// ServerHello, Server Certificate
listenerToConnectionThrottle.Release(1);
// Trigger a resend of ServerHello, ServerCertificate
Thread.Sleep(1000);
listenerToConnectionThrottle.Release(1);
// ServerKeyExchange, ServerHelloDone
listenerToConnectionThrottle.Release(1);
// Trigger a resend of ServerKeyExchange, ServerHelloDone
Thread.Sleep(1000);
listenerToConnectionThrottle.Release(1);
capture.SendToLocalSemaphore = null;
});
throttleThread.Start();
listener.SetCertificate(GetCertificateForServer());
connection.SetValidServerCertificates(GetCertificateForClient());
listener.NewConnection += (evt) =>
{
serverConnected = true;
signal.Release();
evt.Connection.Disconnected += (o, et) => {
serverDisconnected = true;
};
};
connection.Disconnected += (o, evt) => {
clientDisconnected = true;
signal.Release();
};
listener.Start();
connection.Connect();
// wait for the client to connect
signal.WaitOne(10);
listener.Dispose();
// wait for the client to disconnect
signal.WaitOne(100);
Assert.IsTrue(serverConnected);
Assert.IsTrue(clientDisconnected);
Assert.IsFalse(serverDisconnected);
}
}
