#pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // 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 cancelled{false}; // 进度通道:hasProgressToken=false 时一切进度调用都是空操作。 bool hasProgressToken = false; std::string progressTokenJson; // progressToken 的 JSON 文本(原样回显) std::shared_ptr 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 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& 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>& 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& subkeys, std::vector& 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); // 工具线程:写命令前确认 subCtx 仍是该会话在用的子连接。等待提示符期间 shell 可能已退出, // 子连接被 OfflineProc 归还连接池后可能已被新连接复用,此时再写就是往别人的连接里灌命令。 // sessionId 非空时还要求会话是持久的且 token 一致。 bool IsTermSubCtxLive(uint64_t device_id, const std::string& sessionId, 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=是否进程退出。 // 失败时也尽量照实回填 closed:为 true 表示子连接已断开或去向未知,调用方不得再对它 CancelIO。 bool WaitTerminalDone(uint64_t device_id, std::vector& out, int& exitCode, bool& closed, int timeoutMs); // 工具线程:写命令前等 shell 启动完成(收到第一屏输出,通常是提示符)。 // 见 OnTerminalData 注释:Android 的 mksh 启动瞬间行规程仍开 ECHO,此时写入的 // 字节会被驱动额外回显一份,与服务端清洗逻辑(只剔一份回显)对不上。 void WaitTerminalBootstrap(uint64_t device_id, 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); // terminal_exec 不带 session_id 时:复用该主机已有的持久会话;没有就登记一个挂起会话。 // 返回:0=ok(reused=true 复用已有会话;false=本次新建,调用方需发 COMMAND_SHELL 并 // WaitTerminalReady);2=已有会话但尚未就绪(并发 open,调用方报 -32003)。 int OpenOrReuseTermSession(uint64_t device_id, std::string& sessionId, bool& reused); // terminal_open 撞上已有会话时复用它(不再报 -32003):0=ok(输出 token 与 isPty); // 2=已有会话但尚未就绪(有 open 在并发建立中)。 int ReuseTermSession(uint64_t device_id, std::string& sessionId, bool& isPty); // 复位单条命令字段并置 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); // 等待本条命令结束或超时,并交付 [delivered, ...) 的增量输出。 // pollMode=true 表示本次调用没有携带新命令(只轮询),此时会话空闲 = 调用方用错,返回 7。 // 返回:0=命令结束(done=true;closed=true 表示 shell 退出;本次被 maxOutputBytes 截断时 // 会话保留到轮询取完尾巴再清理,否则当场清理) // 1=等待超时,命令仍在运行(done=false;会话保持 busy,可再次轮询) // 2=请求被取消,会话已销毁(与旧语义一致:取消方不会再轮询) // 3=会话不存在/未就绪/等待期间被销毁(细节看 DescribeTermDestroyed) // 4=sessionId 不匹配 // 7=轮询时没有在跑的命令(会话空闲) // 每次最多交付 maxOutputBytes 原始字节(按换行边界回退);truncated=本次是否仍有剩余。 // droppedBytes=该命令因 data 硬上限被丢弃的字节数(累计,如实上报)。 int WaitTermCommand(uint64_t device_id, const std::string& sessionId, std::vector& out, bool& done, int& exitCode, bool& closed, bool& truncated, size_t& droppedBytes, bool& isPty, std::string& nonce, int maxOutputBytes, int timeoutMs, bool pollMode); // 关闭持久终端(校验 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 已有文件会话或一次性挂起请求)。 // maxFileBytes 仅 read_file 使用:首包文件尺寸超过它就拒收(0=不限)。 bool BeginFileTransferPending(uint64_t device_id, const std::string& tool, const std::string& localDir, const std::string& remotePath, bool overwrite, uint64_t maxFileBytes = 0); // 登记上传会话(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& 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& 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& 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& 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& 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& 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 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& 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 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); // 审计日志(\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 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 m_running{false}; // 键鼠锁定看门狗(P10-C):m_blockStop 置位后线程在下一次 100ms 切片退出。 std::thread m_blockThread; std::atomic 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 data; std::vector regPath; // list_registry:TOKEN_REG_PATH 子键包(含 token 字节) std::vector 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 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 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> 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 m_Pending; // ===== P11:在飞 tools/call 上下文(受 m_CallMutex 保护)===== // 向量足够:同时在飞的调用只有个位数,取消/列举都是全表扫描。 std::mutex m_CallMutex; std::vector> m_Calls; // ===== P8:子连接路由(受 m_PendingMutex 保护)===== // 已绑定子连接 → device(该子连接的一切包都由 MCP 消费)。 std::map m_SubCtxToDevice; // CancelIO 之后仍可能到达的包:静默丢弃(避免子连接回收前的尾巴包弹对话框)。 std::set m_AbsorbedSubCtx; // 会话异常结束后 5s 内的迟到就绪包墓碑(device / peer 两个维度)。 struct OrphanMark { std::chrono::steady_clock::time_point expiry; PendingKind kind = PendingKind::Generic; }; std::map m_OrphanByDevice; std::map m_OrphanByPeer; // 清理过期墓碑(持 m_PendingMutex 调用)。 void PruneOrphanMarksLocked(std::chrono::steady_clock::time_point now); // ===== 迟到首包吸收(受 m_FirstPacketMutex 保护,独立锁避免与挂起/传输表形成锁序)===== // 等待函数在「超时/失败」分支调用:登记该工具放弃后可能迟到的应答首包 token。 struct FirstPacketMark { std::set tokens; std::chrono::steady_clock::time_point expiry; }; std::mutex m_FirstPacketMutex; std::map m_FirstPacketMarks; void MarkLateFirstPacket(uint64_t device_id, std::initializer_list tokens); void MarkLateFirstPacketForTool(uint64_t device_id, const std::string& tool); // 路由表大小(已绑定 + 已吸收的子连接数)。MessageHandle 每个包都会调用 // OnManagedSubPacket,若无会话在飞则用它无锁快速返回,避免音频/屏幕等高频 // 子连接逐包争用 m_PendingMutex。只在持锁时更新(store)。 std::atomic m_ManagedRoutes{0}; void RefreshManagedRoutesLocked(); // get_screenshot 的 reqId 发生器(16 位,跳过 0)。与 MFC 预览的 m_PreviewReqId 各自独立计数。 std::atomic 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 data; // 收集的原始 shell 输出 size_t sentPos = 0; // 哨兵在 data 中的位置 int exitCode = -1; bool done = false; // 哨兵命中 bool closed = false; // TOKEN_TERMINAL_CLOSE(进程退出) bool sawOutput = false; // 收到过任意 shell 输出(启动提示符到达 = shell 就绪) // ===== 新增(持久终端)===== 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 // ===== 超时轮询(P0-2)===== size_t delivered = 0; // 已交付给调用方的 data 前缀长度(超时/轮询增量回传) size_t droppedBytes = 0; // 因 data 硬上限被丢弃的最旧字节数(如实上报) std::chrono::steady_clock::time_point busySince{}; // busy 起点(长时间在飞的强制回收兜底) int waiters = 0; // 阻塞在 WaitTermCommand 里的线程数;terminal_close 据此 // 判断 closed 之后是否还有人负责收尾(没有就自己清) }; std::mutex m_TermMutex; std::condition_variable m_TermCv; std::map m_TermSessions; // device_id → 会话 std::map 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 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 m_ScreenCtrlSessions; // device_id → 会话 std::map 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=其他下载失败; // 1008=read_file 拒绝:文件大于 maxFileBytes;1009=read_file 拒绝:路径是目录或命中多个文件 // read_file 专用:只收单个普通文件,首包文件尺寸超过该值直接拒收(0=不限,download_file 用) uint64_t maxFileBytes = 0; DWORD errorDetail = 0; // error=1005/1006/1007 时的 win32 码(原样带进文案,便于分支/排查) std::map fileEntries; // fileIndex → {path,size,sha256} std::set skipIndexes; // overwrite=false 跳过的 fileIndex std::vector 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 m_FileXferSessions; // device_id → 会话 // 子连接反查(受 m_FileXferMutex 保护):OfflineProc 拿不到 device_id,只能按 context* 找会话。 std::map 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 inbox; // 未投递消息(UTF-8) size_t inboxBytes = 0; uint64_t nextMsgId = 1; int dropped = 0; // inbox 溢出丢弃的条数(chat_wait 报告) }; using ChatSessionPtr = std::shared_ptr; std::mutex m_ChatMutex; std::condition_variable m_ChatCv; std::map m_ChatSessions; // device_id → 会话 std::map m_ChatContextToDevice; // subCtx → device_id(顶部路由) std::set m_ChatAbsorbedSubCtx; // CancelIO 后尾巴包静默丢弃 struct ChatOrphanMark { std::chrono::steady_clock::time_point expiry; }; std::map m_ChatOrphanByDevice; // 迟到 62 墓碑(5s) std::map m_ChatOrphanByPeer; std::atomic 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();