The checks engine, the path and the cards: me-web? 0.1 reads the connection

MeWeb.Core runs seven checks concurrently and reports each as it settles:
online or behind a login page, this connection, the public IPv4 and IPv6
seen from v4./v6.meweb, the provider from a built-in map, the router
(UPnP IGD, NAT-PMP and PCP, read-only), address sharing (router WAN
against the echo, TTL hops only as a hint), and the history kept on the
device. The app draws the path from this device to the internet and lights
it node by node, with a card per check and a sheet listing every host it
contacts.

The provider map is iptoasn's table compressed to 2.1 MB by
tools/knowledge.cs and built before every app release; eleven Italian
provider profiles carry each fact with who said it, the source and the
month. The server gains a download page (en, it) and /download/{platform}
from the latest Gitea release.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012CzABvBkbcFqoHdmi8b9WB

src/MeWeb.Core/Checks/ServerProbe.cs

@@ -0,0 +1,120 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Net.Sockets;
+
+using MeWeb.Shared;
+
+namespace MeWeb.Core.Checks;
+
+public enum OnlineState
+{
+  Online,
+  Captive,
+  Rewritten,
+  NoNames,
+  Offline,
+}
+
+public class OnlineReport
+{
+  public OnlineState State { get; set; }
+  public ViewInfo Server { get; set; }
+  public string Portal { get; set; }
+}
+
+public class ServerProbe(HttpClient https, HttpClient plain)
+{
+  static readonly TimeSpan Patience = TimeSpan.FromSeconds(6);
+
+  public async Task<OnlineReport> Online(CancellationToken ct)
+  {
+    var names = Resolves(Endpoints.Host, ct);
+    var info = Info(ct);
+    var web = Plain(ct);
+    await Task.WhenAll(names, info, web);
+    var (plainClean, portal) = web.Result;
+
+    if (info.Result is not null)
+      return new OnlineReport { State = plainClean is false ? OnlineState.Rewritten : OnlineState.Online, Server = info.Result, Portal = portal };
+    if (plainClean is false) return new OnlineReport { State = OnlineState.Captive, Portal = portal };
+    return new OnlineReport { State = names.Result ? OnlineState.Offline : OnlineState.NoNames };
+  }
+
+  public async Task<string> Echo(bool v6, CancellationToken ct)
+  {
+    try
+    {
+      using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
+      timeout.CancelAfter(Patience);
+      var origin = v6 ? Endpoints.BaseV6 : Endpoints.BaseV4;
+      var answer = await https.GetFromJsonAsync(origin + Endpoints.Server.GET_Ip, MeWebJsonContext.Default.ViewIp, timeout.Token);
+      return answer?.Address;
+    }
+    catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or System.Text.Json.JsonException && !ct.IsCancellationRequested)
+    {
+      return null;
+    }
+  }
+
+  public static async Task<IPAddress> ResolveV4(CancellationToken ct)
+  {
+    try
+    {
+      var addresses = await Dns.GetHostAddressesAsync(Endpoints.HostV4, AddressFamily.InterNetwork, ct);
+      return addresses.FirstOrDefault();
+    }
+    catch (SocketException)
+    {
+      return null;
+    }
+  }
+
+  static async Task<bool> Resolves(string host, CancellationToken ct)
+  {
+    try
+    {
+      return (await Dns.GetHostAddressesAsync(host, ct)).Length > 0;
+    }
+    catch (SocketException)
+    {
+      return false;
+    }
+  }
+
+  async Task<ViewInfo> Info(CancellationToken ct)
+  {
+    try
+    {
+      using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
+      timeout.CancelAfter(Patience);
+      return await https.GetFromJsonAsync(Endpoints.Base + Endpoints.Server.GET_Info, MeWebJsonContext.Default.ViewInfo, timeout.Token);
+    }
+    catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or System.Text.Json.JsonException && !ct.IsCancellationRequested)
+    {
+      return null;
+    }
+  }
+
+  async Task<(bool? Clean, string Portal)> Plain(CancellationToken ct)
+  {
+    try
+    {
+      using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
+      timeout.CancelAfter(Patience);
+      using var response = await plain.GetAsync($"http://{Endpoints.Host}{Endpoints.Server.GET_Info}", HttpCompletionOption.ResponseHeadersRead, timeout.Token);
+      var location = response.Headers.Location;
+      if ((int)response.StatusCode is >= 300 and < 400 && location is not null)
+      {
+        var target = location.IsAbsoluteUri ? location : new Uri(new Uri($"http://{Endpoints.Host}"), location);
+        var clean = target.Scheme == Uri.UriSchemeHttps && string.Equals(target.Host, Endpoints.Host, StringComparison.OrdinalIgnoreCase);
+        return (clean, clean ? null : target.Host);
+      }
+      if (response.IsSuccessStatusCode && response.Content.Headers.ContentType?.MediaType == "application/json") return (true, null);
+      return (false, null);
+    }
+    catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException && !ct.IsCancellationRequested)
+    {
+      return (null, null);
+    }
+  }
+}