DnsResolver.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.DNS.Communication;
using Waher.Networking.DNS.Enumerations;
using Waher.Networking.DNS.ResourceRecords;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Profiling;
 
namespace Waher.Networking.DNS
{
    public static class DnsResolver
    {
        public const int DefaultDnsPort = 53;
 
        private static readonly Regex arpanetHostName = new Regex(@"^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?([.][a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$", RegexOptions.Compiled | RegexOptions.Singleline);
        private static readonly object synchObject = new object();
        private static readonly Random rnd = new Random();
        private static ushort nextId = 0;
        private static DnsHttpsClient httpsClient = null;
        private static DnsUdpClient udpClient = null;
        private static bool networkChanged = false;
        private static int nestingDepth = 0;
 
        static DnsResolver()
        {
            try
            {
                NetworkChange.NetworkAddressChanged += (Sender, e) => networkChanged = true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public static Uri DnsOverHttpsUri
        {
            get => httpsClient?.Uri;
            set
            {
                if (value is null)
                {
                    httpsClient?.Dispose();
                    httpsClient = null;
                }
                else if (httpsClient is null)
                    httpsClient = new DnsHttpsClient(value);
                else
                    httpsClient.Uri = value;
            }
        }
 
        public static IPAddress[] DnsServerAddresses
        {
            get
            {
                List<IPAddress> Addresses = new List<IPAddress>();
 
                NetworkInterface[] Interfaces = NetworkInterface.GetAllNetworkInterfaces();
                foreach (NetworkInterface Interface in Interfaces)
                {
                    if (Interface.OperationalStatus == OperationalStatus.Up)
                    {
                        foreach (IPAddress Address in Interface.GetIPProperties().DnsAddresses)
                        {
                            if (!Addresses.Contains(Address))
                                Addresses.Add(Address);
                        }
                    }
                }
 
                return Addresses.ToArray();
            }
        }
 
        public static bool IsValidArpanetHostName(string HostName)
        {
            if (HostName.Length > 255)
                return false;
 
            Match M;
 
            lock (arpanetHostName)
            {
                M = arpanetHostName.Match(HostName);
            }
 
            return (M.Success && M.Index == 0 && M.Length == HostName.Length);
        }
 
        internal static ushort NextID
        {
            get
            {
                lock (synchObject)
                {
                    return nextId++;
                }
            }
        }
 
        public static Task<ResourceRecord[]> Resolve(string Name, QTYPE TYPE, QCLASS CLASS)
        {
            return Resolve(Name, TYPE, null, CLASS, null);
        }
 
        public static Task<ResourceRecord[]> Resolve(string Name, QTYPE TYPE, QCLASS CLASS, ProfilerThread Thread)
        {
            return Resolve(Name, TYPE, null, CLASS, Thread);
        }
 
        public static Task<ResourceRecord[]> Resolve(string Name, QTYPE TYPE, TYPE? ExceptionType, QCLASS CLASS)
        {
            return Resolve(Name, TYPE, ExceptionType, CLASS, null);
        }
 
        public static async Task<ResourceRecord[]> Resolve(string Name, QTYPE TYPE, TYPE? ExceptionType, QCLASS CLASS, ProfilerThread Thread)
        {
            ResourceRecord[] Result = await TryResolve(Name, TYPE, ExceptionType, CLASS, Thread)
                ?? throw new GenericException("Unable to resolve DNS query: " + Name,
                null, Name, null, null, null, null, null,
                new KeyValuePair<string, object>("Name", Name),
                new KeyValuePair<string, object>("TYPE", TYPE),
                new KeyValuePair<string, object>("CLASS", CLASS));
 
            return Result;
        }
 
        public static Task<ResourceRecord[]> TryResolve(string Name, QTYPE TYPE, QCLASS CLASS)
        {
            return TryResolve(Name, TYPE, null, CLASS, null);
        }
 
        public static Task<ResourceRecord[]> TryResolve(string Name, QTYPE TYPE, QCLASS CLASS, ProfilerThread Thread)
        {
            return TryResolve(Name, TYPE, null, CLASS, Thread);
        }
 
        public static Task<ResourceRecord[]> TryResolve(string Name, QTYPE TYPE, TYPE? ExceptionType, QCLASS CLASS)
        {
            return TryResolve(Name, TYPE, ExceptionType, CLASS, null);
        }
 
        public static async Task<ResourceRecord[]> TryResolve(string Name, QTYPE TYPE, TYPE? ExceptionType, QCLASS CLASS, ProfilerThread Thread)
        {
            LinkedList<KeyValuePair<string, IPEndPoint>> Backup = null;
            TYPE? ExpectedType;
            IPEndPoint Destination = null;
            int Timeout = 5000;     // Local timeout
 
            if (Enum.TryParse(TYPE.ToString(), out TYPE T))
                ExpectedType = T;
            else
                ExpectedType = null;
 
            Thread?.NewState("Client");
 
            lock (synchObject)
            {
                if (nestingDepth == 0 && networkChanged)
                {
                    networkChanged = false;
                    udpClient?.Dispose();
                    udpClient = null;
                }
 
                if (udpClient is null)
                    udpClient = new DnsUdpClient();
 
                nestingDepth++;
            }
 
            try
            {
                while (true)
                {
                    Thread?.NewState("Query");
 
                    DnsResponse Response = await TryQuery(Name, TYPE, CLASS, Timeout, Destination, false, Thread);
                    string CName = null;
 
                    if (Response is null)
                    {
                        Destination = await NextDestination(Backup);
                        if (Destination is null)
                            return null;
 
                        continue;   // Check an alternative
                    }
 
                    if (!(Response.Answer is null))
                    {
                        if (!ExpectedType.HasValue)
                            return Response.Answer;
 
                        foreach (ResourceRecord RR in Response.Answer)
                        {
                            if (RR.Type == ExpectedType.Value)
                                return Response.Answer;
 
                            if (CName is null && RR.Type == Enumerations.TYPE.CNAME && RR is CNAME CNAME)
                                CName = CNAME.Name2;
                        }
 
                        if (ExceptionType.HasValue)
                        {
                            foreach (ResourceRecord RR in Response.Answer)
                            {
                                if (RR.Type == ExceptionType.Value)
                                    return Response.Answer;
                            }
                        }
 
                        if (!(CName is null))
                        {
                            Name = CName;
                            Backup = null;
                            continue;
                        }
                    }
 
                    if (!(Response.Authority is null))
                    {
                        foreach (ResourceRecord RR in Response.Authority)
                        {
                            if (RR is NS NS)
                            {
                                string Authority = NS.Name2;
                                IPAddress AuthorityAddress = null;
 
                                if (!(Response.Additional is null))
                                {
                                    foreach (ResourceRecord RR2 in Response.Additional)
                                    {
                                        if (RR2 is A A)
                                        {
                                            AuthorityAddress = A.Address;
                                            break;
                                        }
                                        else if (RR2 is AAAA AAAA)
                                        {
                                            AuthorityAddress = AAAA.Address;
                                            break;
                                        }
                                    }
                                }
 
                                if (Backup is null)
                                    Backup = new LinkedList<KeyValuePair<string, IPEndPoint>>();
 
                                if (AuthorityAddress is null)
                                    Backup.AddLast(new KeyValuePair<string, IPEndPoint>(Authority, null));
                                else
                                    Backup.AddLast(new KeyValuePair<string, IPEndPoint>(null, new IPEndPoint(AuthorityAddress, DefaultDnsPort)));
                            }
                        }
                    }
 
                    Destination = await NextDestination(Backup);
                    if (Destination is null)
                        return null;
 
                    Timeout = 5000;
                }
            }
            catch (Exception)
            {
                return null;
            }
            finally
            {
                lock (synchObject)
                {
                    nestingDepth--;
                }
            }
        }
 
        public static Task<DnsResponse> Query(string Name, QTYPE TYPE, QCLASS CLASS)
        {
            return Query(Name, TYPE, CLASS, null);
        }
 
        public static async Task<DnsResponse> Query(string Name, QTYPE TYPE, QCLASS CLASS, ProfilerThread Thread)
        {
            DnsResponse Result = await TryQuery(Name, TYPE, CLASS, Thread)
                ?? throw new GenericException("Domain name not found: " + Name,
                null, Name, null, null, null, null, null,
                new KeyValuePair<string, object>("Name", Name),
                new KeyValuePair<string, object>("TYPE", TYPE),
                new KeyValuePair<string, object>("CLASS", CLASS));
 
            return Result;
        }
 
        public static Task<DnsResponse> TryQuery(string Name, QTYPE TYPE, QCLASS CLASS)
        {
            return TryQuery(Name, TYPE, CLASS, null);
        }
 
        public static Task<DnsResponse> TryQuery(string Name, QTYPE TYPE, QCLASS CLASS, ProfilerThread Thread)
        {
            lock (synchObject)
            {
                if (nestingDepth == 0 && networkChanged)
                {
                    networkChanged = false;
                    udpClient?.Dispose();
                    udpClient = null;
                }
 
                if (udpClient is null)
                    udpClient = new DnsUdpClient();
 
                nestingDepth++;
            }
 
            try
            {
                return TryQuery(Name, TYPE, CLASS, 2000, null, true, Thread);
            }
            finally
            {
                lock (synchObject)
                {
                    nestingDepth--;
                }
            }
        }
 
        private static async Task<DnsResponse> TryQuery(string Name, QTYPE TYPE, QCLASS CLASS, int Timeout, IPEndPoint Destination,
            bool ReturnRaw, ProfilerThread Thread)
        {
            DnsResponse Response;
            DnsMessage Message;
 
            if (Database.HasProvider)
            {
                try
                {
                    Thread?.NewState("Search");
 
                    IEnumerable<DnsResponse> Records = await Database.Find<DnsResponse>();
 
                    Response = await Database.FindFirstDeleteRest<DnsResponse>(new FilterAnd(
                        new FilterFieldEqualTo("Name", Name),
                        new FilterFieldEqualTo("Type", TYPE),
                        new FilterFieldEqualTo("Class", CLASS)));
 
                    if (!(Response is null) && (Response.Expires <= DateTime.Now || Response.Raw is null))
                    {
                        await Database.Delete(Response);
                        Response = null;
                    }
                }
                catch (Exception ex)
                {
                    Thread?.Exception(ex);
 
                    // Some inconsistency in database. Clear collection to get fresh set of DNS entries.
                    await Database.Clear("DnsCache");
                    Response = null;
                }
            }
            else
                Response = null;
 
            if (Response is null)
            {
                bool Save = true;
                DnsClient Client;
 
                if (Destination is null)
                {
                    Client = httpsClient;
                    if (Client is null)
                    {
                        Client = udpClient;
                        Thread?.NewState("UDP");
                    }
                    else
                        Thread?.NewState("HTTPS");
                }
                else
                {
                    Client = udpClient;
                    Thread?.NewState("UDP");
                }
 
                Client.Thread = Thread;
 
                try
                {
                    Message = await Client.SendRequestAsync(OpCode.Query, true, new Question[]
                    {
                        new Question(Name, TYPE, CLASS)
                    }, Destination, Timeout);
 
                    switch (Message.RCode)
                    {
                        case RCode.NXDomain:
                            if (ReturnRaw)
                                Save = false;
                            else
                                return null;
                            break;
                    }
                }
                catch (TimeoutException ex)
                {
                    Thread?.Exception(ex);
                    Message = null;
                }
                finally
                {
                    Client.Thread = null;
                }
 
                if (Message is null || Message.RCode != RCode.NoError)
                {
                    if (ReturnRaw)
                        Save = false;
                    else
                        return null;
                }
 
                uint Ttl = 60 * 60 * 24 * 30;       // Maximum TTL = 30 days
 
                Response = new DnsResponse()
                {
                    Name = Name,
                    Type = TYPE,
                    Class = CLASS,
                    Answer = CheckTtl(ref Ttl, Message?.Answer),
                    Authority = CheckTtl(ref Ttl, Message?.Authority),
                    Additional = CheckTtl(ref Ttl, Message?.Additional),
                    Raw = Message?.Binary,
                    Expires = DateTime.Now.AddSeconds(Ttl)
                };
 
                if (Save && Database.HasProvider)
                {
                    Thread?.NewState("Store");
                    try
                    {
                        await Database.Insert(Response);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
 
            return Response;
        }
 
        private static async Task<IPEndPoint> NextDestination(LinkedList<KeyValuePair<string, IPEndPoint>> Backup)
        {
            IPEndPoint Destination = null;
 
            while (Destination is null && !(Backup?.First is null))
            {
                KeyValuePair<string, IPEndPoint> P = Backup.First.Value;
                Backup.RemoveFirst();
 
                Destination = P.Value;
 
                if (Destination is null)
                {
                    IPAddress[] Addresses;
 
                    try
                    {
                        Addresses = await LookupIP4Addresses(P.Key);
                    }
                    catch (Exception)
                    {
                        Addresses = null;
                    }
 
                    if (Addresses is null || Addresses.Length == 0)
                    {
                        try
                        {
                            Addresses = await LookupIP6Addresses(P.Key);
                        }
                        catch (Exception)
                        {
                            Addresses = null;
                        }
                    }
 
                    if (!(Addresses is null))
                    {
                        foreach (IPAddress Address in Addresses)
                        {
                            IPEndPoint EP = new IPEndPoint(Address, DefaultDnsPort);
 
                            if (Destination is null)
                                Destination = EP;
                            else
                            {
                                if (Backup is null)
                                    Backup = new LinkedList<KeyValuePair<string, IPEndPoint>>();
 
                                Backup.AddLast(new KeyValuePair<string, IPEndPoint>(null, EP));
                            }
                        }
                    }
                }
            }
 
            return Destination;
        }
 
        private static ResourceRecord[] CheckTtl(ref uint Ttl, ResourceRecord[] Records)
        {
            if (!(Records is null))
            {
                foreach (ResourceRecord RR in Records)
                {
                    if (RR.Ttl < Ttl)
                        Ttl = RR.Ttl;
                }
            }
 
            return Records;
        }
 
        public static Task<IPAddress[]> LookupIP4Addresses(string DomainName)
        {
            return LookupIP4Addresses(DomainName, false);
        }
 
        public static Task<IPAddress[]> TryLookupIP4Addresses(string DomainName)
        {
            return LookupIP4Addresses(DomainName, true);
        }
 
        private static async Task<IPAddress[]> LookupIP4Addresses(string DomainName, bool Try)
        {
            ResourceRecord[] Records;
 
            if (Try)
            {
                Records = await TryResolve(DomainName, QTYPE.A, QCLASS.IN);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(DomainName, QTYPE.A, QCLASS.IN);
 
            List<IPAddress> Result = new List<IPAddress>();
 
            foreach (ResourceRecord RR in Records)
            {
                if (RR is A A)
                    Result.Add(A.Address);
            }
 
            return Result.ToArray();
        }
 
        public static Task<IPAddress[]> LookupIP6Addresses(string DomainName)
        {
            return LookupIP6Addresses(DomainName, false);
        }
 
        public static Task<IPAddress[]> TryLookupIP6Addresses(string DomainName)
        {
            return LookupIP6Addresses(DomainName, true);
        }
 
        private static async Task<IPAddress[]> LookupIP6Addresses(string DomainName, bool Try)
        {
            ResourceRecord[] Records;
 
            if (Try)
            {
                Records = await TryResolve(DomainName, QTYPE.AAAA, QCLASS.IN);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(DomainName, QTYPE.AAAA, QCLASS.IN);
 
            List<IPAddress> Result = new List<IPAddress>();
 
            foreach (ResourceRecord RR in await Resolve(DomainName, QTYPE.AAAA, QCLASS.IN))
            {
                if (RR is AAAA AAAA)
                    Result.Add(AAAA.Address);
            }
 
            return Result.ToArray();
        }
 
        public static Task<string[]> LookupMailExchange(string DomainName)
        {
            return LookupMailExchange(DomainName, false);
        }
 
        public static Task<string[]> TryLookupMailExchange(string DomainName)
        {
            return LookupMailExchange(DomainName, true);
        }
 
        private static async Task<string[]> LookupMailExchange(string DomainName, bool Try)
        {
            ResourceRecord[] RRs;
 
            if (Try)
            {
                RRs = await TryResolve(DomainName, QTYPE.MX, TYPE.A, QCLASS.IN);
                if (RRs is null)
                    return null;
            }
            else
                RRs = await Resolve(DomainName, QTYPE.MX, TYPE.A, QCLASS.IN);
 
            List<MX> Records = new List<MX>();
 
            foreach (ResourceRecord RR in RRs)
            {
                if (RR is MX MX)
                    Records.Add(MX);
            }
 
            if (Records.Count == 0)
            {
                foreach (ResourceRecord RR in RRs)
                {
                    if (RR is A A)
                        Records.Add(new MX() { Exchange = A.Address.ToString() });
                }
            }
            else
                Records.Sort((r1, r2) => r2.Preference - r1.Preference);    // Descending
 
            int i, c = Records.Count;
            string[] Result = new string[c];
 
            for (i = 0; i < c; i++)
                Result[i] = Records[i].Exchange;
 
            return Result;
        }
 
        public static string AddressToName(IPAddress Address, string IP4DomainName, string IP6DomainName)
        {
            byte[] Bin = Address.GetAddressBytes();
 
            switch (Bin.Length)
            {
                case 4:
                    if (string.IsNullOrEmpty(IP4DomainName))
                        throw new ArgumentOutOfRangeException("IPv4 addresses not supported.");
 
                    StringBuilder sb = new StringBuilder();
                    int i;
 
                    for (i = 3; i >= 0; i--)
                    {
                        sb.Append(Bin[i].ToString());
                        sb.Append('.');
                    }
 
                    sb.Append(IP4DomainName);
 
                    return sb.ToString();
 
                case 16:
                    if (string.IsNullOrEmpty(IP6DomainName))
                        throw new ArgumentOutOfRangeException("IPv6 addresses not supported.");
 
                    byte b, b2;
 
                    sb = new StringBuilder();
 
                    for (i = 15; i >= 0; i--)
                    {
                        b = Bin[i];
                        b2 = (byte)(b & 15);
                        if (b2 < 10)
                            sb.Append((char)('0' + b2));
                        else
                            sb.Append((char)('A' + b2 - 10));
 
                        sb.Append('.');
 
                        b2 = (byte)(b >> 4);
                        if (b2 < 10)
                            sb.Append((char)('0' + b2));
                        else
                            sb.Append((char)('A' + b2 - 10));
 
                        sb.Append('.');
                    }
 
                    sb.Append(IP6DomainName);
 
                    return sb.ToString();
 
                default:
                    throw new ArgumentOutOfRangeException("Unrecognized IP address.", nameof(Address));
            }
        }
 
        public static Task<string[]> LookupDomainName(IPAddress Address)
        {
            return LookupDomainName(Address, false);
        }
 
        public static Task<string[]> TryLookupDomainName(IPAddress Address)
        {
            return LookupDomainName(Address, true);
        }
 
        private static async Task<string[]> LookupDomainName(IPAddress Address, bool Try)
        {
            string Name = AddressToName(Address, "IN-ADDR.ARPA", "IP6.ARPA");
            ResourceRecord[] Records;
 
            if (Try)
            {
                Records = await TryResolve(Name, QTYPE.PTR, QCLASS.IN);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(Name, QTYPE.PTR, QCLASS.IN);
 
            List<string> Result = new List<string>();
 
            foreach (ResourceRecord RR in Records)
            {
                if (RR is PTR PTR)
                    Result.Add(PTR.Name2);
            }
 
            return Result.ToArray();
        }
 
        public static Task<string[]> LookupText(string Name)
        {
            return LookupText(Name, false);
        }
 
        public static Task<string[]> TryLookupText(string Name)
        {
            return LookupText(Name, true);
        }
 
        private static async Task<string[]> LookupText(string Name, bool Try)
        {
            ResourceRecord[] Records;
 
            if (Try)
            {
                Records = await TryResolve(Name, QTYPE.TXT, QCLASS.IN);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(Name, QTYPE.TXT, QCLASS.IN);
 
            List<string> Result = new List<string>();
 
            foreach (ResourceRecord RR in Records)
            {
                if (RR is TXT TXT)
                    Result.AddRange(TXT.Text);
            }
 
            return Result.ToArray();
        }
 
        public static async Task<string[]> LookupBlackList(IPAddress Address, string BlackListDomainName)
        {
            string Name = AddressToName(Address, BlackListDomainName, null);
            ResourceRecord[] As;
 
            As = await TryResolve(Name, QTYPE.A, QCLASS.IN);
            if (As is null)
                return null;
 
            List<string> Result = null;
 
            ResourceRecord[] Records = await TryResolve(Name, QTYPE.TXT, QCLASS.IN);
            if (!(Records is null))
            {
                foreach (ResourceRecord RR in Records)
                {
                    if (RR is TXT TXT)
                    {
                        if (Result is null)
                            Result = new List<string>();
 
                        Result.AddRange(TXT.Text);
                    }
                }
            }
 
            if (!(Result is null))
                return Result.ToArray();
 
            foreach (ResourceRecord RR in As)
            {
                if (RR is A A)
                {
                    if (Result is null)
                        Result = new List<string>();
 
                    Result.Add(A.Address.ToString());
                }
            }
 
            return Result?.ToArray();
        }
 
        public static Task<SRV> LookupServiceEndpoint(string DomainName, string ServiceName, string Protocol)
        {
            return LookupServiceEndpoint(DomainName, ServiceName, Protocol, null, false);
        }
 
        public static Task<SRV> LookupServiceEndpoint(string DomainName, string ServiceName, string Protocol, ProfilerThread Thread)
        {
            return LookupServiceEndpoint(DomainName, ServiceName, Protocol, Thread, false);
        }
 
        public static Task<SRV> TryLookupServiceEndpoint(string DomainName, string ServiceName, string Protocol)
        {
            return LookupServiceEndpoint(DomainName, ServiceName, Protocol, null, true);
        }
 
        public static Task<SRV> TryLookupServiceEndpoint(string DomainName, string ServiceName, string Protocol, ProfilerThread Thread)
        {
            return LookupServiceEndpoint(DomainName, ServiceName, Protocol, Thread, true);
        }
 
        private static async Task<SRV> LookupServiceEndpoint(string DomainName, string ServiceName, string Protocol, ProfilerThread Thread, bool Try)
        {
            Thread?.NewState("Resolve");
 
            string Name = "_" + ServiceName + "._" + Protocol.ToLower() + "." + DomainName;
            ResourceRecord[] Records;
 
            if (Try)
            {
                Records = await TryResolve(Name, QTYPE.SRV, QCLASS.IN, Thread);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(Name, QTYPE.SRV, QCLASS.IN, Thread);
 
            SortedDictionary<ushort, List<SRV>> ServicesByPriority = new SortedDictionary<ushort, List<SRV>>();
            List<SRV> SamePriority;
 
            foreach (ResourceRecord RR in Records)
            {
                if (RR is SRV SRV)
                {
                    if (!ServicesByPriority.TryGetValue(SRV.Priority, out SamePriority))
                    {
                        SamePriority = new List<SRV>();
                        ServicesByPriority[SRV.Priority] = SamePriority;
                    }
 
                    SamePriority.Add(SRV);
                }
            }
 
            Thread?.NewState("Select");
 
            while (true)
            {
                ushort? FirstKey = null;
 
                SamePriority = null;
                foreach (KeyValuePair<ushort, List<SRV>> P in ServicesByPriority)
                {
                    FirstKey = P.Key;
                    SamePriority = P.Value;
                    break;
                }
 
                if (!FirstKey.HasValue)
                    throw new IOException("Service Endpoint not found.");
 
                int TotWeight = 0;
                int i;
 
                foreach (SRV SRV in SamePriority)
                    TotWeight += SRV.Weight;
 
                SRV Selected = null;
 
                if (TotWeight > 0)
                {
                    lock (rnd)
                    {
                        i = rnd.Next(TotWeight);
                    }
 
                    foreach (SRV SRV in SamePriority)
                    {
                        if (i < SRV.Weight)
                        {
                            Selected = SRV;
                            SamePriority.Remove(SRV);
                            if (SamePriority.Count == 0)
                                ServicesByPriority.Remove(FirstKey.Value);
                            break;
                        }
                        else
                            i -= SRV.Weight;
                    }
                }
                else
                {
                    foreach (SRV SRV in SamePriority)
                    {
                        Selected = SRV;
                        SamePriority.Remove(SRV);
                        if (SamePriority.Count == 0)
                            ServicesByPriority.Remove(FirstKey.Value);
                        break;
                    }
                }
 
                // TODO: Check host availability on the given port... If not available, continue with next.
 
                if (Selected is null)
                    ServicesByPriority.Remove(FirstKey.Value);
                else if (Selected.TargetHost != ".")
                    return Selected;
            }
        }
 
        public static Task<SRV[]> LookupServiceEndpoints(string DomainName, string ServiceName, string Protocol)
        {
            return LookupServiceEndpoints(DomainName, ServiceName, Protocol, false);
        }
 
        public static Task<SRV[]> TryLookupServiceEndpoints(string DomainName, string ServiceName, string Protocol)
        {
            return LookupServiceEndpoints(DomainName, ServiceName, Protocol, true);
        }
 
        private static async Task<SRV[]> LookupServiceEndpoints(string DomainName, string ServiceName, string Protocol, bool Try)
        {
            string Name = "_" + ServiceName + "._" + Protocol.ToLower() + "." + DomainName;
            List<SRV> Result = new List<SRV>();
 
            foreach (ResourceRecord RR in await Resolve(Name, QTYPE.SRV, QCLASS.IN))
            {
                if (RR is SRV SRV)
                    Result.Add(SRV);
            }
 
            return Result.ToArray();
        }
 
        public static int Next(int MaxValue)
        {
            lock (rnd)
            {
                return rnd.Next(MaxValue);
            }
        }
 
        public static Task<string[]> ReverseDns(IPAddress Address)
        {
            return ReverseDns(Address, false);
        }
 
        public static Task<string[]> TryReverseDns(IPAddress Address)
        {
            return ReverseDns(Address, true);
        }
 
        private static async Task<string[]> ReverseDns(IPAddress Address, bool Try)
        {
            StringBuilder sb = new StringBuilder();
            byte[] Bytes = Address.GetAddressBytes();
            int i = Bytes.Length;
 
            if (Address.AddressFamily == AddressFamily.InterNetwork)
            {
                while (i-- > 0)
                {
                    sb.Append(Bytes[i].ToString());
                    sb.Append('.');
                }
 
                sb.Append("in-addr.arpa");
            }
            else if (Address.AddressFamily == AddressFamily.InterNetworkV6)
            {
                Address.GetAddressBytes();
 
                while (i-- > 0)
                {
                    byte b = Bytes[i];
 
                    sb.Append((b & 15).ToString("x1"));
                    sb.Append('.');
 
                    sb.Append((b >> 4).ToString("x1"));
                    sb.Append('.');
                }
 
                sb.Append("ip6.arpa");
            }
            else
                throw new ArgumentException("Unsupported address family.", nameof(Address));
 
            ResourceRecord[] Records;
            
            if (Try)
            {
                Records = await TryResolve(sb.ToString(), QTYPE.PTR, QCLASS.IN);
                if (Records is null)
                    return null;
            }
            else
                Records = await Resolve(sb.ToString(), QTYPE.PTR, QCLASS.IN);
 
            List<string> Names = new List<string>();
 
            foreach (ResourceRecord Rec in Records)
            {
                if (Rec is PTR PtrRecord)
                    Names.Add(PtrRecord.Name2);
            }
 
            return Names.ToArray();
        }
 
    }
}