Add Smtp SessionTimout

Src/SmtpServer.Tests/RawSmtpClient.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SmtpServer.Tests
+{
+    internal class RawSmtpClient : IDisposable
+    {
+        private readonly TcpClient _tcpClient;
+        private NetworkStream _networkStream;
+
+        internal RawSmtpClient(string host, int port)
+        {
+            _tcpClient = new TcpClient();
+        }
+
+        public void Dispose()
+        {
+            _networkStream?.Dispose();
+            _tcpClient.Dispose();
+        }
+
+        internal async Task<bool> ConnectAsync()
+        {
+            await _tcpClient.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9025));
+            _networkStream = _tcpClient.GetStream();
+
+            var greetingResponse = await WaitForDataAsync();
+            if (greetingResponse.StartsWith("220"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        internal async Task<string> SendCommandAsync(string command)
+        {
+            var commandData = Encoding.UTF8.GetBytes($"{command}\r\n");
+
+            await _networkStream.WriteAsync(commandData, 0, commandData.Length);
+            return await WaitForDataAsync();
+        }
+
+        internal async Task SendDataAsync(string data)
+        {
+            var mailData = Encoding.UTF8.GetBytes(data);
+
+            await _networkStream.WriteAsync(mailData, 0, mailData.Length);
+        }
+
+        internal async Task<string> WaitForDataAsync()
+        {
+            var buffer = new byte[1024];
+            int bytesRead;
+
+            while ((bytesRead = await _networkStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
+            {
+                var receivedData = Encoding.UTF8.GetString(buffer, 0, bytesRead);
+                return receivedData;
+            }
+
+            return null;
+        }
+    }
+}

Src/SmtpServer.Tests/SmtpServerTests.cs

@@ -7,6 +7,7 @@
 using SmtpServer.Storage;
 using SmtpServer.Tests.Mocks;
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Security.Authentication;
@@ -159,6 +160,79 @@ public void WillTimeoutWaitingForCommand()
             }
         }
 
+        [Fact]
+        public async Task WillSessionTimeoutDuringMailDataTransmission()
+        {
+            var sessionTimeout = TimeSpan.FromSeconds(5);
+            var commandWaitTimeout = TimeSpan.FromSeconds(1);
+
+            using var disposable = CreateServer(
+                serverOptions => serverOptions.CommandWaitTimeout(commandWaitTimeout),
+                endpointDefinition => endpointDefinition.SessionTimeout(sessionTimeout));
+
+            var stopwatch = new Stopwatch();
+            stopwatch.Start();
+
+            using var rawSmtpClient = new RawSmtpClient("127.0.0.1", 9025);
+            await rawSmtpClient.ConnectAsync();
+
+            var response = await rawSmtpClient.SendCommandAsync("helo test");
+            if (!response.StartsWith("250"))
+            {
+                Assert.Fail("helo command not successful");
+            }
+
+            response = await rawSmtpClient.SendCommandAsync("mail from:<[email protected]>");
+            if (!response.StartsWith("250"))
+            {
+                Assert.Fail("mail from command not successful");
+            }
+
+            response = await rawSmtpClient.SendCommandAsync("rcpt to:<[email protected]>");
+            if (!response.StartsWith("250"))
+            {
+                Assert.Fail("rcpt to command not successful");
+            }
+
+            response = await rawSmtpClient.SendCommandAsync("data");
+            if (!response.StartsWith("354"))
+            {
+                Assert.Fail("data command not successful");
+            }
+
+            string smtpResponse = null;
+
+            _ = Task.Run (async() =>
+            {
+                smtpResponse = await rawSmtpClient.WaitForDataAsync();
+            });
+
+            var isSessionCancelled = false;
+
+            try
+            {
+                for (var i = 0; i < 1000; i++)
+                {
+                    await rawSmtpClient.SendDataAsync("some text part ");
+                    await Task.Delay(100);
+                }
+            }
+            catch (IOException)
+            {
+                isSessionCancelled = true;
+                stopwatch.Stop();
+            }
+            catch (Exception exception)
+            {
+                Assert.Fail($"Wrong exception type {exception.GetType()}");
+            }
+
+            Assert.True(isSessionCancelled, "Smtp session is not cancelled");
+            Assert.Equal("554 \r\n221 The session has be cancelled.\r\n", smtpResponse);
+
+            Assert.True(stopwatch.Elapsed > sessionTimeout, "SessionTimeout not reached");
+        }
+
         [Fact]
         public void CanReturnSmtpResponseException_DoesNotQuit()
         {

Src/SmtpServer/EndpointDefinitionBuilder.cs

@@ -21,7 +21,7 @@ public IEndpointDefinition Build()
         {
             var definition = new EndpointDefinition
             {
-                ReadTimeout = TimeSpan.FromMinutes(2),
+                SessionTimeout = TimeSpan.FromMinutes(2),
                 SupportedSslProtocols = SslProtocols.Tls12,
             };
 
@@ -103,13 +103,13 @@ public EndpointDefinitionBuilder AllowUnsecureAuthentication(bool value = true)
         }
 
         /// <summary>
-        /// Sets the read timeout to apply to stream operations.
+        /// Sets the session timeout to apply to the session.
         /// </summary>
-        /// <param name="value">The timeout value to apply to read operations.</param>
+        /// <param name="value">The timeout value to apply to the Smtp session.</param>
         /// <returns>A EndpointDefinitionBuilder to continue building on.</returns>
-        public EndpointDefinitionBuilder ReadTimeout(TimeSpan value)
+        public EndpointDefinitionBuilder SessionTimeout(TimeSpan value)
         {
-            _setters.Add(options => options.ReadTimeout = value);
+            _setters.Add(options => options.SessionTimeout = value);
 
             return this;
         }
@@ -152,39 +152,25 @@ public EndpointDefinitionBuilder SupportedSslProtocols(SslProtocols value)
 
         internal sealed class EndpointDefinition : IEndpointDefinition
         {
-            /// <summary>
-            /// The IP endpoint to listen on.
-            /// </summary>
+            /// <inheritdoc />
             public IPEndPoint Endpoint { get; set; }
 
-            /// <summary>
-            /// Indicates whether the endpoint is secure by default.
-            /// </summary>
+            /// <inheritdoc />
             public bool IsSecure { get; set; }
 
-            /// <summary>
-            /// Gets a value indicating whether the client must authenticate in order to proceed.
-            /// </summary>
+            /// <inheritdoc />
             public bool AuthenticationRequired { get; set; }
 
-            /// <summary>
-            /// Gets a value indicating whether authentication should be allowed on an unsecure session.
-            /// </summary>
+            /// <inheritdoc />
             public bool AllowUnsecureAuthentication { get; set; }
 
-            /// <summary>
-            /// The timeout on each individual buffer read.
-            /// </summary>
-            public TimeSpan ReadTimeout { get; set; }
+            /// <inheritdoc />
+            public TimeSpan SessionTimeout { get; set; }
 
-            /// <summary>
-            /// Gets the Server Certificate factory to use when starting a TLS session.
-            /// </summary>
+            /// <inheritdoc />
             public ICertificateFactory CertificateFactory { get; set; }
 
-            /// <summary>
-            /// The supported SSL protocols.
-            /// </summary>
+            /// <inheritdoc />
             public SslProtocols SupportedSslProtocols { get; set; }
         }
 

Src/SmtpServer/IEndpointDefinition.cs

@@ -30,9 +30,9 @@ public interface IEndpointDefinition
         bool AllowUnsecureAuthentication { get; }
 
         /// <summary>
-        /// The timeout on each individual buffer read.
+        /// The timeout of an Smtp session.
         /// </summary>
-        TimeSpan ReadTimeout { get; }
+        TimeSpan SessionTimeout { get; }
 
         /// <summary>
         /// Gets the Server Certificate factory to use when starting a TLS session.

Src/SmtpServer/Net/EndpointListener.cs

@@ -43,12 +43,17 @@ public async Task<ISecurableDuplexPipe> GetPipeAsync(ISessionContext context, Ca
             context.Properties.Add(RemoteEndPointKey, tcpClient.Client.RemoteEndPoint);
 
             var stream = tcpClient.GetStream();
-            stream.ReadTimeout = (int)_endpointDefinition.ReadTimeout.TotalMilliseconds;
 
             return new SecurableDuplexPipe(stream, () =>
             {
-                tcpClient.Close();
-                tcpClient.Dispose();
+                try
+                {
+                    tcpClient.Close();
+                    tcpClient.Dispose();
+                }
+                catch (Exception)
+                {
+                }
             });
         }
 

Src/SmtpServer/SmtpSessionManager.cs

@@ -34,15 +34,18 @@ internal void Run(SmtpSessionContext sessionContext, CancellationToken cancellat
 
         async Task RunAsync(SmtpSessionHandle handle, CancellationToken cancellationToken)
         {
+            using var sessionReadTimeoutCancellationTokenSource = new CancellationTokenSource(handle.SessionContext.EndpointDefinition.SessionTimeout);
+            using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, sessionReadTimeoutCancellationTokenSource.Token);
+
             try
             {
-                await UpgradeAsync(handle, cancellationToken);
+                await UpgradeAsync(handle, linkedTokenSource.Token);
 
-                cancellationToken.ThrowIfCancellationRequested();
+                linkedTokenSource.Token.ThrowIfCancellationRequested();
 
                 _smtpServer.OnSessionCreated(new SessionEventArgs(handle.SessionContext));
 
-                await handle.Session.RunAsync(cancellationToken);
+                await handle.Session.RunAsync(linkedTokenSource.Token);
 
                 _smtpServer.OnSessionCompleted(new SessionEventArgs(handle.SessionContext));
             }