DnsConfiguration.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.DNS;
using Waher.Networking.DNS.Communication;
using Waher.Networking.DNS.Enumerations;
using Waher.Networking.DNS.ResourceRecords;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Runtime.Language;
 
namespace Waher.Service.IoTBroker.Setup
{
    public class DnsConfiguration : SystemConfiguration
    {
        private static DnsConfiguration instance = null;
 
        private HttpResource testDns = null;
 
        public static DnsConfiguration Instance => instance;
 
        public override string Resource => "/Settings/DNS.md";
 
        public override int Priority => 250;
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 29, "DNS");
        }
 
        public override Task ConfigureSystem()
        {
            return Task.CompletedTask;
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as DnsConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.testDns = WebServer.Register("/Settings/TestDns", null, this.TestDns, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.testDns);
 
            return base.UnregisterSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Communication.DNS";
 
        private async Task TestDns(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, this.ConfigPrivilege);
 
            if (!Request.HasData)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is string TabID))
                throw new BadRequestException();
 
            Response.StatusCode = 200;
 
            Task _ = Task.Run(async () => await this.Test(TabID));
        }
 
        private async Task Test(params string[] TabIDs)
        {
            try
            {
                Dictionary<CaseInsensitiveString, bool> Processed = new Dictionary<CaseInsensitiveString, bool>();
                List<KeyValuePair<string, string>> DomainNames = new List<KeyValuePair<string, string>>() { };
 
                if (!string.IsNullOrEmpty(DomainConfiguration.Instance?.Domain))
                    DomainNames.Add(new KeyValuePair<string, string>(DomainConfiguration.Instance.Domain, DomainConfiguration.GATEWAY_DOMAIN_NAME));
 
                if (!(DomainConfiguration.Instance?.AlternativeDomains is null))
                {
                    foreach (string AltDomain in DomainConfiguration.Instance.AlternativeDomains)
                        DomainNames.Add(new KeyValuePair<string, string>(AltDomain, DomainConfiguration.GATEWAY_DOMAIN_ALT));
                }
 
                foreach (KeyValuePair<string, string> P in DomainNames)
                {
                    string DomainName = P.Key;
                    if (Processed.ContainsKey(DomainName))
                        continue;
 
                    try
                    {
                        string[] Exchanges = await DnsResolver.LookupMailExchange(DomainName);
 
                        if (Exchanges.Length != 1)
                            throw new Exception("Invalid number of host names.");
 
                        if (Exchanges[0] != DomainName &&
                            Exchanges[0] != await Networking.SMTP.Server.SmtpServer.GetSalutation(DomainName))
                        {
                            throw new Exception("Does not point to correct host.");
                        }
 
                        this.PushResult(TabIDs, DomainName, "MX", true, string.Empty, P.Value);
                    }
                    catch (Exception ex)
                    {
                        this.PushResult(TabIDs, DomainName, "MX", false, ex.Message, P.Value);
                        await this.DiagnoseQuery(TabIDs, DomainName, QTYPE.MX);
                    }
 
                    try
                    {
                        string[] Rows = await DnsResolver.LookupText(DomainName);
                        int Found = 0;
 
                        foreach (string Row in Rows)
                        {
                            string s = Row.Trim();
 
                            if (s.StartsWith("\"") && s.EndsWith("\""))
                                s = s.Substring(1, s.Length - 2);
 
                            if (s.StartsWith("v=spf1"))
                                Found++;
                        }
 
                        if (Found != 1)
                            throw new Exception("Exactly one SPF record must be configured.");
 
                        this.PushResult(TabIDs, DomainName, "SPF", true, string.Empty, P.Value);
                    }
                    catch (Exception ex)
                    {
                        this.PushResult(TabIDs, DomainName, "SPF", false, ex.Message, P.Value);
                        await this.DiagnoseQuery(TabIDs, DomainName, QTYPE.TXT);
                    }
 
                    try
                    {
                        string[] Rows = await DnsResolver.LookupText("_xmppconnect." + DomainName);
                        int BoshFound = 0;
                        int WsFound = 0;
                        bool BoshValid = true;
                        bool WsValid = true;
                        bool Error = false;
 
                        foreach (string Row in Rows)
                        {
                            string s = Row.Trim();
 
                            if (s.StartsWith("_xmpp-client-xbosh="))
                            {
                                BoshFound++;
                                if (s.Substring(19) != WebServices.WebHostMetaDataXml.BoshLink(DomainName))
                                    BoshValid = false;
                            }
                            else if (s.StartsWith("_xmpp-client-websocket="))
                            {
                                WsFound++;
                                if (s.Substring(23) != WebServices.WebHostMetaDataXml.WebSocketLink(DomainName))
                                    WsValid = false;
                            }
                        }
 
                        if (BoshFound == 1 && BoshValid)
                            this.PushResult(TabIDs, DomainName, "BOSH", true, string.Empty, P.Value);
                        else
                        {
                            Error = true;
 
                            if (BoshFound == 0)
                                this.PushResult(TabIDs, DomainName, "BOSH", false, "TXT Record for BOSH not found.", P.Value);
                            else if (BoshFound > 1)
                                this.PushResult(TabIDs, DomainName, "BOSH", false, "More than one TXT Record for BOSH found.", P.Value);
                            else
                                this.PushResult(TabIDs, DomainName, "BOSH", false, "TXT record for BOSH incorrect.", P.Value);
                        }
 
                        if (WsFound == 1 && WsValid)
                            this.PushResult(TabIDs, DomainName, "WS", true, string.Empty, P.Value);
                        else
                        {
                            Error = true;
 
                            if (WsFound == 0)
                                this.PushResult(TabIDs, DomainName, "WS", false, "TXT Record for WebSockets not found.", P.Value);
                            else if (WsFound > 1)
                                this.PushResult(TabIDs, DomainName, "WS", false, "More than one TXT Record for WebSockets found.", P.Value);
                            else
                                this.PushResult(TabIDs, DomainName, "WS", false, "TXT record for WebSockets incorrect.", P.Value);
                        }
 
                        if (Error)
                            await this.DiagnoseQuery(TabIDs, "_xmppconnect." + DomainName, QTYPE.TXT);
                    }
                    catch (Exception ex)
                    {
                        this.PushResult(TabIDs, DomainName, "BOSH", false, ex.Message, P.Value);
                        this.PushResult(TabIDs, DomainName, "WS", false, ex.Message, P.Value);
 
                        await this.DiagnoseQuery(TabIDs, "_xmppconnect." + DomainName, QTYPE.TXT);
                    }
 
                    try
                    {
                        SRV SRV = await DnsResolver.LookupServiceEndpoint(DomainName, "xmpp-client", "tcp");
 
                        if (SRV.Port != 5222)
                            throw new Exception("Invalid c2s port number.");
 
                        if (SRV.TargetHost != DomainName)
                            throw new Exception("Does not point to correct host.");
 
                        this.PushResult(TabIDs, DomainName, "SRV_XmppTcpClient", true, string.Empty, P.Value);
                    }
                    catch (Exception ex)
                    {
                        this.PushResult(TabIDs, DomainName, "SRV_XmppTcpClient", false, ex.Message, P.Value);
                        await this.DiagnoseQuery(TabIDs, "_xmpp-client._tcp." + DomainName, QTYPE.SRV);
                    }
 
                    try
                    {
                        SRV SRV = await DnsResolver.LookupServiceEndpoint(DomainName, "xmpp-server", "tcp");
 
                        if (SRV.Port != 5269)
                            throw new Exception("Invalid s2s port number.");
 
                        if (SRV.TargetHost != DomainName)
                            throw new Exception("Does not point to correct host.");
 
                        this.PushResult(TabIDs, DomainName, "SRV_XmppTcpServer", true, string.Empty, P.Value);
                    }
                    catch (Exception ex)
                    {
                        this.PushResult(TabIDs, DomainName, "SRV_XmppTcpServer", false, ex.Message, P.Value);
                        await this.DiagnoseQuery(TabIDs, "_xmpp-server._tcp." + DomainName, QTYPE.SRV);
                    }
 
                    foreach (IComponent Component in (XmppServerModule.Server?.Components ?? new IComponent[0]))
                    {
                        string ComponentDomainName = Component.Subdomain.Value + "." + DomainName;
 
                        try
                        {
                            SRV SRV = await DnsResolver.LookupServiceEndpoint(ComponentDomainName, "xmpp-server", "tcp");
 
                            if (SRV.Port != 5269)
                                throw new Exception("Invalid s2s port number.");
 
                            if (SRV.TargetHost != Gateway.Domain.Value)
                                throw new Exception("Does not point to correct host.");
 
                            this.PushResult(TabIDs, ComponentDomainName, "SRV_Component", true, string.Empty, P.Value);
                        }
                        catch (Exception ex)
                        {
                            this.PushResult(TabIDs, ComponentDomainName, "SRV_Component", false, ex.Message, P.Value);
                            await this.DiagnoseQuery(TabIDs, "_xmpp-server._tcp." + ComponentDomainName, QTYPE.SRV);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task DiagnoseQuery(string[] TabIDs, string Name, QTYPE TYPE)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine("============ QUERY ============");
            sb.Append("Name: ");
            sb.AppendLine(Name);
            sb.Append("Type: ");
            sb.AppendLine(TYPE.ToString());
            sb.AppendLine("Class: IN");
            sb.AppendLine();
            sb.AppendLine("========== RESPONSE ===========");
 
            try
            {
                DnsResponse Response = await DnsResolver.Query(Name, TYPE, QCLASS.IN);
                sb.AppendLine(Response.ToString());
            }
            catch (Exception ex)
            {
                sb.AppendLine(ex.Message);
            }
 
            await ClientEvents.PushEvent(TabIDs, "DnsDiagnosis", sb.ToString(), false);
        }
 
        private void PushResult(string[] TabIDs, string DomainName, string Suffix, bool Ok, string Message, string VariableName)
        {
            if (TabIDs is null)
            {
                if (!Ok)
                    this.LogEnvironmentError(Message, VariableName, DomainName);
            }
            else
            {
                ClientEvents.PushEvent(TabIDs, "DnsStatus", JSON.Encode(new Dictionary<string, object>()
                {
                    { "domainName", DomainName },
                    { "suffix", Suffix },
                    { "ok", Ok },
                    { "message", Message }
                }, false), true);
            }
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(true);
        }
 
        public override async Task<bool> EnvironmentConfiguration()
        {
            try
            {
                await this.Test(null);
                return true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
    }
}