add APIs to mark unresolvable addresses as invalid and update them manually

Author: smdn

src/Smdn.Net.AddressResolution/Smdn.Net.AddressResolution.Arp/ProcfsArpMacAddressResolver.cs

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: 2022 smdn <smdn@smdn.jp>
 // SPDX-License-Identifier: MIT
 using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Net.NetworkInformation;
@@ -34,30 +36,48 @@ internal partial class ProcfsArpMacAddressResolver : MacAddressResolver {
     );
   }
 
+  private readonly struct None { }
+
+  private class ConcurrentSet<T> : ConcurrentDictionary<T, None>
+    where T : notnull
+  {
+    public ConcurrentSet()
+    {
+    }
+
+    public void Add(T key)
+      => AddOrUpdate(key: key, addValue: default, updateValueFactory: static (key, old) => default);
+  }
+
   /*
    * instance members
    */
-  private DateTime lastArpScanAt = DateTime.MinValue;
-  private readonly TimeSpan arpScanInterval;
+  private DateTime lastArpFullScanAt = DateTime.MinValue;
+  private readonly TimeSpan arpFullScanInterval;
+
+  private bool HasArpFullScanIntervalElapsed => lastArpFullScanAt + arpFullScanInterval <= DateTime.Now;
+
+  private readonly ConcurrentSet<IPAddress> invalidatedIPAddressSet = new();
+  private readonly ConcurrentSet<PhysicalAddress> invalidatedMacAddressSet = new();
 
-  private bool HasArpScanIntervalElapsed => lastArpScanAt + arpScanInterval <= DateTime.Now;
+  public override bool HasInvalidated => !(invalidatedIPAddressSet.IsEmpty && invalidatedMacAddressSet.IsEmpty);
 
   public ProcfsArpMacAddressResolver(
     MacAddressResolverOptions options,
     ILogger? logger
   )
     : base(logger)
   {
-    arpScanInterval = options.ProcfsArpScanInterval;
+    arpFullScanInterval = options.ProcfsArpFullScanInterval;
   }
 
   protected override async ValueTask<PhysicalAddress?> ResolveIPAddressToMacAddressAsyncCore(
     IPAddress ipAddress,
     CancellationToken cancellationToken
   )
   {
-    if (HasArpScanIntervalElapsed)
-      await ArpScanAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+    if (HasArpFullScanIntervalElapsed)
+      await ArpFullScanAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
 
     ArpTableEntry priorCandidate = default;
     ArpTableEntry candidate = default;
@@ -67,6 +87,9 @@ CancellationToken cancellationToken
       Logger,
       cancellationToken
     ).ConfigureAwait(false)) {
+      if (invalidatedMacAddressSet.ContainsKey(entry.HardwareAddress!))
+        continue; // ignore the entry that is marked as invalidated
+
       if (entry.IsPermanentOrComplete) {
         // prefer permanent or complete entry
         priorCandidate = entry;
@@ -88,8 +111,8 @@ CancellationToken cancellationToken
     CancellationToken cancellationToken
   )
   {
-    if (HasArpScanIntervalElapsed)
-      await ArpScanAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+    if (HasArpFullScanIntervalElapsed)
+      await ArpFullScanAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
 
     ArpTableEntry priorCandidate = default;
     ArpTableEntry candidate = default;
@@ -99,6 +122,9 @@ CancellationToken cancellationToken
       Logger,
       cancellationToken
     ).ConfigureAwait(false)) {
+      if (invalidatedIPAddressSet.ContainsKey(entry.IPAddress!))
+        continue; // ignore the entry that is marked as invalidated
+
       if (entry.IsPermanentOrComplete) {
         // prefer permanent or complete entry
         priorCandidate = entry;
@@ -115,6 +141,12 @@ CancellationToken cancellationToken
       : priorCandidate.IPAddress;
   }
 
+  protected override void InvalidateCore(IPAddress resolvedIPAddress)
+    => invalidatedIPAddressSet.Add(resolvedIPAddress);
+
+  protected override void InvalidateCore(PhysicalAddress resolvedMacAddress)
+    => invalidatedMacAddressSet.Add(resolvedMacAddress);
+
   protected override ValueTask RefreshCacheAsyncCore(
     CancellationToken cancellationToken = default
   )
@@ -124,19 +156,67 @@ protected override ValueTask RefreshCacheAsyncCore(
         ValueTask.FromCanceled(cancellationToken)
 #else
         ValueTaskShim.FromCanceled(cancellationToken)
+#endif
+      : ArpFullScanAsync(cancellationToken: cancellationToken);
+
+  private async ValueTask ArpFullScanAsync(CancellationToken cancellationToken)
+  {
+    Logger?.LogDebug("Performing ARP full scan");
+
+    await ArpFullScanAsyncCore(cancellationToken: cancellationToken).ConfigureAwait(false);
+
+    invalidatedIPAddressSet.Clear();
+    invalidatedMacAddressSet.Clear();
+
+    lastArpFullScanAt = DateTime.Now;
+  }
+
+  protected virtual ValueTask ArpFullScanAsyncCore(CancellationToken cancellationToken)
+  {
+    Logger?.LogWarning("ARP scan is not supported in this class.");
+
+    return default;
+  }
+
+  protected override ValueTask RefreshInvalidatedCacheAsyncCore(
+    CancellationToken cancellationToken = default
+  )
+    => cancellationToken.IsCancellationRequested
+      ?
+#if SYSTEM_THREADING_TASKS_VALUETASK_FROMCANCELED
+        ValueTask.FromCanceled(cancellationToken)
+#else
+        ValueTaskShim.FromCanceled(cancellationToken)
 #endif
       : ArpScanAsync(cancellationToken: cancellationToken);
 
   private async ValueTask ArpScanAsync(CancellationToken cancellationToken)
   {
-    Logger?.LogDebug("Performing ARP scan");
+    Logger?.LogDebug("Performing ARP scan for invalidated targets.");
+
+    var invalidatedIPAddresses = invalidatedIPAddressSet.Keys;
+    var invalidatedMacAddresses = invalidatedMacAddressSet.Keys;
 
-    await ArpScanAsyncCore(cancellationToken: cancellationToken).ConfigureAwait(false);
+    Logger?.LogTrace("Invalidated IP addresses: {InvalidatedIPAddresses}", string.Join(" ", invalidatedIPAddresses));
+    Logger?.LogTrace("Invalidated MAC addresses: {InvalidatedMACAddresses}", string.Join(" ", invalidatedMacAddresses));
 
-    lastArpScanAt = DateTime.Now;
+    await ArpScanAsyncCore(
+      invalidatedIPAddresses: invalidatedIPAddresses,
+      invalidatedMacAddresses: invalidatedMacAddresses,
+      cancellationToken: cancellationToken
+    ).ConfigureAwait(false);
+
+    invalidatedIPAddressSet.Clear();
+    invalidatedMacAddressSet.Clear();
+
+    lastArpFullScanAt = DateTime.Now;
   }
 
-  protected virtual ValueTask ArpScanAsyncCore(CancellationToken cancellationToken)
+  protected virtual ValueTask ArpScanAsyncCore(
+    IEnumerable<IPAddress> invalidatedIPAddresses,
+    IEnumerable<PhysicalAddress> invalidatedMacAddresses,
+    CancellationToken cancellationToken
+  )
   {
     Logger?.LogWarning("ARP scan is not supported in this class.");
 

src/Smdn.Net.AddressResolution/Smdn.Net.AddressResolution.Arp/ProcfsArpNmapScanMacAddressResolver.cs

@@ -5,6 +5,8 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Net;
+using System.Net.NetworkInformation;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -40,7 +42,45 @@ public ProcfsArpNmapScanMacAddressResolver(
       ?? throw new ArgumentException($"{nameof(options.NmapTargetSpecification)} must be specified with {nameof(MacAddressResolverOptions)}");
   }
 
-  protected override async ValueTask ArpScanAsyncCore(CancellationToken cancellationToken)
+  protected override ValueTask ArpFullScanAsyncCore(CancellationToken cancellationToken)
+    => NmapScanAsync(
+      nmapOptionTargetSpecification: nmapTargetSpecification,
+      logger: Logger,
+      cancellationToken: cancellationToken
+    );
+
+  protected override ValueTask ArpScanAsyncCore(
+    IEnumerable<IPAddress> invalidatedIPAddresses,
+    IEnumerable<PhysicalAddress> invalidatedMacAddresses,
+    CancellationToken cancellationToken
+  )
+  {
+    if (invalidatedMacAddresses.Any()) {
+      // perform full scan
+      return NmapScanAsync(
+        nmapOptionTargetSpecification: nmapTargetSpecification,
+        logger: Logger,
+        cancellationToken: cancellationToken
+      );
+    }
+
+    // perform scan for specific target IPs
+    var nmapOptionTargetSpecification = string.Join(" ", invalidatedIPAddresses);
+
+    return nmapOptionTargetSpecification.Length == 0
+      ? default // do nothing
+      : NmapScanAsync(
+          nmapOptionTargetSpecification: nmapOptionTargetSpecification,
+          logger: Logger,
+          cancellationToken: cancellationToken
+        );
+  }
+
+  private static async ValueTask NmapScanAsync(
+    string nmapOptionTargetSpecification,
+    ILogger? logger,
+    CancellationToken cancellationToken
+  )
   {
     // -sn: Ping Scan - disable port scan
     // -n: Never do DNS resolution
@@ -51,13 +91,13 @@ protected override async ValueTask ArpScanAsyncCore(CancellationToken cancellati
 
     var nmapProcessStartInfo = new ProcessStartInfo() {
       FileName = lazyPathToNmap.Value,
-      Arguments = nmapOptions + nmapTargetSpecification,
+      Arguments = nmapOptions + nmapOptionTargetSpecification,
       RedirectStandardOutput = true,
       RedirectStandardError = true,
       UseShellExecute = false,
     };
 
-    Logger?.LogDebug(
+    logger?.LogDebug(
       "[nmap] {ProcessStartInfoFileName} {ProcessStartInfoArguments}",
       nmapProcessStartInfo.FileName,
       nmapProcessStartInfo.Arguments
@@ -76,7 +116,7 @@ protected override async ValueTask ArpScanAsyncCore(CancellationToken cancellati
       nmapProcess.WaitForExit(); // TODO: cacellation
 #endif
 
-      if (Logger is not null) {
+      if (logger is not null) {
         const LogLevel logLevelForStandardOutput = LogLevel.Trace;
         const LogLevel logLevelForStandardError = LogLevel.Error;
 
@@ -87,7 +127,7 @@ protected override async ValueTask ArpScanAsyncCore(CancellationToken cancellati
         }
 
         foreach (var (stdio, logLevel) in EnumerateLogTarget(nmapProcess.StandardOutput, nmapProcess.StandardError)) {
-          if (!Logger.IsEnabled(logLevel))
+          if (!logger.IsEnabled(logLevel))
             continue;
 
           for (; ;) {
@@ -96,13 +136,13 @@ protected override async ValueTask ArpScanAsyncCore(CancellationToken cancellati
             if (line is null)
               break;
 
-            Logger.Log(logLevel, "[nmap] {Line}", line);
+            logger.Log(logLevel, "[nmap] {Line}", line);
           }
         }
       }
     }
     catch (Exception ex) {
-      Logger?.LogError(ex, "[nmap] failed to perform ARP scanning");
+      logger?.LogError(ex, "[nmap] failed to perform ARP scanning");
     }
   }
 }

src/Smdn.Net.AddressResolution/Smdn.Net.AddressResolution/IAddressResolver.cs

@@ -8,4 +8,5 @@ namespace Smdn.Net.AddressResolution;
 public interface IAddressResolver<TAddress, TResolvedAddress> {
   /// <returns>An resolved address. <see langword="null"/> if address could not be resolved.</returns>
   public ValueTask<TResolvedAddress?> ResolveAsync(TAddress address, CancellationToken cancellationToken);
+  public void Invalidate(TResolvedAddress resolvedAddress);
 }