Files
SimpleRemoter/linux/main.cpp
T
yuanyuanxianganddeepseek-flash 3d87ec6720 Fix(client): detach the receive thread instead of leaking one per connection
CloseHandle and SAFE_CLOSE_HANDLE are empty off Windows, so the POSIX
receive thread is never released: nothing detaches it and nothing joins
it. Every IOCPClient keeps one thread for good, and each screen, file,
shell or log sub-connection constructs a fresh IOCPClient. Once the leak
reaches RLIMIT_NPROC, pthread_create returns EAGAIN, std::thread throws,
and OnServerReceiving's catch(...) swallows it: every command that spawns
a worker goes quiet while COMMAND_SYSTEM keeps working. Observed on a Mac
after six weeks: 2048 threads against a 1333 limit.

Detach the thread right after creation so it is reclaimed when it
returns; the destructor still waits on m_bWorkThread, so nothing else
changes. Also log the pthread_create failure that used to be silent, and
publish S_STOP as the very last write in WorkThreadProc: the destructor
reads it as "thread is gone" and frees this, so the m_bIsRunning that
used to follow it could land in freed memory.

Two smaller fixes on the same sub-connection path:

- common/sub_conn_thread.h never called SetDefaultProto, so sub-connects
  fell back to plaintext TCP whatever g_SETTINGS.protoType said: behind a
  reverse proxy the packet dies before the master (no [ConnAuth] on the
  server, only "waiting for ack timed out" on the client). Android did.
- macos/main.mm and linux/main.cpp log the spawn before starting the
  worker and catch std::system_error, reporting e.code().value() rather
  than errno, which libc++/libstdc++ never set here. The macOS skeleton
  also reports ConnectServer failures and a null createHandler.

Co-Authored-By: deepseek-flash
2026-11-14 11:43:04 +01:00

2199 lines
95 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "common/commands.h"
#include "client/IOCPClient.h"
#include <unistd.h>
#include <sys/utsname.h>
#include <sys/sysinfo.h>
#include <sys/stat.h>
#include <sys/prctl.h>
#include <pwd.h>
#include <string.h>
#include <termios.h>
#include <thread>
#include <system_error> // std::system_error:SpawnSubConnWorker 捕获线程创建失败
#include <fcntl.h>
#include <atomic>
#include <mutex>
#include <algorithm>
#include <cerrno>
#include <csignal>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include "common/PTYHandler.h"
#include <iostream>
#include <stdexcept>
#include <cstdio>
#include <ctime>
#include <memory>
#include <array>
#include <regex>
#include <fstream>
#include <map>
#include <cmath>
#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 "LinuxActivityHistory.h"
#include <openssl/evp.h>
#include <cctype>
#include <vector>
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<bool> g_needResendLogin(false); // 分组变更后需要重发登录信息
// 传输层热切换(服务端 COMMAND_TLS_ENABLE/DISABLE 改了信任锚)后需要重建连接。
// DataProcess 跑在接收线程上,直接关 socket 会和主线程的发送竞争,所以只置标志,
// 由主心跳循环择机 Disconnect 并重连。
static std::atomic<bool> 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<long long> g_transferValidTo(0); // >0 = 处于转移状态(到期时刻)
static std::atomic<bool> 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 <entry>` 子进程,子进程直接复用同一份登录、心跳和命令处理代码。
// 解析与 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<std::string, ShareProc> g_shareProcs; // "ip:port" / "transfer:ip:port" -> 子进程
// 分享条目上限:每条都对应一个常驻子进程,服务端误发/恶意刷下发不能把进程表打爆。
static const size_t kMaxShareEntries = 16;
static std::atomic<bool> 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<uint64_t> 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<char*>(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 <X11/extensions/scrnsaver.h>)
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);
}
// 历史活动采样用:有桌面、用户未空闲且存在活动窗口时返回 id+标题,否则 id=0。
// 与 Check 的区别是不把「空闲」包装成 Inactive 文本 —— 采样端只关心"有没有活动"。
LinuxActivity::ProbeResult Probe(unsigned long idle_threshold_ms = 6000)
{
LinuxActivity::ProbeResult r;
if (!m_available) return r;
if (GetIdleTime() >= idle_threshold_ms) return r;
r.winId = GetActiveWindowId();
if (r.winId == 0) return r;
r.title = GetWindowTitle(r.winId); // 用刚取到的 id,别再读一次活动窗口(可能已换)
return r;
}
bool Available() const { return m_available; }
// 有桌面且真能跟踪前台窗口:X 连上了还不够,根窗口上得有 _NET_SUPPORTING_WM_CHECK
// (EWMH 窗口管理器)。Xvfb、裸 X 这类「有 DISPLAY 没有 WM」的环境里
// _NET_ACTIVE_WINDOW 永远读不到,采样只会一直空转,应该按无头后端处理。
bool Usable()
{
if (!m_available) return false;
Atom atom = pXInternAtom(m_display, "_NET_SUPPORTING_WM_CHECK", 0);
if (!atom) return false;
return !GetWindowProperty(m_root, atom, (Atom)0).empty();
}
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;
}
// 从根窗口读取 _NET_ACTIVE_WINDOW 得到活动窗口 ID;无窗口/WM 不支持时返回 0
Window GetActiveWindowId()
{
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 0;
}
Window w = *(Window*)prop;
pXFree(prop);
return w;
}
// 获取当前活动窗口标题(通过 EWMH _NET_ACTIVE_WINDOW + _NET_WM_NAME)
std::string GetActiveWindowTitle()
{
return GetWindowTitle(GetActiveWindowId());
}
// 指定窗口的标题:_NET_WM_NAME (UTF-8),失败回退 WM_NAME
std::string GetWindowTitle(Window win)
{
if (win == 0) return "";
std::string title = GetWindowProperty(win, m_atomWmName, m_atomUtf8String);
if (title.empty())
title = GetWindowProperty(win, 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<PTYHandler>(
"ShellworkingThread",
[](IOCPClient* c) { return std::unique_ptr<PTYHandler>(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<ScreenHandler>(
"ScreenworkingThread",
[](IOCPClient* c) { return std::unique_ptr<ScreenHandler>(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<SystemManager>(
"SystemManagerThread",
[](IOCPClient* c) { return std::unique_ptr<SystemManager>(new SystemManager(c)); },
[](IOCPClient* c, SystemManager*) {
Mprintf(">>> SystemManagerThread [%p] Send: TOKEN_PSLIST\n", c);
});
return NULL;
}
void* FileManagerThread(void* /*param*/)
{
RunSubConnThread<FileManager>(
"FileManagerThread",
[](IOCPClient* c) { return std::unique_ptr<FileManager>(new FileManager(c)); },
[](IOCPClient* c, FileManager*) {
Mprintf(">>> FileManagerThread [%p] Send: TOKEN_DRIVE_LIST\n", c);
});
return NULL;
}
// 日志上报(对应 Windows 端 CClientLogManager):子连接建立即发首包全量。
// 服务端取走首包后会关掉这条子连接,所以这里发完就等连接断开即可。
void* ClientLogThread(void* /*param*/)
{
RunSubConnThread<ClientLogHandler>(
"ClientLogThread",
[](IOCPClient* c) { return std::unique_ptr<ClientLogHandler>(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<int> g_previewInFlight(0);
static void ScreenPreviewThread(ScreenPreviewReq req)
{
// 抓屏/缩放全程可能在几十毫秒量级,跑在独立线程里,不阻塞接收线程
struct InFlightGuard {
~InFlightGuard() { g_previewInFlight.fetch_sub(1); }
} guard;
std::vector<unsigned char> 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<char> 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<std::mutex> 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);
}
// ============== 历史活动(COMMAND_QUERY_ACTIVITY → TOKEN_REPORT_ACTIVITY) ==============
// true=桌面窗口采样(启动时 X11 可用),false=无头后端(登录记录 + shell 命令历史)
static std::atomic<bool> g_activityWindowBackend(false);
// 与 Windows 端一致:主连接一次性快照,不开子连接(服务端 TOKEN_REPORT_ACTIVITY 分支
// 不 CancelIO)。无头后端要跑 last、读历史文件,所以放线程里,别堵接收线程。
// 同时在飞的报表最多一份:连点/多个 MCP 调用会把 popen(last) 和读历史文件叠起来,
// 一次几十毫秒的活堆成几百个子进程没有任何意义。
static std::atomic<int> g_activityReportsInFlight(0);
static void ActivityReportThread()
{
const bool windowBackend = g_activityWindowBackend.load(std::memory_order_relaxed);
std::string text;
if (windowBackend) {
text = LinuxActivity::ActivityHistory::Instance().Dump();
if (text.empty())
text = LinuxActivity::WindowBackendEmptyText(); // 桌面空闲/刚启动,还没有够 5 秒的窗口
} else {
LinuxConfig cfg; // 每次现读:activity_commands 改了立刻生效
const bool includeCommands = cfg.GetInt("activity_commands", 1) != 0;
text = LinuxActivity::BuildHeadlessDump(includeCommands, 200);
}
std::vector<BYTE> pkt(1 + text.size());
pkt[0] = TOKEN_REPORT_ACTIVITY;
if (!text.empty())
memcpy(pkt.data() + 1, text.data(), text.size());
// 取快照可能跑上几十毫秒(last/读历史文件),期间主连接可能已经断了或是进程在退出;
// 与截屏回包一样:Send2Server 内部持锁,但先确认还连着
bool sent = false;
if (g_pMainClient && g_pMainClient->IsConnected() && g_bExit == S_CLIENT_NORMAL)
sent = g_pMainClient->Send2Server((char*)pkt.data(), (ULONG)pkt.size()) != FALSE;
Mprintf("[Activity] report %zu bytes (%s backend)%s\n", text.size(),
windowBackend ? "window" : "headless", sent ? "" : " FAILED");
g_activityReportsInFlight.fetch_sub(1, std::memory_order_relaxed);
}
// 子连接 worker 的唯一启动点(与 macos/main.mm 的 SpawnSubConnWorker 同语义)。
// 线程创建失败(RLIMIT_NPROC 到顶时 pthread_create 返回 EAGAIN/EPERM,std::thread
// 构造抛 std::system_error)必须在这里接住:否则异常穿过 DataProcess 落到
// OnServerReceiving 的 catch(...),日志里只剩一行笼统的
// "[ERROR] OnServerReceiving catch an error",同一批 recv 里的其它完整包也会被丢弃。
// 表现是「点了终端/桌面/文件毫无反应,连收到命令的日志都没有」。
static void SpawnSubConnWorker(const char* name, void* (*entry)(void*))
{
Mprintf("** Received '%s' command, spawning worker ***\n", name);
try {
std::thread(entry, nullptr).detach();
} catch (const std::system_error& e) {
// pthread_create 的返回值被 libc++/libstdc++ 直接包进 error_code,errno 不可信
Mprintf("*** spawn '%s' worker FAILED: %s (code=%d) ***\n",
name, e.what(), e.code().value());
} catch (const std::exception& e) {
Mprintf("*** spawn '%s' worker FAILED: %s ***\n", name, e.what());
}
}
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) {
SpawnSubConnWorker("SHELL", ShellworkingThread);
} else if (szBuffer[0] == COMMAND_SCREEN_SPY) {
SpawnSubConnWorker("SCREEN_SPY", ScreenworkingThread);
} else if (szBuffer[0] == COMMAND_SYSTEM) {
SpawnSubConnWorker("SYSTEM", SystemManagerThread);
} else if (szBuffer[0] == COMMAND_LIST_DRIVE) {
SpawnSubConnWorker("LIST_DRIVE", FileManagerThread);
} else if (szBuffer[0] == COMMAND_QUERY_LOG) {
// 与 Windows 端一致:回日志必须开子连接。服务端取走首包后 CancelIO 关的是
// 子连接;若回在主连接上,被关掉的就是主连接本身。
SpawnSubConnWorker("QUERY_LOG", ClientLogThread);
} else if (szBuffer[0] == COMMAND_QUERY_ACTIVITY) {
// 历史活动:主连接一次性快照(无子连接),有桌面走窗口采样,无桌面走登录+命令记录。
// 已经有报表在飞就丢掉这一次(服务端每主机单飞行,连点也只是重复请求)
if (g_activityReportsInFlight.fetch_add(1) >= 1) {
g_activityReportsInFlight.fetch_sub(1);
return TRUE;
}
Mprintf("** [%p] Received 'QUERY_ACTIVITY' command ***\n", user);
try {
std::thread(ActivityReportThread).detach();
} catch (const std::exception& e) {
// 线程起不来要把在途计数还回去,否则之后的历史活动请求全被当成「忙」丢掉
g_activityReportsInFlight.fetch_sub(1);
Mprintf("** Activity report thread failed: %s ***\n", e.what());
}
} 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) {
// 必须同时认短包:完整结构是 1024 字节,但老服务端 / Go 服务端只回
// HeartbeatACK_OldSize(32)。长度不足就当「没收到」会让下面的 ACK 看门狗
// 每 60s 断开重连一次(表现为链路一直在抖、主连接端口不断变化)。
// Windows 端同样按 min(ulLength, 32) 兼容,见 KernelManager.cpp:2413。
if (ulLength >= 1 + HeartbeatACK_OldSize) {
HeartbeatACK ack = {}; // 短包时缺的字段保持 0(Authorization / ProcessingMs 等)
const size_t copyLen = (ulLength - 1 >= sizeof(HeartbeatACK))
? sizeof(HeartbeatACK)
: (size_t)(ulLength - 1);
memcpy(&ack, szBuffer + 1, copyLen);
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<std::mutex> 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<char, 128> buffer;
std::string result;
std::unique_ptr<FILE, decltype(&pclose)> 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);
}
// 进程已运行秒数(RES_UPTIME):与 getProcessStartTime 同源,都是本机墙钟,相减后
// 时区不影响结果。服务端用它算运行时长,就不必拿自己的时刻去减别的机器的时刻了。
long long getProcessUptimeSeconds()
{
long long up = static_cast<long long>(std::time(nullptr)) -
static_cast<long long>(g_processStartTime);
return up > 0 ? up : 0;
}
// 获取 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<FILE, decltype(&pclose)> 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 时忽略
}
// ============== 主机分享:分享子进程管理 ==============
// 每条分享记录对应一个子进程:`<exe> --share <ip:port[:shine[:transport]]>`。子进程
// 有自己的连接、日志文件(log_*_<pid>.txt)和重连循环,复用 main() 的全部逻辑;主实例
// 只负责起停和收尸。
static void ShareReaperLoop()
{
while (!g_shareReaperStop.load(std::memory_order_relaxed)) {
{
std::lock_guard<std::mutex> 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<char*> args;
args.push_back(&exe[0]);
args.push_back(&flag[0]);
args.push_back(const_cast<char*>(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<std::mutex> 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<std::mutex> 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<std::mutex> 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<pid_t> pids;
{
std::lock_guard<std::mutex> 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<pid_t> 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<pid_t> 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<std::mutex> 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<char*> 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<std::string> 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 <ip:port[:shine[:transport]]> 分享实例(由主实例 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<unsigned int>(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)
logInfo.AddReserved((int)getProcessUptimeSeconds()); // [20] RES_UPTIME(登录时已运行秒数)
// 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID)
ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID);
// 初始化用户活动检测器(用于心跳包中的 ActiveWnd 字段)
ActivityChecker activityChecker;
// 历史活动采样器必须用独立实例:Xlib 连接不能跨线程共用,心跳线程一直在用
// activityChecker。没有桌面 / 有 X 但没有 EWMH 窗口管理器时不启动采样线程,
// 查询时走无头后端。
ActivityChecker historyChecker;
const bool windowBackend = historyChecker.Usable();
g_activityWindowBackend.store(windowBackend, std::memory_order_relaxed);
if (windowBackend) {
LinuxActivity::ActivityHistory::Instance().Start([&historyChecker]() {
return historyChecker.Probe((unsigned long)ACTIVITY_IDLE_BREAK_SEC * 1000UL);
});
}
Mprintf("[Activity] 历史活动后端: %s\n",
windowBackend ? "桌面窗口(X11)"
: (historyChecker.Available() ? "无头(登录+命令,X 上没有 EWMH 窗口管理器)"
: "无头(登录+命令)"));
std::unique_ptr<IOCPClient> 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);
}
// 采样线程要在 main 的局部对象(historyChecker)析构前停掉
LinuxActivity::ActivityHistory::Instance().Stop();
// 历史活动的报表线程是 detached 的,可能还在跑 last / 读历史文件;它最后要写一行日志,
// 等它收尾再关日志。最多等 2 秒,等不到就算了(进程要退出,不能因此卡住)。
for (int i = 0; i < 20 && g_activityReportsInFlight.load(std::memory_order_relaxed) > 0; ++i)
std::this_thread::sleep_for(std::chrono::milliseconds(100));
Logger::getInstance().stop();
if (!g_bShareInstance)
removePidFile();
return 0;
}