Files
SimpleRemoter/server/2015Remote/McpServer.h
T
yuanyuanxiang cdd9c56b3d Feature: Add window/region capture targets to remote_open
Pass the target HWND through the COMMAND_SCREEN_SPY token and send
COMMAND_SCREEN_ROI after session start, so MCP remote control can stream
just the target window or region instead of the scaled virtual desktop.
The session records the target kind, remote_mouse refuses a redundant
window_hwnd basis, and the cached resolution is refreshed per action so
resized windows keep mapping correctly. Cold starts now clear the stale
resolution cache used by the region handshake.
2026-11-10 19:13:45 +01:00

970 lines
63 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.
#pragma once
#include <Windows.h>
#include <string>
#include <thread>
#include <atomic>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <map>
#include <set>
#include <unordered_map>
#include <vector>
#include <deque>
#include <memory>
#include <cstdint>
#include <ctime>
// httplib 与 Windows 头部的 min/max 宏冲突,按 file_server.h 的既有约定处理。
#undef min
#undef max
#include "httplib.h"
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#include "McpTlsProxy.h"
#pragma comment(lib, "ws2_32.lib")
class CMy2015RemoteDlg;
class context;
// 文件传输结果条目(download_file 输出 files[] 的一项)。
// path 为本机落盘绝对路径(ANSI,输出 JSON 时再转 UTF-8);sha256 为小写 hex。
struct FileTransferEntry {
std::string path;
uint64_t size = 0;
std::string sha256;
};
// 远程交谈消息(chat_wait 输出 messages[] 的一项)。
// text 为 UTF-8;at 为收到消息的 Unix 秒;id 为会话内单调递增序号。
struct ChatMessage {
uint64_t id = 0;
int64_t at = 0;
std::string text;
};
// ===== P11:tools/call 的在飞上下文(progress / cancelled / 会话观测)=====
//
// 每一次 tools/call 都在服务端登记一个 McpCallContext(见 CMcpServer::BeginCall),
// 工具实现通过 CurrentMcpCall() 拿到它(实现是 FLS 每线程槽,不是 thread_local:
// 本工程有 shellcode 线程,thread_local 会让服务端启动即崩,原因见 McpServer.cpp):
// - 长任务在等待循环里调用 McpCallProgress(),按 1s 节流把
// notifications/progress 推给带 _meta.progressToken 的请求;
// - 等待循环用 McpCallCancelled() 尽早返回(notifications/cancelled 或
// mcp_cancel_session 置位后 ≤1 个等待切片退出,走既有的超时清理路径);
// - mcp_list_sessions 用它回答「谁占着这台主机」。
// channel 只在 SSE 请求上非空:进度通知随该请求自己的流下发,不需要额外的 GET 流。
struct McpProgressChannel; // 定义见 McpServer.cpp
struct McpCallContext {
std::string idKey; // JSON-RPC id 的紧凑序列化(字符串带引号;"41" 与 41 不混同)
std::string idText; // 同一 id 的展示文本(字符串取原文、整数取十进制),
// 与 mcp_list_sessions 的 request_id 一致,可按它回传取消
std::string tool;
uint64_t device = 0; // 参数里的 id(没有则为 0)
std::string sessionId; // 参数里的 session_id(没有则空)
std::chrono::steady_clock::time_point startedAt;
// 取消位:取消后工具层的等待按超时返回,服务端把最终错误统一改写成 -32800。
std::atomic<bool> cancelled{false};
// 进度通道:hasProgressToken=false 时一切进度调用都是空操作。
bool hasProgressToken = false;
std::string progressTokenJson; // progressToken 的 JSON 文本(原样回显)
std::shared_ptr<McpProgressChannel> channel;
std::mutex progressMu;
std::chrono::steady_clock::time_point lastProgressAt{};
// 节流(约 1s)后投递一条 progress 通知;没有 token/通道时直接返回。
void EmitProgress(double current, double total, bool hasTotal);
bool IsCancelled() const { return cancelled.load(std::memory_order_relaxed); }
};
// 当前工具调用的上下文(每线程槽;非 MCP 工具线程返回 nullptr)。
std::shared_ptr<McpCallContext> CurrentMcpCall();
// 当前调用是否已被取消(没有上下文时为 false)。
bool McpCallCancelled();
// 报告进度:McpCallProgress(n) 表示「进度 n、无总量」;带 total 的重载给出总量。
void McpCallProgress(double current);
void McpCallProgress(double current, double total);
// -32003 的正文:在通用句后附上「谁占着这台主机、已持续多久」(没有占用信息时原样返回
// base)。占着主机的是别的一次调用——当前这次 tools/call 自己会被排除。
std::string BusyMessage(const std::string& base, uint64_t devId);
// MCP (Model Context Protocol) 服务端:httplib 封装 + JSON-RPC 2.0 分发 + 静态 token 校验。
// 与 CWebService 平级、互不依赖;默认禁用,经「扩展 → MCP设置」开启后监听
// (默认 127.0.0.1:6544,仅本机回环)。见 docs/Mcp_Design.md。
class CMcpServer {
public:
static CMcpServer& Instance();
void SetParentDlg(CMy2015RemoteDlg* pDlg) { m_parent = pDlg; }
void SetToken(const std::string& token) { m_token = token; }
// HTTPS(native TLS):开启后 httplib 退到 127.0.0.1:internalPort,对外由 McpTlsProxy
// 在 bind:port 上同端口嗅探(TLS 解密 / 明文直通)。internalPort <= 0 时取 port+1。
void SetHttps(bool enabled, const std::string& certPath, const std::string& keyPath,
int internalPort) {
m_httpsEnabled = enabled;
m_certPath = certPath;
m_keyPath = keyPath;
m_internalPort = internalPort;
}
bool IsHttps() const { return m_httpsEnabled; }
int GetInternalPort() const { return m_internalPort; }
bool Start(const std::string& bind, int port);
void Stop();
bool IsRunning() const { return m_running.load(); }
// ===== P2b:无请求 id 的一次性响应 → 每 host 单飞行 =====
// 进程/窗口列表(TOKEN_PSLIST/TOKEN_WSLIST,一次性子链接)与历史活动
// (TOKEN_REPORT_ACTIVITY,主连接 RPC)都不带请求关联,同一 host 同一时刻
// 只允许一个挂起请求,避免同 host 并发请求响应归属歧义。
// 注意:单飞行只约束 MCP 侧同 host 并发,不约束与 MFC 对话框并存(各用独立子链接)。
// 该 host 是否已有挂起请求(MessageHandle 在 TOKEN_PSLIST/TOKEN_WSLIST 分支调用)。
bool IsPending(uint64_t device_id);
// 拷贝响应缓冲到挂起结果并唤醒等待者(在 MessageHandle 内同步调用,数据此时仍在
// context 缓冲中、IO 线程被阻塞,拷贝是安全的)。
void TakeMainResponse(uint64_t device_id, const BYTE* data, ULONG len);
// 工具线程:登记挂起(false = 该 host 已有挂起请求,设备忙)。
bool BeginPending(uint64_t device_id, const std::string& tool);
// 工具线程:等待响应;成功返回 true 并把缓冲写入 out,超时/失败返回 false(并清理)。
bool WaitPending(uint64_t device_id, std::vector<BYTE>& out, int timeoutMs);
// 工具线程:清理挂起状态(发送失败等提前退出路径)。
void ClearPending(uint64_t device_id);
// ===== P2c:list_files / get_screenshot 扩展 =====
// 登记挂起(带目录路径;list_files 专用,path 为空表示只列盘)。
bool BeginPending(uint64_t device_id, const std::string& tool, const std::string& path);
// get_screenshot:工具线程生成 16 位 reqId(跳过 0,0 表示未设置),用于丢弃过期响应。
uint16_t NextPreviewReqId();
// get_screenshot:登记期望的 reqId(必须在发送 COMMAND_SCREEN_PREVIEW_REQ 前调用)。
void SetPendingReqId(uint64_t device_id, uint16_t reqId);
// get_screenshot:MessageHandle(TOKEN_SCREEN_PREVIEW_RSP) 在 IO 线程同步调用;
// 挂起命中且 reqId 一致则拷贝响应并返回 true,否则 false(回落到 MFC 预览路径)。
bool TakePreviewResponse(uint64_t device_id, uint16_t reqId, const BYTE* data, ULONG len);
// list_files:MessageHandle(TOKEN_DRIVE_LIST) 调用。
// 返回 true = 已取走盘列表(调用方 CancelIO);false = 已转向下发 COMMAND_LIST_FILES、
// 等 TOKEN_FILE_LIST(调用方不关子链接)。
bool OnDriveList(uint64_t device_id, context* subCtx, const BYTE* buf, ULONG len);
// ===== B2:search_file(文件搜索,COMMAND_SEARCH_FILE → N×TOKEN_SEARCH_FILE_LIST
// + TOKEN_SEARCH_FILE_FINISH)=====
//
// 搜索结果是「流式多包」:客户端边搜边发,最后单独发一个 FINISH。子连接在 FINISH
// 之前绝不能关——客户端 CFileManager 的搜索线程持有 this 指针,连接在内搜索未停时
// 断开会让它访问已析构对象(客户端既有缺陷)。
//
// MessageHandle(TOKEN_SEARCH_FILE_LIST) 调用:挂起命中且为 search_file 则收下这一包。
// 超过收集上限时自行下发 COMMAND_FILES_SEARCH_STOP 并标记 truncated。
// 只接受来自登记过的那条子连接(pending.subCtx)的包:被放弃的旧搜索在设备重开后
// 仍可能吐尾包,按 context 身份区分,避免把旧搜索的结果/结束信号算到新搜索头上。
bool OnSearchFileRecords(uint64_t device_id, context* subCtx, const BYTE* buf, ULONG len);
// MessageHandle(TOKEN_SEARCH_FILE_FINISH) 调用:置 finished 并唤醒等待者。
// 同样只认 pending.subCtx 发来的 FINISH;其它子连接的 FINISH 只关它自己,不影响挂起。
void FinishSearchFile(uint64_t device_id, context* subCtx);
// 工具线程:等待搜索结束(或超时)。取走已收集的原始包;finished=false 表示还在搜。
bool WaitSearchFile(uint64_t device_id, std::vector<std::vector<BYTE>>& records,
bool& finished, bool& truncated, context*& subCtx, int timeoutMs);
// 工具线程:让客户端停止搜索(COMMAND_FILES_SEARCH_STOP,客户端会等搜索线程退出
// 后回 FINISH)。幂等。
void StopSearchFile(uint64_t device_id);
// ===== P3:list_registry(注册表查询,三阶段:COMMAND_REGEDIT → TOKEN_REGEDIT →
// COMMAND_REG_FIND → TOKEN_REG_PATH + TOKEN_REG_KEY)=====
// MessageHandle(TOKEN_REGEDIT) 调用:挂起命中且为 list_registry 则下发 COMMAND_REG_FIND
// 并返回 true(接管子链接,不打开 MFC 对话框);否则 false(回落 MFC)。
bool OnRegeditReady(uint64_t device_id, context* subCtx);
// MessageHandle(TOKEN_REG_PATH / TOKEN_REG_KEY) 调用:两包都到齐后置 done 并唤醒等待者。
void TakeRegPath(uint64_t device_id, const BYTE* data, ULONG len);
void TakeRegKey(uint64_t device_id, const BYTE* data, ULONG len);
// MessageHandle(TOKEN_REG_ERROR) 调用:键打不开(不存在/拒绝访问)。失败时客户端只发这一包,
// 故一次置满 pathDone/keyDone/done,让 WaitPendingRegistry 立即返回;错误包原样存进 regPath,
// 由 BuildListRegistry 读首字节转译成 -32009/-32010。
void TakeRegError(uint64_t device_id, const BYTE* data, ULONG len);
// 工具线程:等待注册表两包(子键 + 值);成功返回 true 并把两包分别写入 out,超时返回 false。
bool WaitPendingRegistry(uint64_t device_id, std::vector<BYTE>& subkeys,
std::vector<BYTE>& values, int timeoutMs);
// ===== P3:exec_command(Windows 一次性远程命令,复刻 Web 终端链路)=====
// 流程:工具线程 BeginTermPending → 主连接下发 COMMAND_SHELL → 客户端 shell 子连接回
// TOKEN_TERMINAL_START / TOKEN_SHELL_START → RegisterTerminalContext 接管 → 发
// COMMAND_NEXT(+PTY resize) 启动输出回流 → 工具线程发哨兵命令行 → OnTerminalData 收集
// 并做哨兵检测 → WaitTerminalDone 取 stdout + exit_code → CancelIO 关子链接。
// 单设备单终端(MVP):BeginTermPending 命中已有会话即拒绝,避免同设备并发归属歧义。
// 该 host 是否已有待接管的终端会话(MessageHandle TOKEN_*_START 分支调用)。
bool IsTermPending(uint64_t device_id);
// 终端子连接就绪:接管(登记 subCtx/isPty、清 pending、发 COMMAND_NEXT 唤醒回流)。
void RegisterTerminalContext(uint64_t device_id, context* subCtx, bool isPty);
// 终端子连接是否已被 MCP 接管(MessageHandle 顶部据此把 shell 输出路由到 OnTerminalData)。
bool IsTerminalContext(context* subCtx);
// 追加 shell 输出并做哨兵检测(命中置 done 并唤醒等待者)。
void OnTerminalData(context* subCtx, const BYTE* data, ULONG len);
// shell 进程退出(TOKEN_TERMINAL_CLOSE)。
void OnTerminalClosed(context* subCtx);
// 工具线程:登记终端挂起(false = 该 host 已有终端会话)。
bool BeginTermPending(uint64_t device_id, const std::string& command, const std::string& nonce);
// 工具线程:等待子连接回 START 并接管(true = 已接管,输出 subCtx/isPty)。
bool WaitTerminalReady(uint64_t device_id, context*& subCtx, bool& isPty, int timeoutMs);
// 工具线程:等待输出收集完成(哨兵命中 / 进程退出 / 超时)。
// 成功 true:out=截断到哨兵前的原始字节、exitCode=0/1(进程退出无哨兵时 -1)、closed=是否进程退出。
bool WaitTerminalDone(uint64_t device_id, std::vector<BYTE>& out, int& exitCode, bool& closed, int timeoutMs);
// 工具线程:清理终端挂起(发送失败等提前退出路径)。
void ClearTermPending(uint64_t device_id);
// ===== P4:持久远程终端(terminal_open / terminal_exec / terminal_close)=====
void SetTerminalEnabled(bool enabled) { m_terminalEnabled = enabled; }
bool IsTerminalEnabled() const { return m_terminalEnabled; }
// 登记持久终端挂起(复用单设备单终端约束;sessionId 由调用方生成)。
bool BeginTermOpen(uint64_t device_id, const std::string& sessionId);
// 复位单条命令字段并置 busy;输出 subCtx/isPty。
// 返回:0=ok;1=会话不存在;2=sessionId 不匹配;3=未就绪;4=忙(另一条命令在飞);
// 5=shell 已退出。1/2 之外的原因由 DescribeTermDestroyed 提供可读文案。
int BeginTermCommand(uint64_t device_id, const std::string& sessionId,
const std::string& command, const std::string& nonce,
context*& subCtx, bool& isPty);
// 只读查询持久会话状态与 PTY 形态(不置 busy、不改会话)。
// 返回码与 BeginTermCommand 相同,供调用方在执行前判断命令语法是否被支持。
int PeekTermSession(uint64_t device_id, const std::string& sessionId, bool& isPty);
// 若该设备上的持久终端最近被销毁(超时/退出/关闭),返回可读原因(英文,含时间);
// 否则返回空串。sessionId 不匹配时也返回空串(那是「id 写错」而不是「已销毁」)。
std::string DescribeTermDestroyed(uint64_t device_id, const std::string& sessionId);
// 等待本条命令完成(done || closed || 超时)。done=保持会话;closed/超时=清理会话+路由。
bool WaitTermCommand(uint64_t device_id, std::vector<BYTE>& out, int& exitCode,
bool& closed, int timeoutMs);
// 关闭持久终端(校验 sessionId;CancelIO + 清理路由/会话)。
// 返回:0=已关闭;1=会话不存在(幂等);2=sessionId 不匹配(调用方报错)。
int CloseTermSession(uint64_t device_id, const std::string& sessionId);
// idle 回收:关闭 lastActiveAt 超时且非 busy 的持久会话。返回回收数量。
int SweepIdleTerminals(time_t idleTimeoutSec);
// ===== P5:MCP 远程控制(remote_open / remote_close / remote_mouse / remote_keyboard)=====
// 屏幕子连接由 WebService::StartRemoteDesktop 建立的隐藏 CScreenSpyDlg 持有(复用 Web
// 路径,见 docs/Mcp_RemoteControl_Design.md §6.3);会话仅记录逻辑状态 + 子连接指针。
// 注入走该子连接(COMMAND_SCREEN_CONTROL),与终端一样单设备单会话。
void SetRemoteControlEnabled(bool enabled) { m_remoteControlEnabled = enabled; }
bool IsRemoteControlEnabled() const { return m_remoteControlEnabled; }
// 该 host 的屏幕子连接是否被 MCP 远程控制会话持有(OfflineProc 反查用)。
bool IsScreenCtrlContext(context* subCtx);
// 登记控制会话(单设备单会话;sessionId 由调用方生成)。false = 该设备已有会话。
bool BeginScreenCtrlOpen(uint64_t device_id, const std::string& sessionId);
// 子连接就绪(HasActiveSession && 分辨率到达)后调用:填 subCtx/分辨率并置 started。
// targeted=true 表示 remote_open 指定了 window_hwnd/region(帧不再是整屏)。
// false = 会话已被并发关闭(调用方应放弃本次 open)。
bool MarkScreenCtrlReady(uint64_t device_id, const std::string& sessionId,
context* subCtx, int screenW, int screenH,
bool targeted = false);
// 会话是否只推窗口/区域:此时归一化坐标已经相对目标帧,remote_mouse 的 window_hwnd
// 基准(相对整虚拟桌面)不再适用。须在 BeginScreenCtrlAction 之后调用。
bool IsScreenCtrlTargeted(uint64_t device_id, const std::string& sessionId);
// 注入前登记(校验 sessionId/started/!busy/!closed)。输出 subCtx/screenW/H。
// 注入期间 busy=true,保证 close/sweep/断线不与注入并发擦会话(镜像终端 busy 模式,
// 评审发现 #6)。返回:0=ok;1=不存在/不匹配/未就绪/已断(-32002);2=忙(-32003)。
int BeginScreenCtrlAction(uint64_t device_id, const std::string& sessionId,
context*& subCtx, int& screenW, int& screenH);
// 注入后复位 busy;若注入期间屏幕子连接已断(closed),擦会话+路由(防泄漏)。
void EndScreenCtrlAction(uint64_t device_id, const std::string& sessionId);
// 关闭控制会话(校验 sessionId;擦路由 + 会话)。屏幕子连接的关闭由调用方锁外执行
// (CloseWebRemoteDesktopByClientID)。返回 0=已关;1=不存在(幂等);2=sessionId 不匹配。
int CloseScreenCtrlSession(uint64_t device_id, const std::string& sessionId);
// idle 回收:关闭 lastActiveAt 超时的控制会话,并锁外关闭其隐藏对话框。返回回收数量。
int SweepIdleScreenCtrl(time_t idleTimeoutSec);
// 屏幕子连接断开(OfflineProc 调用):擦除该子连接对应的会话 + 路由(幂等)。
void OnScreenControlClosed(context* subCtx);
// ===== P10-C:键鼠锁定(remote_block_input)=====
// 锁定状态记在会话上,报文由调用方在锁外发([COMMAND_SCREEN_BLOCK_INPUT][0|1])。
// 必须在 BeginScreenCtrlAction 之后调用(busy 期间会话不会被并发擦除,状态才有意义)。
// block=true 时以 maxBlockMs 为自动解锁期限。autoUnblocked 输出「上一次锁定是否因
// 超过 maxBlockMs 被服务端自动解除」(取走后清除),供工具结果标注。
// 返回 false = 会话已不存在(防御;正常不会发生)。
bool ScreenCtrlSetBlock(uint64_t device_id, const std::string& sessionId, bool block,
int maxBlockMs, bool& autoUnblocked);
// 该会话此刻是否锁定着对端键鼠(仅审计用:remote_close 要能说明自己强制解了锁)。
bool IsScreenCtrlBlocked(uint64_t device_id, const std::string& sessionId);
// 键鼠锁定的强制解除:关闭会话 / idle 回收 / 超期自动解锁时必须先发 block=false,
// 否则客户端进程还活着就会一直 BlockInput(人进不来)。三处实现:
// 1) CloseScreenCtrlSession / SweepIdleScreenCtrl —— 擦会话前发(见 .cpp);
// 2) WatchdogScreenBlock —— 每 500ms 扫描超过 blockUntil 的会话;
// 3) OnScreenControlClosed —— 子连接已断,无从下发,只能靠客户端进程退出(既有局限)。
// 另一个既有局限:Windows 要求调用进程有管理员权限(或 UIAccess)才允许 BlockInput,
// 客户端忽略返回值,低权限下会静默不生效——服务端无从得知,故工具结果只承诺「已送达」。
void BlockWatchdogLoop();
void WatchdogScreenBlock();
// ===== P6:MCP 文件传输(download_file,V2 协议)=====
// 下载走 CMD_DOWN_FILES_V2 → 客户端新开流式子连接回传 COMMAND_SEND_FILE_V2 /
// COMMAND_FILE_COMPLETE_V2(dstClientID==0)。会话按 device_id 键控,单设备单传输;
// 复用 list_files 的 COMMAND_LIST_DRIVE → TOKEN_DRIVE_LIST 开文件管理器子链接下发命令。
void SetFileTransferEnabled(bool enabled) { m_fileTransferEnabled = enabled; }
bool IsFileTransferEnabled() const { return m_fileTransferEnabled; }
// ===== P10-B:文件系统写操作(delete_path / move_path / create_folder)=====
// 独立开关 McpFileWrite(默认关),并要求 McpReadonly=0。不复用 McpFileTransfer:
// 上传是「覆盖」,删除是「毁灭」,风险等级不同,必须能分别关掉。
void SetFileWriteEnabled(bool enabled) { m_fileWriteEnabled = enabled; }
bool IsFileWriteEnabled() const { return m_fileWriteEnabled; }
// 该 host 是否有进行中的文件传输会话(MessageHandle 分派守卫)。
bool IsFileTransferPending(uint64_t device_id);
// 该 host 上是否有「MCP 发起的 C2C 传输」正发往 dst_id。用于 COMMAND_SEND_FILE_V2
// 转发分支:MCP 的 C2C 不给源端子连接挂进度对话框(挂上后子连接的后续包会被路由到
// 对话框而不是 MessageHandle,源端最后的 TOKEN_C2C_SEND_RESULT 就会丢)。
bool IsC2CTransferPending(uint64_t src_id, uint64_t dst_id);
// 登记文件传输会话(false = 该 host 已有文件会话或一次性挂起请求)。
bool BeginFileTransferPending(uint64_t device_id, const std::string& tool,
const std::string& localDir, const std::string& remotePath,
bool overwrite);
// 登记上传会话(false = 该 host 已有文件会话或一次性挂起请求)。upload 走主连接、
// 工具线程同步驱动 FileBatchTransferWorkerV2。会话同时用于单设备单传输互斥与
// POSIX 目标端回执匹配(登记 dstClientID/transferID,见 OnC2CRecvResult)。
// (无 fmSubCtx/streamSubCtx,ClearFileTransfer 对空指针安全)。
bool BeginFileUpload(uint64_t device_id, uint64_t transfer_id);
// ===== C2C 文件传输(copy_files_c2c:源客户端 → 目标客户端,服务端只做中继)=====
// 会话键控在「源」设备上:工具线程只等源客户端回传的 TOKEN_C2C_SEND_RESULT,
// 目标端的收发由服务端现有的 COMMAND_SEND_FILE_V2 转发分支完成(不经过 MCP)。
struct C2CResult {
int error = 0; // 0=ok;1002=超时(工具侧);其余为客户端上报的 status
uint32_t status = 0; // C2CSendResultPacket.status(0=全部发出;FEV2_* / 1001)
DWORD win32err = 0; // 源端首个不可访问路径的 win32 码
int32_t workerRc = 0; // FileBatchTransferWorkerV2 返回值
uint32_t fileCount = 0;
uint64_t totalBytes = 0;
// 目标端回执(只有 POSIX 接收端会发;Windows 目标恒为 false)
bool recvAck = false; // 收到了目标端回执
uint32_t recvStatus = 0; // 回执 status(0=写入成功,FEV2_* = 失败原因)
DWORD recvErrno = 0; // 回执 win32err(POSIX 端放 errno)
uint32_t recvFileCount = 0; // 回执 fileCount(实收文件数)
uint64_t recvBytes = 0; // 回执 totalBytes(实收字节数)
};
// 登记 C2C 会话(false = 源设备已有文件会话/挂起请求,或源==目标)。
bool BeginC2CTransfer(uint64_t src_id, uint64_t dst_id, uint64_t transfer_id);
// TOKEN_C2C_SEND_RESULT:源客户端回传发送结果,填会话并唤醒工具线程。
// 无对应会话(迟到的结果、MFC 侧手写包)直接忽略。
void OnC2CResult(uint64_t src_id, const BYTE* buf, ULONG len);
// TOKEN_C2C_RECV_RESULT:目标客户端(目前只有 Linux)回传落盘回执。
// 会话匹配按 dstClientID + transferID:copy_files_c2c 的会话键在源端、只能反查;
// upload_file 的会话键就是目标端本身。回执可能早于源端结果到达,绝不置 done。
void OnC2CRecvResult(uint64_t dst_id, const BYTE* buf, ULONG len);
// 工具线程:等源客户端回传结果;true=全部发出(error=0)。调用方随后 ClearFileTransfer(src)。
bool WaitC2CDone(uint64_t src_id, int timeoutMs, C2CResult& out);
// 工具线程:源端报告发出后再等目标端回执(仅声明 CLIENT_CAP_C2C_RECV_ACK 的端会回);
// true=收到回执(out.recvStatus 判断成败),false=没有回执(老客户端/超时)。
bool WaitC2CReceiver(uint64_t src_id, int timeoutMs, C2CResult& out);
// TOKEN_DRIVE_LIST:识别 download_file,存文件管理器子链接并下发 CMD_DOWN_FILES_V2。
// 返回 true=已接管(保持子链接,收尾由 ClearFileTransfer);false=会话已清理(调用方 CancelIO)。
bool OnDownloadDriveList(uint64_t device_id, context* fmSubCtx);
// COMMAND_SEND_FILE_V2:解析 chunk,路径校验 + overwrite 判定 + 落盘(RecvFileChunkV2)。
void OnFileChunkV2(uint64_t device_id, context* streamSubCtx, const BYTE* buf, ULONG len);
// TOKEN_DOWNLOAD_ERROR:客户端在建立传输子链接之前就判定「无可传输文件」(远端路径不存在/
// 不可访问)。置会话 error=1005(不存在)/1006(拒绝访问)/1007(其他)并唤醒等待线程。
// 不在此 CancelIO:文件管理器子链接由 ClearFileTransfer 统一收尾。
void OnDownloadError(uint64_t device_id, context* fmSubCtx, const BYTE* buf, ULONG len);
// COMMAND_FILE_COMPLETE_V2:SHA-256 校验(HandleFileCompleteV2)+ 完成判定。
void OnFileCompleteV2(uint64_t device_id, const BYTE* buf, ULONG len);
// 工具线程:等待传输完成;true=成功(files 已填,error=0),false=失败/超时(error 填原因)。
// 无论成败,files 都会返回已见文件的落盘路径(成功=完整文件,失败=供调用方删半成品)。
// 调用方随后必须调 ClearFileTransfer 收尾(擦会话 + CancelIO 子链接)。
bool WaitFileTransferDone(uint64_t device_id, int timeoutMs,
std::vector<FileTransferEntry>& files, int& skipped, int& error,
DWORD* errorDetail = nullptr);
// 收尾:擦会话 + 锁外 CancelIO 文件管理器/流式两条子链接(幂等)。
void ClearFileTransfer(uint64_t device_id);
// 文件传输子链接断开(OfflineProc 调用):清反查表 + 置空裸指针,避免工具线程超时路径
// 对已回收(连接池复用)的 context 误 CancelIO。流式子链接断开 = 传输失败(1003);
// 文件管理器子链接断开只是少了收尾对象,传输数据走流式子链接,不判失败。
void OnFileTransferContextClosed(context* subCtx);
// ===== P7:设备管理控制(kill_process / operate_window / control_service / power_action)=====
// 写工具复用 m_Pending 单飞行;followUp/followUpSent/subCtx 标记接管进度。
// 「就绪 token」与「确认 token」是同一 token(客户端子连接构造即回一包,写后再回一包),
// 故必须用 followUpSent 区分两次到达,不能靠 token 区分(与 list_registry 的 PATH/KEY 双 token 不同)。
void SetManageEnabled(bool enabled) { m_manageEnabled = enabled; }
bool IsManageEnabled() const { return m_manageEnabled; }
// 登记写挂起:与 BeginPending 同单飞行,另预填 followUp(写命令 payload)。
bool BeginPendingFollowUp(uint64_t device_id, const std::string& tool,
const std::vector<BYTE>& followUp);
// MessageHandle(TOKEN_PSLIST/TOKEN_WSLIST) 调用:命中且为写工具(kill_process/operate_window)
// 则接管子连接、下发 followUp(返回 true=已接管,调用方不 CancelIO);否则 false(回落 MFC
// 或按确认包走 TakeMainResponse)。
bool OnSystemReady(uint64_t device_id, context* subCtx);
// MessageHandle(TOKEN_SERVERLIST) 调用:命中且为 control_service 则接管、下发
// COMMAND_SERVICECONFIG(返回 true=已接管);否则 false。
bool OnServiceReady(uint64_t device_id, context* subCtx);
// 工具线程:等待写确认包(第二个同 token 包);超时/空数据清挂起并 CancelIO 子连接。
// phaseOut(可空):返回超时/成功那一刻所处的阶段(见 P10-B 的 phase),供调用方区分
// 「连完成包都没收到」与「完成包已到、复核没回来」。
bool WaitPendingWrite(uint64_t device_id, std::vector<BYTE>& out, int timeoutMs,
int* phaseOut = nullptr);
// ===== P10-B:文件系统写操作(delete_path / move_path / create_folder)=====
// 链路与 P7 同构(主连接 COMMAND_LIST_DRIVE → 子连接首包 TOKEN_DRIVE_LIST → 同一子连接
// 上发写命令 → 等 TOKEN_*_FINISH),但多一个阶段:客户端的完成包是无条件回包
// (忽略 DeleteFile/MoveFile/MakeSureDirectoryPathExists 的返回值),所以收到后不直接
// 收尾,而在同一子连接上补发一次 COMMAND_LIST_FILES 复核(phase 0 = 等完成包,
// phase 1 = 等复核列目录,两阶段共用一个超时)。
//
// verifyPath 是复核要列的父目录(客户端 ANSI/GBK,空 = 不复核,直接投递完成包)。
bool BeginPendingFileOp(uint64_t device_id, const std::string& tool,
const std::vector<BYTE>& followUp, const std::string& verifyPath);
// MessageHandle(TOKEN_DELETE_FINISH / TOKEN_RENAME_FINISH / TOKEN_CREATEFOLDER_FINISH) 调用。
// NotMine 与本请求无关(迟到的孤儿包)→ 调用方 CancelIO 收尾;
// KeepSub 已转入 phase 1、在同一子连接上补发了列目录 → 调用方不关子连接;
// CloseSub 已投递最终数据(无复核目标 / 复核包发不出去)→ 调用方 CancelIO 收尾。
enum class FileOpAck { NotMine, KeepSub, CloseSub };
FileOpAck TakeFileOpFinish(uint64_t device_id, context* subCtx, const BYTE* data, ULONG len);
// ===== 迟到首包吸收(工具放弃后不再弹出 MFC 对话框)=====
// 工具超时/失败清掉挂起后,客户端仍可能才把应答首包发上来(列盘、服务列表、注册表、
// 进程列表、终端都是「子连接建成即发」)。那时已无挂起会话,MessageHandle 会把它当成
// 人手点击而打开文件管理器/服务管理器/注册表/进程窗口/日志/终端窗口。
// 工具放弃时按设备登记该工具的应答首包 token;包到达时一次性吸收(调用方关子连接、
// 不弹窗)。命中即消费,过期即失效,绝不长期压制人工操作。
// MessageHandle 各对话框分支开头调用(早于挂起判断:成功路径同样消费,不留残留)。
bool TakeToolFirstPacket(uint64_t device_id, BYTE token);
// OfflineProc 调用:接管的子连接断开时清挂起(置 done 并清 subCtx,唤醒等待线程)。
// 不擦表(由 WaitPendingWrite 持有迭代器时自行擦除,防迭代器失效);清 subCtx 使
// 超时路径不会对已回收(连接池复用)的 context 误 CancelIO。
void OnManageSubClosed(context* subCtx);
// ===== P8:主机管理 / 连接管理(子连接会话)=====
// 协议:主连接下发 COMMAND_MACHINE_MANAGE(162) / COMMAND_CONNECTION(253) → 客户端新建
// 子连接 → 子连接回就绪包(TOKEN_SYSINFOLIST=61 / TOKEN_CONNECTION_LIST=255)→ 在同一
// 子连接上多步收发。会话复用 m_Pending 表(统一「单设备单飞行」),kind 区分工具族。
// 见 docs/Mcp_Machine_Design.md。
void SetMachineEnabled(bool enabled) { m_machineEnabled = enabled; }
bool IsMachineEnabled() const { return m_machineEnabled; }
void SetMachineDangerousEnabled(bool enabled) { m_machineDangerousEnabled = enabled; }
bool IsMachineDangerousEnabled() const { return m_machineDangerousEnabled; }
// MessageHandle 顶部钩子(终端拦截之后、switch 之前):true = 本包已由 MCP 消费。
// 已绑定的子连接:只保存期望 token 的包与 TOKEN_MACHINE_MSG(42),其余丢弃。
// 未绑定的子连接:仅 61/255 可作为就绪包尝试绑定;否则返回 false(MFC 行为不变)。
bool OnManagedSubPacket(context* subCtx, const BYTE* data, ULONG len);
// OfflineProc 钩子:接管的子连接断开 → 置 closed 唤醒等待者(幂等)。
void OnManagedContextClosed(context* subCtx);
// 工具线程:登记会话(false = 该设备已有挂起请求在飞 → 设备忙)。
bool BeginMachineSession(uint64_t device_id, const std::string& tool, context* mainCtx);
bool BeginConnMgrSession(uint64_t device_id, const std::string& tool, context* mainCtx);
// ===== N3:键盘记录(get_keylog)=====
// 复用 P8 的会话表(PendingKind::Keylog,单设备单飞行),但不走「请求-响应」:
// 主连接下发 COMMAND_KEYBOARD(169) → 客户端新建子连接 → TOKEN_KEYBOARD_START(293)
// 作为就绪包绑定 → 之后客户端每约 1s 推一包 TOKEN_KEYBOARD_DATA(294) 击键文本,
// 服务端累积到 keylogBuf 由 WaitKeylogData 取走。独立开关 McpKeylog(默认关)。
// 见 docs/Mcp_Design.md。
void SetKeylogEnabled(bool enabled) { m_keylogEnabled = enabled; }
bool IsKeylogEnabled() const { return m_keylogEnabled; }
// ===== 工具默认等待超时([settings] McpToolTimeoutMs,ini-only 键)=====
// 慢主机上 20s 固定的工具超时太紧;调到 60s 更实用。范围 clamp 到 [1000, 600000]。
// 改动需重启服务端生效(与其它 Mcp* 开关一致)。
void SetToolTimeoutMs(int ms);
int ToolTimeoutMs() const { return m_toolTimeoutMs; }
bool BeginKeylogSession(uint64_t device_id, const std::string& tool, context* mainCtx);
enum class KeylogWaitResult { Ok, Timeout, Closed };
// 取走累积字节并清零;timeoutMs 内无数据则 Timeout。truncated 回传是否已到上限。
KeylogWaitResult WaitKeylogData(uint64_t device_id, std::string& out,
int timeoutMs, bool& truncated);
// 工具线程:发命令前清空上一次响应并登记期望 token。
void ArmManagedResponse(uint64_t device_id, BYTE expectedToken);
// 工具线程:等待子连接就绪包 / 指定 token 的响应(超时由调用方按步给)。
enum class ManagedWaitResult { Ok, Timeout, Closed, ClientError };
ManagedWaitResult WaitManagedPacket(uint64_t device_id, BYTE token,
std::vector<BYTE>& out, context*& subCtxOut,
int timeoutMs, std::string& clientError);
// 工具线程:结束会话;cancelIo = 关闭子连接;markOrphan = 打 5s 墓碑
// (吸收迟到的 61/255,避免超时后弹出 MFC 对话框)。
void EndManagedSession(uint64_t device_id, bool cancelIo, bool markOrphan);
// ===== P9:远程交谈(chat_open / chat_send / chat_wait / chat_close)=====
// 复用 Windows 客户端既有「远程交谈」:主连接下发 COMMAND_CHAT(161) → 客户端新建子连接
// (先 TOKEN_CONN_AUTH(246) 再 TOKEN_CHAT_START(62))→ 服务端在该子连接回
// COMMAND_NEXT_CHAT(0) → 客户端弹 IDD_CHAT。之后双向文本为 raw CP936 + NUL。
// 协议不变(客户端聊天窗口已改为 Unicode 对话框,仅影响显示);独立 m_ChatMutex,
// 不与 P8 的 m_Pending 共享(不受单设备单飞行约束)。
// 见 docs/Mcp_Chat_Design.md。
void SetChatEnabled(bool enabled) { m_chatEnabled = enabled; }
bool IsChatEnabled() const { return m_chatEnabled; }
// MessageHandle 顶部钩子(MCP 终端之后、P8 之前:聊天文本首字节可能是 61/255/246)。
// true = 本包已由 MCP 消费。未绑定子连接上的 246(TOKEN_CONN_AUTH) 走快速路径返回
// false,交给认证分支;已绑定子连接上的 0xF6 前导字节文本则由本函数消费。
bool OnChatSubPacket(context* subCtx, const BYTE* data, ULONG len);
// OfflineProc 钩子:接管的子连接断开 → 会话 closed + 清路由 + 唤醒等待者(幂等)。
void OnChatContextClosed(context* subCtx);
// 工具线程:登记会话并发 COMMAND_CHAT 之后调用。false = 该设备已有未关闭会话(-32003)。
bool BeginChatOpen(uint64_t device_id, context* mainCtx, const std::string& sessionId);
// 工具线程:等待客户端子连接就绪且建窗等待期满(readyAt)。
enum class ChatReadyResult { Ok, Timeout, Closed, NotFound };
ChatReadyResult WaitChatReady(uint64_t device_id, const std::string& sessionId, int timeoutMs);
// 工具线程:发送前登记(校验 sessionId/started/readyAt/sendBusy)。输出 subCtx。
// 返回:0=ok;1=不存在/不匹配/未就绪/已关;2=忙。
int BeginChatSend(uint64_t device_id, const std::string& sessionId, context*& subCtx);
// 工具线程:发送结束(清 sendBusy)。closed 期间发送失败时调用方仍须调用。
void FinishChatSend(uint64_t device_id, const std::string& sessionId);
// 工具线程:取走最多 maxMessages 条;inbox 为空则等到 deadline / closed / 取消。
enum class ChatWaitResult { Ok, Timeout, Closed, NotFound, Mismatch, Busy, Cancelled };
ChatWaitResult WaitChatMessages(uint64_t device_id, const std::string& sessionId,
int timeoutMs, size_t maxMessages,
std::vector<ChatMessage>& out, bool& timedOut,
bool& closed, int& dropped);
// 关闭会话(校验 sessionId;标记 closed + 清路由 + 唤醒)。返回 0=已关;1=不存在(幂等);
// 2=sessionId 不匹配。子连接 [1] 与 CancelIO 由调用方在锁外执行。
int CloseChatSession(uint64_t device_id, const std::string& sessionId,
context*& subCtxOut, bool& hadSession);
// chat_open 超时/失败收尾:标记 closed + 清路由;已绑定子连接写入 subCtxOut(调用方 CancelIO),
// 未绑定则打 device/peer 5s 墓碑,吸收迟到的 62(避免超时后弹出 MFC 对话框)。
void AbortChatOpen(uint64_t device_id, context*& subCtxOut, bool& hadSession);
// idle 回收:关闭 lastActiveAt 超时且无等待/无发送的会话。返回回收数量。
int SweepIdleChats(time_t idleTimeoutSec);
// 安全配置(启动时由 CMy2015RemoteDlg 读 THIS_CFG 后设置)。
void SetReadonly(bool readonly) { m_readonly = readonly; }
void SetCmdWhitelist(const std::string& whitelist) { m_cmdWhitelist = whitelist; }
bool IsReadonly() const { return m_readonly; }
const std::string& GetCmdWhitelist() const { return m_cmdWhitelist; }
// 平台门禁开关:默认开。关闭只影响「错误平台上的调用是否被提前拦住」,
// 不影响任何工具的正常执行路径,可作为出问题时的应急回退手段。
void SetPlatformGuardEnabled(bool enabled) { m_platformGuard = enabled; }
bool IsPlatformGuardEnabled() const { return m_platformGuard; }
// 监听地址/端口(Start 时记录,供 get_server_status 报告)。
const std::string& GetBind() const { return m_bind; }
int GetPort() const { return m_port; }
// get_server_status:在飞会话与鉴权封禁计数。每类各取一次自己的锁,
// 返回前全部释放——调用方拿到的是「大致同一时刻」的估算值,不用来同步。
void GetRuntimeCounters(int& pending, int& terminal, int& screenCtrl,
int& fileXfer, int& chat, int& blockedIps);
// ===== P11:在飞调用登记(progress / cancelled / mcp_list_sessions)=====
// 每次 tools/call 登记一个上下文;EndCall 必须在工具返回后调用(幂等)。
// idKey / idText 是同一个 JSON-RPC id 的两种写法(紧凑 JSON / 展示文本),
// 匹配一律先按 idKey 精确比(区分 "41" 与 41),再退回 idText。
std::shared_ptr<McpCallContext> BeginCall(const std::string& idKey, const std::string& idText,
const std::string& tool,
uint64_t device, const std::string& sessionId);
void EndCall(const std::shared_ptr<McpCallContext>& call);
// notifications/cancelled:按 JSON-RPC id 匹配在飞调用,置取消位。返回是否命中。
bool CancelCallById(const std::string& idKey, const std::string& idText);
// mcp_cancel_session:按主机(device=0 表示任意)与会话 id(空表示任意)匹配在飞调用。
// 返回被取消的数量;工具层的等待会在 ≤1s 内退出并走既有清理路径。
int CancelCalls(uint64_t device, const std::string& sessionId);
// mcp_list_sessions 的快照条目(一把锁一次拷贝,不跨表保持一致性)。
struct SessionSnapshot {
uint64_t device = 0;
std::string kind; // pending / call / terminal / remote_control / file_transfer / chat
std::string tool;
std::string sessionId;
std::string idKey; // kind=call:JSON-RPC id 的紧凑序列化(匹配用,"41" 与 41 不同)
std::string requestId; // kind=call:同一 id 的展示文本(列表输出用,可直接回传 request_id)
bool busy = false;
long long elapsedMs = -1; // 会话已持续(<0 未知)
long long idleMs = -1; // 距最后一次活动(<0 未知)
};
std::vector<SessionSnapshot> ListSessions();
// -32003 文案后缀:说明该主机正被哪个工具占着、已持续多久;没有占用信息时返回空串。
std::string DescribeBusy(uint64_t device_id);
private:
CMcpServer();
~CMcpServer();
CMcpServer(const CMcpServer&) = delete;
CMcpServer& operator=(const CMcpServer&) = delete;
// POST /mcp 处理器:token 校验 + JSON-RPC 分发。
void HandleMcp(const httplib::Request& req, httplib::Response& res);
// 记一条「持久终端已销毁」墓碑(调用方须持有 m_TermMutex)。
void MarkTermDestroyedLocked(uint64_t device_id, const std::string& sessionId,
const std::string& reason);
// ===== 鉴权加固 =====
// 同一 IP 在窗口期内连续鉴权失败达到阈值即封禁一段时间;封禁期内直接 429,不再比对 token。
bool IsAuthBlocked(const std::string& ip);
bool RecordAuthFailure(const std::string& ip); // 返回 true 表示本次失败触发了封禁
void ClearAuthFailures(const std::string& ip);
// 审计日志(<exe>\logs\mcp_audit.log):只写时间/IP/工具名/结果等元数据,
// 绝不写 token、Authorization 头、请求参数或返回内容。
void AuditMcpEvent(const char* event, const std::string& ip, const std::string& detail);
static void AppendAuditFile(const std::string& line);
struct AuthFailRecord {
int count = 0;
std::chrono::steady_clock::time_point windowStart;
std::chrono::steady_clock::time_point blockedUntil;
};
std::mutex m_AuthMutex;
std::unordered_map<std::string, AuthFailRecord> m_AuthFails;
// 挂起请求类型:主机管理/连接管理会话与既有一次性请求共用 m_Pending 保证单设备单飞行,
// 但 MessageHandle 的 P2b/P3/P7 拦截分支(IsPending/TakeMainResponse)必须把这两类排除,
// 否则用户手动打开对话框时 UI 包会被 MCP 抢走。
enum class PendingKind { Generic, FollowUp, Machine, ConnMgr, Keylog };
static bool KindAcceptsToken(PendingKind kind, BYTE token);
bool BeginManagedSession(uint64_t device_id, const std::string& tool,
PendingKind kind, context* mainCtx);
httplib::Server m_server;
McpTlsProxy m_tlsProxy; // HTTPS 前端(仅在 m_httpsEnabled 时启动)
std::thread m_thread;
std::atomic<bool> m_running{false};
// 键鼠锁定看门狗(P10-C):m_blockStop 置位后线程在下一次 100ms 切片退出。
std::thread m_blockThread;
std::atomic<bool> m_blockStop{false};
std::string m_token;
std::string m_bind; // Start 传入的监听地址
int m_port = 0; // Start 传入的监听端口
bool m_httpsEnabled = false; // SetHttps 设置(默认明文)
std::string m_certPath; // MCP TLS 证书(PEM)
std::string m_keyPath; // MCP TLS 私钥(PEM, PKCS#8)
int m_internalPort = 0; // httplib 实际监听的回环端口
CMy2015RemoteDlg* m_parent = nullptr;
// 挂起请求注册表(受 m_PendingMutex 保护,键 = device_id)。
struct PendingRequest {
std::string tool;
std::string path; // list_files:目录路径;list_registry:rootToken(1B)+相对子键路径
// P11:mcp_list_sessions 展示用。默认取构造时刻,所有 Begin* 都不必显式设置。
std::chrono::steady_clock::time_point startedAt = std::chrono::steady_clock::now();
uint16_t expectedReqId = 0; // get_screenshot:期望的预览 reqId(0 = 未设置)
std::vector<BYTE> data;
std::vector<BYTE> regPath; // list_registry:TOKEN_REG_PATH 子键包(含 token 字节)
std::vector<BYTE> regKey; // list_registry:TOKEN_REG_KEY 值包(含 token 字节)
bool pathDone = false; // list_registry:已收到 TOKEN_REG_PATH
bool keyDone = false; // list_registry:已收到 TOKEN_REG_KEY
bool done = false;
// ===== P7:写工具(kill_process / operate_window / control_service)接管进度 =====
std::vector<BYTE> followUp; // 接管后下发的写命令 payload(首字节 = 写命令)
bool followUpSent = false; // false=等子连接就绪(首包);true=已发写命令、等确认包
context* subCtx = nullptr; // 接管的子连接(超时/失败 CancelIO 用,防孤儿子连接)
// ===== P8:主机管理 / 连接管理会话(kind = Machine / ConnMgr 时有效)=====
PendingKind kind = PendingKind::Generic;
context* mainCtx = nullptr; // Begin 时抓取的主连接(只作身份校验,不从其收发)
std::string peer; // mainCtx->GetPeerName()(老客户端子连接 ID=0 时兜底)
BYTE expectedToken = 0; // 期望的响应 token(0 = 未设置)
bool hasResponse = false;
std::vector<BYTE> response; // 含首字节 token
std::string clientError; // TOKEN_MACHINE_MSG(42) 文本(已转 UTF-8)
bool closed = false; // 子连接在等待期间断开
std::chrono::steady_clock::time_point deadline; // 整个会话的截止时间
// ===== N3:键盘记录(kind = Keylog 时有效)=====
std::string keylogBuf; // 累积的原始击键字节(客户端编码,未含 token)
bool keylogTruncated = false; // 已到字节上限,后续数据被丢弃
// ===== B2:search_file(tool == "search_file" 时有效)=====
std::vector<std::vector<BYTE>> searchRecords; // 已收集的 TOKEN_SEARCH_FILE_LIST 原始包
size_t searchBytes = 0;
bool searchFinished = false; // 已收到 TOKEN_SEARCH_FILE_FINISH
// ===== P10-B:文件写工具(delete_path / move_path / create_folder)=====
int phase = 0; // 0=等 TOKEN_*_FINISH;1=等复核用的 TOKEN_FILE_LIST
std::string verifyPath; // phase 1 要列的父目录(客户端 ANSI/GBK)
bool searchStopSent = false; // 已下发 COMMAND_FILES_SEARCH_STOP
bool searchTruncated = false; // 命中收集上限,后续匹配被丢弃
};
std::mutex m_PendingMutex;
std::condition_variable m_PendingCv;
std::map<uint64_t, PendingRequest> m_Pending;
// ===== P11:在飞 tools/call 上下文(受 m_CallMutex 保护)=====
// 向量足够:同时在飞的调用只有个位数,取消/列举都是全表扫描。
std::mutex m_CallMutex;
std::vector<std::shared_ptr<McpCallContext>> m_Calls;
// ===== P8:子连接路由(受 m_PendingMutex 保护)=====
// 已绑定子连接 → device(该子连接的一切包都由 MCP 消费)。
std::map<context*, uint64_t> m_SubCtxToDevice;
// CancelIO 之后仍可能到达的包:静默丢弃(避免子连接回收前的尾巴包弹对话框)。
std::set<context*> m_AbsorbedSubCtx;
// 会话异常结束后 5s 内的迟到就绪包墓碑(device / peer 两个维度)。
struct OrphanMark {
std::chrono::steady_clock::time_point expiry;
PendingKind kind = PendingKind::Generic;
};
std::map<uint64_t, OrphanMark> m_OrphanByDevice;
std::map<std::string, OrphanMark> m_OrphanByPeer;
// 清理过期墓碑(持 m_PendingMutex 调用)。
void PruneOrphanMarksLocked(std::chrono::steady_clock::time_point now);
// ===== 迟到首包吸收(受 m_FirstPacketMutex 保护,独立锁避免与挂起/传输表形成锁序)=====
// 等待函数在「超时/失败」分支调用:登记该工具放弃后可能迟到的应答首包 token。
struct FirstPacketMark {
std::set<BYTE> tokens;
std::chrono::steady_clock::time_point expiry;
};
std::mutex m_FirstPacketMutex;
std::map<uint64_t, FirstPacketMark> m_FirstPacketMarks;
void MarkLateFirstPacket(uint64_t device_id, std::initializer_list<BYTE> tokens);
void MarkLateFirstPacketForTool(uint64_t device_id, const std::string& tool);
// 路由表大小(已绑定 + 已吸收的子连接数)。MessageHandle 每个包都会调用
// OnManagedSubPacket,若无会话在飞则用它无锁快速返回,避免音频/屏幕等高频
// 子连接逐包争用 m_PendingMutex。只在持锁时更新(store)。
std::atomic<int> m_ManagedRoutes{0};
void RefreshManagedRoutesLocked();
// get_screenshot 的 reqId 发生器(16 位,跳过 0)。与 MFC 预览的 m_PreviewReqId 各自独立计数。
std::atomic<uint16_t> m_PreviewReqId{1};
// ===== P3:exec_command 终端会话(受 m_TermMutex 保护)=====
struct TermSession {
bool started = false; // false=已发 COMMAND_SHELL 待 START;true=已接管
context* subCtx = nullptr; // shell 子连接上下文
bool isPty = false; // true=ConPTY(UTF-8);false=老 cmd 管道(GBK)
std::string command; // 原始 UTF-8 命令(审计用)
std::string nonce; // 哨兵随机串
std::vector<BYTE> data; // 收集的原始 shell 输出
size_t sentPos = 0; // 哨兵在 data 中的位置
int exitCode = -1;
bool done = false; // 哨兵命中
bool closed = false; // TOKEN_TERMINAL_CLOSE(进程退出)
// ===== 新增(持久终端)=====
std::string sessionId; // 持久会话 token(一次性 exec 为空)
bool persistent = false;
bool busy = false; // 一条命令在飞(terminal_exec 复位→WaitTermCommand 返回)
time_t lastActiveAt = 0; // idle 回收用(秒)
std::chrono::steady_clock::time_point startedAt = std::chrono::steady_clock::now(); // P11
};
std::mutex m_TermMutex;
std::condition_variable m_TermCv;
std::map<uint64_t, TermSession> m_TermSessions; // device_id → 会话
std::map<context*, uint64_t> m_TermContextToDevice; // subCtx → device_id(顶部路由)
// 最近一次持久终端被销毁的原因(device → 信息)。终端因超时/退出/关闭被清理后,后续
// terminal_exec 无法区分「会话被超时销毁」与「session_id 写错」,只能报同一句
// "not found"(评审 P1)。留一条短墓碑,让错误文案能说清是哪种情况。
struct TermDestroyedInfo {
std::string sessionId;
std::string reason; // 英文短句,直接拼进 -32002 文案
std::chrono::steady_clock::time_point expiry;
};
std::map<uint64_t, TermDestroyedInfo> m_TermDestroyed; // device_id → 墓碑(10 分钟内有效)
// ===== P5:远程控制会话(受 m_ScreenCtrlMutex 保护;单设备单会话)=====
struct ScreenCtrlSession {
std::string sessionId; // 会话 token(每次 open 独立随机)
context* subCtx = nullptr; // 屏幕子连接上下文(就绪后填;用于注入)
bool started = false; // false=子连接建立中;true=已就绪
bool busy = false; // 一条注入在飞(BeginScreenCtrlAction→End 之间)
bool closed = false; // 注入期间屏幕子连接已断(由注入线程收尾)
time_t lastActiveAt = 0; // idle 回收用(秒)
std::chrono::steady_clock::time_point startedAt = std::chrono::steady_clock::now(); // P11
int screenW = 0; // 抓屏帧宽度(TOKEN_BITMAPINFO;目标窗口/区域时为裁剪后尺寸)
int screenH = 0;
// remote_open 指定了 window_hwnd/region:帧是窗口/区域而非整屏,归一化坐标已相对该帧。
bool targeted = false;
// P10-C 键鼠锁定:inputBlocked 是服务端认为的锁定状态(唯一真相,用于强制解锁);
// blockUntil 是自动解锁期限;blockAutoReleased 待下一次 remote_block_input 上报。
bool inputBlocked = false;
std::chrono::steady_clock::time_point blockUntil{};
bool blockAutoReleased = false;
};
std::mutex m_ScreenCtrlMutex;
std::map<uint64_t, ScreenCtrlSession> m_ScreenCtrlSessions; // device_id → 会话
std::map<context*, uint64_t> m_ScreenCtrlContextToDevice; // subCtx → device_id(OfflineProc 反查)
// ===== P6:文件传输会话(受 m_FileXferMutex 保护;单设备单传输)=====
struct FileTransferSession {
std::string tool; // "download_file" / "upload_file" / "copy_files_c2c"
uint64_t dstClientID = 0; // copy_files_c2c:目标客户端(其余工具恒 0)
bool c2cResult = false; // copy_files_c2c:已收到源端结果包
uint32_t c2cStatus = 0; // 结果包 status(0=全部发出)
DWORD c2cWin32 = 0; // 结果包 win32err
int32_t c2cWorkerRc = 0; // 结果包 workerRc
uint32_t c2cFileCount = 0; // 结果包 fileCount
uint64_t c2cBytes = 0; // 结果包 totalBytes
// 目标端回执(POSIX 接收端写完最后一包后发的同一个 175 包,dstClientID = 自己)
bool recvAck = false; // 已收到目标端回执
uint32_t recvStatus = 0; // 回执 status(0=写入成功)
DWORD recvErrno = 0; // 回执 win32err(POSIX 端放 errno)
uint32_t recvFileCount = 0; // 回执 fileCount(实收文件数)
uint64_t recvBytes = 0; // 回执 totalBytes(实收字节数)
std::string localDir; // download:本机保存目录(ANSI,结尾 '\')
std::string remotePath; // 客户端远程路径(ANSI,发 CMD_DOWN_FILES_V2 用)
bool overwrite = false; // 是否覆盖已存在文件
context* fmSubCtx = nullptr; // 文件管理器子链接(下发 CMD_DOWN_FILES_V2)
context* streamSubCtx = nullptr; // 流式子链接(首个 chunk 填,收尾 CancelIO)
uint64_t transferID = 0; // 客户端回填的传输会话 ID
uint32_t totalFiles = 0; // 客户端声明的文件总数(含目录项,见 F4)
uint32_t directoryCount = 0; // 目录项计数(目录不发 COMPLETE 包)
uint32_t filesDone = 0; // 已完成的文件数(含跳过的)
bool done = false; // 全部完成或出错
int error = 0; // 0=ok;8=哈希不匹配;1001=路径逃逸;1002=超时;1003=流式子连接断线;
// 1004=停滞(看门狗);1005=远端路径不存在;1006=拒绝访问;1007=其他下载失败
DWORD errorDetail = 0; // error=1005/1006/1007 时的 win32 码(原样带进文案,便于分支/排查)
std::map<uint32_t, FileTransferEntry> fileEntries; // fileIndex → {path,size,sha256}
std::set<uint32_t> skipIndexes; // overwrite=false 跳过的 fileIndex
std::vector<FileTransferEntry> skipped; // 跳过的文件(供输出)
time_t startAt = 0;
std::chrono::steady_clock::time_point startedAt = std::chrono::steady_clock::now(); // P11
// P11:已收到的数据字节数(进度通知用;download 按 chunk 累加)
uint64_t bytesReceived = 0;
// 停滞看门狗:最后一次收到数据的时间。远程路径不存在时客户端一个包都不发,
// 旧实现只能干等满 timeout_ms(默认 600s,整台主机被单飞互斥锁住,评审 P2)。
std::chrono::steady_clock::time_point lastDataAt;
};
std::mutex m_FileXferMutex;
std::condition_variable m_FileXferCv;
std::map<uint64_t, FileTransferSession> m_FileXferSessions; // device_id → 会话
// 子连接反查(受 m_FileXferMutex 保护):OfflineProc 拿不到 device_id,只能按 context* 找会话。
std::map<context*, uint64_t> m_FileXferContextToDevice;
// ===== P9:远程交谈(受 m_ChatMutex 保护;单设备单会话)=====
// 用 shared_ptr 持有会话:chat_wait / chat_send 在工作线程里复制一份后,即使 map 条目
// 被 chat_close 或断线删除也安全,不需要额外的「迭代器有效」规则。
struct ChatSession {
std::string sessionId;
context* mainCtx = nullptr; // 主连接(仅身份校验)
uint64_t mainClientId = 0;
context* subCtx = nullptr; // 已绑定的子连接;关闭后置空
std::string peer; // GetPeerName()(老客户端 clientID=0 兜底)
bool started = false; // 已收到 TOKEN_CHAT_START 并回 [0]
bool closed = false;
bool sendBusy = false; // 同一会话串行发送
bool waitBusy = false; // 同一会话只允许一个 chat_wait
std::chrono::steady_clock::time_point readyAt; // 建窗等待期满(绑定 + 1000ms)
time_t lastActiveAt = 0;
std::chrono::steady_clock::time_point startedAt = std::chrono::steady_clock::now(); // P11
std::deque<ChatMessage> inbox; // 未投递消息(UTF-8)
size_t inboxBytes = 0;
uint64_t nextMsgId = 1;
int dropped = 0; // inbox 溢出丢弃的条数(chat_wait 报告)
};
using ChatSessionPtr = std::shared_ptr<ChatSession>;
std::mutex m_ChatMutex;
std::condition_variable m_ChatCv;
std::map<uint64_t, ChatSessionPtr> m_ChatSessions; // device_id → 会话
std::map<context*, uint64_t> m_ChatContextToDevice; // subCtx → device_id(顶部路由)
std::set<context*> m_ChatAbsorbedSubCtx; // CancelIO 后尾巴包静默丢弃
struct ChatOrphanMark { std::chrono::steady_clock::time_point expiry; };
std::map<uint64_t, ChatOrphanMark> m_ChatOrphanByDevice; // 迟到 62 墓碑(5s)
std::map<std::string, ChatOrphanMark> m_ChatOrphanByPeer;
std::atomic<int> m_ChatRoutes{0}; // 路由集合大小(快速路径)
bool m_chatEnabled = false; // P9 开关(默认关)
// 持 m_ChatMutex 调用:只更新 m_ChatRoutes(store,relaxed 读取在锁外)。
void RefreshChatRoutesLocked();
// 持 m_ChatMutex 调用:清理过期墓碑。
void PruneChatOrphansLocked(std::chrono::steady_clock::time_point now);
bool m_readonly = true;
std::string m_cmdWhitelist;
bool m_terminalEnabled = false; // 持久终端开关(默认关;要求 m_readonly=false)
bool m_remoteControlEnabled = false; // 远程控制开关(默认关;要求 m_readonly=false)
bool m_fileTransferEnabled = false; // 文件传输开关(默认关;download_file)
bool m_fileWriteEnabled = false; // P10-B 文件写入开关(默认关;要求 m_readonly=false)
bool m_manageEnabled = false; // P7 管理控制开关(默认关;要求 m_readonly=false)
bool m_machineEnabled = false; // P8 主机管理族总开关(默认关;16 个 host_* 工具)
bool m_machineDangerousEnabled = false; // P8 高风险子集(冻结/解冻进程、停止/重启服务)
bool m_keylogEnabled = false; // N3 键盘记录开关(默认关;get_keylog)
// 平台门禁(默认开):调用前拦掉「该客户端根本没实现」的工具,立刻返回 -32005。
// 关闭后这类调用会照常下发命令,通常表现为白等超时。判据表见 McpServer.cpp 的
// kToolPlatforms,与 mcp/tools.json 的 platforms 字段对应。
bool m_platformGuard = true;
int m_toolTimeoutMs = 20000; // 工具默认等待超时(McpToolTimeoutMs,见 SetToolTimeoutMs)
};
// 全局访问器(仿 WebService(),见 WebService.h 末尾)
inline CMcpServer& McpServer() { return CMcpServer::Instance(); }
// 生成 32 hex(128-bit)随机 token;供运行时兜底与「MCP设置」对话框预填复用。
std::string GenerateRandomToken();