diff --git a/common/client_auth_state.h b/common/client_auth_state.h index f138307..7ac4e9c 100644 --- a/common/client_auth_state.h +++ b/common/client_auth_state.h @@ -56,6 +56,13 @@ inline bool IsCommandAllowed(unsigned char cmd) return g_settingsVerified.load(std::memory_order_acquire) || cmd == CMD_MASTERSETTING; } +// 本连接是否已通过 MasterSettings 校验。转移主机用它判断「目标主控是否真的可用」: +// 连得上但校验一直不通过(对端不是主控,或不是本构建的主控)与连不上等价。 +inline bool IsVerified() +{ + return g_settingsVerified.load(std::memory_order_acquire); +} + // 处理 CMD_MASTERSETTING(payload = szBuffer + 1,payloadLen = ulLength - 1): // 强制要求完整 MasterSettings(包含 Signature 字段);不完整 / 签名失败 → 不更新 // g_settingsVerified,让心跳循环 30s 超时自然把本次连接断开重连。 diff --git a/common/host_endpoint.h b/common/host_endpoint.h index 1b11f2f..42eeb23 100644 --- a/common/host_endpoint.h +++ b/common/host_endpoint.h @@ -43,10 +43,20 @@ inline bool ParseHeaderEnc(const std::string& s, int& out) return true; } +// 端点能安全写进 CONNECT_ADDRESS 的边界。非 Windows 上 strcpy_s/sprintf_s 就是无界的 +// strcpy/sprintf(见 commands.h),地址超长会直接踩坏 szPort/iType 等后续字段, +// 所以来自命令或配置文件的端点必须先过这一关。 +inline bool FitsConnAddress(const Endpoint& ep) +{ + return !ep.ip.empty() + && ep.ip.size() <= sizeof(((CONNECT_ADDRESS*)nullptr)->szServerIP) - 1 + && ep.port > 0 && ep.port <= 65535; +} + // 把端点写进连接参数。只在连接生命周期的持有线程调用(见文件头注释)。 inline void ApplyEndpoint(CONNECT_ADDRESS& conn, const Endpoint& ep) { - if (ep.ip.empty() || ep.port <= 0) + if (!FitsConnAddress(ep)) return; conn.SetServer(ep.ip.c_str(), ep.port); if (ep.transport >= 0) diff --git a/common/host_transfer.h b/common/host_transfer.h index e6cc405..c4123b0 100644 --- a/common/host_transfer.h +++ b/common/host_transfer.h @@ -17,6 +17,7 @@ namespace HostTransfer { using HostEndpoint::Endpoint; +using HostEndpoint::FitsConnAddress; using HostEndpoint::ParseTransport; using HostEndpoint::ParseHeaderEnc; using HostEndpoint::ApplyEndpoint; @@ -28,7 +29,8 @@ struct Target { long long validTo; // <= 0 表示无效 Target() : validTo(0) {} - bool Valid() const { return !ep.ip.empty() && ep.port > 0 && validTo > 0; } + // 端点容量由 FitsConnAddress 守住:记录里存的是外部输入,直接 ApplyTarget 会越界。 + bool Valid() const { return FitsConnAddress(ep) && validTo > 0; } bool Active(long long now) const { return Valid() && now <= validTo; } }; @@ -54,7 +56,9 @@ inline bool ParseAssignCommand(const unsigned char* buf, unsigned long len, Target t; t.ep.ip = v[0]; t.ep.port = atoi(v[1].c_str()); - if (t.ep.ip.empty() || t.ep.port <= 0 || t.ep.port > 65535) + // 长度/端口范围都要挡住:服务端只限制整条载荷不超过 250 字节,地址本身可以顶到 + // CONNECT_ADDRESS::szServerIP[100] 之外,写进 g_SETTINGS 时就是堆栈/全局越界。 + if (!FitsConnAddress(t.ep)) return false; double days = atof(v[2].c_str()); diff --git a/docs/Client_Capability_Matrix.md b/docs/Client_Capability_Matrix.md index 27e35f9..59e87b0 100644 --- a/docs/Client_Capability_Matrix.md +++ b/docs/Client_Capability_Matrix.md @@ -23,10 +23,10 @@ | 远程切换传输协议(TCP/WS/WSS) | ✓ | — | — | — | | 客户端 ID 重建(克隆机撞 ID) | ✓ | — | — | — | | 分享主机 / 取消分享 | ✓ | ✓ | — | — | -| 转移主机(到期自动复原) | ✓ | ✓ | — | ✓ | +| 转移主机(到期自动复原) | ✓ | ✓ | ✓ | ✓ | 说明: -- 分享/转移:Android 实现转移、不实现分享(收到分享命令会回“不支持”);macOS 两者均未实现。 +- 分享/转移:Android 实现转移、不实现分享(收到分享命令会回“不支持”);macOS 同样只实现转移(收包即迁移主连接,记录存 `~/.config/ghost/config.conf` 的 `transfer` 键,连不上目标满 60 秒且连续失败 3 次后退回原主控),分享命令回“不支持”。 - **WebSocket/WSS 是“出包能力”,不是“运行时切换能力”**:四个平台的网络层(`IOCPClient` + `WsChannel.h`)都实现了 WS/WSS,生成客户端时把「协议」选为 WebSocket 或 WS+TLS 即可,客户端启动后按烘焙的 `protoType` 连接(需经反向代理入口;WSS 还需内嵌或在线下发的信任锚)。但运行时的「协议切换」菜单走 `COMMAND_SET_PROTO`,只有 Windows 客户端处理该命令并声明 `CLIENT_CAP_PROTO_SWITCH`;其他平台该菜单整组置灰,菜单里勾选 TCP 只是当前实际连接的传输,不代表客户端只能走 TCP。 - UDP/KCP/HTTP 伪装传输:只有 Windows 客户端有对应实现;Linux/macOS/Android 的网络层只处理 TCP/WS/WSS,出包时选其他协议不会生效。 - 并发上线(`RUNNING_PARALLEL`)只有 Windows 客户端实现;其他平台按单实例运行。 diff --git a/macos/main.mm b/macos/main.mm index e295e89..621fbd6 100644 --- a/macos/main.mm +++ b/macos/main.mm @@ -17,6 +17,7 @@ #import #import #import +#import #import #import #import @@ -29,6 +30,7 @@ #include "../common/xxhash.h" #include "../common/rtt_estimator.h" #include "../common/client_auth_state.h" +#include "../common/host_transfer.h" // 主机转移(COMMAND_ASSIGN_MASTER),与 Linux/Android 共用 #include "../common/posix_net_helpers.h" #include "../common/sub_conn_thread.h" #include "../common/ClientLogHandler.h" @@ -82,6 +84,9 @@ State g_bExit = S_CLIENT_NORMAL; static std::string g_configDir; static std::string g_configPath; static std::map g_configData; +// 收包线程会写配置(分组变更、转移记录),主线程也会读/写(登录信息、到期清除), +// 而 g_configData 和整文件重写都不是线程安全的——所有访问都必须持有这把锁。 +static std::mutex g_configMu; // Initialize config paths static void initConfigPaths() @@ -112,6 +117,7 @@ static void mkdirRecursive(const std::string& path) // Load all config from file static void loadConfig() { + std::lock_guard lk(g_configMu); initConfigPaths(); g_configData.clear(); @@ -127,8 +133,8 @@ static void loadConfig() } } -// Save all config to file -static void saveConfig() +// Save all config to file. 调用方必须持有 g_configMu(setConfigStr 已在锁内)。 +static void saveConfigLocked() { initConfigPaths(); mkdirRecursive(g_configDir); @@ -148,6 +154,7 @@ static void saveConfig() // Get config string value static std::string getConfigStr(const std::string& key, const std::string& def = "") { + std::lock_guard lk(g_configMu); auto it = g_configData.find(key); return it != g_configData.end() ? it->second : def; } @@ -155,8 +162,9 @@ static std::string getConfigStr(const std::string& key, const std::string& def = // Set config string value static void setConfigStr(const std::string& key, const std::string& value) { + std::lock_guard lk(g_configMu); g_configData[key] = value; - saveConfig(); + saveConfigLocked(); } // Save group name to config file @@ -172,6 +180,175 @@ static std::string loadGroupName() return getConfigStr("group_name"); } +// ============== 主机转移(COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA_FOREVER)============== +// 服务端「转移主机」下发的载荷是 host:port:days:shine[:transport],解析与记录编解码在 +// common/host_transfer.h(与 Linux/Android 共用)。收包线程只记「待应用」,地址切换 +// 放在主连接线程——CONNECT_ADDRESS 不参与跨线程同步(同 linux/main.cpp 与 Android)。 +// 语义与 Android 对齐:主连接立即搬到新主控;目标持续一分钟连不上就退回原主控; +// 新主控也能把主机「提前归还」(把到期时刻设成当时)。 +// 原主控只存在内存里(启动时的地址),绝不写回配置——恢复时读到的若还是转移目标, +// 就成了原地打转。 +static HostTransfer::Endpoint g_transferOrig; +static std::atomic g_transferValidTo(0); // >0 = 转移中(到期时刻) +static std::atomic g_transferPending(false); // 接收线程已写好新目标,待主线程应用 +static std::atomic g_transferEndEarly(false); // true = 新主控提前归还,不是到期 +static std::mutex g_transferMu; +static HostTransfer::Target g_transferPendingTarget; +static int g_transferFailStreak = 0; // 仅主连接线程访问,无需原子 +static long long g_transferFailAt = 0; // 本轮连续失败的起点(主连接线程) + +// 回退判据:连续失败次数和已尝试时长**同时**满足才退回原主控。只看次数会被网络抖动 +// 误伤:一次正常的转移会被无声撤销。计时从「本轮第一次失败」开始而不是从转移生效 +// 开始——否则转移跑满一分钟后,任何几次瞬时连不上都会立刻把主机撤回去。 +static const int kTransferRevertAttempts = 3; +static const long long kTransferRevertGraceSec = 60; + +static std::string FormatUnixTimeHuman(long long epochSec) +{ + const time_t t = (time_t)epochSec; + struct tm tmv; + if (!localtime_r(&t, &tmv)) + return std::to_string(epochSec); + char buf[32] = { 0 }; + if (strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tmv) == 0) + return std::to_string(epochSec); + const long off = tmv.tm_gmtoff; + const long absOff = off < 0 ? -off : off; + char zone[16] = { 0 }; + snprintf(zone, sizeof(zone), "%c%02ld%02ld", off < 0 ? '-' : '+', + absOff / 3600, (absOff % 3600) / 60); + return std::string(buf) + " " + zone; +} + +static std::string FormatDurationHuman(long long seconds) +{ + if (seconds < 0) seconds = 0; + const long long h = seconds / 3600; + const long long m = (seconds % 3600) / 60; + const long long s = seconds % 60; + char buf[48] = { 0 }; + if (h > 0) snprintf(buf, sizeof(buf), "%lldh %02lldm", h, m); + else if (m > 0) snprintf(buf, sizeof(buf), "%lldm %02llds", m, s); + else snprintf(buf, sizeof(buf), "%llds", s); + return buf; +} + +// 主连接上的提示消息(服务端消息栏 + get_audit_log)。title/text 必须是纯 ASCII: +// 服务端按 ANSI(GBK) 解释这两个定长字段。 +static void SendClientNotice(const char* title, const char* text) +{ + if (g_bExit != S_CLIENT_NORMAL || !g_pMainClient || !g_pMainClient->IsConnected()) + return; + ClientMsg msg(title, text); + g_pMainClient->Send2Server((char*)&msg, sizeof(msg)); +} + +static void SaveTransferRecord(const HostTransfer::Target& t) +{ + setConfigStr("transfer", HostTransfer::EncodeRecord(t)); +} + +static void ClearTransferRecord() +{ + setConfigStr("transfer", ""); +} + +static void RestoreOrigTarget() +{ + HostTransfer::ApplyEndpoint(g_SETTINGS, g_transferOrig); + Mprintf("TRANSFER: restored to %s:%d\n", + g_transferOrig.ip.c_str(), g_transferOrig.port); +} + +static bool TransferExpired() +{ + const long long vt = g_transferValidTo.load(std::memory_order_relaxed); + return vt > 0 && (long long)time(nullptr) >= vt; +} + +// 到期(或提前归还)就恢复原主控并清记录,返回是否真的复原了。 +static bool HandleTransferExpiry() +{ + if (!TransferExpired()) + return false; + const bool early = g_transferEndEarly.exchange(false, std::memory_order_relaxed); + g_transferValidTo.store(0, std::memory_order_relaxed); + ClearTransferRecord(); + RestoreOrigTarget(); + Mprintf("TRANSFER: %s, back to original master\n", + early ? "ended early" : "expired"); + return true; +} + +// 把接收线程记下的目标落到连接参数。只在主连接线程调用:CONNECT_ADDRESS 没有跨线程 +// 同步,ConnectServer 读的就是它。 +static void ApplyPendingTransfer() +{ + if (!g_transferPending.load(std::memory_order_acquire)) + return; + HostTransfer::Target t; + { + std::lock_guard lk(g_transferMu); + t = g_transferPendingTarget; + g_transferPending.store(false, std::memory_order_release); + } + HostTransfer::ApplyTarget(g_SETTINGS, t); + // 新转移生效:上一个「提前归还」若还没被 HandleTransferExpiry 消费,就作废了, + // 留着会让这次转移将来自然到期时被误报成“ended early”。 + g_transferEndEarly.store(false, std::memory_order_relaxed); + g_transferFailStreak = 0; + g_transferFailAt = 0; + Mprintf("TRANSFER: applying %s:%d (transport=%d)\n", + t.ep.ip.c_str(), t.ep.port, t.ep.transport); +} + +// 转移目标「不可用」的两种形态都算一次失败:连不上,以及连上了却始终通不过 +// MasterSettings 校验(对端不是主控,或不是本构建的主控)。只看连不上的话, +// 一个「端口开着但不是主控」的地址会让主机一直空转,原主控那边已经看不到它了。 +// 连续的失败次数和已尝试时长同时满足才退回原主控——只看次数会被网络抖动误伤。 +static void NoteTransferFailure(const char* reason) +{ + if (g_transferValidTo.load(std::memory_order_relaxed) <= 0) + return; + const long long now = (long long)time(nullptr); + if (g_transferFailStreak == 0) + g_transferFailAt = now; // 本轮第一次失败:60 秒窗口从这里开始 + ++g_transferFailStreak; + if (g_transferFailStreak < kTransferRevertAttempts + || now - g_transferFailAt < kTransferRevertGraceSec) + return; + Mprintf("TRANSFER: target unusable for %s (%d tries, %s), reverting\n", + FormatDurationHuman(now - g_transferFailAt).c_str(), g_transferFailStreak, reason); + g_transferValidTo.store(0, std::memory_order_relaxed); + g_transferEndEarly.store(false, std::memory_order_relaxed); + g_transferFailStreak = 0; + g_transferFailAt = 0; + ClearTransferRecord(); + RestoreOrigTarget(); +} + +// 启动时读记录:未过期就切到转移目标,过期/损坏就删掉。必须在建连之前调用—— +// 同时记下此刻的连接参数作为「原主控」,之后才可能被转移目标覆盖。 +static void LoadTransferRecord() +{ + g_transferOrig = HostTransfer::CaptureEndpoint(g_SETTINGS); + + HostTransfer::Target t; + if (!HostTransfer::DecodeRecord(getConfigStr("transfer"), t)) + return; + const long long now = (long long)time(nullptr); + if (!t.Active(now)) { + Mprintf("TRANSFER: record expired at %s, removed\n", + FormatUnixTimeHuman(t.validTo).c_str()); + ClearTransferRecord(); + return; + } + g_transferValidTo.store(t.validTo, std::memory_order_relaxed); + HostTransfer::ApplyTarget(g_SETTINGS, t); + Mprintf("TRANSFER: active, target %s:%d, %s left\n", + t.ep.ip.c_str(), t.ep.port, FormatDurationHuman(t.validTo - now).c_str()); +} + // ============== System Information Functions ============== // Get macOS version string (e.g., "macOS 14.0 Sonoma") @@ -1272,6 +1449,92 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) } else { Mprintf("** [%p] TLS trust anchor removal: %s ***\n", user, err.c_str()); } + } else if (szBuffer[0] == COMMAND_SHARE || szBuffer[0] == COMMAND_SHARE_CANCEL) { + // 「分享主机」/「取消分享」:macOS 尚未实现。分享要在不改主连接的前提下再起 + // 一条完整登录的连接,而登录校验状态、心跳、主连接句柄都是进程级单例, + // 第二条连接会把第一条顶掉(与 Android 的结论一致)。 + // 服务端分享用的是 COMMAND_SHARE(assignFunction 用 ASSIGN + FOREVER 只发转移), + // 这里必须显式接住并回一条消息,否则主控那边以为下发成功了。 + Mprintf("** [%p] SHARE not supported on macOS (%d), ignored ***\n", + user, (int)szBuffer[0]); + SendClientNotice("Share host", "macOS client does not support sharing a host"); + return TRUE; + } else if (szBuffer[0] == COMMAND_ASSIGN_MASTER) { + // 「转移主机」:host:port:days:shine[:transport],解析见 common/host_transfer.h。 + // 服务端只在这个命令上发 SHARE_TYPE_YAMA_FOREVER;类型不符(老版本或异常载荷) + // 一律不按转移处理。 + if (ulLength < 3) { + Mprintf("** [%p] ASSIGN too short (%lu), ignored ***\n", + user, (unsigned long)ulLength); + return TRUE; + } + if (szBuffer[1] != SHARE_TYPE_YAMA_FOREVER) { + if (szBuffer[1] == SHARE_TYPE_YAMA) { + // 老服务端把「分享」发在同一个命令字节上(见 common/host_share.h:48)。 + // 同样要回消息,否则主控那边以为这台主机的分享下发成功了。 + Mprintf("** [%p] SHARE via ASSIGN (legacy), not supported on macOS ***\n", user); + SendClientNotice("Share host", "macOS client does not support sharing a host"); + } else { + Mprintf("** [%p] ASSIGN type=%d not supported, ignored ***\n", + user, (int)szBuffer[1]); + } + return TRUE; + } + HostTransfer::Target t; + const 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/Android 的 now <= valid_to 判断一致), + // 同时挡住「新主控再转一手」:主机此刻只连着新主控,它无权再改归属。 + // 唯一例外:目标就是原主控——那是提前归还,把到期时刻设成「现在」, + // 走心跳循环里那条已经验证过的复原路径。 + const bool toOriginal = + (t.ep.ip == g_transferOrig.ip && t.ep.port == g_transferOrig.port); + const long long active = g_transferValidTo.load(std::memory_order_relaxed); + if (now <= active) { + if (toOriginal) { + Mprintf("** [%p] ASSIGN back to original master, ending transfer early ***\n", user); + g_transferEndEarly.store(true, std::memory_order_relaxed); + g_transferValidTo.store(now, std::memory_order_relaxed); + // 记录立刻作废:主线程通常 1 秒内就会复原并再清一次,但若这期间进程 + // 崩了/被杀,重启时旧记录(有效期还在)会把主机送回转移目标。 + ClearTransferRecord(); + SendClientNotice("Transfer host", + "Transfer ended early, returning to original master (validity ignored)"); + return TRUE; + } + Mprintf("** [%p] ASSIGN ignored, already assigned until %s ***\n", + user, FormatUnixTimeHuman(active).c_str()); + char msg[192]; + snprintf(msg, sizeof(msg), + "Host is already transferred until %s (%s left), ignored", + FormatUnixTimeHuman(active).c_str(), + FormatDurationHuman(active - now).c_str()); + SendClientNotice("Transfer host", msg); + return TRUE; + } + if (toOriginal) { + // 没在转移而目标就是原主控:无事可做,放行只会白白断线重连一次。 + Mprintf("** [%p] ASSIGN target equals original master, ignored ***\n", user); + return TRUE; + } + // 先把新的到期时刻和记录落下来,最后才发布「待应用」。主线程看到 pending 就会 + // 应用地址并紧接着检查到期,若 validTo 还是旧的(恰好已过期),就会把刚接受的 + // 这次转移当成到期撤销掉。先挡住后续重复下发,再落盘。 + g_transferValidTo.store(t.validTo, std::memory_order_relaxed); + SaveTransferRecord(t); + { + std::lock_guard lk(g_transferMu); + g_transferPendingTarget = t; + g_transferPending.store(true, std::memory_order_release); + } + Mprintf("** [%p] ASSIGN to %s:%d for %s, moving the main link now ***\n", + user, t.ep.ip.c_str(), t.ep.port, + FormatDurationHuman(t.validTo - now).c_str()); } else { Mprintf("** [%p] Received unimplemented command: %d ***\n", user, int(szBuffer[0])); } @@ -1346,6 +1609,10 @@ int main(int argc, const char* argv[]) loadConfig(); Mprintf("Config loaded from %s\n", g_configPath.c_str()); + // 上次的「转移主机」还没到期就改连目标主控(原地址记在内存里,到期恢复)。 + // 必须在建连之前:它决定本次启动要连哪台主控。 + LoadTransferRecord(); + // 历史活动采样:进程一启动就开始攒(服务端随时可能来查), // 与 Linux 端在登录前 Start 的时机一致。 MacActivityHistory::Instance().Start(); @@ -1418,9 +1685,6 @@ int main(int argc, const char* argv[]) // C2C 落盘回执要在主连接上回包,但 DataProcess 拿到的 user 恒为 NULL, // 只能靠全局句柄(同 linux/main.cpp)。重连复用同一个对象,因此只在这里赋一次。 g_pMainClient = ClientObject.get(); - // 同 Linux:不传 conn 就取不到注入的 CONNECT_ADDRESS,协议必须显式喂进去, - // 否则配成 WS/WSS 也只会静默按明文 TCP 直连。 - ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); 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); @@ -1439,8 +1703,19 @@ int main(int argc, const char* argv[]) Mprintf("Auto-restart failed; continuing with the current process\n"); g_autoRestartPending = false; } + // 转移目标先落到连接参数;到期(或被新主控提前归还)则恢复原主控。 + // 两者都只改地址/协议,真正的建连由本轮下面的 ConnectServer 完成。 + ApplyPendingTransfer(); + HandleTransferExpiry(); + // 同 Linux:不传 conn 就取不到注入的 CONNECT_ADDRESS,协议必须显式喂进去, + // 否则配成 WS/WSS 也只会静默按明文 TCP 直连。每轮重喂还因为转移可能把目标 + // 换成另一台主控,它的入口未必和原主控同构(原 WSS、对方直连设备端口时是 TCP)。 + ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); clock_t c = clock(); if (!ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) { + // 转移目标连不上:连续失败且已持续一分钟才退回原主控并清掉记录, + // 否则一个写错的地址会让这台主机彻底失联——原主控那边已经看不到它了。 + NoteTransferFailure("unreachable"); Sleep(5000); continue; } @@ -1476,6 +1751,10 @@ int main(int argc, const char* argv[]) break; if (g_autoRestartPending) break; + // 转移与到期复原按 1 秒粒度判断:0.001 天(86 秒)这种短转移等满 + // 一个心跳周期才动就晚了。这里只 break,断开由循环外统一做。 + if (g_transferPending.load(std::memory_order_acquire) || TransferExpired()) + break; if (!ClientObject->IsRunning() || !ClientObject->IsConnected() || g_bExit != S_CLIENT_NORMAL) break; Sleep(1000); @@ -1486,6 +1765,19 @@ int main(int argc, const char* argv[]) ClientObject->Disconnect(); break; } + // 转移主机:接收线程已写好新目标,先断开当前(原主控)连接,再由外层 + // 循环换地址重连。地址必须在本线程、断开之后才改(见 ApplyPendingTransfer)。 + if (g_transferPending.load(std::memory_order_acquire)) { + Mprintf("TRANSFER: leaving current master\n"); + ClientObject->Disconnect(); + break; + } + // 转移结束:恢复启动时记下的原主控。自然到期与新主控「提前归还」 + // (它把到期时刻设成了当时,见 DataProcess 的 ASSIGN 分支)都走这里。 + if (HandleTransferExpiry()) { + ClientObject->Disconnect(); + break; + } // 信任锚热切换(COMMAND_TLS_ENABLE/DISABLE)会置这个标志: // 断开后由外层循环按新的传输方式重连。 if (g_needReconnect.exchange(false)) { @@ -1497,7 +1789,8 @@ int main(int argc, const char* argv[]) break; // 30 秒内未通过 MasterSettings 校验 → 断开本连接让外层重连, - // 永不退出进程(详见 ClientAuth::IsTimedOut 注释)。 + // 永不退出进程(详见 ClientAuth::IsTimedOut 注释)。转移期间这类连接 + // 记为一次失败(见下面心跳循环结束处),否则主机只能等到期才回原主控。 if (ClientAuth::IsTimedOut()) { ClientObject->Disconnect(); break; @@ -1516,6 +1809,22 @@ int main(int argc, const char* argv[]) memcpy(buf + 1, &hb, sizeof(Heartbeat)); ClientObject->Send2Server((char*)buf, sizeof(buf)); } + + // 一条连接结束了,按「这条连接有没有通过 MasterSettings 校验」记账: + // · 校验通过 → 转移目标确实可用,失败计数清零(原实现只在建连成功时清零, + // 等于把「连得上但校验不过」的目标排除在回退判据之外); + // · 从未通过 → 目标「连得上但不是主控」:典型是端口上跑着别的服务 + // (连上就被关掉,走不到 30 秒超时分支),或对端不认本构建。 + // 正常退出/自动重启触发的断开不计(条件在后半段挡住);已经到期或提前归还 + // 时 transfer 已结束,NoteTransferFailure 自己会返回。 + if (g_running && g_bExit == S_CLIENT_NORMAL && !g_autoRestartPending) { + if (ClientAuth::IsVerified()) { + g_transferFailStreak = 0; + g_transferFailAt = 0; // 有可用连接:60 秒窗口整体重置 + } else { + NoteTransferFailure("no master auth"); + } + } } // 退出原因留痕:signal handler 不能直接打日志,在这里补一行。