Improve SMTP protocol support, streaming paths, benchmarks, and conformance

CHANGELOG.md

@@ -1,10 +1,40 @@
 # Change Log
 
+## v11.2.1
+
+- Fixed: Repacked the SS-17 feature surface from the correct release build so the package includes configurable SMTP extensions, session policy callbacks, and safe command snapshots.
+
+## v11.2.0
+
+- Added: Configurable SMTP extension surface for SMTPUTF8, DSN, and CHUNKING. Extensions remain enabled by default for compatibility and can be disabled through `SmtpServerOptionsBuilder.Extensions(...)`.
+- Added: Session policy callbacks for accepted connections and EHLO/HELO identity checks through `SmtpServerOptionsBuilder.SessionPolicy(...)`.
+- Added: Safe command snapshots on command events so AUTH arguments can be logged without exposing credentials.
+
+```cs
+var options = new SmtpServerOptionsBuilder()
+	.ServerName("My mail server")
+	.Extensions(extensions => extensions
+		.SmtpUtf8(false)
+		.Dsn(false)
+		.Chunking(false))
+	.SessionPolicy(policy => policy
+		.OnConnectionAccepted((context, token) => Task.FromResult(SmtpResponse.Ok))
+		.OnHelo((context, name, token) => Task.FromResult(SmtpResponse.Ok)));
+```
+
 ## v11.1.0
 
 - Added: Configuration option to define the maximum allowed message size.
 - Added: Support for custom SMTP greeting messages.
+- Added: DSN envelope parameter support for MAIL and RCPT commands.
+- Added: Enhanced status code support for common SMTP responses.
+- Added: HELP, VRFY, and EXPN command handling with conservative default VRFY/EXPN responses and an opt-in `ISmtpCommandPolicy` extension point.
+- Added: CHUNKING/BDAT support with multi-chunk streaming, LAST chunk completion, and strict size-limit enforcement.
+- Added: `MaxCommandLineLength` option for SMTP command and AUTH continuation line limits, separate from message body size limits.
+- Fixed: NetworkBufferSize now controls the stream read buffer used by the SMTP connection pipe.
+- Improved: Reduced allocations in EHLO response generation and AUTH credential parsing.
 - Improved: Optimized protection against excessively long text segments to enhance stability and performance.
+- Improved: Documented ESMTP extension advertisement behavior and added tests for conditional EHLO SIZE, STARTTLS, and AUTH advertisement.
 
 ```cs
 var options = new SmtpServerOptionsBuilder()

README.md

@@ -18,8 +18,59 @@ SmtpServer currently supports the following extensions:
 - PIPELINING
 - 8BITMIME
 - SMTPUTF8
+- DSN
+- CHUNKING
 - AUTH PLAIN LOGIN
 
+PIPELINING is advertised because the session reads queued command lines sequentially from the pipe. Commands are still validated against the SMTP state machine in order.
+
+8BITMIME is advertised because message content is accepted and stored as bytes without 7-bit rewriting. Applications remain responsible for MIME validation or normalization in their message store if they need stricter policy.
+
+SMTPUTF8 support covers UTF-8 mailbox/domain parsing and message acceptance. Applications remain responsible for downstream delivery compatibility and storage policy.
+
+SIZE is advertised when `MaxMessageSize(...)` is configured. MAIL `SIZE` parameters are checked before accepting the transaction, and strict DATA/BDAT body limits are enforced while reading content.
+
+DSN support parses and exposes `RET`, `ENVID`, `NOTIFY`, and `ORCPT` envelope parameters. Applications remain responsible for generating and delivering delivery status notifications from their message store or mailbox filter code.
+
+CHUNKING support accepts `BDAT <size> [LAST]` message content without DATA dot-stuffing. Multi-chunk messages are stored only after the `LAST` chunk; strict maximum message size limits are enforced across the full BDAT transfer.
+
+SMTPUTF8, DSN, and CHUNKING are enabled by default for compatibility. Applications can disable advertised and accepted support explicitly:
+
+```cs
+var options = new SmtpServerOptionsBuilder()
+    .ServerName("localhost")
+    .Extensions(extensions => extensions
+        .SmtpUtf8(false)
+        .Dsn(false)
+        .Chunking(false))
+    .Build();
+```
+
+STARTTLS is advertised only when the endpoint has a certificate and the current connection is not already secure.
+
+AUTH PLAIN LOGIN is advertised only when an authenticator is registered and the current connection is secure or the endpoint explicitly allows insecure authentication.
+
+SMTP replies include enhanced status codes for common success, syntax, authentication, mailbox, size, bad sequence, and transaction failure responses. AUTH continuation challenges are left unchanged for SASL compatibility.
+
+HELP is implemented for basic command discovery. VRFY and EXPN are accepted, but the default policy avoids mailbox or mailing list enumeration and returns conservative `252` responses. Applications that intentionally disclose verification or expansion results can register `ISmtpCommandPolicy` or `ISmtpCommandPolicyFactory`.
+
+## Configuration Limits
+
+`MaxMessageSize(length, handling)` applies to DATA and BDAT message content. `MaxCommandLineLength(length)` applies separately to SMTP command lines and AUTH continuation lines; the default is 4096 bytes, excluding the terminating CRLF.
+
+## Session Policy
+
+Connection and HELO/EHLO policy can be configured without replacing command handlers:
+
+```cs
+var options = new SmtpServerOptionsBuilder()
+    .ServerName("localhost")
+    .SessionPolicy(policy => policy
+        .OnConnectionAccepted((context, token) => Task.FromResult(SmtpResponse.Ok))
+        .OnHelo((context, name, token) => Task.FromResult(SmtpResponse.Ok)))
+    .Build();
+```
+
 ## Installation
 
 The package is available on [NuGet](https://www.nuget.org/packages/SmtpServer)
@@ -43,7 +94,7 @@ await smtpServer.StartAsync(CancellationToken.None);
 
 ### What hooks are provided?
 
-There are three hooks that can be implemented; IMessageStore, IMailboxFilter, and IUserAuthenticator.
+There are four hooks that can be implemented: `IMessageStore`, `IMailboxFilter`, `IUserAuthenticator`, and `ISmtpCommandPolicy`.
 
 ```cs
 var options = new SmtpServerOptionsBuilder()

src/SmtpServer.Benchmarks/AuthEhloBenchmarks.cs

@@ -0,0 +1,89 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using SmtpServer.Authentication;
+using SmtpServer.ComponentModel;
+using SmtpServer.IO;
+using SmtpServer.Protocol;
+
+namespace SmtpServer.Benchmarks
+{
+    [MemoryDiagnoser]
+    [ShortRunJob]
+    public class AuthEhloBenchmarks
+    {
+        readonly EhloCommand _ehloCommand = new EhloCommand("example.com");
+        readonly AuthCommand _authPlainCommand = new AuthCommand(AuthenticationMethod.Plain, "AHVzZXIAcGFzc3dvcmQ=");
+        readonly AuthCommand _invalidAuthPlainCommand = new AuthCommand(AuthenticationMethod.Plain, "not-base64");
+
+        MemoryStream _ehloStream;
+        SmtpSessionContext _ehloContext;
+        MemoryStream _authStream;
+        SmtpSessionContext _authContext;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _ehloStream = new MemoryStream();
+            _ehloContext = CreateContext(_ehloStream, addAuthenticator: false);
+
+            _authStream = new MemoryStream();
+            _authContext = CreateContext(_authStream, addAuthenticator: true);
+        }
+
+        [Benchmark]
+        public Task Ehlo()
+        {
+            Reset(_ehloStream);
+
+            return _ehloCommand.ExecuteAsync(_ehloContext, CancellationToken.None);
+        }
+
+        [Benchmark]
+        public Task AuthPlain()
+        {
+            Reset(_authStream);
+
+            return _authPlainCommand.ExecuteAsync(_authContext, CancellationToken.None);
+        }
+
+        [Benchmark]
+        public Task InvalidAuthPlain()
+        {
+            Reset(_authStream);
+
+            return _invalidAuthPlainCommand.ExecuteAsync(_authContext, CancellationToken.None);
+        }
+
+        static SmtpSessionContext CreateContext(Stream stream, bool addAuthenticator)
+        {
+            var endpointDefinition = new EndpointDefinitionBuilder()
+                .AllowUnsecureAuthentication()
+                .Build();
+            var options = new SmtpServerOptionsBuilder()
+                .ServerName("localhost")
+                .Endpoint(endpointDefinition)
+                .Build();
+            var serviceProvider = new ServiceProvider();
+
+            if (addAuthenticator)
+            {
+                serviceProvider.Add(new DelegatingUserAuthenticator((user, password) => true));
+            }
+
+            var context = new SmtpSessionContext(serviceProvider, options, endpointDefinition)
+            {
+                Pipe = new SecurableDuplexPipe(stream, 128, () => { })
+            };
+
+            return context;
+        }
+
+        static void Reset(MemoryStream stream)
+        {
+            stream.Position = 0;
+            stream.SetLength(0);
+        }
+    }
+}

src/SmtpServer.Benchmarks/BdatCommandBenchmarks.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Buffers;
+using System.IO.Pipelines;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using SmtpServer.ComponentModel;
+using SmtpServer.IO;
+using SmtpServer.Mail;
+using SmtpServer.Protocol;
+using SmtpServer.Storage;
+
+namespace SmtpServer.Benchmarks
+{
+    [MemoryDiagnoser]
+    [ShortRunJob]
+    public class BdatCommandBenchmarks
+    {
+        byte[] _message;
+
+        public enum StoreMode
+        {
+            BufferedMaterializing,
+            StreamingDrain
+        }
+
+        [Params(StoreMode.BufferedMaterializing, StoreMode.StreamingDrain)]
+        public StoreMode Mode { get; set; }
+
+        [Params(1024, 65536)]
+        public int BodySize { get; set; }
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _message = CreateMessage(BodySize);
+        }
+
+        [Benchmark]
+        public async Task BdatLastChunk()
+        {
+            var input = new Pipe();
+            var output = new Pipe();
+
+            input.Writer.Write(_message);
+            await input.Writer.CompleteAsync().ConfigureAwait(false);
+
+            var context = CreateContext(input.Reader, output.Writer);
+            var command = new BdatCommand(_message.Length, true);
+
+            await command.ExecuteAsync(context, CancellationToken.None).ConfigureAwait(false);
+            await output.Writer.CompleteAsync().ConfigureAwait(false);
+
+            while (true)
+            {
+                var result = await output.Reader.ReadAsync().ConfigureAwait(false);
+                output.Reader.AdvanceTo(result.Buffer.End);
+
+                if (result.IsCompleted)
+                {
+                    break;
+                }
+            }
+
+            await output.Reader.CompleteAsync().ConfigureAwait(false);
+        }
+
+        SmtpSessionContext CreateContext(PipeReader input, PipeWriter output)
+        {
+            var endpointDefinition = new EndpointDefinitionBuilder().Build();
+            var options = new SmtpServerOptionsBuilder()
+                .ServerName("localhost")
+                .Endpoint(endpointDefinition)
+                .Build();
+
+            var serviceProvider = new ServiceProvider();
+            serviceProvider.Add(Mode == StoreMode.StreamingDrain
+                ? (IMessageStore)new StreamingDrainMessageStore()
+                : new BufferedMaterializingMessageStore());
+
+            var context = new SmtpSessionContext(serviceProvider, options, endpointDefinition)
+            {
+                Pipe = new BenchmarkDuplexPipe(input, output)
+            };
+
+            context.Transaction.From = new Mailbox("sender@example.com");
+            context.Transaction.To.Add(new Mailbox("recipient@example.com"));
+
+            return context;
+        }
+
+        static byte[] CreateMessage(int bodySize)
+        {
+            var headers = Encoding.ASCII.GetBytes("From: sender@example.com\r\nTo: recipient@example.com\r\nSubject: BDAT benchmark\r\n\r\n");
+            var body = Encoding.ASCII.GetBytes(new string('x', bodySize));
+            var message = new byte[headers.Length + body.Length];
+
+            headers.CopyTo(message, 0);
+            body.CopyTo(message, headers.Length);
+
+            return message;
+        }
+
+        sealed class BenchmarkDuplexPipe : ISecurableDuplexPipe
+        {
+            public BenchmarkDuplexPipe(PipeReader input, PipeWriter output)
+            {
+                Input = input;
+                Output = output;
+            }
+
+            public PipeReader Input { get; }
+
+            public PipeWriter Output { get; }
+
+            public bool IsSecure => false;
+
+            public SslProtocols SslProtocol => SslProtocols.None;
+
+            public Task UpgradeAsync(X509Certificate certificate, SslProtocols protocols, CancellationToken cancellationToken = default)
+            {
+                throw new NotSupportedException();
+            }
+
+            public void Dispose()
+            {
+            }
+        }
+
+        sealed class BufferedMaterializingMessageStore : MessageStore
+        {
+            public override Task<SmtpResponse> SaveAsync(ISessionContext context, IMessageTransaction transaction, ReadOnlySequence<byte> buffer, CancellationToken cancellationToken)
+            {
+                _ = buffer.ToArray();
+
+                return Task.FromResult(SmtpResponse.Ok);
+            }
+        }
+
+        sealed class StreamingDrainMessageStore : MessageStore, IStreamingMessageStore
+        {
+            public override Task<SmtpResponse> SaveAsync(ISessionContext context, IMessageTransaction transaction, ReadOnlySequence<byte> buffer, CancellationToken cancellationToken)
+            {
+                throw new NotSupportedException();
+            }
+
+            public async Task<SmtpResponse> SaveAsync(ISessionContext context, IMessageTransaction transaction, PipeReader reader, CancellationToken cancellationToken)
+            {
+                while (true)
+                {
+                    var result = await reader.ReadAsync(cancellationToken).ConfigureAwait(false);
+                    var buffer = result.Buffer;
+
+                    reader.AdvanceTo(buffer.End);
+
+                    if (result.IsCompleted)
+                    {
+                        break;
+                    }
+                }
+
+                return SmtpResponse.Ok;
+            }
+        }
+    }
+}