packServer/desktop/Services/Edge/EdgeDiscoveryClient.cs
liufumingren c280e94b9a 加固局域网询问应答:主体 + 后端身份双校验
主体 id 在各环境的库里都从 1 开始,光比 subjectId 挡不住跨环境串台
(开发库和生产库的测试仓库都是 1),旧机器只要 agent.json 还在就会一直应答。

- 询问必须带 subjectId>0 和 server,缺任一项不应答
- 应答回带 server,A 侧也校验一致;不一致直接丢弃
- 多台应答按 (SN, 主机) 去重,并优先本机地址
- 版本号提到 1.0.105

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-22 01:27:49 +08:00

238 lines
8.6 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Scan;
namespace YuncangTrace.LocalService.Services.Edge;
/// <summary>局域网里发现到的一台「取流服务」(即扫码服务拉起的 hik-worker)。</summary>
/// <param name="Sn">设备序列号(与 scanners.sn 对应,用于去重与排障)</param>
/// <param name="Reachable">这次询问里它实测能连通的 NVR 主机(空 = 没带 NVR 询问)</param>
public sealed record EdgePeer(
string Sn,
string Host,
int Port,
int SubjectId,
IReadOnlyList<string> Reachable,
string Version)
{
public string BaseUrl => $"http://{Host}:{Port}";
public string Display => $"{Sn}({Host}:{Port})";
}
/// <summary>
/// 局域网询问-应答的客户端(查询机这一侧)。
///
/// **只问不喊**:发一次广播询问,在同 socket 上收应答 —— 这样回包的源地址天然就是
/// 「从哪块网卡能到它」,多网卡机器不用自己猜用哪个 IP。
///
/// 询问可以带 <c>nvrHosts</c>:对面的服务会先实测能不能连到这些 NVR,
/// 连不上就不应答。所以「收到应答」= 对端确实能替你取流,而不是单纯在线。
/// </summary>
public static class EdgeDiscoveryClient
{
/// <summary>带 NVR 时给对端留出探测时间(对端最多 800ms 探测)</summary>
private static readonly TimeSpan ProbeWait = TimeSpan.FromSeconds(3);
/// <summary>不带 NVR 时只需等应答返回</summary>
private static readonly TimeSpan QuickWait = TimeSpan.FromSeconds(1);
/// <summary>
/// 找一台能处理这些 NVR 的取流服务。
/// </summary>
/// <param name="subjectId">当前主体(对端只回同主体的询问)</param>
/// <param name="server">当前后端地址(对端只回同环境的询问)</param>
/// <param name="nvrs">要问的 NVR(host/port);传空表示只问「有没有服务」</param>
/// <returns>多台应答时优先本机、再按 SN 取第一台</returns>
public static async Task<EdgePeer?> FindAsync(int subjectId, string? server,
IReadOnlyList<(string Host, int Port)>? nvrs,
CancellationToken ct = default)
{
if (subjectId <= 0) return null;
var ownServer = HikWorkerDiscovery.NormalizeServer(server);
if (ownServer.Length == 0)
{
AppLog.Write("[edge] 本机后端地址未知,跳过局域网询问");
return null;
}
using var udp = new UdpClient(AddressFamily.InterNetwork);
udp.EnableBroadcast = true;
var payload = BuildQuery(subjectId, ownServer, nvrs);
var bytes = Encoding.UTF8.GetBytes(payload);
foreach (var target in DeviceScanner.BroadcastTargets())
{
try
{
await udp.SendAsync(bytes, bytes.Length, new IPEndPoint(target, HikWorkerPorts.UdpQuery))
.WaitAsync(ct).ConfigureAwait(false);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 广播到 {target} 失败:{ex.Message}");
}
}
var wait = nvrs is { Count: > 0 } ? ProbeWait : QuickWait;
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(wait);
var peers = new List<EdgePeer>();
while (!timeout.IsCancellationRequested)
{
UdpReceiveResult received;
try
{
received = await udp.ReceiveAsync(timeout.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[edge] 接收应答失败:{ex.Message}");
break;
}
var peer = TryParseReply(received.Buffer, received.RemoteEndPoint.Address, subjectId, ownServer);
if (peer is null) continue;
// 带了 NVR 询问时,对端必须确认能连通其中至少一台(它已经自己筛过,这里再兜一层)
if (nvrs is { Count: > 0 } && !HasAnyReachable(peer, nvrs)) continue;
peers.Add(peer);
}
if (peers.Count == 0) return null;
// 同一台机器会因为我们发了「广播 + 各网段定向广播」而回多次,先按 (SN, 主机) 去重
return peers
.GroupBy(item => item.Sn + "|" + item.Host, StringComparer.Ordinal)
.Select(group => group.First())
// 多台都能服务时优先本机(自己就在这台机器上,省一次跨机转发)
.OrderByDescending(item => IsLocalAddress(item.Host))
.ThenBy(item => item.Sn, StringComparer.Ordinal)
.First();
}
private static bool IsLocalAddress(string host)
{
if (IPAddress.TryParse(host, out var address) && IPAddress.IsLoopback(address)) return true;
try
{
return System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()
.SelectMany(item => item.GetIPProperties().UnicastAddresses)
.Any(item => item.Address.Equals(address ?? IPAddress.None));
}
catch
{
return false;
}
}
private static bool HasAnyReachable(EdgePeer peer, IReadOnlyList<(string Host, int Port)> nvrs)
{
if (peer.Reachable.Count == 0) return false;
var set = new HashSet<string>(peer.Reachable, StringComparer.OrdinalIgnoreCase);
return nvrs.Any(item => set.Contains(item.Host));
}
private static string BuildQuery(int subjectId, string server, IReadOnlyList<(string Host, int Port)>? nvrs)
{
if (nvrs is not { Count: > 0 })
{
return JsonSerializer.Serialize(new
{
type = HikWorkerDiscovery.QueryType,
subjectId,
server,
}, HikWorkerJson.Options);
}
return JsonSerializer.Serialize(new
{
type = HikWorkerDiscovery.QueryType,
subjectId,
server,
nvrHosts = nvrs.Select(item => new { host = item.Host, port = item.Port }).ToArray(),
}, HikWorkerJson.Options);
}
private static EdgePeer? TryParseReply(byte[] buffer, IPAddress from, int expectedSubject, string expectedServer)
{
try
{
var text = Encoding.UTF8.GetString(buffer).TrimStart();
if (text.Length == 0 || text[0] != '{') return null;
using var doc = JsonDocument.Parse(text);
var root = doc.RootElement;
if (!root.TryGetProperty("type", out var type) || type.GetString() != HikWorkerDiscovery.ReplyType)
{
return null;
}
// 应答必须同主体:防止同 LAN 里别的主体广播回来
if (!root.TryGetProperty("subjectId", out var subjectElement)
|| !subjectElement.TryGetInt32(out var subjectId)
|| subjectId != expectedSubject)
{
return null;
}
// 还要同环境:主体 id 在各环境都从 1 开始,光比主体会把别环境的机器招进来
if (!string.Equals(GetString(root, "server"), expectedServer, StringComparison.Ordinal))
{
return null;
}
var port = root.TryGetProperty("port", out var portElement) && portElement.TryGetInt32(out var p)
? p
: HikWorkerPorts.Http;
var reachable = new List<string>();
if (root.TryGetProperty("reachable", out var reachableElement)
&& reachableElement.ValueKind == JsonValueKind.Array)
{
foreach (var item in reachableElement.EnumerateArray())
{
var value = item.GetString();
if (!string.IsNullOrWhiteSpace(value)) reachable.Add(value);
}
}
return new EdgePeer(
GetString(root, "sn") ?? "",
from.ToString(),
port,
subjectId,
reachable,
GetString(root, "version") ?? "");
}
catch
{
return null;
}
}
private static string? GetString(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
? value.GetString()
: null;
}