SmtpServer.cs

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Multipart;
using Waher.Events;
using Waher.Networking.DNS;
using Waher.Networking.SASL;
using Waher.Networking.SMTP.Exceptions;
using Waher.Networking.Sniffers;
using Waher.Persistence;
using Waher.Runtime.Cache;
using Waher.Runtime.Inventory;
using Waher.Runtime.Timing;
using Waher.Security.SPF;
 
namespace Waher.Networking.SMTP.Server
{
    public class SmtpServer : IDisposable
    {
        public const int DefaultSmtpPort = 25;
 
        public const int DefaultSmtpRelayPort = 587;
 
        public const int DefaultConnectionBacklog = 10;
 
        public const int DefaultBufferSize = 16384;
 
        public const string SmtpRelayPrivilegeID = "SMTP.Relay";
 
        private static string salutation = null;
        private static DateTime salutationExpires = DateTime.MinValue;
 
        private LinkedList<TcpListener> listeners = new LinkedList<TcpListener>();
        private Cache<Guid, SmtpClientConnection> clientConnections;
        private Cache<CaseInsensitiveString, XmlFileSniffer> sniffers;
        private X509Certificate serverCertificate;
        private readonly ISaslPersistenceLayer persistenceLayer;
        private readonly CaseInsensitiveString domain;
        private readonly bool encryptionRequired;
        private readonly int maxMessageSize;
        private readonly string[] ip4DnsBlackLists;
        private readonly string[] ip6DnsBlackLists;
        private readonly SpfExpression[] spfExpressions;
        private string smtpSnifferPath = null;
        private bool disposed = false;
        private readonly CommunicationLayer externalSniffers = new CommunicationLayer(false);
 
        private string[] relayDomains = null;
        private Regex[] relayDomainsEx = null;
        private string relayHost = string.Empty;
        private string relayUserName = string.Empty;
        private string relayPassword = string.Empty;
        private int relayPort = 587;
        private bool useRelayServer = false;
        private bool relayLocked = false;
 
        #region Constructors
 
        public SmtpServer(CaseInsensitiveString Domain, int MaxMessageSize,
            X509Certificate ServerCertificate, bool EncryptionRequired, ISaslPersistenceLayer PersistenceLayer,
            string[] Ip4DnsBlackLists, string[] Ip6DnsBlackLists, SpfExpression[] SpfExpressions)
            : this(Domain, new int[] { DefaultSmtpPort, DefaultSmtpRelayPort }, MaxMessageSize, ServerCertificate,
                EncryptionRequired, PersistenceLayer, Ip4DnsBlackLists, Ip6DnsBlackLists, SpfExpressions)
        {
        }
 
        public SmtpServer(CaseInsensitiveString Domain, int Port, int MaxMessageSize,
            X509Certificate ServerCertificate, bool EncryptionRequired, ISaslPersistenceLayer PersistenceLayer,
            string[] Ip4DnsBlackLists, string[] Ip6DnsBlackLists, SpfExpression[] SpfExpressions)
            : this(Domain, new int[] { Port }, MaxMessageSize, ServerCertificate, EncryptionRequired, PersistenceLayer,
                Ip4DnsBlackLists, Ip6DnsBlackLists, SpfExpressions)
        {
        }
 
        public SmtpServer(CaseInsensitiveString Domain, int[] Ports, int MaxMessageSize, X509Certificate ServerCertificate,
            bool EncryptionRequired, ISaslPersistenceLayer PersistenceLayer, string[] Ip4DnsBlackLists, string[] Ip6DnsBlackLists,
            SpfExpression[] SpfExpressions)
        {
            this.persistenceLayer = PersistenceLayer;
            this.serverCertificate = ServerCertificate;
            this.encryptionRequired = EncryptionRequired;
            this.domain = Domain;
            this.maxMessageSize = MaxMessageSize;
            this.ip4DnsBlackLists = Ip4DnsBlackLists;
            this.ip6DnsBlackLists = Ip6DnsBlackLists;
            this.spfExpressions = SpfExpressions;
 
            if (EncryptionRequired && this.serverCertificate is null)
                throw new ArgumentException("Server Certificate must be provided, if encryption is required.", nameof(ServerCertificate));
 
            this.clientConnections = new Cache<Guid, SmtpClientConnection>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromMinutes(2), true);
            this.clientConnections.Removed += this.ClientConnections_Removed;
 
            this.Initialize(Ports);
        }
 
        private async void Initialize(int[] Ports)
        {
            try
            {
                TcpListener Listener;
 
                foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())
                {
                    if (Interface.OperationalStatus != OperationalStatus.Up)
                        continue;
 
                    IPInterfaceProperties Properties = Interface.GetIPProperties();
 
                    foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)
                    {
                        if ((UnicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4) ||
                            (UnicastAddress.Address.AddressFamily == AddressFamily.InterNetworkV6 && Socket.OSSupportsIPv6))
                        {
                            if (!(Ports is null))
                            {
                                foreach (int Port in Ports)
                                {
                                    try
                                    {
                                        await this.externalSniffers.Information("Opening port " + Port.ToString() + " on " + UnicastAddress.Address.ToString() + ".");
 
                                        Listener = new TcpListener(UnicastAddress.Address, Port);
                                        Listener.Start(DefaultConnectionBacklog);
                                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, Listener);
                                        this.listeners.AddLast(Listener);
 
                                        await this.externalSniffers.Information("Port " + Port.ToString() + " on " + UnicastAddress.Address.ToString() + " opened.");
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex, UnicastAddress.Address.ToString() + ":" + Port);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public CommunicationLayer ExternalSniffers => this.externalSniffers;
 
        public string SmtpSnifferPath
        {
            get => this.smtpSnifferPath;
            set => this.smtpSnifferPath = value;
        }
 
        private async Task ClientConnections_Removed(object Sender, CacheItemEventArgs<Guid, SmtpClientConnection> e)
        {
            try
            {
                await this.ClientConnectionRemoved.Raise(this, new ClientConnectionEventArgs(e.Value));
                await e.Value.DisposeAsync();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public int NrClientConnections
        {
            get => this.clientConnections.Count;
        }
 
        public SmtpClientConnection[] GetClientConnections()
        {
            List<SmtpClientConnection> Connections = new List<SmtpClientConnection>();
 
            foreach (Guid Id in this.clientConnections.GetKeys())
            {
                if (this.clientConnections.TryGetValue(Id, out SmtpClientConnection Connection))
                    Connections.Add(Connection);
            }
 
            Connections.Sort((c1, c2) =>
            {
                return c1.UserName.CompareTo(c2.UserName);
            });
 
            return Connections.ToArray();
        }
 
        public bool TryGetClientConnection(Guid ID, out SmtpClientConnection Connection)
        {
            return this.clientConnections.TryGetValue(ID, out Connection);
        }
 
        public CaseInsensitiveString Domain
        {
            get => this.domain;
        }
 
        public X509Certificate ServerCertificate
        {
            get => this.serverCertificate;
        }
 
        public void UpdateCertificate(X509Certificate ServerCertificate)
        {
            this.serverCertificate = ServerCertificate;
        }
 
        public bool EncryptionRequired
        {
            get => this.encryptionRequired;
        }
 
        internal ISaslPersistenceLayer PersistenceLayer
        {
            get => this.persistenceLayer;
        }
 
        internal string[] Ip4DnsBlackLists => this.ip4DnsBlackLists;
        internal string[] Ip6DnsBlackLists => this.ip6DnsBlackLists;
        internal SpfExpression[] SpfExpressions => this.spfExpressions;
 
        public void Dispose()
        {
            this.disposed = true;
 
            if (!(this.clientConnections is null))
            {
                this.clientConnections.Clear();
                this.clientConnections.Dispose();
                this.clientConnections = null;
            }
 
            if (!(this.listeners is null))
            {
                LinkedList<TcpListener> Listeners = this.listeners;
                this.listeners = null;
 
                foreach (TcpListener Listener in Listeners)
                    Listener.Stop();
            }
 
            if (!(this.sniffers is null))
            {
                this.sniffers.Clear();
                this.sniffers.Dispose();
                this.sniffers = null;
            }
 
            if (!(this.externalSniffers is null))
            {
                foreach (ISniffer Sniffer in this.externalSniffers)
                    (Sniffer as IDisposable)?.Dispose();
            }
        }
 
        public int[] OpenPorts
        {
            get
            {
                return this.GetOpenPorts(this.listeners);
            }
        }
 
        private int[] GetOpenPorts(LinkedList<TcpListener> Listeners)
        {
            SortedDictionary<int, bool> Open = new SortedDictionary<int, bool>();
 
            if (!(Listeners is null))
            {
                IPEndPoint IPEndPoint;
 
                foreach (TcpListener Listener in Listeners)
                {
                    IPEndPoint = Listener.LocalEndpoint as IPEndPoint;
                    if (!(IPEndPoint is null))
                        Open[IPEndPoint.Port] = true;
                }
            }
 
            int[] Result = new int[Open.Count];
            Open.Keys.CopyTo(Result, 0);
 
            return Result;
        }
 
        #endregion
 
        #region Connections
 
        private async void AcceptTcpClientCallback(IAsyncResult ar)
        {
            try
            {
                if (this.disposed || NetworkingModule.Stopping)
                    return;
 
                TcpListener Listener = (TcpListener)ar.AsyncState;
 
                try
                {
                    TcpClient Client = Listener.EndAcceptTcpClient(ar);
                    SmtpClientConnection ClientConnection;
                    ISniffer[] Sniffers;
 
                    if (!string.IsNullOrEmpty(this.smtpSnifferPath))
                        Sniffers = new ISniffer[] { new InMemorySniffer() };
                    else if (this.externalSniffers.HasSniffers)
                        Sniffers = this.externalSniffers.Sniffers;
                    else
                        Sniffers = new ISniffer[0];
 
                    BinaryTcpClient BinaryTcpClient = new BinaryTcpClient(Client, false, false);
                    BinaryTcpClient.Bind(true);
 
                    ClientConnection = new SmtpClientConnection(BinaryTcpClient, this, this.persistenceLayer, this.maxMessageSize, Sniffers);
                    await ClientConnection.Information("Connection accepted from " + Client.Client.RemoteEndPoint.ToString() + ".");
 
                    this.clientConnections[ClientConnection.ID] = ClientConnection;
 
                    await this.ClientConnectionAdded.Raise(this, new ClientConnectionEventArgs(ClientConnection));
 
                    BinaryTcpClient.Continue();
                    await ClientConnection.BeginWrite("220 " + this.domain + " ESMTP Sendmail ...\r\n", null, null);
                }
                finally
                {
                    if (!this.disposed)
                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, Listener);
                }
            }
            catch (SocketException)
            {
                // Ignore
            }
            catch (ObjectDisposedException)
            {
                // Ignore
            }
            catch (NullReferenceException)
            {
                // Ignore
            }
            catch (Exception ex)
            {
                if (this.listeners is null)
                    return;
 
                Log.Exception(ex);
            }
        }
 
        internal string GetTransformPath()
        {
            foreach (ISniffer Sniffer in this.externalSniffers.Sniffers)
            {
                if (Sniffer is XmlFileSniffer XmlFileSniffer)
                    return XmlFileSniffer.Transform;
            }
 
            return null;
        }
 
        internal void Closed(SmtpClientConnection Connection)
        {
            this.clientConnections?.Remove(Connection.ID);
        }
 
        #endregion
 
        #region Accounts
 
        internal Task<IAccount> GetAccount(CaseInsensitiveString UserName)
        {
            return this.persistenceLayer.GetAccount(UserName);
        }
 
        public event EventHandlerAsync<ClientConnectionEventArgs> ClientConnectionAdded = null;
 
        public event EventHandlerAsync<ClientConnectionEventArgs> ClientConnectionRemoved = null;
 
        #endregion
 
        #region Messages
 
        public event EventHandlerAsync<SmtpMessageEventArgs> MessageReceived = null;
 
        internal Task ProcessMessage(SmtpMessage Message)
        {
            return this.MessageReceived.Raise(this, new SmtpMessageEventArgs(Message));
        }
 
        #endregion
 
        #region Sniffers
 
        internal XmlFileSniffer GetSniffer(string Key)
        {
            string FileName;
 
            FileName = this.smtpSnifferPath.Replace("%ENDPOINT%", Key);
 
            if (!(this.sniffers is null) && this.sniffers.TryGetValue(FileName, out XmlFileSniffer XmlFileSniffer))
                return XmlFileSniffer;
 
            return new XmlFileSniffer(FileName, this.GetTransformPath(), 7, BinaryPresentationMethod.ByteCount);
        }
 
        internal void CacheSniffers(IEnumerable<ISniffer> Sniffers)
        {
            foreach (ISniffer Sniffer in Sniffers)
            {
                if (Sniffer is XmlFileSniffer XmlFileSniffer)
                    this.CacheSniffer(XmlFileSniffer);
                else if (Sniffer is IDisposable Disposable)
                    Disposable.Dispose();
            }
        }
 
        internal void CacheSniffer(XmlFileSniffer Sniffer)
        {
            if (this.sniffers is null)
            {
                this.sniffers = new Cache<CaseInsensitiveString, XmlFileSniffer>(int.MaxValue, TimeSpan.MaxValue, new TimeSpan(1, 1, 0), true);
                this.sniffers.Removed += this.Sniffers_Removed;
            }
 
            this.sniffers.Add(Sniffer.FileName, Sniffer);
        }
 
        private Task Sniffers_Removed(object Sender, CacheItemEventArgs<CaseInsensitiveString, XmlFileSniffer> e)
        {
            if (this.disposed || (DateTime.Now - e.Value.LastEvent).TotalMinutes > 30)
                e.Value.Dispose();
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Relay
 
        public void SetRelaySettings(bool UseRelayServer, string HostName, int PortNumber,
            string UserName, string Password, string[] RelayDomains, bool LockSettings)
        {
            if (this.useRelayServer != UseRelayServer ||
                this.relayHost != HostName ||
                this.relayPort != PortNumber ||
                this.relayUserName != UserName ||
                this.relayPassword != Password ||
                !AreSame(this.relayDomains, RelayDomains))
            {
                if (this.relayLocked)
                    throw new InvalidOperationException("Relay settings locked.");
 
                this.useRelayServer = UseRelayServer;
                this.relayHost = HostName;
                this.relayPort = PortNumber;
                this.relayUserName = UserName;
                this.relayPassword = Password;
                this.relayDomains = RelayDomains;
                this.relayDomainsEx = null;
            }
 
            if (LockSettings)
                this.relayLocked = true;
        }
 
        private static bool AreSame(string[] A1, string[] A2)
        {
            if ((A1 is null) ^ (A2 is null))
                return false;
 
            if (A1 is null)
                return true;
 
            int c = A1.Length;
            if (c != A2.Length)
                return false;
 
            int i;
 
            for (i = 0; i < c; i++)
            {
                if (A1[i] != A2[i])
                    return false;
            }
 
            return true;
        }
 
        public bool CanRelayForDomain(string Domain)
        {
            if (this.relayDomains is null)
                return false;
 
            int i, c = this.relayDomains.Length;
 
            for (i = 0; i < c; i++)
            {
                string s = this.relayDomains[i];
 
                if (string.Compare(s, Domain, true) == 0)
                    return true;
 
                if (s.IndexOf('*') < 0)
                    continue;
 
                if (this.relayDomainsEx is null)
                    this.relayDomainsEx = new Regex[this.relayDomains.Length];
 
                if (this.relayDomainsEx[i] is null)
                    this.relayDomainsEx[i] = new Regex(Database.WildcardToRegex(s, "*"), RegexOptions.Singleline | RegexOptions.IgnoreCase);
 
                Match M = this.relayDomainsEx[i].Match(Domain);
                if (M.Success && M.Index == 0 && M.Length == Domain.Length)
                    return true;
            }
 
            return false;
        }
 
        public async Task<bool> SendMessage(CaseInsensitiveString From, CaseInsensitiveString To,
            string Subject, object[] AlternativeBodies)
        {
            int i, c = AlternativeBodies.Length;
            EmbeddedContent[] Alternatives = new EmbeddedContent[c];
 
            for (i = 0; i < c; i++)
            {
                KeyValuePair<byte[], string> P = await InternetContent.EncodeAsync(AlternativeBodies[i], Encoding.UTF8);
                byte[] EncodedBody = P.Key;
                string BodyContentType = P.Value;
                Alternatives[i] = new EmbeddedContent()
                {
                    ContentType = BodyContentType,
                    TransferDecoded = EncodedBody
                };
            }
 
            return await this.SendMessage(From, To, Subject, Alternatives, null);
        }
 
        public Task<bool> SendMessage(CaseInsensitiveString From, CaseInsensitiveString To, string Subject,
            EmbeddedContent[] Alternatives, EmbeddedContent[] Attachments)
        {
            return this.SendMessage(From, To, Subject, string.Empty, Alternatives, Attachments);
        }
 
        public async Task<bool> SendMessage(CaseInsensitiveString From, CaseInsensitiveString To, string Subject, string MessageId,
            EmbeddedContent[] Alternatives, EmbeddedContent[] Attachments)
        {
            KeyValuePair<byte[], string> P = await InternetContent.EncodeAsync(new ContentAlternatives(Alternatives), Encoding.UTF8);
            byte[] BodyBin = P.Key;
            string ContentType = P.Value;
 
            if (!(Attachments is null) && Attachments.Length > 0)
            {
                EmbeddedContent[] Mixed = new EmbeddedContent[Attachments.Length + 1];
                Mixed[0] = new EmbeddedContent()
                {
                    ContentType = ContentType,
                    Raw = BodyBin
                };
                Array.Copy(Attachments, 0, Mixed, 1, Attachments.Length);
 
                P = await InternetContent.EncodeAsync(new MixedContent(Mixed), Encoding.UTF8);
                BodyBin = P.Key;
                ContentType = P.Value;
            }
 
            DateTime Now = DateTime.Now;
            List<KeyValuePair<string, string>> Headers = new List<KeyValuePair<string, string>>()
            {
                new KeyValuePair<string, string>("MIME-VERSION", "1.0"),
                new KeyValuePair<string, string>("FROM", From),
                new KeyValuePair<string, string>("TO", To),
                new KeyValuePair<string, string>("SUBJECT", Subject),
                new KeyValuePair<string, string>("DATE", CommonTypes.EncodeRfc822(Now)),
                new KeyValuePair<string, string>("IMPORTANCE", "normal"),
                new KeyValuePair<string, string>("X-PRIORITY", "3"),
                new KeyValuePair<string, string>("MESSAGE-ID", string.IsNullOrEmpty(MessageId) ? Guid.NewGuid().ToString() : MessageId),
                new KeyValuePair<string, string>("CONTENT-TYPE", ContentType)
            };
 
            return await this.SendMessage(From, To, Headers.ToArray(), BodyBin, Now);
        }
 
        public async Task<bool> SendMessage(CaseInsensitiveString From, CaseInsensitiveString To, KeyValuePair<string, string>[] Headers,
            byte[] Data, DateTime Start)
        {
            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.relayHost;
                Port = this.relayPort;
                UserName = this.relayUserName;
                Password = this.relayPassword;
            }
            else
            {
                string[] Exchanges = await DnsResolver.LookupMailExchange(Domain);
                if (Exchanges is null || Exchanges.Length == 0)
                    throw new ArgumentException("No mail exchange at " + Domain + ".", nameof(To));
 
                Host = Exchanges[SmtpClientConnection.Next(Exchanges.Length)];
                Port = DefaultSmtpPort;
                UserName = null;
                Password = null;
            }
 
            return await this.SendMessage(Domain, Host, Port, UserName, Password, From, To, Headers, Data, Start);
        }
 
        public async Task<bool> SendMessage(string Domain, string Host, int Port, string UserName, string Password,
            CaseInsensitiveString From, CaseInsensitiveString To, KeyValuePair<string, string>[] Headers, byte[] Data, DateTime Start)
        {
            Exception Exception = null;
            bool Retry = false;
 
            try
            {
                using (SimpleSmtpClient Client = new SimpleSmtpClient(Domain, Host, Port, UserName, Password,
                    this.GetSniffer(Host + " OUT")))
                {
                    await Client.Connect();
                    await Client.EHLO(await GetSalutation(this.domain));    // Also performs Encryption & Authentication handshakes, as required.
                    await Client.MAIL_FROM(From);
                    await Client.RCPT_TO(To);
                    await Client.DATA(Headers, Data);
                    await Client.QUIT();
                }
 
                return true;
            }
            catch (TimeoutException ex)
            {
                Exception = ex;
                Retry = true;
            }
            catch (SmtpTemporaryErrorException ex)
            {
                Exception = ex;
                Retry = true;
            }
            catch (Exception ex)
            {
                Exception = ex;
                Retry = false;
            }
 
            if (!Retry ||
                !Types.TryGetModuleParameter("Scheduler", out object Obj) ||
                !(Obj is Scheduler Scheduler))
            {
                Log.Error("Unable to send message.\r\n\r\n" + Exception?.Message,
                    new KeyValuePair<string, object>("From", From),
                    new KeyValuePair<string, object>("To", To));
 
                // TODO: Mail error message back to sender.
 
                return false;
            }
 
            DateTime TP = DateTime.Now;
            double Minutes = (TP - Start).TotalMinutes;
 
            if (Minutes >= 24 * 60)
                return false;
 
            if (Minutes < 5)
                TP = TP.AddMinutes(1);
            else if (Minutes < 60)
                TP = TP.AddMinutes(5);
            else
                TP = TP.AddMinutes(15);
 
            // TODO: Mail message (only once) back to sender saying a temporary error occurred, but that new attempts will be made.
            //          (make configurable/controllable by argument)
 
            Scheduler.Add(TP, this.Resend, new object[] { Domain, Host, Port, UserName, Password, From, To, Headers, Data, Start });
 
            return true;
        }
 
        private async void Resend(object State)
        {
            try
            {
                object[] P = (object[])State;
                string Domain = (string)P[0];
                string Host = (string)P[1];
                int Port = (int)P[2];
                string UserName = (string)P[3];
                string Password = (string)P[4];
                CaseInsensitiveString From = (CaseInsensitiveString)P[5];
                CaseInsensitiveString To = (CaseInsensitiveString)P[6];
                KeyValuePair<string, string>[] Headers = (KeyValuePair<string, string>[])P[7];
                byte[] Data = (byte[])P[8];
                DateTime Start = (DateTime)P[9];
 
                await this.SendMessage(Domain, Host, Port, UserName, Password, From, To, Headers, Data, Start);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public static async Task<string> GetSalutation(string DefaultDomain)
        {
            if (salutationExpires < DateTime.Now)
                salutation = null;
 
            if (salutation is null)
            {
                try
                {
                    foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())
                    {
                        if (Interface.OperationalStatus != OperationalStatus.Up)
                            continue;
 
                        IPInterfaceProperties Properties = Interface.GetIPProperties();
 
                        foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)
                        {
                            if (UnicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4)
                            {
                                if (IsPublicAddress(UnicastAddress.Address))
                                {
                                    try
                                    {
                                        string AddrStr = UnicastAddress.Address.ToString();
                                        string[] Names = await DnsResolver.LookupDomainName(UnicastAddress.Address);
 
                                        foreach (string Name in Names)
                                        {
                                            try
                                            {
                                                IPAddress[] Addresses = await DnsResolver.LookupIP4Addresses(Name);
 
                                                foreach (IPAddress Addr in Addresses)
                                                {
                                                    if (Addr.ToString() == AddrStr)
                                                    {
                                                        salutation = Name;
                                                        break;
                                                    }
                                                }
 
                                                if (!(salutation is null))
                                                    break;
                                            }
                                            catch (Exception)
                                            {
                                                // Ignore
                                            }
                                        }
 
                                        if (!(salutation is null))
                                            break;
                                    }
                                    catch (Exception)
                                    {
                                        // Ignore
                                    }
                                }
                            }
                        }
 
                        if (!(salutation is null))
                            break;
                    }
                }
                catch (Exception)
                {
                    // Ignore
                }
 
                if (salutation is null)
                    salutation = DefaultDomain;
 
                salutationExpires = DateTime.Now.AddHours(1);
            }
 
            return salutation;
        }
 
        public static bool IsPublicAddress(IPAddress Address)
        {
            if (Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4)
            {
                byte[] Addr = Address.GetAddressBytes();
 
                if (Addr[0] == 127)
                    return false;   // Loopback address range: 127.0.0.0 - 127.255.255.55
 
                else if (Addr[0] == 10)
                    return false;   // Private address range: 10.0.0.0 - 10.255.255.55
 
                else if (Addr[0] == 172 && Addr[1] >= 16 && Addr[1] <= 31)
                    return false;   // Private address range: 172.16.0.0 - 172.31.255.255
 
                else if (Addr[0] == 192 && Addr[1] == 168)
                    return false;   // Private address range: 192.168.0.0 - 192.168.255.255
 
                else if (Addr[0] == 169 && Addr[1] == 254)
                    return false;   // Link-local address range: 169.254.0.0 - 169.254.255.255
 
                return true;
            }
            else
                return false;
        }
        #endregion
 
    }
}