terminal_exec no longer requires session_id. Given a command and no session_id, it reuses the host's persistent terminal session or opens one through the same path as terminal_open, and reports session_id, is_pty and reused in the result so the caller can keep using it. Polling still requires the session token. terminal_open now returns the existing session with reused:true instead of -32003 when one is already active. An implicitly created session is invisible to the caller, so rejecting would silently lock the host's single terminal slot and leave exec_command failing with a busy error. A session that is still starting, or one owned by a one-shot exec_command, still answers -32003. The server instruction line that told models to always pair terminal_open with terminal_close is updated accordingly. Co-Authored-By: deepseek-flash
1001 lines
65 KiB
C++
1001 lines
65 KiB
C++
#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);
|
||
|
||
// 工具线程:写命令前等 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 退出,会话已清理)
|
||
// 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<BYTE>& 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 已有文件会话或一次性挂起请求)。
|
||
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(进程退出)
|
||
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 起点(长时间在飞的强制回收兜底)
|
||
};
|
||
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();
|