adding dns client lookup to test fix

tpurschke · tpurschke · commit 269b59c6366b · 2025-11-12T11:53:23.000+01:00
diff --git a/roles/lib/files/FWO.Basics/FWO.Basics.csproj b/roles/lib/files/FWO.Basics/FWO.Basics.csproj
@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="DnsClient" Version="1.8.0" />
     <PackageReference Include="IPAddressRange" Version="6.2.0" />
   </ItemGroup>
 
diff --git a/roles/lib/files/FWO.Basics/IpOperations.cs b/roles/lib/files/FWO.Basics/IpOperations.cs
@@ -2,18 +2,56 @@
 using System.Net;
 using NetTools;
 using System;
+using DnsClient;
 
 namespace FWO.Basics
 {
     public static class IpOperations
     {
+
+        // reuse the client to avoid socket churn; disable client-side cache
+        private static readonly LookupClient ReverseLookupClient = new(new LookupClientOptions
+        {
+            UseCache = false,
+            ContinueOnDnsError = true,
+            ThrowDnsErrors = false
+        });
+
+        public static async Task<IReadOnlyList<string>> DnsReverseLookUpAllAsync(
+            IPAddress address,
+            CancellationToken cancellationToken = default)
+        {
+            // QueryReverseAsync issues a PTR query and returns all answers from the DNS server
+            IDnsQueryResponse response = await ReverseLookupClient.QueryReverseAsync(address, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (response.HasError || response.Answers.Count == 0)
+            {
+                return Array.Empty<string>();
+            }
+
+            return response.Answers
+                .PtrRecords()
+                .Select(ptr => ptr.PtrDomainName.Value.TrimEnd('.')) // drop trailing dot
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        public static async Task<string> DnsReverseLookUpPreferredAsync(IPAddress address)
+        {
+            IReadOnlyList<string> names = await DnsReverseLookUpAllAsync(address);
+            return names.FirstOrDefault(name => !name.StartsWith("lx", StringComparison.OrdinalIgnoreCase))
+                ?? names.FirstOrDefault()
+                ?? string.Empty;
+        }
+
         public static async Task<string> DnsReverseLookUp(IPAddress address)
         {
             try
             {
                 return (await Dns.GetHostEntryAsync(address)).HostName;
             }
-            catch(Exception)
+            catch (Exception)
             {
                 return "";
             }
@@ -51,25 +89,25 @@ public static bool TryParseIPStringToRange(this string ipString, out (string Sta
                 bool ipStartOK = IPAddress.TryParse(ipStart, out IPAddress? ipAdressStart);
                 bool ipEndOK = IPAddress.TryParse(ipEnd, out IPAddress? ipAdressEnd);
 
-                if(ipAdressStart is null || ipAdressEnd is null)
+                if (ipAdressStart is null || ipAdressEnd is null)
                 {
                     return false;
                 }
 
-                if(strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)
+                if (strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)
                 {
-                    if(!IsValidIPv4(ipStart) || !IsValidIPv4(ipEnd))
+                    if (!IsValidIPv4(ipStart) || !IsValidIPv4(ipEnd))
                     {
                         return false;
                     }
                 }
 
-                if(!ipStartOK || !ipEndOK)
+                if (!ipStartOK || !ipEndOK)
                 {
                     return false;
                 }
 
-                if(!IPAddress.TryParse(ipStart, out _) || !IPAddress.TryParse(ipEnd, out _))
+                if (!IPAddress.TryParse(ipStart, out _) || !IPAddress.TryParse(ipEnd, out _))
                 {
                     return false;
                 }
@@ -79,51 +117,52 @@ public static bool TryParseIPStringToRange(this string ipString, out (string Sta
 
                 return true;
             }
-            catch(Exception) 
+            catch (Exception)
             {
                 return false;
             }
         }
 
-        public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bool strictv4Parse = false) 
+        public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bool strictv4Parse = false)
         {
             ipResult = default;
-            
+
             try
             {
                 (string ipStart, string ipEnd) = SplitIpToRange(ipString);
 
                 bool ipStartOK = IPAddress.TryParse(ipStart, out IPAddress? ipAdressStart);
                 bool ipEndOK = IPAddress.TryParse(ipEnd, out IPAddress? ipAdressEnd);
 
-                if(ipAdressStart is null || ipAdressEnd is null)
+                if (ipAdressStart is null || ipAdressEnd is null)
                 {
                     return false;
                 }
 
-                if(strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)
+                if (strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)
                 {
-                    if(!IsValidIPv4(ipStart) || !IsValidIPv4(ipEnd))
+                    if (!IsValidIPv4(ipStart) || !IsValidIPv4(ipEnd))
                     {
                         return false;
                     }
                 }
 
-                if(!ipStartOK || !ipEndOK)
+                if (!ipStartOK || !ipEndOK)
                 {
                     return false;
                 }
 
-                if(typeof(T) == typeof((string, string)))
+                if (typeof(T) == typeof((string, string)))
                 {
                     ipResult = (T)Convert.ChangeType((ipAdressStart!.ToString(), ipAdressEnd!.ToString()), typeof(T));
                     return true;
                 }
-                else if(typeof(T) == typeof(IPAddressRange) && IPAddressRange.TryParse(ipString, out IPAddressRange ipRange))
+                else if (typeof(T) == typeof(IPAddressRange) && IPAddressRange.TryParse(ipString, out IPAddressRange ipRange))
                 {
                     ipResult = (T)Convert.ChangeType(ipRange, typeof(T));
                     return true;
-                }else if(typeof(T) == typeof((IPAddress, IPAddress)))
+                }
+                else if (typeof(T) == typeof((IPAddress, IPAddress)))
                 {
                     Tuple<IPAddress, IPAddress>? ipTuple = new(ipAdressStart!, ipAdressEnd!);
                     ipResult = (T)Convert.ChangeType(ipTuple, typeof(T));
@@ -132,7 +171,7 @@ public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bo
 
                 return false;
             }
-            catch(Exception)
+            catch (Exception)
             {
                 return false;
             }
@@ -142,7 +181,7 @@ private static bool IsValidIPv4(string ipAddress)
         {
             byte[] addBytes = [.. ipAddress.Split('.').Where(_ => byte.Parse(_) <= 255 && byte.Parse(_) >= 0).Select(byte.Parse)];
 
-            return addBytes.Length == 4;            
+            return addBytes.Length == 4;
         }
 
         public static string GetObjectType(string ip1, string ip2)
@@ -333,11 +372,11 @@ public static int CompareIpValues(IPAddress ip1, IPAddress ip2)
         /// </summary>
         public static int CompareIpFamilies(IPAddress ip1, IPAddress ip2)
         {
-            if (ip1.AddressFamily == AddressFamily.InterNetwork && ip2.AddressFamily == AddressFamily.InterNetworkV6 )
+            if (ip1.AddressFamily == AddressFamily.InterNetwork && ip2.AddressFamily == AddressFamily.InterNetworkV6)
             {
                 return -1;
             }
-            if (ip1.AddressFamily == AddressFamily.InterNetworkV6 && ip2.AddressFamily == AddressFamily.InterNetwork )
+            if (ip1.AddressFamily == AddressFamily.InterNetworkV6 && ip2.AddressFamily == AddressFamily.InterNetwork)
             {
                 return 1;
             }
diff --git a/roles/lib/files/FWO.Services/AppServerHelper.cs b/roles/lib/files/FWO.Services/AppServerHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -2,18 +2,56 @@`
`2`	`2`	`using System.Net;`
`3`	`3`	`using NetTools;`
`4`	`4`	`using System;`
	`5`	`+using DnsClient;`
`5`	`6`
`6`	`7`	`namespace FWO.Basics`
`7`	`8`	`{`
`8`	`9`	`public static class IpOperations`
`9`	`10`	`{`
	`11`	`+`
	`12`	`+ // reuse the client to avoid socket churn; disable client-side cache`
	`13`	`+ private static readonly LookupClient ReverseLookupClient = new(new LookupClientOptions`
	`14`	`+ {`
	`15`	`+ UseCache = false,`
	`16`	`+ ContinueOnDnsError = true,`
	`17`	`+ ThrowDnsErrors = false`
	`18`	`+ });`
	`19`	`+`
	`20`	`+ public static async Task<IReadOnlyList<string>> DnsReverseLookUpAllAsync(`
	`21`	`+ IPAddress address,`
	`22`	`+ CancellationToken cancellationToken = default)`
	`23`	`+ {`
	`24`	`+ // QueryReverseAsync issues a PTR query and returns all answers from the DNS server`
	`25`	`+ IDnsQueryResponse response = await ReverseLookupClient.QueryReverseAsync(address, cancellationToken)`
	`26`	`+ .ConfigureAwait(false);`
	`27`	`+`
	`28`	`+ if (response.HasError \|\| response.Answers.Count == 0)`
	`29`	`+ {`
	`30`	`+ return Array.Empty<string>();`
	`31`	`+ }`
	`32`	`+`
	`33`	`+ return response.Answers`
	`34`	`+ .PtrRecords()`
	`35`	`+ .Select(ptr => ptr.PtrDomainName.Value.TrimEnd('.')) // drop trailing dot`
	`36`	`+ .Distinct(StringComparer.OrdinalIgnoreCase)`
	`37`	`+ .ToArray();`
	`38`	`+ }`
	`39`	`+`
	`40`	`+ public static async Task<string> DnsReverseLookUpPreferredAsync(IPAddress address)`
	`41`	`+ {`
	`42`	`+ IReadOnlyList<string> names = await DnsReverseLookUpAllAsync(address);`
	`43`	`+ return names.FirstOrDefault(name => !name.StartsWith("lx", StringComparison.OrdinalIgnoreCase))`
	`44`	`+ ?? names.FirstOrDefault()`
	`45`	`+ ?? string.Empty;`
	`46`	`+ }`
	`47`	`+`
`10`	`48`	`public static async Task<string> DnsReverseLookUp(IPAddress address)`
`11`	`49`	`{`
`12`	`50`	`try`
`13`	`51`	`{`
`14`	`52`	`return (await Dns.GetHostEntryAsync(address)).HostName;`
`15`	`53`	`}`
`16`		`- catch(Exception)`
	`54`	`+ catch (Exception)`
`17`	`55`	`{`
`18`	`56`	`return "";`
`19`	`57`	`}`
`@@ -51,25 +89,25 @@ public static bool TryParseIPStringToRange(this string ipString, out (string Sta`
`51`	`89`	`bool ipStartOK = IPAddress.TryParse(ipStart, out IPAddress? ipAdressStart);`
`52`	`90`	`bool ipEndOK = IPAddress.TryParse(ipEnd, out IPAddress? ipAdressEnd);`
`53`	`91`
`54`		`- if(ipAdressStart is null \|\| ipAdressEnd is null)`
	`92`	`+ if (ipAdressStart is null \|\| ipAdressEnd is null)`
`55`	`93`	`{`
`56`	`94`	`return false;`
`57`	`95`	`}`
`58`	`96`
`59`		`- if(strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)`
	`97`	`+ if (strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)`
`60`	`98`	`{`
`61`		`- if(!IsValidIPv4(ipStart) \|\| !IsValidIPv4(ipEnd))`
	`99`	`+ if (!IsValidIPv4(ipStart) \|\| !IsValidIPv4(ipEnd))`
`62`	`100`	`{`
`63`	`101`	`return false;`
`64`	`102`	`}`
`65`	`103`	`}`
`66`	`104`
`67`		`- if(!ipStartOK \|\| !ipEndOK)`
	`105`	`+ if (!ipStartOK \|\| !ipEndOK)`
`68`	`106`	`{`
`69`	`107`	`return false;`
`70`	`108`	`}`
`71`	`109`
`72`		`- if(!IPAddress.TryParse(ipStart, out _) \|\| !IPAddress.TryParse(ipEnd, out _))`
	`110`	`+ if (!IPAddress.TryParse(ipStart, out _) \|\| !IPAddress.TryParse(ipEnd, out _))`
`73`	`111`	`{`
`74`	`112`	`return false;`
`75`	`113`	`}`
`@@ -79,51 +117,52 @@ public static bool TryParseIPStringToRange(this string ipString, out (string Sta`
`79`	`117`
`80`	`118`	`return true;`
`81`	`119`	`}`
`82`		`- catch(Exception)`
	`120`	`+ catch (Exception)`
`83`	`121`	`{`
`84`	`122`	`return false;`
`85`	`123`	`}`
`86`	`124`	`}`
`87`	`125`
`88`		`- public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bool strictv4Parse = false)`
	`126`	`+ public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bool strictv4Parse = false)`
`89`	`127`	`{`
`90`	`128`	`ipResult = default;`
`91`		`-`
	`129`	`+`
`92`	`130`	`try`
`93`	`131`	`{`
`94`	`132`	`(string ipStart, string ipEnd) = SplitIpToRange(ipString);`
`95`	`133`
`96`	`134`	`bool ipStartOK = IPAddress.TryParse(ipStart, out IPAddress? ipAdressStart);`
`97`	`135`	`bool ipEndOK = IPAddress.TryParse(ipEnd, out IPAddress? ipAdressEnd);`
`98`	`136`
`99`		`- if(ipAdressStart is null \|\| ipAdressEnd is null)`
	`137`	`+ if (ipAdressStart is null \|\| ipAdressEnd is null)`
`100`	`138`	`{`
`101`	`139`	`return false;`
`102`	`140`	`}`
`103`	`141`
`104`		`- if(strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)`
	`142`	`+ if (strictv4Parse && ipAdressStart?.AddressFamily == AddressFamily.InterNetwork && ipAdressEnd?.AddressFamily == AddressFamily.InterNetwork)`
`105`	`143`	`{`
`106`		`- if(!IsValidIPv4(ipStart) \|\| !IsValidIPv4(ipEnd))`
	`144`	`+ if (!IsValidIPv4(ipStart) \|\| !IsValidIPv4(ipEnd))`
`107`	`145`	`{`
`108`	`146`	`return false;`
`109`	`147`	`}`
`110`	`148`	`}`
`111`	`149`
`112`		`- if(!ipStartOK \|\| !ipEndOK)`
	`150`	`+ if (!ipStartOK \|\| !ipEndOK)`
`113`	`151`	`{`
`114`	`152`	`return false;`
`115`	`153`	`}`
`116`	`154`
`117`		`- if(typeof(T) == typeof((string, string)))`
	`155`	`+ if (typeof(T) == typeof((string, string)))`
`118`	`156`	`{`
`119`	`157`	`ipResult = (T)Convert.ChangeType((ipAdressStart!.ToString(), ipAdressEnd!.ToString()), typeof(T));`
`120`	`158`	`return true;`
`121`	`159`	`}`
`122`		`- else if(typeof(T) == typeof(IPAddressRange) && IPAddressRange.TryParse(ipString, out IPAddressRange ipRange))`
	`160`	`+ else if (typeof(T) == typeof(IPAddressRange) && IPAddressRange.TryParse(ipString, out IPAddressRange ipRange))`
`123`	`161`	`{`
`124`	`162`	`ipResult = (T)Convert.ChangeType(ipRange, typeof(T));`
`125`	`163`	`return true;`
`126`		`- }else if(typeof(T) == typeof((IPAddress, IPAddress)))`
	`164`	`+ }`
	`165`	`+ else if (typeof(T) == typeof((IPAddress, IPAddress)))`
`127`	`166`	`{`
`128`	`167`	`Tuple<IPAddress, IPAddress>? ipTuple = new(ipAdressStart!, ipAdressEnd!);`
`129`	`168`	`ipResult = (T)Convert.ChangeType(ipTuple, typeof(T));`
`@@ -132,7 +171,7 @@ public static bool TryParseIPString<T>(this string ipString, out T? ipResult, bo`
`132`	`171`
`133`	`172`	`return false;`
`134`	`173`	`}`
`135`		`- catch(Exception)`
	`174`	`+ catch (Exception)`
`136`	`175`	`{`
`137`	`176`	`return false;`
`138`	`177`	`}`
`@@ -142,7 +181,7 @@ private static bool IsValidIPv4(string ipAddress)`
`142`	`181`	`{`
`143`	`182`	`byte[] addBytes = [.. ipAddress.Split('.').Where(_ => byte.Parse(_) <= 255 && byte.Parse(_) >= 0).Select(byte.Parse)];`
`144`	`183`
`145`		`- return addBytes.Length == 4;`
	`184`	`+ return addBytes.Length == 4;`
`146`	`185`	`}`
`147`	`186`
`148`	`187`	`public static string GetObjectType(string ip1, string ip2)`
`@@ -333,11 +372,11 @@ public static int CompareIpValues(IPAddress ip1, IPAddress ip2)`
`333`	`372`	`/// </summary>`
`334`	`373`	`public static int CompareIpFamilies(IPAddress ip1, IPAddress ip2)`
`335`	`374`	`{`
`336`		`- if (ip1.AddressFamily == AddressFamily.InterNetwork && ip2.AddressFamily == AddressFamily.InterNetworkV6 )`
	`375`	`+ if (ip1.AddressFamily == AddressFamily.InterNetwork && ip2.AddressFamily == AddressFamily.InterNetworkV6)`
`337`	`376`	`{`
`338`	`377`	`return -1;`
`339`	`378`	`}`
`340`		`- if (ip1.AddressFamily == AddressFamily.InterNetworkV6 && ip2.AddressFamily == AddressFamily.InterNetwork )`
	`379`	`+ if (ip1.AddressFamily == AddressFamily.InterNetworkV6 && ip2.AddressFamily == AddressFamily.InterNetwork)`
`341`	`380`	`{`
`342`	`381`	`return 1;`
`343`	`382`	`}`