Fix breaking changes.

2026-10-19 19:13:11 +08:00 · 2017-06-03 22:48:22 +02:00
parent 1317fa3e2a
commit 929cdb971a
92 changed files with 1363 additions and 1309 deletions
@@ -0,0 +1,90 @@
+using System;
+using System.Security.Cryptography.X509Certificates;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
+using MQTTnet.Core.Server;
+using Windows.Networking.Sockets;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        private StreamSocketListener _defaultEndpointSocket;
+        private StreamSocketListener _sslEndpointSocket;
+        private X509Certificate2 _sslCertificate;
+
+        private bool _isRunning;
+
+        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
+
+        public void Start(MqttServerOptions options)
+        {
+            if (_isRunning) throw new InvalidOperationException("Server is already started.");
+            _isRunning = true;
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _defaultEndpointSocket = new StreamSocketListener();
+                _defaultEndpointSocket.BindServiceNameAsync(options.GetDefaultEndpointPort().ToString(), SocketProtectionLevel.PlainSocket).GetAwaiter().GetResult();
+                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;                
+            }
+
+            if (options.SslEndpointOptions.IsEnabled)
+            {
+                if (options.SslEndpointOptions.Certificate == null)
+                {
+                    throw new ArgumentException("SSL certificate is not set.");
+                }
+
+                _sslCertificate = new X509Certificate2(options.SslEndpointOptions.Certificate);
+
+                _sslEndpointSocket = new StreamSocketListener();
+                _sslEndpointSocket.BindServiceNameAsync(options.GetSslEndpointPort().ToString(), SocketProtectionLevel.Tls12).GetAwaiter().GetResult();
+                _sslEndpointSocket.ConnectionReceived += AcceptSslEndpointConnectionsAsync;
+            }
+        }
+
+        public void Stop()
+        {
+            _isRunning = false;
+
+            _defaultEndpointSocket?.Dispose();
+            _defaultEndpointSocket = null;
+
+            _sslEndpointSocket?.Dispose();
+            _sslEndpointSocket = null;
+        }
+
+        public void Dispose()
+        {
+            Stop();
+        }
+
+        private void AcceptDefaultEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
+        {
+            try
+            {
+                var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(args.Socket), new DefaultMqttV311PacketSerializer());
+                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(args.Socket.Information.RemoteAddress.ToString(), clientAdapter));
+            }
+            catch (Exception exception)
+            {
+                MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while acceping connection at default endpoint.");
+            }
+        }
+
+        private void AcceptSslEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
+        {
+            try
+            {
+                var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(args.Socket), new DefaultMqttV311PacketSerializer());
+                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(args.Socket.Information.RemoteAddress.ToString(), clientAdapter));
+            }
+            catch (Exception exception)
+            {
+                MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while acceping connection at SSL endpoint.");
+            }
+        }
+    }
+}
@@ -0,0 +1,121 @@
+using System;
+using System.Linq;
+using System.Net.Sockets;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading.Tasks;
+using Windows.Networking;
+using Windows.Networking.Sockets;
+using Windows.Security.Cryptography.Certificates;
+using Windows.Storage.Streams;
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using MQTTnet.Core.Exceptions;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private readonly StreamSocket _socket;
+
+        public MqttTcpChannel()
+        {
+            _socket = new StreamSocket();
+        }
+
+        public MqttTcpChannel(StreamSocket socket)
+        {
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+        }
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            try
+            {
+                if (!options.SslOptions.UseSsl)
+                {
+                    await _socket.ConnectAsync(new HostName(options.Server), options.GetPort().ToString());
+                }
+                else
+                {
+                    _socket.Control.ClientCertificate = LoadCertificate(options);
+
+                    if (!options.SslOptions.CheckCertificateRevocation)
+                    {
+                        _socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Revoked);
+                        _socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.IncompleteChain);
+                        _socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.RevocationInformationMissing);
+                    }
+                    
+                    await _socket.ConnectAsync(new HostName(options.Server), options.GetPort().ToString(), SocketProtectionLevel.Tls12);
+                }
+            }
+            catch (SocketException exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        public Task DisconnectAsync()
+        {
+            try
+            {
+                _socket.Dispose();
+                return Task.FromResult(0);
+            }
+            catch (SocketException exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        public async Task WriteAsync(byte[] buffer)
+        {
+            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+
+            try
+            {
+                await _socket.OutputStream.WriteAsync(buffer.AsBuffer());
+                await _socket.OutputStream.FlushAsync();
+            }
+            catch (SocketException exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        public async Task ReadAsync(byte[] buffer)
+        {
+            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+
+            try
+            {
+                await _socket.InputStream.ReadAsync(buffer.AsBuffer(), (uint)buffer.Length, InputStreamOptions.Partial);
+            }
+            catch (SocketException exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        public void Dispose()
+        {
+            _socket?.Dispose();
+        }
+
+        private static Certificate LoadCertificate(MqttClientOptions options)
+        {
+            if (options.SslOptions.Certificates == null || !options.SslOptions.Certificates.Any())
+            {
+                return null;
+            }
+
+            if (options.SslOptions.Certificates.Count > 1)
+            {
+                throw new NotSupportedException("Only one client certificate is supported for UWP.");
+            }
+
+            return new Certificate(options.SslOptions.Certificates.First().AsBuffer());
+        }
+    }
+}