边端是手写的 HTTP 读取,只认 Content-Length;而 A 侧一直用 JsonContent.Create(),它产生的是 chunked 请求 —— 边端把 body 读成空, /check 直接 400,界面就显示「设备管理服务无响应,改由本机校验」。 也就是说局域网共用取流池这条路,用真实客户端从来没成功过, 此前只有 curl 验证过所以一直没暴露。 - EdgeClient 改用 StringContent(显式 Content-Length) - 边端遇到 chunked 请求时明确记一行,不再让调用方看到「空 body」的怪错误 实测:JsonContent → 400 contentLength=null;StringContent → 200 contentLength=186 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
651 lines
24 KiB
C#
651 lines
24 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.IO;
|
||
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.Hik;
|
||
|
||
namespace YuncangTrace.LocalService.Services;
|
||
|
||
/// <summary>
|
||
/// 取流服务对外提供的极简 HTTP 接口(TCP <see cref="HikWorkerPorts.Http"/>)。
|
||
///
|
||
/// 端点:
|
||
/// <list type="bullet">
|
||
/// <item><c>GET /health</c> —— 连通性 + 身份(同 LAN 判定就靠它)</item>
|
||
/// <item><c>POST /probe</c> —— 我这台机器能不能连到指定 NVR(查询机据此决定要不要把活派过来)</item>
|
||
/// <item><c>POST /download</c> —— 下发下载计划,立即返回 taskId(后台执行)</item>
|
||
/// <item><c>GET /download/{id}</c> —— 查进度 / 结果</item>
|
||
/// <item><c>GET /download/{id}/file</c> —— 取成片,**传完立即删除**</item>
|
||
/// </list>
|
||
///
|
||
/// 为什么不用 HttpListener:绑定非 localhost 需要 urlacl(安装时要多一步提权操作),
|
||
/// 而这几个端点的报文都很简单,直接 TcpListener + 手写 HTTP 更可控。
|
||
/// </summary>
|
||
public sealed class EdgeHttpService
|
||
{
|
||
/// <summary>单次下载请求体的上限(流计划带几十个通道也远小于它)</summary>
|
||
private const int MaxBodyBytes = 4 * 1024 * 1024;
|
||
|
||
/// <summary>探测 NVR 的超时</summary>
|
||
private static readonly TimeSpan ProbeTimeout = TimeSpan.FromMilliseconds(800);
|
||
|
||
private readonly EdgeDownloadTasks _tasks;
|
||
private readonly SemaphoreSlim _downloadGate;
|
||
private readonly SemaphoreSlim _checkGate = new(4, 4);
|
||
private readonly Func<int, bool> _subjectGuard;
|
||
|
||
/// <param name="subjectGuard">主体校验:返回 false 直接 403(避免跨主体取流)</param>
|
||
public EdgeHttpService(EdgeDownloadTasks tasks, SemaphoreSlim downloadGate, Func<int, bool> subjectGuard)
|
||
{
|
||
_tasks = tasks;
|
||
_downloadGate = downloadGate;
|
||
_subjectGuard = subjectGuard;
|
||
}
|
||
|
||
public async Task RunAsync(PlaybackDownloadService download, HikPlaybackService playback,
|
||
CancellationToken ct)
|
||
{
|
||
TcpListener listener;
|
||
try
|
||
{
|
||
listener = new TcpListener(IPAddress.Parse(HikWorkerPorts.BindAddress), HikWorkerPorts.Http);
|
||
listener.Start();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 取流端口 {HikWorkerPorts.Http} 监听失败(跨网取流不可用):{ex.Message}");
|
||
return;
|
||
}
|
||
|
||
AppLog.Write($"[edge] 取流接口已就绪:TCP {HikWorkerPorts.Http}");
|
||
|
||
// 每分钟清理一次过期临时文件
|
||
_ = Task.Run(async () =>
|
||
{
|
||
while (!ct.IsCancellationRequested)
|
||
{
|
||
try
|
||
{
|
||
await Task.Delay(TimeSpan.FromMinutes(1), ct).ConfigureAwait(false);
|
||
_tasks.Cleanup();
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
break;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 清理任务异常:{ex.Message}");
|
||
}
|
||
}
|
||
}, CancellationToken.None);
|
||
|
||
try
|
||
{
|
||
while (!ct.IsCancellationRequested)
|
||
{
|
||
TcpClient client;
|
||
try
|
||
{
|
||
client = await listener.AcceptTcpClientAsync(ct).ConfigureAwait(false);
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
break;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 接受连接失败(继续):{ex.Message}");
|
||
continue;
|
||
}
|
||
|
||
_ = Task.Run(() => HandleAsync(client, download, playback, ct), CancellationToken.None);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
try
|
||
{
|
||
listener.Stop();
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
}
|
||
|
||
private sealed record HttpRequest(string Method, string Path, Dictionary<string, string> Headers, byte[] Body);
|
||
|
||
private async Task HandleAsync(TcpClient client, PlaybackDownloadService download,
|
||
HikPlaybackService playback, CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
using (client)
|
||
using (var stream = client.GetStream())
|
||
using (var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct))
|
||
{
|
||
timeout.CancelAfter(TimeSpan.FromMinutes(5));
|
||
|
||
var request = await ReadRequestAsync(stream, timeout.Token).ConfigureAwait(false);
|
||
if (request is null) return;
|
||
|
||
await RouteAsync(stream, request, download, playback, timeout.Token).ConfigureAwait(false);
|
||
}
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
// 超时/取消:不记日志(探测连接本来就短)
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 请求处理失败:{ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async Task RouteAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
|
||
HikPlaybackService playback, CancellationToken ct)
|
||
{
|
||
var path = request.Path.Split('?')[0];
|
||
|
||
if (path.Equals("/health", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var config = AgentFiles.LoadConfig();
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
service = "yuncang-edge",
|
||
sn = config?.DeviceSn,
|
||
subjectId = config?.SubjectId,
|
||
port = HikWorkerPorts.Http,
|
||
}, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
// 除 health 外都要校验主体
|
||
if (!CheckSubject(request, out var subjectError))
|
||
{
|
||
var config = AgentFiles.LoadConfig();
|
||
AppLog.Write($"[edge] 拒绝 {request.Method} {path}:{subjectError}"
|
||
+ $"(本体主体 {(config is null ? "无" : config.SubjectId.ToString())})");
|
||
await WriteJsonAsync(stream, 403, "Forbidden", new { ok = false, error = subjectError }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.Equals("/probe", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
await HandleProbeAsync(stream, request, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.Equals("/check", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
await HandleCheckAsync(stream, request, playback, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.Equals("/download", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
await HandleDownloadAsync(stream, request, download, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.StartsWith("/download/", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var rest = path["/download/".Length..];
|
||
var isFile = rest.EndsWith("/file", StringComparison.OrdinalIgnoreCase);
|
||
var id = isFile ? rest[..^"/file".Length] : rest;
|
||
|
||
var task = _tasks.Get(id);
|
||
if (task is null)
|
||
{
|
||
await WriteJsonAsync(stream, 404, "Not Found", new { ok = false, error = "任务不存在或已过期" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (isFile)
|
||
{
|
||
await WriteFileAsync(stream, task, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
taskId = task.Id,
|
||
state = task.State,
|
||
progress = task.Progress,
|
||
size = task.Size,
|
||
error = task.Error,
|
||
}, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 404, "Not Found", new { ok = false, error = "未知接口" }, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>主体校验:优先看请求头,缺省按"不允许"处理</summary>
|
||
private bool CheckSubject(HttpRequest request, out string error)
|
||
{
|
||
error = "";
|
||
|
||
if (!request.Headers.TryGetValue("x-edge-subject", out var raw) || !int.TryParse(raw, out var subjectId))
|
||
{
|
||
error = "缺少 X-Edge-Subject";
|
||
return false;
|
||
}
|
||
|
||
if (!_subjectGuard(subjectId))
|
||
{
|
||
error = "主体不匹配";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private static async Task HandleProbeAsync(Stream stream, HttpRequest request, CancellationToken ct)
|
||
{
|
||
string host;
|
||
int port = 8000;
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(request.Body);
|
||
host = doc.RootElement.TryGetProperty("nvrHost", out var h) ? h.GetString() ?? "" : "";
|
||
if (doc.RootElement.TryGetProperty("nvrPort", out var p) && p.TryGetInt32(out var parsed)) port = parsed;
|
||
}
|
||
catch
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = "请求体不是合法 JSON" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(host) || port is <= 0 or > 65535)
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = "nvrHost/nvrPort 不合法" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var sw = Stopwatch.StartNew();
|
||
var reachable = false;
|
||
try
|
||
{
|
||
using var tcp = new TcpClient();
|
||
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
|
||
timeout.CancelAfter(ProbeTimeout);
|
||
await tcp.ConnectAsync(host, port, timeout.Token).ConfigureAwait(false);
|
||
reachable = tcp.Connected;
|
||
}
|
||
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
|
||
{
|
||
reachable = false;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
reachable = false;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
reachable,
|
||
latencyMs = sw.ElapsedMilliseconds,
|
||
}, ct).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 校验该时段有没有录像:**真拉一小段**(与桌面端本地的校验同一套实现)。
|
||
///
|
||
/// 查询机会先在局域网问"谁能服务这台 NVR",拿到应答后把校验也交给它,
|
||
/// 这样多台查询机不会各自登录一次 NVR。
|
||
/// </summary>
|
||
private async Task HandleCheckAsync(Stream stream, HttpRequest request, HikPlaybackService playback,
|
||
CancellationToken ct)
|
||
{
|
||
string host;
|
||
int port = 8000;
|
||
string username;
|
||
string password;
|
||
int channelNo;
|
||
DateTimeOffset start;
|
||
DateTimeOffset end;
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(request.Body);
|
||
var root = doc.RootElement;
|
||
|
||
host = ReadString(root, "nvrHost") ?? "";
|
||
username = ReadString(root, "username") ?? "";
|
||
password = ReadString(root, "password") ?? "";
|
||
|
||
if (root.TryGetProperty("nvrPort", out var portElement) && portElement.TryGetInt32(out var parsedPort))
|
||
{
|
||
port = parsedPort;
|
||
}
|
||
|
||
if (!root.TryGetProperty("channelNo", out var channelElement) || !channelElement.TryGetInt32(out channelNo))
|
||
{
|
||
throw new InvalidOperationException("缺少 channelNo");
|
||
}
|
||
|
||
if (!root.TryGetProperty("startTime", out var startElement) || !startElement.TryGetDateTimeOffset(out start)
|
||
|| !root.TryGetProperty("endTime", out var endElement) || !endElement.TryGetDateTimeOffset(out end))
|
||
{
|
||
throw new InvalidOperationException("startTime/endTime 不合法");
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(host) || port is <= 0 or > 65535)
|
||
{
|
||
throw new InvalidOperationException("nvrHost/nvrPort 不合法");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = ex.Message }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
await _checkGate.WaitAsync(ct).ConfigureAwait(false);
|
||
try
|
||
{
|
||
var check = await playback.CheckAsync(host, port, username, password, channelNo, start, end, ct)
|
||
.ConfigureAwait(false);
|
||
|
||
AppLog.Write($"[edge] 校验 {host}:{port} 通道 {channelNo} "
|
||
+ $"{start:HH:mm:ss}~{end:HH:mm:ss} → hasRecord={check.HasRecord}"
|
||
+ $"({check.Source},{check.Frames} 帧{(string.IsNullOrEmpty(check.Error) ? "" : "," + check.Error)})");
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
hasRecord = check.HasRecord,
|
||
frames = check.Frames,
|
||
error = check.Error,
|
||
source = check.Source,
|
||
}, ct).ConfigureAwait(false);
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
throw;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 校验失败 {host}:{port} 通道 {channelNo}:{ex.Message}");
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
hasRecord = false,
|
||
frames = 0,
|
||
error = ex.Message,
|
||
source = "",
|
||
}, ct).ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
_checkGate.Release();
|
||
}
|
||
}
|
||
|
||
private async Task HandleDownloadAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
|
||
CancellationToken ct)
|
||
{
|
||
string code;
|
||
List<PackStream> streams;
|
||
Dictionary<int, NvrCredential> credentials;
|
||
DateTime scanTime;
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(request.Body);
|
||
var root = doc.RootElement;
|
||
|
||
code = root.TryGetProperty("code", out var c) ? c.GetString() ?? "" : "";
|
||
if (code.Length == 0) throw new InvalidOperationException("缺少运单号");
|
||
|
||
streams = root.TryGetProperty("streams", out var s)
|
||
? s.Deserialize<List<PackStream>>(HikWorkerJson.Options) ?? new List<PackStream>()
|
||
: new List<PackStream>();
|
||
if (streams.Count == 0) throw new InvalidOperationException("缺少 streams");
|
||
|
||
credentials = new Dictionary<int, NvrCredential>();
|
||
if (root.TryGetProperty("credentials", out var cr) && cr.ValueKind == JsonValueKind.Array)
|
||
{
|
||
foreach (var item in cr.EnumerateArray())
|
||
{
|
||
var id = item.TryGetProperty("nvrId", out var idElement) ? idElement.GetInt32() : 0;
|
||
if (id <= 0) continue;
|
||
|
||
credentials[id] = new NvrCredential(
|
||
id,
|
||
ReadString(item, "name") ?? "",
|
||
ReadString(item, "host") ?? "",
|
||
item.TryGetProperty("port", out var portElement) ? portElement.GetInt32() : 8000,
|
||
ReadString(item, "username") ?? "",
|
||
ReadString(item, "password") ?? "");
|
||
}
|
||
}
|
||
|
||
var missing = streams.Select(item => item.NvrId).Distinct()
|
||
.Where(id => !credentials.ContainsKey(id)).ToList();
|
||
if (missing.Count > 0) throw new InvalidOperationException($"缺少录像机凭据:{string.Join("、", missing)}");
|
||
|
||
scanTime = root.TryGetProperty("scanTime", out var st) && st.TryGetDateTimeOffset(out var parsed)
|
||
? parsed.LocalDateTime
|
||
: streams[0].StartTime.LocalDateTime;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = ex.Message }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var task = _tasks.Create(code);
|
||
var workDir = _tasks.WorkDirectory(task.Id);
|
||
|
||
// 后台执行:接口立刻返回,查询机轮询 /download/{id}
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
task.State = "running";
|
||
task.Progress = "开始下载";
|
||
AppLog.Write($"[edge] 任务 {task.Id} 开始:{code},{streams.Count} 路");
|
||
|
||
await _downloadGate.WaitAsync(CancellationToken.None).ConfigureAwait(false);
|
||
try
|
||
{
|
||
var result = await download.DownloadByPlanAsync(
|
||
code,
|
||
streams,
|
||
scanTime,
|
||
workDir,
|
||
(nvrId, _) => Task.FromResult(credentials[nvrId]),
|
||
new Progress<string>(text => task.Progress = text),
|
||
CancellationToken.None).ConfigureAwait(false);
|
||
|
||
var file = result.Merged
|
||
?? result.Segments.FirstOrDefault();
|
||
if (string.IsNullOrEmpty(file) || !File.Exists(file))
|
||
{
|
||
_tasks.Fail(task, "下载完成但没有生成成片");
|
||
AppLog.Write($"[edge] 任务 {task.Id} 失败:没有生成成片");
|
||
return;
|
||
}
|
||
|
||
_tasks.Finish(task, file);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 完成:{file}({task.Size / 1024 / 1024} MB),等待查询机取走");
|
||
}
|
||
finally
|
||
{
|
||
_downloadGate.Release();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_tasks.Fail(task, ex.Message);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 失败:{ex.Message}");
|
||
}
|
||
}, CancellationToken.None);
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new { ok = true, taskId = task.Id }, ct).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>流式返回成片;**写完立即删除**,查询机那边才负责落盘</summary>
|
||
private async Task WriteFileAsync(Stream stream, EdgeDownloadTask task, CancellationToken ct)
|
||
{
|
||
if (task.State != "done" || string.IsNullOrEmpty(task.FilePath) || !File.Exists(task.FilePath))
|
||
{
|
||
await WriteJsonAsync(stream, 409, "Conflict", new { ok = false, error = "任务还没完成", state = task.State }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var fileInfo = new FileInfo(task.FilePath);
|
||
var name = Path.GetFileName(task.FilePath);
|
||
|
||
var header = "HTTP/1.1 200 OK\r\n"
|
||
+ "Content-Type: video/mp4\r\n"
|
||
+ $"Content-Length: {fileInfo.Length}\r\n"
|
||
+ $"Content-Disposition: attachment; filename=\"{Uri.EscapeDataString(name)}\"\r\n"
|
||
+ "Connection: close\r\n\r\n";
|
||
|
||
await stream.WriteAsync(Encoding.UTF8.GetBytes(header), ct).ConfigureAwait(false);
|
||
|
||
try
|
||
{
|
||
using var file = File.OpenRead(task.FilePath);
|
||
await file.CopyToAsync(stream, 81920, ct).ConfigureAwait(false);
|
||
await stream.FlushAsync(ct).ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
// 无论传完还是中途断开,都释放磁盘:现场机器不会有人来打扫
|
||
_tasks.Delivered(task);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 已投递并清理");
|
||
}
|
||
}
|
||
|
||
private static async Task WriteJsonAsync(Stream stream, int status, string reason, object payload,
|
||
CancellationToken ct)
|
||
{
|
||
var body = JsonSerializer.SerializeToUtf8Bytes(payload, HikWorkerJson.Options);
|
||
var header = $"HTTP/1.1 {status} {reason}\r\n"
|
||
+ "Content-Type: application/json; charset=utf-8\r\n"
|
||
+ $"Content-Length: {body.Length}\r\n"
|
||
+ "Connection: close\r\n\r\n";
|
||
|
||
await stream.WriteAsync(Encoding.UTF8.GetBytes(header), ct).ConfigureAwait(false);
|
||
await stream.WriteAsync(body, ct).ConfigureAwait(false);
|
||
await stream.FlushAsync(ct).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>读一个 HTTP 请求(只支持 Content-Length,够我们这些端点用)</summary>
|
||
private static async Task<HttpRequest?> ReadRequestAsync(Stream stream, CancellationToken ct)
|
||
{
|
||
var buffer = new MemoryStream();
|
||
var chunk = new byte[4096];
|
||
var headerEnd = -1;
|
||
|
||
while (headerEnd < 0 && buffer.Length < 64 * 1024)
|
||
{
|
||
var read = await stream.ReadAsync(chunk, ct).ConfigureAwait(false);
|
||
if (read == 0) return null;
|
||
|
||
buffer.Write(chunk, 0, read);
|
||
headerEnd = FindHeaderEnd(buffer.GetBuffer(), (int)buffer.Length);
|
||
}
|
||
|
||
if (headerEnd < 0) return null;
|
||
|
||
var all = buffer.GetBuffer();
|
||
var headerText = Encoding.UTF8.GetString(all, 0, headerEnd);
|
||
var lines = headerText.Split("\r\n", StringSplitOptions.None);
|
||
if (lines.Length == 0) return null;
|
||
|
||
var requestLine = lines[0].Split(' ');
|
||
if (requestLine.Length < 2) return null;
|
||
|
||
var method = requestLine[0];
|
||
var path = requestLine[1];
|
||
|
||
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||
for (var i = 1; i < lines.Length; i++)
|
||
{
|
||
var index = lines[i].IndexOf(':');
|
||
if (index <= 0) continue;
|
||
headers[lines[i][..index].Trim()] = lines[i][(index + 1)..].Trim();
|
||
}
|
||
|
||
var contentLength = headers.TryGetValue("Content-Length", out var raw)
|
||
&& int.TryParse(raw, out var parsed)
|
||
? parsed
|
||
: 0;
|
||
|
||
if (contentLength == 0
|
||
&& headers.TryGetValue("Transfer-Encoding", out var transferEncoding)
|
||
&& transferEncoding.Contains("chunked", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
// 手写解析只认 Content-Length:真遇到 chunked 就明说,别让调用方看到「空 body」的怪错误
|
||
AppLog.Write($"[edge] 收到 chunked 请求 {method} {path}(不支持,请用 Content-Length)");
|
||
return null;
|
||
}
|
||
|
||
if (contentLength is < 0 or > MaxBodyBytes) return null;
|
||
|
||
var bodyStart = headerEnd + 4;
|
||
var body = new byte[contentLength];
|
||
var available = (int)buffer.Length - bodyStart;
|
||
if (available > 0) Array.Copy(all, bodyStart, body, 0, Math.Min(available, contentLength));
|
||
|
||
var remaining = contentLength - Math.Min(available, contentLength);
|
||
var offset = Math.Min(available, contentLength);
|
||
while (remaining > 0)
|
||
{
|
||
var read = await stream.ReadAsync(body.AsMemory(offset, remaining), ct).ConfigureAwait(false);
|
||
if (read == 0) break;
|
||
offset += read;
|
||
remaining -= read;
|
||
}
|
||
|
||
return new HttpRequest(method, path, headers, body);
|
||
}
|
||
|
||
private static int FindHeaderEnd(byte[] buffer, int length)
|
||
{
|
||
for (var i = 0; i + 3 < length; i++)
|
||
{
|
||
if (buffer[i] == '\r' && buffer[i + 1] == '\n' && buffer[i + 2] == '\r' && buffer[i + 3] == '\n')
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
private static string? ReadString(JsonElement element, string name)
|
||
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
|
||
? value.GetString()
|
||
: null;
|
||
}
|