Add SessionId to SessionContext, fix missing timeout for starttls

Src/SmtpServer/IO/SecurableDuplexPipe.cs

@@ -38,11 +38,27 @@ internal SecurableDuplexPipe(Stream stream, Action disposeAction)
         /// <returns>A task that asynchronously performs the operation.</returns>
         public async Task UpgradeAsync(X509Certificate certificate, SslProtocols protocols, CancellationToken cancellationToken = default)
         {
-            var stream = new SslStream(_stream, true);
+            var sslStream = new SslStream(_stream, true);
 
-            await stream.AuthenticateAsServerAsync(certificate, false, protocols, true).ConfigureAwait(false);
+            try
+            {
+                var sslServerAuthenticationOptions = new SslServerAuthenticationOptions
+                {
+                    ServerCertificate = certificate,
+                    ClientCertificateRequired = false,
+                    EnabledSslProtocols = protocols,
+                    CertificateRevocationCheckMode = X509RevocationMode.Online
+                };
 
-            _stream = stream;
+                await sslStream.AuthenticateAsServerAsync(sslServerAuthenticationOptions, cancellationToken);
+            }
+            catch
+            {
+                sslStream.Dispose();
+                throw;
+            }
+
+            _stream = sslStream;
 
             Input = PipeReader.Create(_stream);
             Output = PipeWriter.Create(_stream);

Src/SmtpServer/ISessionContext.cs

@@ -9,6 +9,11 @@ namespace SmtpServer
     /// </summary>
     public interface ISessionContext
     {
+        /// <summary>
+        /// A unique Id for the Session
+        /// </summary>
+        public Guid SessionId { get; }
+
         /// <summary>
         /// Fired when a command is about to execute.
         /// </summary>

Src/SmtpServer/SmtpServer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard2.1</TargetFramework>
     <LangVersion>8.0</LangVersion>
     <AssemblyName>SmtpServer</AssemblyName>
     <RootNamespace>SmtpServer</RootNamespace>

Src/SmtpServer/SmtpSessionContext.cs

@@ -7,6 +7,9 @@ namespace SmtpServer
 {
     internal sealed class SmtpSessionContext : ISessionContext
     {
+        /// <inheritdoc />
+        public Guid SessionId { get; private set; }
+
         /// <inheritdoc />
         public event EventHandler<SmtpCommandEventArgs> CommandExecuting;
 
@@ -27,6 +30,7 @@ internal sealed class SmtpSessionContext : ISessionContext
         /// <param name="endpointDefinition">The endpoint definition.</param>
         internal SmtpSessionContext(IServiceProvider serviceProvider, ISmtpServerOptions options, IEndpointDefinition endpointDefinition)
         {
+            SessionId = Guid.NewGuid();
             ServiceProvider = serviceProvider;
             ServerOptions = options;
             EndpointDefinition = endpointDefinition;

Src/SmtpServer/SmtpSessionManager.cs

@@ -1,5 +1,5 @@
 using System;
-using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,8 +9,7 @@ namespace SmtpServer
     internal sealed class SmtpSessionManager
     {
         readonly SmtpServer _smtpServer;
-        readonly HashSet<SmtpSessionHandle> _sessions = new HashSet<SmtpSessionHandle>();
-        readonly object _sessionsLock = new object();
+        readonly ConcurrentDictionary<Guid, SmtpSessionHandle> _sessions = new ConcurrentDictionary<Guid, SmtpSessionHandle>();
 
         internal SmtpSessionManager(SmtpServer smtpServer)
         {
@@ -20,16 +19,13 @@ internal SmtpSessionManager(SmtpServer smtpServer)
         internal void Run(SmtpSessionContext sessionContext, CancellationToken cancellationToken)
         {
             var handle = new SmtpSessionHandle(new SmtpSession(sessionContext), sessionContext);
-            Add(handle);
 
-            handle.CompletionTask = RunAsync(handle, cancellationToken);
+            var smtpSessionTask = RunAsync(handle, cancellationToken).ContinueWith(task =>
+            {
+                Remove(handle);
+            });
 
-            // ReSharper disable once MethodSupportsCancellation
-            handle.CompletionTask.ContinueWith(
-                task =>
-                {
-                    Remove(handle);
-                });
+            handle.CompletionTask = smtpSessionTask;
         }
 
         async Task RunAsync(SmtpSessionHandle handle, CancellationToken cancellationToken)
@@ -79,30 +75,18 @@ async Task UpgradeAsync(SmtpSessionHandle handle, CancellationToken cancellation
 
         internal Task WaitAsync()
         {
-            IReadOnlyList<Task> tasks;
-
-            lock (_sessionsLock)
-            {
-                tasks = _sessions.Select(session => session.CompletionTask).ToList();
-            }
-
+            var tasks = _sessions.Values.Select(session => session.CompletionTask).ToList().AsReadOnly();
             return Task.WhenAll(tasks);
         }
 
         void Add(SmtpSessionHandle handle)
         {
-            lock (_sessionsLock)
-            {
-                _sessions.Add(handle);
-            }
+            _sessions.TryAdd(handle.SessionContext.SessionId, handle);
         }
 
         void Remove(SmtpSessionHandle handle)
         {
-            lock (_sessionsLock)
-            {
-                _sessions.Remove(handle);
-            }
+            _sessions.TryRemove(handle.SessionContext.SessionId, out _);
         }
 
         class SmtpSessionHandle
@@ -118,6 +102,20 @@ public SmtpSessionHandle(SmtpSession session, SmtpSessionContext sessionContext)
             public SmtpSessionContext SessionContext { get; }
 
             public Task CompletionTask { get; set; }
+
+            public override bool Equals(object obj)
+            {
+                if (obj is SmtpSessionHandle other)
+                {
+                    return SessionContext.SessionId == other.SessionContext.SessionId;
+                }
+                return false;
+            }
+
+            public override int GetHashCode()
+            {
+                return SessionContext.SessionId.GetHashCode();
+            }
         }
     }
 }