Improve dns lookup

Source/NETworkManager/Helpers/HistoryListHelper.cs → Source/NETworkManager/Helpers/ListHelper.cs

@@ -2,7 +2,7 @@
 
 namespace NETworkManager.Helpers
 {
-    public static class HistoryListHelper
+    public static class ListHelper
     {
         public static List<string> Modify(List<string> list, string entry, int length)
         {

Source/NETworkManager/MainWindow.xaml

@@ -595,9 +595,9 @@
                                     <ColumnDefinition Width="Auto" />
                                     <ColumnDefinition Width="*" />
                                 </Grid.ColumnDefinitions>
-                                <Rectangle Grid.Column="0" Width="24" Height="24">
+                                <Rectangle Grid.Column="0" Width="20" Height="20">
                                     <Rectangle.OpacityMask>
-                                        <VisualBrush Stretch="Uniform" Visual="{IconPacks:MaterialLight Kind=ArrowLeftCircle}" />
+                                        <VisualBrush Stretch="Uniform" Visual="{IconPacks:MaterialLight Kind=ArrowLeft}" />
                                     </Rectangle.OpacityMask>
                                     <Rectangle.Style>
                                         <Style TargetType="{x:Type Rectangle}">

Source/NETworkManager/Models/Network/DNSLookup.cs

@@ -1,14 +1,17 @@
 using Heijden.DNS;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net;
+using System.Net.NetworkInformation;
 using System.Threading.Tasks;
 
 namespace NETworkManager.Models.Network
 {
     public class DNSLookup
     {
         #region Variables
-        Resolver DNSResolver = new Resolver();
+        Resolver dnsResolver = new Resolver();
         #endregion
 
         #region Events
@@ -26,103 +29,145 @@ protected virtual void OnLookupError(DNSLookupErrorArgs e)
             LookupError?.Invoke(this, e);
         }
 
-        public event EventHandler<DNSLookupCompleteArgs> LookupComplete;
+        public event EventHandler LookupComplete;
 
-        protected virtual void OnLookupComplete(DNSLookupCompleteArgs e)
+        protected virtual void OnLookupComplete()
         {
-            LookupComplete?.Invoke(this, e);
+            LookupComplete?.Invoke(this, EventArgs.Empty);
         }
         #endregion
 
         #region Methods        
-        public void LookupAsync(string hostnameOrIPAddress, DNSLookupOptions DNSLookupOptions)
+        public void LookupAsync(List<string> hosts, DNSLookupOptions dnsLookupOptions)
         {
             Task.Run(() =>
             {
-                // This will convert the query to an Arpa request
-                if (DNSLookupOptions.Type == QType.PTR)
+                // DNS server list
+                List<string> dnsServers = new List<string>();
+
+                if (dnsLookupOptions.UseCustomDNSServer)
+                    dnsLookupOptions.CustomDNSServers.ForEach(x => dnsServers.Add(x));
+                else // Use windows default dns server, but filter/remove IPv6 site local addresses (fec0:0:0:0:ffff::)
+                    dnsResolver.DnsServers.Where(x => !x.Address.ToString().StartsWith(@"fec0")).Select(y => y.Address.ToString()).ToList().ForEach(x => dnsServers.Add(x));
+
+                // Foreach host
+                foreach (string host in hosts)
                 {
-                    if (IPAddress.TryParse(hostnameOrIPAddress, out IPAddress ip))
-                        hostnameOrIPAddress = Resolver.GetArpaFromIp(ip);
-                }
+                    // Default
+                    string name = host;
 
-                if (DNSLookupOptions.Type == QType.NAPTR)
-                    hostnameOrIPAddress = Resolver.GetArpaFromEnum(hostnameOrIPAddress);
+                    string dnsSuffix = string.Empty;
 
-                if (DNSLookupOptions.UseCustomDNSServer)
-                    DNSResolver.DnsServer = DNSLookupOptions.CustomDNSServer;
+                    if (name.IndexOf(".", StringComparison.OrdinalIgnoreCase) == -1)
+                    {
+                        if (dnsLookupOptions.AddDNSSuffix)
+                        {
+                            if (dnsLookupOptions.UseCustomDNSSuffix)
+                                dnsSuffix = dnsLookupOptions.CustomDNSSuffix;
+                            else
+                                dnsSuffix = IPGlobalProperties.GetIPGlobalProperties().DomainName;
+                        }
+                    }
 
-                DNSResolver.Recursion = DNSLookupOptions.Recursion;
-                DNSResolver.TransportType = DNSLookupOptions.TransportType;
-                DNSResolver.Retries = DNSLookupOptions.Attempts;
-                DNSResolver.TimeOut = DNSLookupOptions.Timeout;
+                    // Append dns suffix to hostname
+                    if (!string.IsNullOrEmpty(dnsSuffix))
+                        name += string.Format(".{0}", dnsSuffix);
 
-                Response dnsResponse = DNSResolver.Query(hostnameOrIPAddress, DNSLookupOptions.Type, DNSLookupOptions.Class);
+                    // PTR
+                    if (dnsLookupOptions.Type == QType.PTR)
+                    {
+                        if (IPAddress.TryParse(name, out IPAddress ip))
+                            name = Resolver.GetArpaFromIp(ip);
+                    }
 
-                // If there was an error... return
-                if (!string.IsNullOrEmpty(dnsResponse.Error))
-                {
-                    OnLookupError(new DNSLookupErrorArgs(dnsResponse.Error, DNSResolver.DnsServer));
-                    return;
-                }
+                    // NAPTR
+                    if (dnsLookupOptions.Type == QType.NAPTR)
+                        name = Resolver.GetArpaFromEnum(name);
 
-                // Process the results...
-                ProcessResponse(dnsResponse);
+                    int port = dnsLookupOptions.UseCustomDNSServer ? dnsLookupOptions.Port : Resolver.DefaultPort;
 
-                // If we get a CNAME back (from a result), do a second request and try to get the A, AAAA etc... 
-                if (DNSLookupOptions.ResolveCNAME && DNSLookupOptions.Type != QType.CNAME)
-                {
-                    foreach (RecordCNAME r in dnsResponse.RecordsCNAME)
+                    Parallel.ForEach(dnsServers, dnsServer =>
                     {
-                        Response DNSResponse2 = DNSResolver.Query(r.CNAME, DNSLookupOptions.Type, DNSLookupOptions.Class);
+                        // Create a new for each request
+                        Resolver resolver = new Resolver(dnsServer, port)
+                        {
+                            Recursion = dnsLookupOptions.Recursion,
+                            TransportType = dnsLookupOptions.TransportType,
+                            Retries = dnsLookupOptions.Attempts,
+                            TimeOut = dnsLookupOptions.Timeout
+                        };
 
-                        if (!string.IsNullOrEmpty(DNSResponse2.Error))
+                        Response dnsResponse = resolver.Query(name, dnsLookupOptions.Type, dnsLookupOptions.Class);
+
+                        // If there was an error... return
+                        if (!string.IsNullOrEmpty(dnsResponse.Error))
                         {
-                            OnLookupError(new DNSLookupErrorArgs(DNSResponse2.Error, DNSResolver.DnsServer));
-                            continue;
+                            OnLookupError(new DNSLookupErrorArgs(dnsResponse.Error, resolver.DnsServer));
+                            return;
                         }
 
-                        ProcessResponse(DNSResponse2);
-                    }
+                        // Process the results...
+                        ProcessResponse(dnsResponse);
+
+                        // If we get a CNAME back (from an ANY result), do a second request and try to get the A, AAAA etc... 
+                        if (dnsLookupOptions.ResolveCNAME && dnsLookupOptions.Type == QType.ANY)
+                        {
+                            foreach (RecordCNAME r in dnsResponse.RecordsCNAME)
+                            {
+                                Response dnsResponse2 = resolver.Query(r.CNAME, dnsLookupOptions.Type, dnsLookupOptions.Class);
+
+                                if (!string.IsNullOrEmpty(dnsResponse2.Error))
+                                {
+                                    OnLookupError(new DNSLookupErrorArgs(dnsResponse2.Error, resolver.DnsServer));
+                                    continue;
+                                }
+
+                                ProcessResponse(dnsResponse2);
+                            }
+                        }
+                    });
                 }
-                
-                OnLookupComplete(new DNSLookupCompleteArgs(dnsResponse.Server.ToString(), dnsResponse.Questions.Count, dnsResponse.Answers.Count, dnsResponse.Authorities.Count, dnsResponse.Additionals.Count, dnsResponse.MessageSize));
+
+                OnLookupComplete();
             });
         }
 
         private void ProcessResponse(Response dnsResponse)
         {
+            string dnsServer = dnsResponse.Server.Address.ToString();
+            int port = dnsResponse.Server.Port;
+
             // A
             foreach (RecordA r in dnsResponse.RecordsA)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // AAAA
             foreach (RecordAAAA r in dnsResponse.RecordsAAAA)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // CNAME
             foreach (RecordCNAME r in dnsResponse.RecordsCNAME)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // MX
             foreach (RecordMX r in dnsResponse.RecordsMX)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // NS
             foreach (RecordNS r in dnsResponse.RecordsNS)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // PTR
             foreach (RecordPTR r in dnsResponse.RecordsPTR)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // SOA
             foreach (RecordSOA r in dnsResponse.RecordsSOA)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
 
             // TXT
             foreach (RecordTXT r in dnsResponse.RecordsTXT)
-                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r));
+                OnRecordReceived(new DNSLookupRecordArgs(r.RR, r, dnsServer, port));
         }
         #endregion
     }

Source/NETworkManager/Models/Network/DNSLookupOptions.cs

@@ -1,11 +1,16 @@
 using Heijden.DNS;
+using System.Collections.Generic;
 
 namespace NETworkManager.Models.Network
 {
     public class DNSLookupOptions
     {
         public bool UseCustomDNSServer { get; set; }
-        public string CustomDNSServer { get; set; }
+        public List<string> CustomDNSServers { get; set; }
+        public int Port { get; set; }
+        public bool AddDNSSuffix { get; set; }
+        public bool UseCustomDNSSuffix { get; set; }
+        public string CustomDNSSuffix { get; set; }
         public QClass Class { get; set; }
         public QType Type { get; set; }
         public bool Recursion { get; set; }

Source/NETworkManager/Models/Network/DNSLookupRecordArgs.cs

@@ -6,16 +6,20 @@ public class DNSLookupRecordArgs : System.EventArgs
     {        
         public RR ResourceRecord { get; set; }
         public string Result { get; set; }
+        public string DNSServer { get; set; }
+        public int Port { get; set; }
 
         public DNSLookupRecordArgs()
         {
 
         }
 
-        public DNSLookupRecordArgs(RR resourceRecord, object result)
+        public DNSLookupRecordArgs(RR resourceRecord, object result, string dnsServer, int port)
         {
             ResourceRecord = resourceRecord;
             Result = result.ToString().TrimEnd();
+            DNSServer = dnsServer;
+            Port = port;
         }
     }
 }

Source/NETworkManager/Models/Network/DNSLookupRecordInfo.cs

@@ -9,24 +9,28 @@ public class DNSLookupRecordInfo
         public string Class { get; set; }
         public string Type { get; set; }
         public string Result { get; set; }
+        public string DNSServer { get; set; }
+        public int Port { get; set; }
 
         public DNSLookupRecordInfo()
         {
 
         }
 
-        public DNSLookupRecordInfo(RR resourceRecord, string result)
+        public DNSLookupRecordInfo(RR resourceRecord, string result, string dnsServer, int port)
         {
             Name = resourceRecord.NAME;
             TTL = resourceRecord.TTL;
             Class = resourceRecord.Class.ToString();
             Type = resourceRecord.Type.ToString();
             Result = result;
+            DNSServer = dnsServer;
+            Port = port;
         }
 
         public static DNSLookupRecordInfo Parse(DNSLookupRecordArgs e)
         {
-            return new DNSLookupRecordInfo(e.ResourceRecord, e.Result);
+            return new DNSLookupRecordInfo(e.ResourceRecord, e.Result, e.DNSServer, e.Port);
         }
     }
 }

Source/NETworkManager/Models/Settings/SettingsInfo.cs

@@ -903,8 +903,8 @@ public bool DNSLookup_UseCustomDNSServer
             }
         }
 
-        private string _dnsLookup_CustomDNSServer;
-        public string DNSLookup_CustomDNSServer
+        private List<string> _dnsLookup_CustomDNSServer;
+        public List<string> DNSLookup_CustomDNSServer
         {
             get { return _dnsLookup_CustomDNSServer; }
             set
@@ -917,6 +917,20 @@ public string DNSLookup_CustomDNSServer
             }
         }
 
+        private int _dnsLookup_Port = 53;
+        public int DNSLookup_Port
+        {
+            get { return _dnsLookup_Port; }
+            set
+            {
+                if (value == _dnsLookup_Port)
+                    return;
+
+                _dnsLookup_Port = value;
+                SettingsChanged = true;
+            }
+        }
+
         private QClass _dnsLookup_Class = QClass.IN;
         public QClass DNSLookup_Class
         {
@@ -973,7 +987,7 @@ public bool DNSLookup_UseCustomDNSSuffix
             }
         }
 
-        private string _dnsLookup_CustomDNSSuffix;
+        private string _dnsLookup_CustomDNSSuffix = string.Empty;
         public string DNSLookup_CustomDNSSuffix
         {
             get { return _dnsLookup_CustomDNSSuffix; }

Source/NETworkManager/NETworkManager.csproj

@@ -214,6 +214,7 @@
     <Compile Include="Models\Update\UpdateAvailableArgs.cs" />
     <Compile Include="Models\Update\Updater.cs" />
     <Compile Include="Validators\Int32Validator.cs" />
+    <Compile Include="Validators\MultipleIPAddressesValidator.cs" />
     <Compile Include="Validators\MultipleHostsValidator.cs" />
     <Compile Include="Validators\HttpAndHttpsUriValidator.cs" />
     <Compile Include="Validators\SubnetCalculatorSubnetValidator.cs" />
@@ -676,7 +677,7 @@
     <Compile Include="Converters\ValidateSettingsImportConverter.cs" />
     <Compile Include="Converters\ValidateSettingsResetConverter.cs" />
     <Compile Include="Converters\ValidateSettingsExportConverter.cs" />
-    <Compile Include="Helpers\HistoryListHelper.cs" />
+    <Compile Include="Helpers\ListHelper.cs" />
     <Compile Include="Helpers\HotKeysHelper.cs" />
     <Compile Include="Models\Network\ARPTable.cs" />
     <Compile Include="Helpers\PortRangeHelper.cs" />