SmtpClientConnection.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Net.Security;
using System.Net.Sockets;
using System.Runtime.ExceptionServices;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Multipart;
using Waher.Content.Text;
using Waher.Events;
using Waher.Networking.DNS;
using Waher.Networking.SASL;
using Waher.Networking.Sniffers;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Security.LoginMonitor;
using Waher.Security.SPF;
 
namespace Waher.Networking.SMTP.Server
{
    internal enum ReceptionMode
    {
        Command,
        MailHeader,
        MailBody,
        MailBodyCR,
        MailBodyCRLF,
        MailBodyCRLFPeriod,
        MailBodyCRLFPeriodCR,
        ChallengeResponse
    };
 
    public enum Priority
    {
        High = 1,
        Normal = 3,
        Low = 5
    }
 
    public class SmtpClientConnection : CommunicationLayer, ISaslServerSide
    {
        private static readonly Random rnd = new Random();
 
        private readonly Guid id = Guid.NewGuid();
        private readonly UTF8Encoding encoding = new UTF8Encoding(false, false);
        private SmtpServer server;
        private BinaryTcpClient client;
        private readonly ISaslPersistenceLayer persistence;
        private IAccount account = null;
        private bool disposed = false;
        private SmtpConnectionState state;
        private CaseInsensitiveString userName = CaseInsensitiveString.Empty;
        private object tag = null;
        private string clientName = null;
        private string authId = null;
        private MailAddress mailFrom = null;
        private CaseInsensitiveString mailFromDomain = null;
        private bool mailFromMe = false;
        private List<MailAddress> recipients = null;
        private List<KeyValuePair<string, string>> headers = null;
        private MemoryStream body = null;
        private ReceptionMode mode = ReceptionMode.Command;
        private IAuthenticationMechanism mechanism = null;
        private readonly MemoryStream incoming = new MemoryStream();
        private readonly int maxMessageSize;
        private int incomingSize = 0;
        private int messageSize = 0;
        private bool overflow = false;
        private bool upgradeToTls = false;
 
        public SmtpClientConnection(BinaryTcpClient Client, SmtpServer Server, ISaslPersistenceLayer Persistence,
            int MaxMessageSize, params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.state = SmtpConnectionState.Initiating;
            this.client = Client;
            this.server = Server;
            this.persistence = Persistence;
            this.maxMessageSize = MaxMessageSize;
 
            this.client.OnDisconnected += this.Client_OnDisconnected;
            this.client.OnError += this.Client_OnError;
            this.client.OnReceived += this.Client_OnReceived;
            this.client.OnPaused += this.Client_OnPaused;
        }
 
        public Guid ID => this.id;
 
        public string ClientName => this.clientName;
 
        public string AuthId
        {
            get => this.authId;
        }
 
        public SmtpConnectionState State
        {
            get => this.state;
        }
 
        internal async Task SetState(SmtpConnectionState NewState)
        {
            if (this.state != NewState && !this.disposed)
            {
                this.state = NewState;
 
                await this.Information("State changed to " + NewState.ToString());
 
                await this.OnStateChanged.Raise(this, NewState);
            }
        }
 
        public event EventHandlerAsync<SmtpConnectionState> OnStateChanged = null;
 
        public object Tag
        {
            get => this.tag;
            set => this.tag = value;
        }
 
        public SmtpServer Server => this.server;
 
        public CaseInsensitiveString UserName => this.userName;
 
        public string RemoteEndpoint
        {
            get { return this.client?.Client?.Client?.RemoteEndPoint?.ToString(); }
        }
 
        public string Protocol => "SMTP";
 
        internal X509Certificate ClientCertificate => this.client.RemoteCertificate;
        internal bool ClientCertificateValid => this.client.RemoteCertificateValid;
 
        [Obsolete("Use the DisposeAsync() method.")]
        public async void Dispose()
        {
            try
            {
                await this.DisposeAsync();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public async Task DisposeAsync()
        {
            if (!this.disposed)
            {
                if (this.state != SmtpConnectionState.Error)
                    await this.SetState(SmtpConnectionState.Offline);
 
                ISniffer[] Sniffers = this.Sniffers;
                if (!(Sniffers is null))
                    this.server?.CacheSniffers(Sniffers);
 
                this.disposed = true;
                this.server = null;
 
                this.client?.DisposeWhenDone();
                this.client = null;
            }
        }
 
        private async Task<bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
        {
            try
            {
                return await this.ParseIncoming(Buffer, Offset, Count);
            }
            catch (Exception ex)
            {
                if (!this.disposed)
                {
                    await this.Exception(ex);
                    await this.DisposeAsync();
                }
 
                return false;
            }
        }
 
        private async Task Client_OnError(object Sender, Exception Exception)
        {
            await this.SetState(SmtpConnectionState.Error);
            await this.DisposeAsync();
        }
 
        private Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            return this.DisposeAsync();
        }
 
        private async Task<bool> ParseIncoming(byte[] Data, int Offset, int NrRead)
        {
            byte b;
 
            while (Offset < NrRead)
            {
                b = Data[Offset++];
 
                switch (this.mode)
                {
                    case ReceptionMode.MailBody:
                        if (b == 13)
                            this.mode = ReceptionMode.MailBodyCR;
                        else
                        {
                            this.messageSize++;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(b);
                        }
                        break;
 
                    case ReceptionMode.MailBodyCR:
                        if (b == 10)
                            this.mode = ReceptionMode.MailBodyCRLF;
                        else if (b == 13)
                        {
                            this.messageSize++;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                        }
                        else
                        {
                            this.messageSize += 2;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(b);
                            this.mode = ReceptionMode.MailBody;
                        }
                        break;
 
                    case ReceptionMode.MailBodyCRLF:
                        if (b == (byte)'.')
                            this.mode = ReceptionMode.MailBodyCRLFPeriod;
                        else if (b == 13)
                        {
                            this.messageSize += 2;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(10);
                            this.mode = ReceptionMode.MailBodyCR;
                        }
                        else
                        {
                            this.messageSize += 3;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(10);
                            this.body.WriteByte(b);
                            this.mode = ReceptionMode.MailBody;
                        }
                        break;
 
                    case ReceptionMode.MailBodyCRLFPeriod:
                        if (b == 13)
                            this.mode = ReceptionMode.MailBodyCRLFPeriodCR;
                        else
                        {
                            this.messageSize += 3;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(10);
                            this.body.WriteByte(b);
                            this.mode = ReceptionMode.MailBody;
                        }
                        break;
 
                    case ReceptionMode.MailBodyCRLFPeriodCR:
                        if (b == 10)
                        {
                            if (this.overflow)
                            {
                                if (!await this.BeginWrite("552 Requested mail action aborted: exceeded storage allocation.\r\n", null, null))
                                    return false;
                            }
                            else
                            {
                                try
                                {
                                    byte[] Body = this.body.ToArray();
                                    await this.ReceiveBinary(Body);
 
                                    string Id = await this.ProcessIncomingMail(this.mailFrom, this.recipients.ToArray(),
                                        this.headers.ToArray(), Body, this.clientName, this.RemoteEndpoint);
 
                                    if (!await this.BeginWrite("250 2.6.0 " + Id.ToString() + " Message accepted for delivery.\r\n", null, null))
                                        return false;
                                }
                                catch (Exception ex)
                                {
                                    await this.Error(ex.Message + "\r\n\r\n" + Log.CleanStackTrace(ex.StackTrace));
                                    if (!await this.BeginWrite("554 Unable to parse incoming message: " + FirstRow(ex.Message) + "\r\n", null, null))
                                        return false;
                                }
                            }
 
                            this.ResetState();
                        }
                        else if (b == 13)
                        {
                            this.messageSize += 3;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(10);
                            this.body.WriteByte(13);
                            this.mode = ReceptionMode.MailBodyCR;
                        }
                        else
                        {
                            this.messageSize += 4;
                            if (this.overflow || this.messageSize > this.maxMessageSize)
                            {
                                this.overflow = true;
                                break;
                            }
 
                            this.body.WriteByte(13);
                            this.body.WriteByte(10);
                            this.body.WriteByte(13);
                            this.body.WriteByte(b);
                            this.mode = ReceptionMode.MailBody;
                        }
                        break;
 
                    default:
                        if (b == 13)    // CR
                            break;
                        else if (b == 10)   // LF
                        {
                            string Row = Encoding.UTF8.GetString(this.incoming.ToArray());
                            this.incoming.Position = 0;
                            this.incoming.SetLength(0);
                            this.incomingSize = 0;
 
                            await this.ReceiveText(Row);
                            if (!await this.ParseIncomingRow(Row))
                                return false;
 
                            if (this.mode == ReceptionMode.MailBody)
                                break;
                        }
                        else
                        {
                            this.incoming.WriteByte(b);
                            this.incomingSize++;
 
                            if (this.incomingSize > this.maxMessageSize)
                            {
                                await this.BeginWrite("552 Requested mail action aborted: exceeded storage allocation.\r\n", async (Sender, e) =>
                                {
                                    await this.SetState(SmtpConnectionState.Offline);
                                    this.server.Closed(this);
                                }, null);
                                return false;
                            }
                        }
                        break;
                }
            }
 
            return true;
        }
 
        private async Task<bool> ParseIncomingRow(string s)
        {
            switch (this.mode)
            {
                case ReceptionMode.Command:
                    int i = s.IndexOf(' ');
                    string Cmd, Value;
 
                    if (i < 0)
                    {
                        Cmd = s;
                        Value = string.Empty;
                    }
                    else
                    {
                        Cmd = s.Substring(0, i);
                        Value = s.Substring(i + 1);
                    }
 
                    switch (Cmd.ToUpper())
                    {
                        case "HELO":
                        case "EHLO":
                            if (this.clientName is null)
                            {
                                this.clientName = Value.Trim();
                                await this.SetState(SmtpConnectionState.Greeting);
                                await this.SetUserIdentity(this.clientName);
                            }
 
                            StringBuilder Response = new StringBuilder();
 
                            Response.Append("250-");
                            Response.Append(this.server.Domain);
                            Response.Append(" Hello ");
                            Response.Append(this.clientName);
                            Response.Append(" [");
                            Response.Append(this.client.Client.Client.RemoteEndPoint.ToString());
                            Response.Append("]. Pleased to meet you.\r\n250-SIZE ");
                            Response.Append(this.maxMessageSize.ToString());
 
                            if (!(this.server.ServerCertificate is null) && !(this.client.Stream is SslStream))
                                Response.Append("\r\n250-STARTTLS");
 
                            SslStream SslStream;
 
                            if (this.account is null)
                            {
                                Response.Append("\r\n250-AUTH");
 
                                if (!(this.ClientCertificate is null) && this.ClientCertificateValid)
                                    Response.Append(" EXTERNAL");
 
                                // TODO: EXTERNAL authentication mechanism
 
                                SslStream = this.client.Stream as SslStream;
                                foreach (IAuthenticationMechanism M in SaslModule.Mechanisms)
                                {
                                    if (M.Allowed(SslStream))
                                    {
                                        Response.Append(' ');
                                        Response.Append(M.Name);
                                    }
                                }
                            }
 
                            Response.Append("\r\n250-SMTPUTF8\r\n250-8BITMIME\r\n250-ENHANCEDSTATUSCODES\r\n250 HELP\r\n");
 
                            if (!await this.BeginWrite(Response.ToString(), null, null))
                                return false;
 
                            break;
 
                        case "MAIL":
                            s = Value.Trim();
                            i = s.IndexOf(':');
                            if (i < 0)
                            {
                                if (!await this.BeginWrite("554 : expected.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            Cmd = s.Substring(0, i).ToUpper();
                            s = s.Substring(i + 1).TrimStart();
 
                            switch (Cmd)
                            {
                                case "FROM":
                                    MailAddress From = this.ParseMailAddress(ref s);
 
                                    int j = From.Address.IndexOf('@');
                                    if (j < 0)
                                    {
                                        if (!await this.BeginWrite("554 @ expected\r\n", null, null))
                                            return false;
                                        break;
                                    }
 
                                    CaseInsensitiveString Domain = From.Address.Substring(j + 1);
                                    CaseInsensitiveString AccountName = From.Address.Substring(0, j);
 
                                    if (Domain == this.server.Domain)
                                    {
                                        if (this.account is null)
                                        {
                                            if (!await this.BeginWrite("530 5.7.0 Authentication required.\r\n", null, null))
                                                return false;
                                            break;
                                        }
 
                                        if (AccountName != this.account.UserName)
                                        {
                                            if (!await this.BeginWrite("555 Sender must be the same as the authenticated user.\r\n", null, null))
                                                return false;
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        if (!(this.client.Client.Client.RemoteEndPoint is IPEndPoint RemoteIPEndPoint))
                                        {
                                            if (!await this.BeginWrite("550 Invalid remote address.\r\n", null, null))
                                                return false;
                                            break;
                                        }
 
                                        await this.Information("Checking SPF records.");
 
                                        KeyValuePair<SpfResult, string> SpfStatus = await SpfResolver.CheckHost(RemoteIPEndPoint.Address,
                                            Domain, From.Address, this.clientName, this.server.Domain, this.server.SpfExpressions);
 
                                        bool Accept = false;
 
                                        switch (SpfStatus.Key)
                                        {
                                            case SpfResult.Pass:
                                                await this.Information("SPF check passed.");
                                                Accept = true;
                                                break;
 
                                            case SpfResult.Fail:
                                                await this.Warning("SPF check failed.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "SPF check failed.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            case SpfResult.SoftFail:
                                                await this.Warning("SPF check soft-failed.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "SPF check soft-failed.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            case SpfResult.Neutral:
                                                await this.Warning("SPF check neutral.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "SPF check neutral. Only senders successfully passing a SPF check will be accepted.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            case SpfResult.None:
                                                await this.Warning("No SPF records.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "No SPF records found.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            case SpfResult.PermanentError:
                                                await this.Error("SPF records contain a permanent error.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "SPF records contain a permanent error.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            case SpfResult.TemporaryError:
                                                await this.Error("SPF records contain a temporary error.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "SPF records contain a temporary error.") + "\r\n", null, null))
                                                    return false;
                                                break;
 
                                            default:
                                                await this.Error("Unable to evaluate SPF records.");
                                                if (!await this.BeginWrite("550 " + (SpfStatus.Value ?? "Unable to evaluate SPF records.") + "\r\n", null, null))
                                                    return false;
                                                break;
                                        }
 
                                        if (!Accept)
                                        {
                                            Log.Warning("Remote IP blocked by SPF records.", RemoteIPEndPoint.Address.ToString(),
                                                new KeyValuePair<string, object>("Status", SpfStatus.Key),
                                                new KeyValuePair<string, object>("Reason", SpfStatus.Value));
                                            break;
                                        }
 
                                        string[] BlackLists;
 
                                        switch (RemoteIPEndPoint.Address.AddressFamily)
                                        {
                                            case AddressFamily.InterNetwork:
                                                BlackLists = this.server.Ip4DnsBlackLists;
                                                break;
 
                                            case AddressFamily.InterNetworkV6:
                                                BlackLists = this.server.Ip6DnsBlackLists;
 
                                                if ((BlackLists is null || BlackLists.Length == 0) &&
                                                    !(this.server.Ip4DnsBlackLists is null) && this.server.Ip4DnsBlackLists.Length > 0)
                                                {
                                                    BlackLists = null;
                                                }
                                                break;
 
                                            default:
                                                BlackLists = null;
                                                break;
                                        }
 
                                        if (!(BlackLists is null))
                                        {
                                            List<string> A = new List<string>();
                                            int c = BlackLists.Length;
 
                                            A.AddRange(BlackLists);
                                            BlackLists = new string[c];
 
                                            lock (rnd)
                                            {
                                                j = 0;
 
                                                while (c > 0)
                                                {
                                                    i = rnd.Next(c--);
                                                    BlackLists[j++] = A[i];
                                                    A.RemoveAt(i);
                                                }
                                            }
 
                                            BlackLists = A.ToArray();
 
                                            foreach (string BlackList in BlackLists)
                                            {
                                                await this.Information("Checking DNSBL " + BlackList);
 
                                                string[] Reason = await DnsResolver.LookupBlackList(RemoteIPEndPoint.Address, BlackList);
 
                                                if (Reason is null)
                                                    await this.Information(RemoteIPEndPoint.Address.ToString() + " not in DNSBL " + BlackList);
                                                else
                                                {
                                                    await this.Warning(RemoteIPEndPoint.Address.ToString() + " exists in DNSBL " + BlackList);
 
                                                    StringBuilder sb = new StringBuilder();
 
                                                    sb.Append("550 Blocked by " + BlackList + ".");
 
                                                    foreach (string s2 in Reason)
                                                    {
                                                        sb.Append(' ');
                                                        sb.Append(s2);
                                                    }
 
                                                    sb.Append("\r\n");
 
                                                    if (!await this.BeginWrite(sb.ToString(), null, null))
                                                        return false;
                                                    Accept = false;
 
                                                    Log.Warning("Remote IP blocked by DNS Black List.", RemoteIPEndPoint.Address.ToString(), BlackList);
                                                    break;
                                                }
                                            }
 
                                            if (!Accept)
                                                break;
                                        }
                                    }
 
                                    this.mailFrom = From;
                                    this.mailFromDomain = Domain;
                                    this.mailFromMe = !(this.account is null) && (AccountName == this.account.UserName) &&
                                        Domain == this.server.Domain;
 
                                    if (!await this.BeginWrite("250 2.1.0 Originator <" + this.mailFrom +
                                        (this.mailFromMe ? "> ok (you).\r\n" : "> ok.\r\n"), null, null))
                                    {
                                        return false;
                                    }
                                    break;
 
                                default:
                                    if (!await this.BeginWrite("500 Syntax error\r\n", null, null))
                                        return false;
                                    break;
                            }
                            break;
 
                        case "RCPT":
                            s = Value.Trim();
                            i = s.IndexOf(':');
                            if (i < 0)
                            {
                                if (!await this.BeginWrite("554 : expected.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            Cmd = s.Substring(0, i).ToUpper();
                            s = s.Substring(i + 1).TrimStart();
 
                            switch (Cmd)
                            {
                                case "TO":
                                    if (this.mailFrom is null)
                                    {
                                        if (!await this.BeginWrite("503 Bad sequence of commands.\r\n", null, null))
                                            return false;
                                        break;
                                    }
 
                                    MailAddress Recipient = this.ParseMailAddress(ref s);
 
                                    int j = Recipient.Address.IndexOf('@');
                                    if (j < 0)
                                    {
                                        if (!await this.BeginWrite("554 @ expected.\r\n", null, null))
                                            return false;
                                        break;
                                    }
 
                                    CaseInsensitiveString Domain = Recipient.Address.Substring(j + 1);
                                    CaseInsensitiveString AccountName = Recipient.Address.Substring(0, j);
 
                                    if (Domain == this.server.Domain)
                                    {
                                        IAccount Account = await this.persistence.GetAccount(AccountName);
                                        if (Account is null)
                                        {
                                            if (!await this.BeginWrite("550 5.1.1 Mailbox does not exist.\r\n", null, null))
                                                return false;
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        if (this.account is null)
                                        {
                                            if (!await this.BeginWrite("530 5.7.0 Authentication required\r\n", null, null))
                                                return false;
                                            break;
                                        }
 
                                        if (!this.account.HasPrivilege(SmtpServer.SmtpRelayPrivilegeID))
                                        {
                                            Log.Warning("Failed attempt to relay SMTP message. Account does not have relay permissions.", Recipient.ToString(), this.account.UserName,
                                                new KeyValuePair<string, object>("From", this.mailFrom.Address),
                                                new KeyValuePair<string, object>("RemoteEndpoint", this.RemoteEndpoint),
                                                new KeyValuePair<string, object>("ClientName", this.clientName));
 
                                            if (!await this.BeginWrite("550 5.7.1 Relaying messages using this account not permitted.\r\n", null, null))
                                                return false;
                                            break;
                                        }
 
                                        if (!(this.mailFromMe || this.server.CanRelayForDomain(this.mailFromDomain)))
                                        {
                                            Log.Warning("Failed attempt to relay SMTP message. From Domain not white-listed.", Recipient.ToString(), this.account.UserName,
                                                new KeyValuePair<string, object>("From", this.mailFrom.Address),
                                                new KeyValuePair<string, object>("FromDomain", this.mailFromDomain),
                                                new KeyValuePair<string, object>("RemoteEndpoint", this.RemoteEndpoint),
                                                new KeyValuePair<string, object>("ClientName", this.clientName));
 
                                            if (!await this.BeginWrite("550 5.7.1 Relaying messages from " + this.mailFromDomain + " not allowed.\r\n", null, null))
                                                return false;
                                            break;
                                        }
                                    }
 
                                    this.messageSize += Recipient.Address.Length + Recipient.DisplayName.Length;
                                    if (this.overflow || this.messageSize > this.maxMessageSize)
                                    {
                                        this.overflow = true;
                                        if (!await this.BeginWrite("554 Message too large.\r\n", null, null))
                                            return false;
                                        break;
                                    }
 
                                    if (this.recipients is null)
                                        this.recipients = new List<MailAddress>();
 
                                    this.recipients.Add(Recipient);
 
                                    if (!await this.BeginWrite("250 2.1.5 Recipient <" + Recipient + "> ok.\r\n", null, null))
                                        return false;
                                    break;
 
                                default:
                                    if (!await this.BeginWrite("500 Syntax error\r\n", null, null))
                                        return false;
                                    break;
                            }
                            break;
 
                        case "DATA":
                            if (this.overflow)
                            {
                                if (!await this.BeginWrite("552 Requested mail action aborted: exceeded storage allocation.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            if (this.mailFrom is null || this.recipients is null || this.recipients.Count == 0)
                            {
                                if (!await this.BeginWrite("503 Bad sequence of commands.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            this.headers = new List<KeyValuePair<string, string>>();
                            this.body = new MemoryStream();
                            this.messageSize = 0;
                            this.mode = ReceptionMode.MailHeader;
 
                            if (!await this.BeginWrite("354 Enter message body, end with \".\" on a line by itself.\r\n", null, null))
                                return false;
                            break;
 
                        case "QUIT":
                            await this.SetState(SmtpConnectionState.Closing);
 
                            await this.BeginWrite("221 2.0.0 " + this.server.Domain + " closing connection.\r\n", async (Sender, e) =>
                            {
                                await this.SetState(SmtpConnectionState.Offline);
                                this.server.Closed(this);
 
                            }, null);
                            break;
 
                        case "VRFY":
                        case "EXPN":
                            if (!await this.BeginWrite("252 Command disabled.\r\n", null, null))
                                return false;
                            break;
 
                        case "RSET":
                            this.ResetState();
                            if (!await this.BeginWrite("250 OK\r\n", null, null))
                                return false;
                            break;
 
                        case "HELP":
                            if (!await this.BeginWrite("214 " + typeof(SmtpServer).Namespace + " mail-server.\r\n", null, null))
                                return false;
                            break;
 
                        case "NOOP":
                            if (!await this.BeginWrite("250 OK\r\n", null, null))
                                return false;
                            break;
 
                        case "AUTH":
                            if (!(this.account is null))
                            {
                                if (!await this.BeginWrite("503 5.5.4 Already authenticated.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            LoginAuditor Auditor = this.persistence.Auditor;
                            DateTime? Next;
 
                            if (Auditor is null)
                                Next = null;
                            else
                                Next = await Auditor.GetEarliestLoginOpportunity(this.RemoteEndpoint, "SMTP");
 
                            if (Next.HasValue)
                            {
                                StringBuilder sb = new StringBuilder();
                                DateTime TP = Next.Value;
                                DateTime Today = DateTime.Today;
 
                                sb.Append("550 5.7.26 ");
 
                                if (Next.Value == DateTime.MaxValue)
                                {
                                    sb.Append("This endpoint (");
                                    sb.Append(this.RemoteEndpoint);
                                    sb.Append(") has been blocked from the system");
                                }
                                else
                                {
                                    sb.Append("Too many failed login attempts in a row registered. Try again after ");
                                    sb.Append(TP.ToLongTimeString());
 
                                    if (TP.Date != Today)
                                    {
                                        if (TP.Date == Today.AddDays(1))
                                            sb.Append(" tomorrow");
                                        else
                                        {
                                            sb.Append(", ");
                                            sb.Append(TP.ToShortDateString());
                                        }
                                    }
                                }
 
                                sb.Append(". Remote Endpoint: ");
                                sb.Append(this.RemoteEndpoint);
                                sb.Append("\r\n");
 
                                if (!await this.BeginWrite(sb.ToString(), null, null))
                                    return false;
                                break;
                            }
 
                            await this.SetState(SmtpConnectionState.Authenticating);
                            s = Value.Trim();
 
                            CaseInsensitiveString Name;
 
                            i = s.IndexOf(' ');
                            if (i < 0)
                            {
                                Name = s;
                                s = string.Empty;
                            }
                            else
                            {
                                Name = s.Substring(0, i);
                                s = s.Substring(i + 1).TrimStart();
                            }
 
                            this.mechanism = null;
 
                            foreach (IAuthenticationMechanism M in SaslModule.Mechanisms)
                            {
                                if (M.Name == Name)
                                {
                                    this.mechanism = M;
                                    break;
                                }
                            }
 
                            if (this.mechanism is null)
                            {
                                if (!await this.BeginWrite("503 5.5.4 Invalid authentication mechanism.\r\n", null, null))
                                    return false;
                                break;
                            }
 
                            SslStream = this.client.Stream as SslStream;
                            if (!this.mechanism.Allowed(SslStream))
                            {
                                this.mechanism = null;
 
                                if (SslStream is null)
                                {
                                    if (!await this.BeginWrite("538 5.7.11 Encryption required for requested authentication mechanism\r\n", null, null))
                                        return false;
                                }
                                else
                                {
                                    if (!await this.BeginWrite("534 5.7.9 Authentication mechanism is too weak\r\n", null, null))
                                        return false;
                                }
 
                                break;
                            }
 
                            this.mode = ReceptionMode.ChallengeResponse;
                            await this.mechanism.AuthenticationRequest(s, this, this.persistence);
                            break;
 
                        case "STARTTLS":
                            if (await this.BeginWrite("220 Go ahead\r\n", null, null))
                                this.upgradeToTls = true;
                            return false;
 
                        default:
                            if (!await this.BeginWrite("502 Command not implemented\r\n", null, null))
                                return false;
                            break;
                    }
                    break;
 
                case ReceptionMode.ChallengeResponse:
                    bool? AuthResult = await this.mechanism.ResponseRequest(s, this, this.persistence);
                    if (AuthResult.HasValue)
                    {
                        this.ResetState(true);
 
                        if (AuthResult.Value)
                        {
                            if (!await this.SaslSuccess(null))
                                return false;
                        }
                        else
                        {
                            if (!await this.SaslErrorNotAuthorized())
                                return false;
                        }
 
                        this.mode = ReceptionMode.Command;
                    }
                    break;
 
                case ReceptionMode.MailHeader:
                    if (string.IsNullOrEmpty(s))
                        this.mode = ReceptionMode.MailBody;
                    else
                    {
                        this.messageSize += s.Length;
                        if (this.overflow || this.messageSize > this.maxMessageSize)
                        {
                            this.overflow = true;
                            break;
                        }
 
                        int c;
 
                        if (char.IsWhiteSpace(s[0]) && (c = this.headers.Count) > 0)
                        {
                            KeyValuePair<string, string> P = this.headers[c - 1];
                            this.headers[c - 1] = new KeyValuePair<string, string>(P.Key, P.Value + s);
                        }
                        else
                        {
                            string Key;
 
                            i = s.IndexOf(':');
                            if (i < 0)
                            {
                                Key = s;
                                Value = string.Empty;
                            }
                            else
                            {
                                Key = s.Substring(0, i);
                                Value = s.Substring(i + 1).Trim();
                            }
 
                            i = s.Length;
 
                            Key = Key.ToUpper();
 
                            this.headers.Add(new KeyValuePair<string, string>(Key, Value));
                        }
                    }
                    break;
            }
 
            return true;
        }
 
        private async Task Client_OnPaused(object Sender, EventArgs e)
        {
            if (this.upgradeToTls)
            {
                this.upgradeToTls = false;
 
                string RemoteIpEndpoint;
                EndPoint EP = this.client.Client.Client.RemoteEndPoint;
 
                if (EP is IPEndPoint IpEP)
                    RemoteIpEndpoint = IpEP.Address.ToString();
                else
                    RemoteIpEndpoint = EP.ToString();
 
                if (LoginAuditor.CanStartTls(RemoteIpEndpoint))
                {
                    try
                    {
                        SmtpConnectionState Bak = this.state;
                        await this.SetState(SmtpConnectionState.StartingEncryption);
 
                        await this.client.UpgradeToTlsAsServer(this.server.ServerCertificate, SslProtocols.Tls12, ClientCertificates.Optional);
 
                        await this.SetState(Bak);
 
                        this.client.Continue();
                    }
                    catch (AuthenticationException ex)
                    {
                        await this.LoginFailure(ex, RemoteIpEndpoint);
                    }
                    catch (Win32Exception ex)
                    {
                        await this.LoginFailure(ex, RemoteIpEndpoint);
                    }
                    catch (Exception ex)
                    {
                        await this.Exception(ex);
                        await this.ToError(null);
                    }
                }
                else
                    await this.ToError(null);
            }
        }
 
        private async Task LoginFailure(Exception ex, string RemoteIpEndpoint)
        {
            Exception ex2 = Log.UnnestException(ex);
            await LoginAuditor.ReportTlsHackAttempt(RemoteIpEndpoint, "TLS handshake failed: " + ex2.Message, "SMTP");
 
            await this.ToError(null);
        }
 
        private static string FirstRow(string s)
        {
            int i = s.IndexOfAny(CRLF);
            if (i < 0)
                return s;
            else
                return s.Substring(0, i);
        }
 
        private static readonly char[] CRLF = new char[] { '\r', '\n' };
 
        private MailAddress[] ParseMailAddresses(string s)
        {
            List<MailAddress> Result = null;
            MailAddress Addr;
 
            foreach (string Part in s.Split(','))
            {
                s = Part;
                Addr = this.ParseMailAddress(ref s);
                if (Addr is null)
                    continue;
 
                if (Result is null)
                    Result = new List<MailAddress>();
 
                Result.Add(Addr);
            }
 
            return Result?.ToArray();
        }
 
        private MailAddress ParseMailAddress(ref string s)
        {
            int i = s.IndexOf('<');
            if (i < 0)
            {
                if (s.IndexOf('@') >= 0)
                    return new MailAddress(s.Trim());
                else
                    return null;
            }
 
            int j = s.IndexOf('>', i + 1);
            if (j < 0)
                return null;
 
            string Name = s.Substring(0, i).Trim();
            string Address = s.Substring(i + 1, j - i - 1).Trim();
 
            s = s.Substring(j + 1).TrimStart();
 
            if (string.IsNullOrEmpty(Name))
                return new MailAddress(Address);
            else
                return new MailAddress(Address, Name);
        }
 
        private async Task ToError(string ClosingCommand)
        {
            if (string.IsNullOrEmpty(ClosingCommand))
            {
                await this.SetState(SmtpConnectionState.Error);
                await this.DisposeAsync();
            }
            else
            {
                await this.BeginWrite(ClosingCommand, async (Sender, e) =>
                {
                    await this.SetState(SmtpConnectionState.Error);
                    await this.DisposeAsync();
                }, null);
            }
        }
 
        public Task<bool> BeginWrite(string Text, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            if (this.disposed)
                return Task.FromResult(false);
 
            return this.client.SendAsync(this.encoding.GetBytes(Text), async (Sender, e) =>
            {
                await this.TransmitText(Text);
                await Callback.Raise(this, e);
            }, State);
        }
 
        public async Task SetUserIdentity(CaseInsensitiveString UserName)
        {
            InMemorySniffer InMemorySniffer = null;
 
            foreach (ISniffer Sniffer in this.Sniffers)
            {
                InMemorySniffer = Sniffer as InMemorySniffer;
                if (!(InMemorySniffer is null))
                    break;
            }
 
            if (!(InMemorySniffer is null))
            {
                this.Remove(InMemorySniffer);
                this.Add(this.server.GetSniffer(UserName + " IN"));
                await InMemorySniffer.ReplayAsync(this);
            }
 
            this.userName = UserName;
            this.authId = UserName + "@" + this.server.Domain;
        }
 
        public async Task SetAccount(IAccount Account)
        {
            this.account = Account;
            this.userName = Account.UserName;
 
            await this.SetState(SmtpConnectionState.Authenticated);
            this.server.PersistenceLayer.AccountLogin(this.userName, this.client.Client.Client.RemoteEndPoint.ToString());
        }
 
        public bool CheckLive()
        {
            try
            {
                if (this.disposed || this.state == SmtpConnectionState.Error || this.state == SmtpConnectionState.Offline)
                    return false;
 
                if (!this.client.Connected)
                    return false;
 
                // https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.connected.aspx
 
                bool BlockingBak = this.client.Client.Client.Blocking;
                try
                {
                    byte[] Temp = new byte[1];
 
                    this.client.Client.Client.Blocking = false;
                    this.client.Client.Client.Send(Temp, 0, 0);
 
                    return true;
                }
                catch (SocketException e)
                {
                    if (e.NativeErrorCode.Equals(10035))    // WSAEWOULDBLOCK
                        return true;
                    else
                        return false;
                }
                finally
                {
                    this.client.Client.Client.Blocking = BlockingBak;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }
 
        public void ResetState()
        {
            this.ResetState(!(this.account is null));
        }
 
        public void ResetState(bool Authenticated)
        {
            this.mode = ReceptionMode.Command;
            this.mailFrom = null;
            this.mailFromDomain = null;
            this.recipients = null;
            this.headers = null;
            this.body = null;
            this.messageSize = 0;
            this.overflow = false;
        }
 
        public Task<bool> SaslErrorNotAuthorized()
        {
            this.mode = ReceptionMode.Command;
            return this.BeginWrite("535 5.7.8  Authentication credentials invalid\r\n", null, null);
        }
 
        public Task<bool> SaslErrorAccountDisabled()
        {
            this.mode = ReceptionMode.Command;
            return this.BeginWrite("454 4.7.0  Accound disabled.\r\n", null, null);
        }
 
        public Task<bool> SaslErrorMalformedRequest()
        {
            this.mode = ReceptionMode.Command;
            return this.BeginWrite("503 Malformed request.\r\n", null, null);
        }
 
        public Task<bool> SaslChallenge(string ChallengeBase64)
        {
            if (string.IsNullOrEmpty(ChallengeBase64))
                return this.BeginWrite("334\r\n", null, null);
            else
                return this.BeginWrite("334 " + ChallengeBase64 + "\r\n", null, null);
        }
 
        public Task<bool> SaslSuccess(string ProofBase64)
        {
            this.mode = ReceptionMode.Command;
            return this.BeginWrite("235 2.7.0 Authentication successful\r\n", null, null);
        }
 
        private async Task<string> ProcessIncomingMail(MailAddress From, MailAddress[] Recipients, KeyValuePair<string, string>[] Header,
            byte[] Body, string ClientName, string RemoteEndpoint)
        {
            SmtpMessage Message = new SmtpMessage()
            {
                FromMail = From,
                Recipients = Recipients,
                AllHeaders = Header,
                UntransformedBody = Body,
                ClientName = ClientName,
                RemoteEndpoint = RemoteEndpoint
 
            };
            List<MailAddress> To = null;
            List<MailAddress> Cc = null;
            List<MailAddress> Bcc = null;
            List<MailAddress> ReplyTo = null;
            List<KeyValuePair<string, string>> OtherHeaders = new List<KeyValuePair<string, string>>();
            string ContentType = PlainTextCodec.DefaultContentType;
            Uri BaseUri = null;
 
            foreach (KeyValuePair<string, string> P in Header)
            {
                string s = P.Key.ToUpper();
                int i;
 
                switch (s)
                {
                    case "CC":
                        if (!this.AddRecipients(ref Cc, P.Value))
                            OtherHeaders.Add(P);
                        break;
 
                    case "CONTENT-ID":
                        Message.ContentId = P.Value.Trim();
                        break;
 
                    case "CONTENT-LOCATION":
                        Message.ContentLocation = P.Value.Trim();
                        BaseUri = new Uri(Message.ContentLocation);
                        break;
 
                    case "CONTENT-TRANSFER-ENCODING":
                        Message.ContentTransferEncoding = P.Value.Trim();
                        break;
 
                    case "CONTENT-TYPE":
                        Message.ContentType = ContentType = P.Value.Trim();
                        break;
 
                    case "DATE":
                        if (CommonTypes.TryParseRfc822(P.Value, out DateTimeOffset DTO))
                            Message.Date = DTO;
                        else
                            OtherHeaders.Add(P);
                        break;
 
                    case "FROM":
                        s = P.Value;
                        Message.FromHeader = this.ParseMailAddress(ref s);
                        if (Message.FromHeader is null)
                            OtherHeaders.Add(P);
                        break;
 
                    case "IMPORTANCE":
                        switch (P.Value.ToLower())
                        {
                            case "high":
                                Message.Priority = Priority.High;
                                break;
 
                            case "normal":
                                Message.Priority = Priority.Normal;
                                break;
 
                            case "low":
                                Message.Priority = Priority.Low;
                                break;
 
                            default:
                                OtherHeaders.Add(P);
                                break;
                        }
                        break;
 
                    case "MESSAGE-ID":
                        Message.MessageID = P.Value;
                        break;
 
                    case "MIME-VERSION":
                        if (CommonTypes.TryParse(P.Value, out double d))
                            Message.MimeVersion = d;
                        else
                            OtherHeaders.Add(P);
                        break;
 
                    case "PRIORITY":
                        switch (P.Value.ToLower())
                        {
                            case "urgent":
                                Message.Priority = Priority.High;
                                break;
 
                            case "normal":
                                Message.Priority = Priority.Normal;
                                break;
 
                            case "non-urgent":
                                Message.Priority = Priority.Low;
                                break;
 
                            default:
                                OtherHeaders.Add(P);
                                break;
                        }
                        break;
 
                    case "REPLY-TO":
                        if (!this.AddRecipients(ref ReplyTo, P.Value))
                            OtherHeaders.Add(P);
                        break;
 
                    case "SENDER":
                        s = P.Value;
                        Message.Sender = this.ParseMailAddress(ref s);
                        if (Message.Sender is null)
                            OtherHeaders.Add(P);
                        break;
 
                    case "SUBJECT":
                        Message.Subject = P.Value;
                        break;
 
                    case "TO":
                        if (!this.AddRecipients(ref To, P.Value))
                            OtherHeaders.Add(P);
                        break;
 
                    case "X-PRIORITY":
                        s = P.Value;
                        i = s.IndexOf(' ');
                        if (i > 0)
                            s = s.Substring(0, i);
 
                        if (int.TryParse(s.Trim(), out i))
                            Message.Priority = (Priority)i;
                        else
                            OtherHeaders.Add(P);
                        break;
 
                    default:
                        OtherHeaders.Add(P);
                        break;
                }
            }
 
            if (Message.ContentTransferEncoding is null)
                Message.TransformedBody = null;
            else
            {
                if (!FormDataDecoder.TryTransferDecode(Body, Message.ContentTransferEncoding, out byte[] ToDecode))
                    throw new NotSupportedException("Content-Transfer-Encoding not supported: " + Message.ContentTransferEncoding);
 
                Message.TransformedBody = ToDecode;
            }
 
            KeyValuePair<string, string>[] ContentTypeFields = null;
            string ContentType0 = ContentType;
 
            if (!string.IsNullOrEmpty(ContentType))
            {
                int i = ContentType.IndexOf(';');
                if (i >= 0)
                {
                    ContentTypeFields = CommonTypes.ParseFieldValues(
                        ContentType.Substring(i + 1).Trim());
 
                    ContentType = ContentType.Substring(0, i).Trim();
 
                    foreach (KeyValuePair<string, string> P in ContentTypeFields)
                    {
                        if (string.Compare(P.Key, "charset", true) == 0)
                        {
                            Message.ContentTypeEncoding = Encoding.GetEncoding(P.Value);
                            break;
                        }
                    }
                }
            }
 
            if (!InternetContent.Decodes(ContentType, out Grade _, out IContentDecoder Decoder))
                Message.DecodedBody = Message.TransformedBody ?? Message.UntransformedBody;
            else
            {
                try
                {
                    Message.DecodedBody = await Decoder.DecodeAsync(ContentType, Message.TransformedBody ?? Message.UntransformedBody,
                        Message.ContentTypeEncoding, ContentTypeFields ?? new KeyValuePair<string, string>[0], BaseUri);
                }
                catch (Exception ex)
                {
                    if (Types.TryGetModuleParameter("AppData", out object Obj) && Obj is string AppDataFolder)
                    {
                        string Path = System.IO.Path.Combine(AppDataFolder, "SMTP");
                        if (!Directory.Exists(Path))
                            Directory.CreateDirectory(Path);
 
                        string LocalId = Guid.NewGuid().ToString();
                        Path = System.IO.Path.Combine(Path, LocalId);
 
                        await Resources.WriteAllBytesAsync(Path + ".bin", Message.TransformedBody ?? Message.UntransformedBody);
                        await Resources.WriteAllTextAsync(Path + ".txt", ContentType0);
                        await Resources.WriteAllTextAsync(Path + ".err", ex.Message + "\r\n\r\n" + Log.CleanStackTrace(ex.StackTrace));
 
                        throw new Exception("Error when decoding message. Content stored under " + LocalId + "[.bin][.txt][.err].");
                    }
                    else
                        ExceptionDispatchInfo.Capture(ex).Throw();
                }
 
                if (Message.DecodedBody is MixedContent MixedContent)
                {
                    List<EmbeddedContent> InlineObjects = null;
                    List<EmbeddedContent> Attachments = null;
                    EmbeddedContent First = null;
 
                    foreach (EmbeddedContent Object in MixedContent.Content)
                    {
                        if (First is null)
                            First = Object;
                        else
                        {
                            switch (Object.Disposition)
                            {
                                case ContentDisposition.Inline:
                                    if (InlineObjects is null)
                                        InlineObjects = new List<EmbeddedContent>();
 
                                    InlineObjects.Add(Object);
                                    break;
 
                                case ContentDisposition.Attachment:
                                    if (Attachments is null)
                                        Attachments = new List<EmbeddedContent>();
 
                                    Attachments.Add(Object);
                                    break;
 
                                default:
                                    switch (First.Disposition)
                                    {
                                        case ContentDisposition.Inline:
                                            if (InlineObjects is null)
                                                InlineObjects = new List<EmbeddedContent>();
 
                                            InlineObjects.Insert(0, First);
                                            First = Object;
                                            break;
 
                                        case ContentDisposition.Attachment:
                                            if (Attachments is null)
                                                Attachments = new List<EmbeddedContent>();
 
                                            Attachments.Insert(0, First);
                                            First = Object;
                                            break;
 
                                        default:
                                            if (Attachments is null)
                                                Attachments = new List<EmbeddedContent>();
 
                                            Attachments.Add(Object);
                                            break;
                                    }
                                    break;
                            }
                        }
                    }
 
                    Message.InlineObjects = InlineObjects?.ToArray();
                    Message.Attachments = Attachments?.ToArray();
                    Message.DecodedBody = First.Decoded;
                }
            }
 
            foreach (MailAddress Addr in Message.Recipients)
            {
                bool Found = false;
 
                if (!(To is null))
                {
                    foreach (MailAddress A in To)
                    {
                        if (Addr.Address == A.Address)
                        {
                            Found = true;
                            break;
                        }
                    }
 
                    if (Found)
                        continue;
                }
 
                if (!(Cc is null))
                {
                    foreach (MailAddress A in Cc)
                    {
                        if (Addr.Address == A.Address)
                        {
                            Found = true;
                            break;
                        }
                    }
 
                    if (Found)
                        continue;
                }
 
                if (Bcc is null)
                    Bcc = new List<MailAddress>();
 
                Bcc.Add(Addr);
            }
 
            Message.UnparsedHeaders = OtherHeaders.ToArray();
            Message.To = To?.ToArray();
            Message.Cc = Cc?.ToArray();
            Message.Bcc = Bcc?.ToArray();
            Message.ReplyTo = ReplyTo?.ToArray();
 
            if (Message.Sender is null)
                Message.Sender = Message.FromMail;
 
            if (!Message.Date.HasValue)
                Message.Date = DateTimeOffset.Now;
 
            if (Message.MessageID is null)
                Message.MessageID = Guid.NewGuid().ToString();
 
            await this.server.ProcessMessage(Message);
 
            return Message.MessageID;
        }
 
        private bool AddRecipients(ref List<MailAddress> AddressList, string s)
        {
            if (AddressList is null)
                AddressList = new List<MailAddress>();
 
            MailAddress[] Addresses = this.ParseMailAddresses(s);
            if (Addresses is null)
                return false;
            else
            {
                AddressList.AddRange(Addresses);
                return true;
            }
        }
 
        internal static int Next(int MaxValue)
        {
            lock (rnd)
            {
                return rnd.Next(MaxValue);
            }
        }
 
    }
}