RelayConfiguration.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.DNS;
using Waher.Networking.HTTP;
using Waher.Networking.SMTP;
using Waher.Networking.SMTP.Server;
using Waher.Networking.Sniffers;
using Waher.Networking.Sniffers.Model;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
 
namespace Waher.Service.IoTBroker.Setup
{
    public class RelayConfiguration : SystemMultiStepConfiguration, IEncryptedProperties
    {
        private static RelayConfiguration instance = null;
 
        private string host = string.Empty;
        private string userName = string.Empty;
        private string password = string.Empty;
        private string testMailRecipient = string.Empty;
        private string sender = string.Empty;
        private string[] relayDomains = null;
        private int port = 587;
        private bool useRelayServer = false;
 
        private HttpResource testMail = null;
 
        [DefaultValueStringEmpty]
        public string Host
        {
            get => this.host;
            set => this.host = value;
        }
 
        [DefaultValue(587)]
        public int Port
        {
            get => this.port;
            set => this.port = value;
        }
 
        [DefaultValueStringEmpty]
        public string UserName
        {
            get => this.userName;
            set => this.userName = value;
        }
 
        [Encrypted(32)]
        public string Password
        {
            get => this.password;
            set => this.password = value;
        }
 
        public string[] EncryptedProperties => new string[] { nameof(this.Password) };
 
        [DefaultValue(false)]
        public bool UseRelayServer
        {
            get => this.useRelayServer;
            set => this.useRelayServer = value;
        }
 
        [DefaultValueStringEmpty]
        public string TestMailRecipient
        {
            get => this.testMailRecipient;
            set => this.testMailRecipient = value;
        }
 
        [DefaultValueStringEmpty]
        public string Sender
        {
            get => this.sender;
            set => this.sender = value;
        }
 
        [DefaultValueNull]
        public string[] RelayDomains
        {
            get => this.relayDomains;
            set => this.relayDomains = value;
        }
 
        public string RelayDomainsText
        {
            get
            {
                if (this.relayDomains is null)
                    return string.Empty;
 
                StringBuilder Result = new StringBuilder();
 
                foreach (string Domain in this.relayDomains)
                    Result.AppendLine(Domain);
 
                return Result.ToString();
            }
        }
 
        public static RelayConfiguration Instance => instance;
 
        public override string Resource => "/Settings/Relay.md";
 
        public override int Priority => 450;
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 31, "Mail Relay");
        }
 
        public override Task ConfigureSystem()
        {
            XmppServerModule.MailServer?.SetRelaySettings(this.useRelayServer, this.host, this.port,
                this.userName, this.password, this.relayDomains, true);
            return Task.CompletedTask;
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as RelayConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.testMail = WebServer.Register("/Settings/TestMail", null, this.TestMail, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.testMail);
 
            return base.UnregisterSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Communication.MailRelay";
 
        private async Task TestMail(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, this.ConfigPrivilege);
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            
            if (Content.HasError ||
                !(Content.Decoded is Dictionary<string, object> Form) ||
                !Form.TryGetValue("useRelayServer", out object Obj) || !(Obj is bool UseRelayServer) ||
                !Form.TryGetValue("testMailRecipient", out Obj) || !(Obj is string TestMailRecipient) ||
                !Form.TryGetValue("sender", out Obj) || !(Obj is string Sender) ||
                !Form.TryGetValue("relayDomains", out Obj) || !(Obj is string RelayDomains) ||
                !Form.TryGetValue("sendMail", out Obj) || !(Obj is bool SendMail))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.TryGetValue("hostName", out Obj) || !(Obj is string HostName) ||
                !Form.TryGetValue("portNumber", out Obj) || !(Obj is int PortNumber) || PortNumber < 1 || PortNumber > 65535 ||
                !Form.TryGetValue("userName", out Obj) || !(Obj is string UserName) ||
                !Form.TryGetValue("password", out Obj) || !(Obj is string Password))
            {
                if (UseRelayServer)
                {
                    await Response.SendResponse(new BadRequestException());
                    return;
                }
                else
                {
                    HostName = string.Empty;
                    PortNumber = 0;
                    UserName = string.Empty;
                    Password = string.Empty;
                }
            }
 
            string TabID = Request.Header["X-TabID"];
            if (string.IsNullOrEmpty(TabID))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
 
            this.useRelayServer = UseRelayServer;
            this.host = HostName;
            this.port = PortNumber;
            this.userName = UserName;
            this.password = Password;
            this.testMailRecipient = TestMailRecipient;
            this.sender = Sender;
            this.relayDomains = RelayDomains.Trim().Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
            await Database.Update(this);
 
            Task _ = Task.Run(async () =>
            {
                if (SendMail)
                {
                    try
                    {
                        string[] TabIDs = new string[] { TabID };
                        string Message = await this.Test(TabIDs);
 
                        if (string.IsNullOrEmpty(Message))
                            await ClientEvents.PushEvent(TabIDs, "MailSent", string.Empty, false, "User");
                        else
                        {
                            await ClientEvents.PushEvent(TabIDs, "ShowStatus", Message, false, "User");
                            await ClientEvents.PushEvent(TabIDs, "MailError", string.Empty, false, "User");
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            });
        }
 
        private async Task<string> Test(string[] TabIDs)
        {
            try
            {
                string DefaultDomain = DomainConfiguration.Instance.Domain;
                if (string.IsNullOrEmpty(DefaultDomain))
                    DefaultDomain = "localhost";
 
                string Sender = this.sender;
                if (string.IsNullOrEmpty(Sender))
                    Sender = XmppConfiguration.Instance.BareJid;
 
                await this.SendMessage(TabIDs, Sender, this.testMailRecipient,
                    "Test message",
                    "Test message\r\n" +
                    "------------------\r\n\r\n" +
                    "This is a test message sent from `" + await SmtpServer.GetSalutation(DefaultDomain) + "`");
 
                return null;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return ex.Message;
            }
        }
 
        private async Task SendMessage(string[] TabIDs, CaseInsensitiveString From, CaseInsensitiveString To, string Subject, string Markdown)
        {
            int i = To.IndexOf('@');
            if (i < 0)
                throw new ArgumentException("Invalid mail address: " + To, nameof(To));
 
            string Domain = To.Substring(i + 1).Trim();
            string UserName;
            string Password;
            string Host;
            int Port;
 
            if (this.useRelayServer)
            {
                Host = this.host;
                Port = this.port;
                UserName = this.userName;
                Password = this.password;
            }
            else
            {
                string[] Exchanges = await DnsResolver.TryLookupMailExchange(Domain);
                if (Exchanges is null || Exchanges.Length == 0)
                    throw new ArgumentException("No mail exchange at " + Domain + ".", nameof(To));
 
                Host = Exchanges[Gateway.NextInteger(Exchanges.Length)];
                Port = SmtpServer.DefaultSmtpPort;
                UserName = null;
                Password = null;
            }
 
            using SimpleSmtpClient Client = new SimpleSmtpClient(Domain, Host, Port, UserName, Password);
            
            if (!(TabIDs is null))
            {
                Client.Add(new SnifferProxy()
                {
                    Config = this,
                    TabIDs = TabIDs
                });
            }
 
            await Client.Connect();
            await Client.EHLO(await SmtpServer.GetSalutation(Domain));    // Also performs Encryption & Authentication handshakes, as required.
            await Client.SendFormattedEMail(From, To, Subject, Markdown);
            await Client.QUIT();
        }
 
        private class SnifferProxy : SnifferBase
        {
            public RelayConfiguration Config;
            public string[] TabIDs;
 
            public SnifferProxy()
                : base("Relay Sniffer Proxy")
            {
            }
 
            public override BinaryPresentationMethod BinaryPresentationMethod => BinaryPresentationMethod.ByteCount;
 
            public override Task Process(SnifferRxBinary Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "Rx: <" + 
                    Event.Count.ToString() + " bytes>", false, "User");
            }
 
            public override Task Process(SnifferTxBinary Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "Tx: <" + 
                    Event.Count.ToString() + " bytes>", false, "User");
            }
 
            public override Task Process(SnifferRxText Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "Rx: " + 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
 
            public override Task Process(SnifferTxText Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "Tx: " + 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
 
            public override Task Process(SnifferInformation Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
 
            public override Task Process(SnifferWarning Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "Warning: " + 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
 
            public override Task Process(SnifferError Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "ERROR: " + 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
 
            public override Task Process(SnifferException Event, CancellationToken Cancel)
            {
                return ClientEvents.PushEvent(this.TabIDs, "ShowStatus", "EXCEPTION: " + 
                    XML.HtmlValueEncode(Event.Text), false, "User");
            }
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(true);
        }
 
        public const string BROKER_RELAY_USE = nameof(BROKER_RELAY_USE);
 
        public const string BROKER_RELAY_DOMAINS = nameof(BROKER_RELAY_DOMAINS);
 
        public const string BROKER_RELAY_SENDER = nameof(BROKER_RELAY_SENDER);
 
        public const string BROKER_RELAY_HOST = nameof(BROKER_RELAY_HOST);
 
        public const string BROKER_RELAY_PORT = nameof(BROKER_RELAY_PORT);
 
        public const string BROKER_RELAY_USER = nameof(BROKER_RELAY_USER);
 
        public const string BROKER_RELAY_PASSWORD = nameof(BROKER_RELAY_PASSWORD);
 
        public override async Task<bool> EnvironmentConfiguration()
        {
            if (!this.TryGetEnvironmentVariable(BROKER_RELAY_USE, false, out this.useRelayServer))
                return false;
 
            string Value = Environment.GetEnvironmentVariable(BROKER_RELAY_DOMAINS);
            if (!string.IsNullOrEmpty(Value))
                this.relayDomains = Value.Split(',');
 
            Value = Environment.GetEnvironmentVariable(BROKER_RELAY_SENDER);
            if (!string.IsNullOrEmpty(Value))
                this.sender = Value;
 
            if (this.useRelayServer)
            {
                if (!this.TryGetEnvironmentVariable(BROKER_RELAY_HOST, true, out this.host))
                    return false;
 
                if (!this.TryGetEnvironmentVariable(BROKER_RELAY_PORT, 1, 65535, true, ref this.port))
                    return false;
 
                if (!this.TryGetEnvironmentVariable(BROKER_RELAY_USER, true, out this.userName))
                    return false;
 
                if (!this.TryGetEnvironmentVariable(BROKER_RELAY_PASSWORD, true, out this.password))
                    return false;
 
                Value = await this.Test(null);
                if (!string.IsNullOrEmpty(Value))
                {
                    this.LogEnvironmentError("Unable to send e-mail with Relay settings: " + Value, BROKER_RELAY_HOST, this.host);
                    return false;
                }
            }
 
            return true;
        }
 
    }
}