SmtpS2SEndpoint.cs

using System;
using System.Collections.Generic;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Multipart;
using Waher.Content.Text;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.SMTP.Server;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP.Server.Mail;
using Waher.Persistence;
using Waher.Runtime.Cache;
 
namespace Waher.Networking.XMPP.Server
{
    public class SmtpS2SEndpoint : ServerConnection
    {
        private static Cache<string, OutgoingMail> outgoingMails;
        private readonly SmtpServer smtpServer;
        private readonly XmppServer xmppServer;
 
        static SmtpS2SEndpoint()
        {
            outgoingMails = new Cache<string, OutgoingMail>(int.MaxValue, TimeSpan.FromHours(1), TimeSpan.FromMinutes(1), true);
            outgoingMails.Removed += OutgoingMails_Removed;
 
            Log.Terminating += (Sender, e) =>
            {
                outgoingMails?.Dispose();
                outgoingMails = null;
                return Task.CompletedTask;
            };
        }
 
        public SmtpS2SEndpoint(CaseInsensitiveString LocalDomain, CaseInsensitiveString RemoteDomain, SmtpServer SmtpServer, XmppServer XmppServer, params ISniffer[] Sniffers)
            : base(LocalDomain, RemoteDomain, Sniffers)
        {
            this.smtpServer = SmtpServer;
            this.xmppServer = XmppServer;
        }
 
        public bool TrustServer => false;
 
        public override string Type => "SMTP";
 
        public override async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            if (string.Compare(Type, "chat", true) == 0)
            {
                string Key = From.Address + " | " + To.Address;
                outgoingMails.TryGetValue(Key, out OutgoingMail Mail);
 
                try
                {
                    Stanza Stanza = XmppServer.ToStanza("message", Type, Id, To, From, Language, ContentXml);
                    List<EmbeddedContent> EmbeddedContent = null;
                    string Text = null;
                    string Html = null;
                    string Markdown = null;
                    string Subject = null;
                    string ReplaceId = null;
                    bool Immediate = false;
 
                    foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                    {
                        if (N is XmlElement E)
                        {
                            switch (E.LocalName)
                            {
                                case "subject":
                                    Subject = E.InnerText;
                                    break;
 
                                case "body":
                                    Text = E.InnerText;
                                    break;
 
                                case "replace":
                                    if (E.NamespaceURI == "urn:xmpp:message-correct:0")
                                        ReplaceId = XML.Attribute(E, "id");
                                    break;
 
                                case "html":
                                    foreach (XmlNode N2 in E.ChildNodes)
                                    {
                                        if (N2 is XmlElement E2 && E2.LocalName == "body")
                                        {
                                            Html = E.InnerXml;
                                            break;
                                        }
                                    }
                                    break;
 
                                case "content":
                                    switch (E.NamespaceURI)
                                    {
                                        case XmppServer.ContentNamespace:
                                            switch (XML.Attribute(E, "type").ToLower())
                                            {
                                                case PlainTextCodec.DefaultContentType:
                                                    Text = E.InnerText;
                                                    break;
 
                                                case HtmlCodec.DefaultContentType:
                                                    Html = E.InnerText;
                                                    break;
 
                                                case MarkdownCodec.ContentType:
                                                    Markdown = E.InnerText;
                                                    break;
                                            }
                                            break;
 
                                        case XmppServer.MailNamespace:
                                            EmbeddedContent ??= new List<EmbeddedContent>();
 
                                            byte[] Bin = Convert.FromBase64String(E.InnerText);
 
                                            EmbeddedContent.Add(new EmbeddedContent()
                                            {
                                                ID = XML.Attribute(E, "cid"),
                                                ContentType = XML.Attribute(E, "type"),
                                                Disposition = XML.Attribute(E, "disposition", ContentDisposition.Unknown),
                                                Name = XML.Attribute(E, "name"),
                                                FileName = XML.Attribute(E, "fileName"),
                                                Description = XML.Attribute(E, "description"),
                                                Size = Bin.Length,
                                                TransferDecoded = Bin
                                            });
                                            break;
                                    }
                                    break;
 
                                case "immediate":
                                    if (E.NamespaceURI == XmppServer.MailNamespace)
                                        Immediate = true;
                                    break;
                            }
                        }
                    }
 
                    if (!(Markdown is null) && (Text is null || Html is null))
                    {
                        MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown);
 
                        Text ??= await Doc.GeneratePlainText();
                        Html ??= HtmlDocument.GetBody(await Doc.GenerateHTML());
                    }
 
 
                    if (Subject is null && Text is null && Html is null)
                        return true;
 
                    if (Mail is null)
                    {
                        Mail = new OutgoingMail()
                        {
                            Endpoint = this,
                            From = From.BareJid,
                            To = To.BareJid
                        };
 
                        outgoingMails[Key] = Mail;
                    }
 
                    if (!string.IsNullOrEmpty(ReplaceId) &&
                        !(Mail.ById is null) &&
                        Mail.ById.TryGetValue(ReplaceId, out OutgoingMailRec Rec))
                    {
                        Rec.Html = Html;
                        Rec.Text = Text;
                        Rec.Embedded = EmbeddedContent?.ToArray();
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(Mail.Subject))
                            Mail.Subject = Subject;
                        else if (Mail.Subject != Subject && !string.IsNullOrEmpty(Subject))
                        {
                            await Send(Mail);
                            Mail.Subject = Subject;
                            Mail.Records.Clear();
                            Mail.ById?.Clear();
                        }
 
                        if (string.IsNullOrEmpty(Id) && !string.IsNullOrEmpty(ReplaceId))
                            Id = ReplaceId;
 
                        Rec = new OutgoingMailRec()
                        {
                            Id = Id,
                            Html = Html,
                            Text = Text,
                            Embedded = EmbeddedContent?.ToArray()
                        };
 
                        Mail.Records.AddLast(Rec);
 
                        if (!string.IsNullOrEmpty(Id))
                        {
                            Mail.ById ??= new Dictionary<string, OutgoingMailRec>();
                            Mail.ById[Id] = Rec;
                        }
                    }
 
                    if (Immediate)
                        outgoingMails.Remove(Key);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
 
            return true;
        }
 
        private static async Task OutgoingMails_Removed(object Sender, CacheItemEventArgs<string, OutgoingMail> e)
        {
            try
            {
                await Send(e.Value);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private static async Task<bool> Send(OutgoingMail Mail)
        {
            List<EmbeddedContent> Attachments = null;
            List<EmbeddedContent> Inline = null;
            StringBuilder PlainText = null;
            StringBuilder Html = null;
            string Id = null;
 
            foreach (OutgoingMailRec Rec in Mail.Records)
            {
                if (Id is null && !string.IsNullOrEmpty(Rec.Id))
                    Id = Rec.Id;
 
                if (!string.IsNullOrEmpty(Rec.Text))
                {
                    PlainText ??= new StringBuilder();
                    PlainText.AppendLine(Rec.Text.Trim());
                }
 
                if (!string.IsNullOrEmpty(Rec.Html))
                {
                    Html ??= new StringBuilder();
                    Html.AppendLine(Rec.Html.Trim());
                }
 
                if (!(Rec.Embedded is null))
                {
                    foreach (EmbeddedContent Embedded in Rec.Embedded)
                    {
                        switch (Embedded.Disposition)
                        {
                            case ContentDisposition.Inline:
                                Inline ??= new List<EmbeddedContent>();
                                Inline.Add(Embedded);
                                break;
 
                            case ContentDisposition.Attachment:
                            default:
                                Attachments ??= new List<EmbeddedContent>();
                                Attachments.Add(Embedded);
                                break;
                        }
                    }
                }
            }
 
            List<EmbeddedContent> Alternatives = new List<EmbeddedContent>();
            string Subject = Mail.Subject;
            string s;
 
            if (!(PlainText is null))
            {
                s = PlainText.ToString();
 
                Alternatives.Add(new EmbeddedContent()
                {
                    ContentType = "text/plain; charset=utf-8",
                    Raw = Encoding.UTF8.GetBytes(s)
                });
 
                if (string.IsNullOrEmpty(Subject))
                    Subject = FirstRow(s);
            }
 
            if (!(Html is null))
            {
                s = Html.ToString();
 
                EmbeddedContent HtmlContent = new EmbeddedContent()
                {
                    ContentType = "text/html; charset=utf-8",
                    Raw = Encoding.UTF8.GetBytes(s)
                };
 
                if (!(Inline is null) && Inline.Count > 0)
                {
                    EmbeddedContent[] RelatedContent = new EmbeddedContent[Inline.Count + 1];
                    RelatedContent[0] = HtmlContent;
                    Inline.CopyTo(RelatedContent, 1);
                    RelatedContent Related = new RelatedContent(RelatedContent, HtmlContent.ContentType);
 
                    ContentResponse P = await InternetContent.EncodeAsync(Related, null);
 
                    if (P.HasError)
                    {
                        Log.Exception(P.Error);
                        return false;
                    }
 
                    byte[] Encoded = P.Encoded;
                    string ContentType = P.ContentType;
 
                    HtmlContent = new EmbeddedContent()
                    {
                        ContentType = ContentType,
                        Raw = Encoded
                    };
                }
 
                Alternatives.Add(HtmlContent);
 
                if (string.IsNullOrEmpty(Subject))
                {
                    HtmlDocument Doc = new HtmlDocument("<html><body>" + s + "</body></html>");
                    LinkedList<HtmlNode> ToProcess = new LinkedList<HtmlNode>();
                    string FirstHeader = null;
                    int FirstHeaderLevel = int.MaxValue;
                    string FirstParagraph = null;
 
                    foreach (HtmlNode N in Doc.Body.Children)
                        ToProcess.AddLast(N);
 
                    while (!(ToProcess.First is null))
                    {
                        HtmlNode N = ToProcess.First.Value;
                        ToProcess.RemoveFirst();
 
                        if (N is HtmlElement E)
                        {
                            if (string.Compare(E.FullName, "P", true) == 0)
                                FirstParagraph ??= GetText(E);
                            else if (E.FullName.ToUpper().StartsWith('H') && int.TryParse(E.FullName[1..], out int Level))
                            {
                                if (Level < FirstHeaderLevel)
                                {
                                    FirstHeader = GetText(E);
                                    FirstHeaderLevel = Level;
                                }
                            }
 
                            if (E.HasChildren)
                            {
                                foreach (HtmlNode N2 in E.Children)
                                    ToProcess.AddLast(N2);
                            }
                        }
                    }
 
                    Subject = FirstRow(FirstHeader);
                    if (string.IsNullOrEmpty(Subject))
                        Subject = FirstRow(FirstParagraph);
                }
            }
 
            if (string.IsNullOrEmpty(Subject))
                Subject = CommonTypes.EncodeRfc822(DateTimeOffset.Now);
 
            return await Mail.Endpoint.smtpServer.SendMessage(Mail.From, Mail.To, Subject, Id, Alternatives.ToArray(), Attachments?.ToArray());
        }
 
        private static string FirstRow(string s)
        {
            s = s.Trim();
            int i = s.IndexOfAny(CommonTypes.CRLF);
            if (i < 0)
                return s;
            else
                return s[..i].TrimEnd();
        }
 
        private static string GetText(HtmlElement E)
        {
            StringBuilder Output = new StringBuilder();
            GetText(E, Output);
            return Output.ToString();
        }
 
        private static void GetText(HtmlElement E, StringBuilder Output)
        {
            if (string.Compare(E.FullName, "BR", true) == 0)
                Output.AppendLine();
 
            if (E.HasChildren)
            {
                foreach (HtmlNode N in E.Children)
                {
                    if (N is HtmlElement E2)
                        GetText(E2, Output);
                    else if (N is HtmlText Text)
                        Output.Append(Text.InlineText);
                    else if (N is CDATA CDATA)
                        Output.Append(CDATA.Content);
                }
            }
        }
 
        public override async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            switch (Type)
            {
                case "subscribe":
                    await this.xmppServer.Presence("subscribed", Id, From, To, Language, string.Empty, this);
 
                    StringBuilder Markdown = new StringBuilder();
 
                    Markdown.AppendLine("e-Mail Invitation");
                    Markdown.AppendLine("======================");
                    Markdown.AppendLine();
 
                    Markdown.Append("**");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** has added you to its white-list. This means you can send e-mail to **");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** from **");
                    Markdown.Append(MarkdownDocument.Encode(To.BareJid));
                    Markdown.AppendLine("**.");
 
                    if (!await this.xmppServer.SendMailMessage(From.BareJid, To.BareJid, "Added to white-list", Markdown.ToString()))
                        return false;
 
                    Log.Informational("Added to white-list.", To.BareJid, From.BareJid);
                    break;
 
                case "unsubscribe":
                    await this.xmppServer.Presence("unsubscribed", Id, From, To, Language, string.Empty, this);
 
                    Markdown = new StringBuilder();
 
                    Markdown.AppendLine("White-list removal");
                    Markdown.AppendLine("======================");
                    Markdown.AppendLine();
 
                    Markdown.Append("**");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** has removed you from its white-list. This means you can no longer send e-mail to **");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** from **");
                    Markdown.Append(MarkdownDocument.Encode(To.BareJid));
                    Markdown.AppendLine("**.");
 
                    if (!await this.xmppServer.SendMailMessage(From.BareJid, To.BareJid, "Removed from white-list", Markdown.ToString()))
                        return false;
 
                    Log.Informational("Removed from white-list.", To.BareJid, From.BareJid);
                    break;
 
                case "subscribed":
                    Markdown = new StringBuilder();
 
                    Markdown.AppendLine("Request approved");
                    Markdown.AppendLine("===================");
                    Markdown.AppendLine();
 
                    Markdown.Append("Your request to be permitted to send e-mail to **");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** from **");
                    Markdown.Append(MarkdownDocument.Encode(To.BareJid));
                    Markdown.AppendLine("** has been approved.");
 
                    if (!await this.xmppServer.SendMailMessage(From.BareJid, To.BareJid, "White-listing request approved", Markdown.ToString()))
                        return false;
 
                    Log.Informational("White-listing request approved.", To.BareJid, From.BareJid);
                    break;
 
                case "unsubscribed":
                    Markdown = new StringBuilder();
 
                    Markdown.AppendLine("Request rejected");
                    Markdown.AppendLine("===================");
                    Markdown.AppendLine();
 
                    Markdown.Append("Your request to be permitted to send e-mail to **");
                    Markdown.Append(MarkdownDocument.Encode(From.BareJid));
                    Markdown.Append("** from **");
                    Markdown.Append(MarkdownDocument.Encode(To.BareJid));
                    Markdown.AppendLine("** has been rejected.");
 
                    if (!await this.xmppServer.SendMailMessage(From.BareJid, To.BareJid, "White-listing request rejected", Markdown.ToString()))
                        return false;
 
                    Log.Informational("White-listing request rejected.", To.BareJid, From.BareJid);
                    break;
            }
 
            return true;
        }
 
        public override async Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            if (Type == "get" || Type == "set")
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append("IQ stanzas not supported for mail recipients. From: ");
                sb.Append(From.Address.Value);
                sb.Append(", To: ");
                sb.Append(To.Address.Value);
 
                return !(await Sender.IqErrorServiceUnavailable(Id, From, To, sb.ToString(), "en") is null);
            }
            else
                return true;
        }
 
        public override Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.IQ(Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.Message(Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.Presence(Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> IqError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            return Task.FromResult(true); // Ignore
        }
 
        public override Task<string> IqError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(string.Empty); // Ignore
        }
 
        public override Task<bool> IqResult(string Id, XmppAddress To, XmppAddress From, string ResultXml)
        {
            return Task.FromResult(true); // Ignore
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return this.Message(Type, Id, To, From, Language, ContentXml, null);
        }
 
        public override Task<bool> MessageError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(true); // Ignore
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return this.Presence(Type, Id, To, From, Language, ContentXml, null);
        }
 
        public override Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            return Task.FromResult(true); // Ignore
        }
 
        public override Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(true); // Ignore
        }
 
        public Task<bool> RelayMessage(SmtpMessage Message, MailAddress Recipient)
        {
            StringBuilder Received = new StringBuilder();
 
            Received.Append("from ");
            Received.Append(Message.ClientName);
            Received.Append(" [");
            Received.Append(Message.RemoteEndPoint);
            Received.Append("] by ");
            Received.Append(this.smtpServer.Domain);
            Received.Append(" with ");
            Received.Append(typeof(SmtpServer).Namespace);
            Received.Append(" ");
            Received.Append(typeof(SmtpServer).Assembly.ImageRuntimeVersion);
            Received.Append("; ");
            Received.Append(CommonTypes.EncodeRfc822(DateTimeOffset.Now));
 
            KeyValuePair<string, string>[] Headers = new KeyValuePair<string, string>[Message.AllHeaders.Length + 1];
 
            Message.AllHeaders.CopyTo(Headers, 1);
            Headers[0] = new KeyValuePair<string, string>("Received", Received.ToString());
 
            return this.smtpServer.SendMessage(Message.FromMail.Address, Recipient.Address, Headers, Message.UntransformedBody, DateTime.Now);
        }
 
    }
}