Improve socket handling.

Source/MQTTnet/Implementations/CrossPlatformSocket.cs

@@ -0,0 +1,229 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class CrossPlatformSocket : IDisposable
+    {
+        readonly Socket _socket;
+
+        public CrossPlatformSocket(AddressFamily addressFamily)
+        {
+            _socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
+        }
+
+        public CrossPlatformSocket()
+        {
+            // Having this contructor is important because avoiding the address family as parameter
+            // will make use of dual mode in the .net framework.
+            _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+        }
+
+        public CrossPlatformSocket(Socket socket)
+        {
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+        }
+
+        public bool NoDelay
+        {
+            get
+            {
+                return (int)_socket.GetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay) > 0;
+            }
+
+            set
+            {
+                _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, value ? 1 : 0);
+            }
+        }
+
+        public bool DualMode
+        {
+            get
+            {
+                return _socket.DualMode;
+            }
+
+            set
+            {
+                _socket.DualMode = value;
+            }
+        }
+
+        public int ReceiveBufferSize
+        {
+            get
+            {
+                return _socket.ReceiveBufferSize;
+            }
+
+            set
+            {
+                _socket.ReceiveBufferSize = value;
+            }
+        }
+
+        public int SendBufferSize
+        {
+            get
+            {
+                return _socket.SendBufferSize;
+            }
+
+            set
+            {
+                _socket.SendBufferSize = value;
+            }
+        }
+
+        public EndPoint RemoteEndPoint
+        {
+            get
+            {
+                return _socket.RemoteEndPoint;
+            }
+        }
+
+        public bool ReuseAddress
+        {
+            get
+            {
+                return (int)_socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress) != 0;
+            }
+
+            set
+            {
+                _socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, value ? 1 : 0);
+            }
+        }
+
+        public async Task<CrossPlatformSocket> AcceptAsync()
+        {
+            try
+            {
+#if NET452 || NET461
+                var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null).ConfigureAwait(false);
+                return new CrossPlatformSocket(clientSocket);
+#else
+                var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
+                return new CrossPlatformSocket(clientSocket);
+#endif
+            }
+            catch (ObjectDisposedException)
+            {
+                // This will happen when _socket.EndAccept gets called by Task library but the socket is already disposed.
+                return null;
+            }
+        }
+
+        public void Bind(EndPoint localEndPoint)
+        {
+            if (localEndPoint is null) throw new ArgumentNullException(nameof(localEndPoint));
+
+            _socket.Bind(localEndPoint);
+        }
+
+        public void Listen(int connectionBacklog)
+        {
+            _socket.Listen(connectionBacklog);
+        }
+
+        public async Task ConnectAsync(string host, int port, CancellationToken cancellationToken)
+        {
+            if (host is null) throw new ArgumentNullException(nameof(host));
+
+            try
+            {
+                // Workaround for: workaround for https://github.com/dotnet/corefx/issues/24430
+                using (cancellationToken.Register(() => _socket.Dispose()))
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+
+#if NET452 || NET461
+                    await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, host, port, null).ConfigureAwait(false);
+#else
+                    await _socket.ConnectAsync(host, port).ConfigureAwait(false);
+#endif
+                }
+            }
+            catch (ObjectDisposedException)
+            {
+                // This will happen when _socket.EndConnect gets called by Task library but the socket is already disposed.
+            }
+        }
+
+        public async Task SendAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
+        {
+            try
+            {
+#if NET452 || NET461
+                await Task.Factory.FromAsync(SocketWrapper.BeginSend, _socket.EndSend, new SocketWrapper(_socket, buffer, socketFlags)).ConfigureAwait(false);
+#else
+                await _socket.SendAsync(buffer, socketFlags).ConfigureAwait(false);
+#endif
+            }
+            catch (ObjectDisposedException)
+            {
+                // This will happen when _socket.EndConnect gets called by Task library but the socket is already disposed.
+            }
+        }
+
+        public async Task<int> ReceiveAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
+        {
+            try
+            {
+#if NET452 || NET461
+                return await Task.Factory.FromAsync(SocketWrapper.BeginReceive, _socket.EndReceive, new SocketWrapper(_socket, buffer, socketFlags)).ConfigureAwait(false);
+#else
+                return await _socket.ReceiveAsync(buffer, socketFlags).ConfigureAwait(false);
+#endif
+            }
+            catch (ObjectDisposedException)
+            {
+                // This will happen when _socket.EndReceive gets called by Task library but the socket is already disposed.
+                return -1;
+            }
+        }
+
+        public NetworkStream GetStream()
+        {
+            return new NetworkStream(_socket, true);
+        }
+
+        public void Dispose()
+        {
+            _socket?.Dispose();
+        }
+
+#if NET452 || NET461
+        class SocketWrapper
+        {
+            readonly Socket _socket;
+            readonly ArraySegment<byte> _buffer;
+            readonly SocketFlags _socketFlags;
+
+            public SocketWrapper(Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
+            {
+                _socket = socket;
+                _buffer = buffer;
+                _socketFlags = socketFlags;
+            }
+
+            public static IAsyncResult BeginSend(AsyncCallback callback, object state)
+            {
+                var socketWrapper = (SocketWrapper)state;
+                return socketWrapper._socket.BeginSend(socketWrapper._buffer.Array, socketWrapper._buffer.Offset, socketWrapper._buffer.Count, socketWrapper._socketFlags, callback, state);
+            }
+
+            public static IAsyncResult BeginReceive(AsyncCallback callback, object state)
+            {
+                var socketWrapper = (SocketWrapper)state;
+                return socketWrapper._socket.BeginReceive(socketWrapper._buffer.Array, socketWrapper._buffer.Offset, socketWrapper._buffer.Count, socketWrapper._socketFlags, callback, state);
+            }
+        }
+#endif
+    }
+}

Source/MQTTnet/Implementations/MqttTcpChannel.cs

@@ -46,15 +46,15 @@ namespace MQTTnet.Implementations
 
         public async Task ConnectAsync(CancellationToken cancellationToken)
         {
-            Socket socket;
+            CrossPlatformSocket socket;
 
             if (_options.AddressFamily == AddressFamily.Unspecified)
             {
-                socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                socket = new CrossPlatformSocket();
             }
             else
             {
-                socket = new Socket(_options.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+                socket = new CrossPlatformSocket(_options.AddressFamily);
             }
 
             socket.ReceiveBufferSize = _options.BufferSize;
@@ -69,20 +69,24 @@ namespace MQTTnet.Implementations
                 socket.DualMode = _options.DualMode.Value;
             }
 
-            // Workaround for: workaround for https://github.com/dotnet/corefx/issues/24430
-            using (cancellationToken.Register(() => socket.Dispose()))
-            {
-                await PlatformAbstractionLayer.ConnectAsync(socket, _options.Server, _options.GetPort()).ConfigureAwait(false);
-            }
+            await socket.ConnectAsync(_options.Server, _options.GetPort(), cancellationToken).ConfigureAwait(false);
 
-            var networkStream = new NetworkStream(socket, true);
+            var networkStream = socket.GetStream();
 
             if (_options.TlsOptions.UseTls)
             {
                 var sslStream = new SslStream(networkStream, false, InternalUserCertificateValidationCallback);
-                _stream = sslStream;
+                try
+                {
+                    await sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), _options.TlsOptions.SslProtocol, !_options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+                }
+                catch
+                {
+                    sslStream.Dispose();
+                    throw;
+                }
 
-                await sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), _options.TlsOptions.SslProtocol, !_options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+                _stream = sslStream;
             }
             else
             {
@@ -107,17 +111,14 @@ namespace MQTTnet.Implementations
                 // Workaround for: https://github.com/dotnet/corefx/issues/24430
                 using (cancellationToken.Register(Dispose))
                 {
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        return 0;
-                    }
+                    cancellationToken.ThrowIfCancellationRequested();
 
                     return await _stream.ReadAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (ObjectDisposedException)
             {
-                return 0;
+                return -1;
             }
             catch (IOException exception)
             {
@@ -139,10 +140,7 @@ namespace MQTTnet.Implementations
                 // Workaround for: https://github.com/dotnet/corefx/issues/24430
                 using (cancellationToken.Register(Dispose))
                 {
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        return;
-                    }
+                    cancellationToken.ThrowIfCancellationRequested();
 
                     await _stream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
                 }

Source/MQTTnet/Implementations/MqttTcpServerListener.cs

@@ -23,7 +23,7 @@ namespace MQTTnet.Implementations
         readonly MqttServerTlsTcpEndpointOptions _tlsOptions;
         readonly X509Certificate2 _tlsCertificate;
 
-        private Socket _socket;
+        private CrossPlatformSocket _socket;
         private IPEndPoint _localEndPoint;
 
         public MqttTcpServerListener(
@@ -59,18 +59,18 @@ namespace MQTTnet.Implementations
 
                 _logger.Info($"Starting TCP listener for {_localEndPoint} TLS={_tlsCertificate != null}.");
 
-                _socket = new Socket(_addressFamily, SocketType.Stream, ProtocolType.Tcp);
+                _socket = new CrossPlatformSocket(_addressFamily);
 
                 // Usage of socket options is described here: https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.socket.setsocketoption?view=netcore-2.2
 
                 if (_options.ReuseAddress)
                 {
-                    _socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+                    _socket.ReuseAddress = true;
                 }
 
                 if (_options.NoDelay)
                 {
-                    _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
+                    _socket.NoDelay = true;
                 }
 
                 _socket.Bind(_localEndPoint);
@@ -107,7 +107,7 @@ namespace MQTTnet.Implementations
             {
                 try
                 {
-                    var clientSocket = await PlatformAbstractionLayer.AcceptAsync(_socket).ConfigureAwait(false);
+                    var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
                     if (clientSocket == null)
                     {
                         continue;
@@ -135,7 +135,7 @@ namespace MQTTnet.Implementations
             }
         }
 
-        async Task TryHandleClientConnectionAsync(Socket clientSocket)
+        async Task TryHandleClientConnectionAsync(CrossPlatformSocket clientSocket)
         {
             Stream stream = null;
             string remoteEndPoint = null;
@@ -151,7 +151,7 @@ namespace MQTTnet.Implementations
 
                 clientSocket.NoDelay = _options.NoDelay;
 
-                stream = new NetworkStream(clientSocket, true);
+                stream = clientSocket.GetStream();
 
                 X509Certificate2 clientCertificate = null;
 

Source/MQTTnet/Implementations/PlatformAbstractionLayer.cs

@@ -1,94 +1,9 @@
-using System;
-using System.Net;
-using System.Net.Sockets;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 
 namespace MQTTnet.Implementations
 {
     public static class PlatformAbstractionLayer
     {
-        // TODO: Consider creating primitives like "MqttNetSocket" which will wrap all required methods and do the platform stuff.
-        public static async Task<Socket> AcceptAsync(Socket socket)
-        {
-#if NET452 || NET461
-            try
-            {
-                return await Task.Factory.FromAsync(socket.BeginAccept, socket.EndAccept, null).ConfigureAwait(false);
-            }
-            catch (ObjectDisposedException)
-            {
-                return null;
-            }
-#else
-            return await socket.AcceptAsync().ConfigureAwait(false);
-#endif
-        }
-
-
-        public static Task ConnectAsync(Socket socket, IPAddress ip, int port)
-        {
-#if NET452 || NET461
-            return Task.Factory.FromAsync(socket.BeginConnect, socket.EndConnect, ip, port, null);
-#else
-            return socket.ConnectAsync(ip, port);
-#endif
-        }
-
-        public static Task ConnectAsync(Socket socket, string host, int port)
-        {
-#if NET452 || NET461
-            return Task.Factory.FromAsync(socket.BeginConnect, socket.EndConnect, host, port, null);
-#else
-            return socket.ConnectAsync(host, port);
-#endif
-        }
-
-#if NET452 || NET461
-        public class SocketWrapper 
-        {
-            private readonly Socket _socket;
-            private readonly ArraySegment<byte> _buffer;
-            private readonly SocketFlags _socketFlags;
-
-            public SocketWrapper(Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
-            {
-                _socket = socket;
-                _buffer = buffer;
-                _socketFlags = socketFlags;
-            }
-
-            public static IAsyncResult BeginSend(AsyncCallback callback, object state)
-            {
-                var real = (SocketWrapper)state;
-                return real._socket.BeginSend(real._buffer.Array, real._buffer.Offset, real._buffer.Count, real._socketFlags, callback, state);
-            }
-
-            public static IAsyncResult BeginReceive(AsyncCallback callback, object state)
-            {
-                var real = (SocketWrapper)state;
-                return real._socket.BeginReceive(real._buffer.Array, real._buffer.Offset, real._buffer.Count, real._socketFlags, callback, state);
-            }
-        }
-#endif
-
-        public static Task SendAsync(Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
-        {
-#if NET452 || NET461            
-            return Task.Factory.FromAsync(SocketWrapper.BeginSend, socket.EndSend, new SocketWrapper(socket, buffer, socketFlags));
-#else
-            return socket.SendAsync(buffer, socketFlags);
-#endif
-        }
-
-        public static Task<int> ReceiveAsync(Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
-        {
-#if NET452 || NET461
-            return Task.Factory.FromAsync(SocketWrapper.BeginReceive, socket.EndReceive, new SocketWrapper(socket, buffer, socketFlags));
-#else
-            return socket.ReceiveAsync(buffer, socketFlags);
-#endif
-        }
-
         public static Task CompletedTask
         {
             get