Expose more properties to connection validator context.

MQTTnet.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.28307.645
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29009.5
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MQTTnet.Tests", "Tests\MQTTnet.Core.Tests\MQTTnet.Tests.csproj", "{A7FF0C91-25DE-4BA6-B39E-F54E8DADF1CC}"
 EndProject

README.md

@@ -26,7 +26,7 @@ MQTTnet is a high performance .NET library for MQTT based communication. It prov
 * Uniform API across all supported versions of the MQTT protocol
 * Interfaces included for mocking and testing
 * Access to internal trace messages
-* Unit tested (~200 tests)
+* Unit tested (~210 tests)
 * No external dependencies
 
 \* Tested on local machine (Intel i7 8700K) with MQTTnet client and server running in the same process using the TCP channel. The app for verification is part of this repository and stored in _/Tests/MQTTnet.TestApp.NetCore_.

Source/MQTTnet/Formatter/IMqttDataConverter.cs

@@ -5,6 +5,8 @@
 using MQTTnet.Client.Subscribing;
 using MQTTnet.Client.Unsubscribing;
 using MQTTnet.Packets;
+using MQTTnet.Server;
+using MqttClientSubscribeResult = MQTTnet.Client.Subscribing.MqttClientSubscribeResult;
 
 namespace MQTTnet.Formatter
 {
@@ -20,6 +22,8 @@ public interface IMqttDataConverter
 
         MqttConnectPacket CreateConnectPacket(MqttApplicationMessage willApplicationMessage, IMqttClientOptions options);
 
+        MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext);
+
         MqttClientSubscribeResult CreateClientSubscribeResult(MqttSubscribePacket subscribePacket, MqttSubAckPacket subAckPacket);
 
         MqttClientUnsubscribeResult CreateClientUnsubscribeResult(MqttUnsubscribePacket unsubscribePacket, MqttUnsubAckPacket unsubAckPacket);

Source/MQTTnet/Formatter/V3/MqttV310DataConverter.cs

@@ -9,6 +9,8 @@
 using MQTTnet.Exceptions;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Server;
+using MqttClientSubscribeResult = MQTTnet.Client.Subscribing.MqttClientSubscribeResult;
 
 namespace MQTTnet.Formatter.V3
 {
@@ -124,6 +126,16 @@ public MqttConnectPacket CreateConnectPacket(MqttApplicationMessage willApplicat
             };
         }
 
+        public MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext)
+        {
+            if (connectionValidatorContext == null) throw new ArgumentNullException(nameof(connectionValidatorContext));
+
+            return new MqttConnAckPacket
+            {
+                ReturnCode = new MqttConnectReasonCodeConverter().ToConnectReturnCode(connectionValidatorContext.ReasonCode)
+            };
+        }
+
         public MqttClientSubscribeResult CreateClientSubscribeResult(MqttSubscribePacket subscribePacket, MqttSubAckPacket subAckPacket)
         {
             if (subscribePacket == null) throw new ArgumentNullException(nameof(subscribePacket));

Source/MQTTnet/Formatter/V5/MqttV500DataConverter.cs

@@ -10,6 +10,9 @@
 using MQTTnet.Exceptions;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Server;
+
+using MqttClientSubscribeResult = MQTTnet.Client.Subscribing.MqttClientSubscribeResult;
 
 namespace MQTTnet.Formatter.V5
 {
@@ -129,6 +132,22 @@ public MqttConnectPacket CreateConnectPacket(MqttApplicationMessage willApplicat
             };
         }
 
+        public MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext)
+        {
+            return new MqttConnAckPacket
+            {
+                ReasonCode = connectionValidatorContext.ReasonCode,
+                Properties = new MqttConnAckPacketProperties
+                {
+                    UserProperties = connectionValidatorContext.UserProperties,
+                    AuthenticationMethod = connectionValidatorContext.AuthenticationMethod,
+                    AuthenticationData = connectionValidatorContext.ResponseAuthenticationData,
+                    AssignedClientIdentifier = connectionValidatorContext.AssignedClientIdentifier,
+                    ReasonString = connectionValidatorContext.ReasonString
+                }
+            };
+        }
+
         public MqttClientSubscribeResult CreateClientSubscribeResult(MqttSubscribePacket subscribePacket, MqttSubAckPacket subAckPacket)
         {
             if (subscribePacket == null) throw new ArgumentNullException(nameof(subscribePacket));

Source/MQTTnet/Protocol/MqttConnectReasonCodeConverter.cs

@@ -0,0 +1,91 @@
+using MQTTnet.Exceptions;
+
+namespace MQTTnet.Protocol
+{
+    public class MqttConnectReasonCodeConverter
+    {
+        public MqttConnectReturnCode ToConnectReturnCode(MqttConnectReasonCode reasonCode)
+        {
+            switch (reasonCode)
+            {
+                case MqttConnectReasonCode.Success:
+                    {
+                        return MqttConnectReturnCode.ConnectionAccepted;
+                    }
+
+                case MqttConnectReasonCode.NotAuthorized:
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedNotAuthorized;
+                    }
+
+                case MqttConnectReasonCode.BadUserNameOrPassword:
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
+                    }
+
+                case MqttConnectReasonCode.ClientIdentifierNotValid:
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
+                    }
+
+                case MqttConnectReasonCode.UnsupportedProtocolVersion:
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedUnacceptableProtocolVersion;
+                    }
+
+                case MqttConnectReasonCode.ServerUnavailable:
+                case MqttConnectReasonCode.ServerBusy:
+                case MqttConnectReasonCode.ServerMoved:
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedServerUnavailable;
+                    }
+
+                default:
+                    {
+                        throw new MqttProtocolViolationException("Unable to convert connect reason code (MQTTv5) to return code (MQTTv3).");
+                    }
+            }
+        }
+
+        public MqttConnectReasonCode ToConnectReasonCode(MqttConnectReturnCode returnCode)
+        {
+            switch (returnCode)
+            {
+                case MqttConnectReturnCode.ConnectionAccepted:
+                    {
+                        return MqttConnectReasonCode.Success;
+                    }
+
+                case MqttConnectReturnCode.ConnectionRefusedUnacceptableProtocolVersion:
+                    {
+                        return MqttConnectReasonCode.UnsupportedProtocolVersion;
+                    }
+
+                case MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword:
+                    {
+                        return MqttConnectReasonCode.BadUserNameOrPassword;
+                    }
+
+                case MqttConnectReturnCode.ConnectionRefusedIdentifierRejected:
+                    {
+                        return MqttConnectReasonCode.ClientIdentifierNotValid;
+                    }
+
+                case MqttConnectReturnCode.ConnectionRefusedServerUnavailable:
+                    {
+                        return MqttConnectReasonCode.ServerUnavailable;
+                    }
+
+                case MqttConnectReturnCode.ConnectionRefusedNotAuthorized:
+                    {
+                        return MqttConnectReasonCode.NotAuthorized;
+                    }
+
+                default:
+                    {
+                        throw new MqttProtocolViolationException("Unable to convert connect reason code (MQTTv5) to return code (MQTTv3).");
+                    }
+            }
+        }
+    }
+}

Source/MQTTnet/Server/MqttClientSessionsManager.cs

@@ -5,6 +5,7 @@
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
+using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
@@ -227,7 +228,7 @@ private async Task TryProcessNextQueuedApplicationMessageAsync(CancellationToken
         private async Task HandleClientAsync(IMqttChannelAdapter channelAdapter, CancellationToken cancellationToken)
         {
             var disconnectType = MqttClientDisconnectType.NotClean;
-            var clientId = string.Empty;
+            string clientId = null;
 
             try
             {
@@ -242,20 +243,12 @@ private async Task HandleClientAsync(IMqttChannelAdapter channelAdapter, Cancell
 
                 var validatorContext = await ValidateConnectionAsync(connectPacket, channelAdapter).ConfigureAwait(false);
 
-                if (validatorContext.ReturnCode != MqttConnectReturnCode.ConnectionAccepted)
+                if (validatorContext.ReasonCode != MqttConnectReasonCode.Success)
                 {
-                    // TODO: Move to channel adapter data converter.
-
                     // Send failure response here without preparing a session. The result for a successful connect
                     // will be sent from the session itself.
-                    await channelAdapter.SendPacketAsync(
-                        new MqttConnAckPacket
-                        {
-                            ReturnCode = validatorContext.ReturnCode,
-                            ReasonCode = MqttConnectReasonCode.NotAuthorized
-                        },
-                        _options.DefaultCommunicationTimeout,
-                        cancellationToken).ConfigureAwait(false);
+                    var connAckPacket = channelAdapter.PacketFormatterAdapter.DataConverter.CreateConnAckPacket(validatorContext);
+                    await channelAdapter.SendPacketAsync(connAckPacket, _options.DefaultCommunicationTimeout, cancellationToken).ConfigureAwait(false);
 
                     return;
                 }
@@ -275,39 +268,51 @@ await channelAdapter.SendPacketAsync(
             }
             finally
             {
-                _connections.TryRemove(clientId, out _);
-
-                if (!_options.EnablePersistentSessions)
+                if (clientId != null)
                 {
-                    await DeleteSessionAsync(clientId).ConfigureAwait(false);
+                    _connections.TryRemove(clientId, out _);
+
+                    if (!_options.EnablePersistentSessions)
+                    {
+                        await DeleteSessionAsync(clientId).ConfigureAwait(false);
+                    }
                 }
 
                 await TryCleanupChannelAsync(channelAdapter).ConfigureAwait(false);
 
-                await _eventDispatcher.HandleClientDisconnectedAsync(clientId, disconnectType).ConfigureAwait(false);
+                if (clientId != null)
+                {
+                    await _eventDispatcher.TryHandleClientDisconnectedAsync(clientId, disconnectType).ConfigureAwait(false);
+                }
             }
         }
 
-        private async Task<MqttConnectionValidatorContext> ValidateConnectionAsync(MqttConnectPacket connectPacket, IMqttChannelAdapter clientAdapter)
+        private async Task<MqttConnectionValidatorContext> ValidateConnectionAsync(MqttConnectPacket connectPacket, IMqttChannelAdapter channelAdapter)
         {
-            var context = new MqttConnectionValidatorContext(
-                connectPacket.ClientId,
-                connectPacket.Username,
-                connectPacket.Password,
-                connectPacket.WillMessage,
-                clientAdapter.Endpoint,
-                clientAdapter.IsSecureConnection,
-                clientAdapter.ClientCertificate);
+            var context = new MqttConnectionValidatorContext(connectPacket, channelAdapter);
 
             var connectionValidator = _options.ConnectionValidator;
 
             if (connectionValidator == null)
             {
-                context.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
+                context.ReasonCode = MqttConnectReasonCode.Success;
                 return context;
             }
 
             await connectionValidator.ValidateConnectionAsync(context).ConfigureAwait(false);
+
+            // Check the client ID and set a random one if supported.
+            if (string.IsNullOrEmpty(connectPacket.ClientId) &&
+                channelAdapter.PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.V500)
+            {
+                connectPacket.ClientId = context.AssignedClientIdentifier;
+            }
+
+            if (string.IsNullOrEmpty(connectPacket.ClientId))
+            {
+                context.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
+            }
+
             return context;
         }