SimpleSmtpClient.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Multipart;
using Waher.Content.Text;
using Waher.Events;
using Waher.Networking.SASL;
using Waher.Networking.SMTP.Exceptions;
using Waher.Networking.Sniffers;
using Waher.Security;
 
namespace Waher.Networking.SMTP
{
    public class SimpleSmtpClient : CommunicationLayer, ISaslClientSide, IDisposableAsync
    {
        public const int DefaultSmtpPort = 25;
 
        public const int AlternativeSmtpPort = 587;
 
        private readonly List<KeyValuePair<int, string>> response = new List<KeyValuePair<int, string>>();
        private TaskCompletionSource<KeyValuePair<int, string>[]> responseSource = new TaskCompletionSource<KeyValuePair<int, string>[]>();
        private RowTcpClient client;
        private readonly object synchObj = new object();
        private readonly string userName;
        private readonly string password;
        private readonly string host;
        private readonly int port;
        private string domain;
        private bool startTls = false;
        //private bool smptUtf8 = false;
        //private bool eightBitMime = false;
        //private bool enhancedStatusCodes = false;
        //private bool help = false;
        private bool trustCertificate = false;
        //private int? size = null;
        private string[] authMechanisms = null;
        private string[] permittedAuthenticationMechanisms = null;
 
        public SimpleSmtpClient(string Domain, string Host, int Port, params ISniffer[] Sniffers)
            : this(Domain, Host, Port, null, null, Sniffers)
        {
        }
 
        public SimpleSmtpClient(string Domain, string Host, int Port, string UserName, string Password, params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.domain = Domain;
            this.host = Host;
            this.port = Port;
            this.userName = UserName;
            this.password = Password;
        }
 
        public async Task Connect()
        {
            if (!(this.client is null))
            {
                await this.client.DisposeAsync();
                this.client = null;
            }
 
            lock (this.synchObj)
            {
                this.response.Clear();
            }
 
            this.client = new RowTcpClient(Encoding.UTF8, 10000, false);
            this.client.Client.ReceiveTimeout = 10000;
            this.client.Client.SendTimeout = 10000;
 
            this.client.OnReceived += this.Client_OnReceived;
            this.client.OnSent += this.Client_OnSent;
            this.client.OnError += this.Client_OnError;
            this.client.OnInformation += this.Client_OnInformation;
            this.client.OnWarning += this.Client_OnWarning;
 
            this.Information("Connecting to " + this.host + ":" + this.port.ToString());
            await this.client.ConnectAsync(this.host, this.port);
            this.Information("Connected to " + this.host + ":" + this.port.ToString());
 
            await this.AssertOkResult();
        }
 
        private string Client_OnWarning(string Text)
        {
            this.Warning(Text);
            return Text;
        }
 
        private string Client_OnInformation(string Text)
        {
            this.Information(Text);
            return Text;
        }
 
        private Task Client_OnError(object Sender, Exception Exception)
        {
            this.Error(Exception.Message);
            return Task.CompletedTask;
        }
 
        private Task<bool> Client_OnSent(object Sender, string Text)
        {
            this.TransmitText(Text);
            return Task.FromResult(true);
        }
 
        private Task<bool> Client_OnReceived(object Sender, string Row)
        {
            if (string.IsNullOrEmpty(Row))
            {
                this.Error("No response returned.");
                return Task.FromResult(true);
            }
 
            this.ReceiveText(Row);
 
            int i = Row.IndexOfAny(spaceHyphen);
            if (i < 0)
                i = Row.Length;
 
            if (!int.TryParse(Row[..i], out int Code))
            {
                this.Error("Invalid response returned.");
                return Task.FromResult(true);
            }
 
            bool More = i < Row.Length && Row[i] == '-';
 
            lock (this.synchObj)
            {
                if (i < Row.Length)
                    Row = Row[(i + 1)..].Trim();
                else
                    Row = string.Empty;
 
                this.response.Add(new KeyValuePair<int, string>(Code, Row));
 
                if (!More)
                {
                    this.responseSource.TrySetResult(this.response.ToArray());
                    this.response.Clear();
                }
            }
 
            return Task.FromResult(true);
        }
 
        [Obsolete("Use DisposeAsync() instead.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async Task DisposeAsync()
        {
            if (!(this.client is null))
            {
                await this.client.DisposeAsync();
                this.client = null;
            }
        }
 
        public string Domain => this.domain;
 
        public bool TrustCertificate
        {
            get => this.trustCertificate;
            set => this.trustCertificate = value;
        }
 
        public X509Certificate ServerCertificate => this.client.RemoteCertificate;
 
        public bool ServerCertificateValid => this.client.RemoteCertificateValid;
 
        public string[] PermittedAuthenticationMechanisms
        {
            get => this.permittedAuthenticationMechanisms;
            set => this.permittedAuthenticationMechanisms = value;
        }
 
        public Task<KeyValuePair<int, string>[]> ReadResponse()
        {
            return this.ReadResponse(10000);
        }
 
        public async Task<KeyValuePair<int, string>[]> ReadResponse(int Timeout)
        {
            TaskCompletionSource<KeyValuePair<int, string>[]> Source = this.responseSource;
            if (await Task.WhenAny(Source.Task, Task.Delay(Timeout)) != Source.Task)
                throw new TimeoutException("Response not returned in time.");
 
            return Source.Task.Result;
        }
 
        private static readonly char[] spaceHyphen = new char[] { ' ', '-' };
 
        private Task WriteLine(string Row)
        {
            lock (this.synchObj)
            {
                this.response.Clear();
                this.responseSource = new TaskCompletionSource<KeyValuePair<int, string>[]>();
            }
 
            return this.client.SendAsync(Row);
        }
 
        private Task Write(bool ConstantBuffer, byte[] Bytes)
        {
            return this.client.SendAsync(ConstantBuffer, Bytes);
        }
 
        private Task<string> AssertOkResult()
        {
            return this.AssertResult(300);
        }
 
        private Task<string> AssertContinue()
        {
            return this.AssertResult(400);
        }
 
        private async Task<string> AssertResult(int MaxExclusive)
        {
            KeyValuePair<int, string>[] Response = await this.ReadResponse();
            int Code = Response[0].Key;
            string Message = Response[0].Value.Trim();
 
            if (string.IsNullOrEmpty(Message))
                Message = "Request rejected.";
 
            if (Code < 200 || Code >= MaxExclusive)
            {
                if (Code >= 400 && Code < 500)
                    throw new SmtpTemporaryErrorException(Message, Code);
                else
                    throw new SmtpException(Message, Code);
            }
 
            return Response[0].Value;
        }
 
        public async Task<string> EHLO(string Domain)
        {
            this.startTls = false;
            //this.size = null;
            this.authMechanisms = null;
            //this.smptUtf8 = false;
            //this.eightBitMime = false;
            //this.enhancedStatusCodes = false;
            //this.help = false;
 
            if (string.IsNullOrEmpty(Domain))
                await this.WriteLine("EHLO");
            else
                await this.WriteLine("EHLO " + Domain);
 
            KeyValuePair<int, string>[] Response = await this.ReadResponse();
            if (Response[0].Key < 200 || Response[0].Key >= 300)
                throw new IOException("Request rejected.");
 
            int i = Response[0].Value.LastIndexOf('[');
            int j = Response[0].Value.LastIndexOf(']');
            string ResponseDomain;
 
            if (i >= 0 && j > i)
            {
                ResponseDomain = Response[0].Value.Substring(i + 1, j - i - 1);
 
                if (string.IsNullOrEmpty(Domain))
                    Domain = ResponseDomain;
 
                if (string.IsNullOrEmpty(this.domain))
                    this.domain = ResponseDomain;
            }
            else
                ResponseDomain = string.Empty;
 
            foreach (KeyValuePair<int, string> P in Response)
            {
                string s = P.Value.ToUpper();
 
                switch (s)
                {
                    case "STARTTLS":
                        this.startTls = true;
                        break;
 
                    case "SMTPUTF8":
                        //this.smptUtf8 = true;
                        break;
 
                    case "8BITMIME":
                        //this.eightBitMime = true;
                        break;
 
                    case "ENHANCEDSTATUSCODES":
                        //this.enhancedStatusCodes = true;
                        break;
 
                    case "HELP":
                        //this.help = true;
                        break;
 
                    default:
                        /*if (s.StartsWith("SIZE "))
                        {
                            if (int.TryParse(s.Substring(5).Trim(), out int i))
                                this.size = i;
                        }
                        else*/
                        if (s.StartsWith("AUTH "))
                            this.authMechanisms = s[5..].Trim().Split(space, StringSplitOptions.RemoveEmptyEntries);
                        break;
                }
            }
 
            if (this.startTls && !(this.client.Stream is SslStream))
            {
                await this.WriteLine("STARTTLS");
                await this.AssertOkResult();    // Will pause when complete.
 
                await this.client.PauseReading();
 
                this.Information("Starting TLS handshake.");
                await this.client.UpgradeToTlsAsClient(null, Crypto.SecureTls, this.trustCertificate);
                this.Information("TLS handshake complete.");
                this.client.Continue();
 
                ResponseDomain = await this.EHLO(Domain);
            }
            else if (!(this.authMechanisms is null) && !string.IsNullOrEmpty(this.userName) && !string.IsNullOrEmpty(this.password))
            {
                foreach (string Mechanism in this.authMechanisms)
                {
                    if (Mechanism == "EXTERNAL")
                        continue;
 
                    SslStream SslStream = this.client.Stream as SslStream;
                    foreach (IAuthenticationMechanism M in SaslModule.Mechanisms)
                    {
                        if (M.Name != Mechanism)
                            continue;
 
                        if (!M.Allowed(SslStream))
                            break;
 
                        if (!(this.permittedAuthenticationMechanisms is null) &&
                            Array.IndexOf(this.permittedAuthenticationMechanisms, Mechanism) < 0)
                        {
                            break;
                        }
 
                        bool? b;
 
                        try
                        {
                            b = await M.Authenticate(this.userName, this.password, this);
                            if (!b.HasValue)
                                continue;
                        }
                        catch (Exception)
                        {
                            b = false;
                        }
 
                        if (!b.Value)
                            throw new AuthenticationException("Unable to authenticate user.");
 
                        return ResponseDomain;
                    }
                }
 
                throw new AuthenticationException("No suitable and supported authentication mechanism found.");
            }
 
            return ResponseDomain;
        }
 
        private static readonly char[] space = new char[] { ' ' };
 
        public async Task VRFY(string Account)
        {
            await this.WriteLine("VRFY " + Account);
            await this.AssertOkResult();
        }
 
        public async Task MAIL_FROM(string Sender)
        {
            await this.WriteLine("MAIL FROM: <" + Sender + ">");
            await this.AssertOkResult();
        }
 
        public async Task RCPT_TO(string Receiver)
        {
            await this.WriteLine("RCPT TO: <" + Receiver + ">");
            await this.AssertOkResult();
        }
 
        public async Task QUIT()
        {
            await this.WriteLine("QUIT");
            await this.AssertOkResult();
        }
 
        public Task DATA(KeyValuePair<string, string>[] Headers, byte[] Body)
        {
            return this.DATA(Headers, false, Body);
        }
 
        public async Task DATA(KeyValuePair<string, string>[] Headers, bool ConstantBody, byte[] Body)
        {
            await this.WriteLine("DATA");
            await this.AssertContinue();
 
            foreach (KeyValuePair<string, string> Header in Headers)
                await this.WriteLine(Header.Key + ": " + Header.Value);
 
            await this.WriteLine(string.Empty);
 
            int c = Body.Length;
            int i = 0;
            int j;
 
            while (i < c)
            {
                j = this.IndexOf(Body, crLfDot, i);
                if (j < 0)
                    j = c;
 
                if (i == 0 && j == c)
                    await this.Write(ConstantBody, Body);
                else
                {
                    byte[] Bin = new byte[j - i];
                    Buffer.BlockCopy(Body, i, Bin, 0, j - i);
                    await this.Write(true, Bin);
                }
 
                i = j;
                if (i < c)
                {
                    await this.Write(true, crLfDot);
                    i += 2;
                }
            }
 
            await this.WriteLine(string.Empty);
            await this.WriteLine(string.Empty);
            await this.WriteLine(".");
 
            await this.AssertOkResult();
        }
 
        private static readonly byte[] crLfDot = new byte[] { (byte)'\r', (byte)'\n', (byte)'.' };
 
        private int IndexOf(byte[] Data, byte[] Segment, int StartIndex)
        {
            int i, j;
            int d = Segment.Length;
            int c = Data.Length - d + 1;
 
            for (i = StartIndex; i < c; i++)
            {
                for (j = 0; j < d; j++)
                {
                    if (Data[i + j] != Segment[j])
                        break;
                }
 
                if (j == d)
                    return i;
            }
 
            return -1;
        }
 
        public async Task<string> Initiate(IAuthenticationMechanism Mechanism, string Parameters)
        {
            string s = "AUTH " + Mechanism.Name;
            if (!string.IsNullOrEmpty(Parameters))
                s += " " + Parameters;
 
            await this.WriteLine(s);
            return await this.AssertContinue();
        }
 
        public async Task<string> ChallengeResponse(IAuthenticationMechanism Mechanism, string Parameters)
        {
            await this.WriteLine(Parameters);
            return await this.AssertContinue();
        }
 
        public async Task<string> FinalResponse(IAuthenticationMechanism Mechanism, string Parameters)
        {
            await this.WriteLine(Parameters);
            await this.AssertOkResult();
 
            return null;    // No response in SMTP
        }
 
        public async Task SendFormattedEMail(string Sender, string Recipient, string Subject,
            string MarkdownContent, params object[] Attachments)
        {
            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(MarkdownContent);
            string HTML = "<html><body>" + HtmlDocument.GetBody(await Doc.GenerateHTML()) + "</body></html>";
            string PlainText = await Doc.GeneratePlainText();
            ContentAlternatives Content = new ContentAlternatives(new EmbeddedContent[]
            {
                new EmbeddedContent()
                {
                    ContentType = "text/html; charset=utf-8",
                    Raw = Encoding.UTF8.GetBytes(HTML)
                },
                new EmbeddedContent()
                {
                    ContentType = PlainTextCodec.DefaultContentType + "; charset=utf-8",
                    Raw = Encoding.UTF8.GetBytes(PlainText)
                },
                new EmbeddedContent()
                {
                    ContentType = "text/markdown; charset=utf-8",
                    Raw = Encoding.UTF8.GetBytes(MarkdownContent)
                }
            });
 
            ContentResponse P = await InternetContent.EncodeAsync(Content, Encoding.UTF8);
 
            if (Attachments.Length > 0)
            {
                List<EmbeddedContent> Parts = new List<EmbeddedContent>()
                {
                    new EmbeddedContent()
                    {
                        ContentType = P.ContentType,
                        Raw = P.Encoded
                    }
                };
 
                foreach (object Attachment in Attachments)
                    Parts.Add(await EmbeddedContent.Encode(Attachment, Encoding.UTF8));
 
                MixedContent Mixed = new MixedContent(Parts.ToArray());
 
                P = await InternetContent.EncodeAsync(Mixed, Encoding.UTF8);
            }
 
            byte[] BodyBin = P.Encoded;
            string ContentType = P.ContentType;
 
            List<KeyValuePair<string, string>> Headers = new List<KeyValuePair<string, string>>()
            {
                new KeyValuePair<string, string>("MIME-VERSION", "1.0"),
                new KeyValuePair<string, string>("FROM", Sender),
                new KeyValuePair<string, string>("TO", Recipient),
                new KeyValuePair<string, string>("SUBJECT", Subject),
                new KeyValuePair<string, string>("DATE", CommonTypes.EncodeRfc822(DateTime.Now)),
                new KeyValuePair<string, string>("IMPORTANCE", "normal"),
                new KeyValuePair<string, string>("X-PRIORITY", "3"),
                new KeyValuePair<string, string>("MESSAGE-ID", Guid.NewGuid().ToString()),
                new KeyValuePair<string, string>("CONTENT-TYPE", ContentType)
            };
 
            await this.MAIL_FROM(Sender);
            await this.RCPT_TO(Recipient);
            await this.DATA(Headers.ToArray(), true, BodyBin);
        }
 
    }
}