Merge branch 'develop'

Author: EvilLord666

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Wissance.Hydra CI
+
+on:
+  pull_request:
+    branches: [develop, master]
+  push:
+    branches: [develop, master]
+    
+env:
+  DOTNET_VERSION: '6.0.x'
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  build-and-test:
+    name: Building Wissance.Hydra and running Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up .Net
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+      - name: Install dependencies 
+        run: dotnet restore ./Wissance.Hydra/Wissance.Hydra
+      - name: Build Solution
+        run: dotnet build --configuration Release ./Wissance.Hydra/Wissance.Hydra
+      #- name: Run Wissance.Hydra.Tcp.Tests
+      #  run: dotnet test -c Release ./Wissance.Hydra/Wissance.Hydra/Wissance.Hydra.Tcp.Tests/Wissance.Hydra.Tcp.Tests.csproj
+

Wissance.Hydra/Wissance.Hydra/Wissance.Hydra.Common/Wissance.Hydra.Common.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
+        <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
     </PropertyGroup>
 
 </Project>

Wissance.Hydra/Wissance.Hydra/Wissance.Hydra.Tcp.Tests/TestUtils/TestTcpClient.cs

@@ -1,16 +1,19 @@
 using System;
+using System.Net.Security;
 using System.Net.Sockets;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 
 namespace Wissance.Hydra.Tcp.Tests.TestUtils
 {
     public class TestTcpClient : IDisposable
     {
         public TestTcpClient(Boolean isAsync, String server, UInt16 port, Int32 readTimeout = DefaultReadTimeout,
-            Int32 writeTimeout = DefaultWriteTimeout, int connAttempts = 8)
+            Int32 writeTimeout = DefaultWriteTimeout, int connAttempts = 8, Boolean isSecure = false)
         {
-            Init(server, port, isAsync);
+            Init(server, port, isAsync, isSecure);
             _client = new TcpClient();
+            _client.ExclusiveAddressUse = false;
             _readTimeout = readTimeout > 0 ? readTimeout : DefaultReadTimeout;
             _writeTimeout = writeTimeout > 0 ? writeTimeout : DefaultWriteTimeout;
             _client.ReceiveTimeout = _readTimeout;
@@ -19,9 +22,9 @@ public TestTcpClient(Boolean isAsync, String server, UInt16 port, Int32 readTime
             _connAttempts = connAttempts;
         }
 
-        public Boolean Open(String server, UInt16 port, Boolean isAsync = true)
+        public Boolean Open(String server, UInt16 port, Boolean isAsync = true, Boolean isSecure = false)
         {
-            Init(server, port, isAsync);
+            Init(server, port, isAsync, isSecure);
             return Open();
         }
 
@@ -31,14 +34,14 @@ public Boolean Open()
             {
                 try
                 {
-                    if (_isAsync)
-                        OpenAsync();
-                    else OpenSync();
-                    return _client.Connected;
+                    bool result = _isAsync ? OpenAsync() : OpenSync();
+                    if (result)
+                        return true;
+                    Thread.Sleep(20 * (attempt + 1));
                 }
                 catch (Exception e)
                 {
-                    Thread.Sleep(20);
+                    Thread.Sleep(20 * (attempt + 1));
                 }
             }
             return false;
@@ -72,35 +75,63 @@ public Boolean Write(Byte[] data)
             return WriteSync(data);
         }
 
-        private void OpenSync()
+        private bool OpenSync()
         {
-            _client.Connect(_host, _port);
+            try
+            {
+                _client.Connect(_host, _port);
+                return _client.Connected;
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+            
         }
 
-        private void OpenAsync()
+        private bool OpenAsync()
         {
-            _connectCompleted.Reset();
-            _client.BeginConnect(_host, _port, OpenAsyncCallback, _client);
-            _connectCompleted.Wait(DefaultConnectTimeout);
+            try
+            {
+                _connectCompleted.Reset();
+                _client.BeginConnect(_host, _port, OpenAsyncCallback, _client);
+                _connectCompleted.Wait(DefaultConnectTimeout);
+                return _client.Connected;
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+
         }
 
-        private void Init(String server, UInt16 port, Boolean isAsync)
+        private void Init(String server, UInt16 port, Boolean isAsync, Boolean isSecure)
         {
             if (String.IsNullOrEmpty(server))
                 throw new ArgumentNullException("server");
             _isAsync = isAsync;
+            _isSecure = isSecure;
             _host = server;
             _port = port;
         }
 
         private void OpenAsyncCallback(IAsyncResult result)
         {
-            TcpClient client = (result.AsyncState as TcpClient);
-            if (client == null)
-                // ReSharper disable once NotResolvedInText
-                throw new ArgumentNullException("client");
-            client.EndConnect(result);
-            _connectCompleted.Set();
+            try
+            {
+
+                TcpClient client = (result.AsyncState as TcpClient);
+                if (client == null)
+                    // ReSharper disable once NotResolvedInText
+                    throw new ArgumentNullException("client");
+                client.EndConnect(result);
+                _connectCompleted.Set();
+
+            }
+            catch (Exception e)
+            {
+                //do nothing yet
+            }
         }
 
         private Boolean WriteSync(Byte[] data)
@@ -147,7 +178,7 @@ private Boolean ReadSync(Byte[] data, out Int32 bytesRead)
         {
             bytesRead = 0;
             _bytesRead = 0;
-            NetworkStream stream = _client.GetStream();
+            Stream stream = GetStream(_client);
             Int32 errorsNumber = 0;
             for (Int32 retryNumber = 0; retryNumber < ReadRetriesNumber; retryNumber++)
             {
@@ -174,7 +205,7 @@ private Boolean ReadSync(Byte[] data, out Int32 bytesRead)
         private Boolean ReadAsync(Byte[] data, out Int32 bytesRead)
         {
             bytesRead = 0;
-            NetworkStream stream = _client.GetStream();
+            Stream stream = GetStream(_client);
             try
             {
                 _bytesRead = 0;
@@ -190,7 +221,7 @@ private Boolean ReadAsync(Byte[] data, out Int32 bytesRead)
                 bytesRead = _bytesRead;
                 return true;
             }
-            catch (Exception)
+            catch (Exception e)
             {
                 return false;
             }
@@ -202,16 +233,42 @@ private void ReadAsyncCallback(IAsyncResult result)
             if (client == null)
                 // ReSharper disable once NotResolvedInText
                 throw new ArgumentNullException("client");
-            _bytesRead += client.GetStream().EndRead(result);
+            _bytesRead += GetStream(client).EndRead(result);
             _readCompleted.Set();
         }
 
+        private Stream GetStream(TcpClient client)
+        {
+            try
+            {
+                NetworkStream ns = client.GetStream();
+                if (!_isSecure)
+                    return ns;
+                SslStream sslStream = new SslStream(ns, false,  ValidateServerCertificate, null);
+                sslStream.AuthenticateAsClient(_host);
+                return sslStream;
+            }
+            catch (Exception e)
+            {
+                return null;
+            }
+
+        }
+        
+        public bool ValidateServerCertificate(object sender, X509Certificate certificate,
+            X509Chain chain, SslPolicyErrors sslPolicyErrors)
+        {
+            return true;
+        }
+
+
         private const Int32 DefaultConnectTimeout = 2000;
         private const Int32 DefaultReadTimeout = 1000;
         private const Int32 DefaultWriteTimeout = 1000;
         private const Int32 ReadRetriesNumber = 16;
 
         private Boolean _isAsync;
+        private Boolean _isSecure;
         private String _host;
         private UInt16 _port;
         private readonly TcpClient _client;