From de9e9a73691e220edbec303ae88c1e7a1bb0daae Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Sat, 21 Nov 2026 10:01:17 +0100 Subject: [PATCH] Feature(client): support host transfer in the macOS client Mirror the Android semantics: move the main link to the assigned master immediately, persist the record in config so it survives restarts, return to the original master on expiry or early return, and revert after the new master stays unreachable for 60s. Share requests are answered as unsupported, and the capability matrix is updated accordingly. A target counts as unusable when the connection is refused or when it is accepted but never passes MasterSettings (a foreign service on that port, or a master built with another key). The latter used to be retried forever, stranding the host until expiry; both shapes now count toward the revert gate and reset only once a connection verifies. Early return clears the persisted record at once, so a crash before the main loop restores the original master cannot resurrect the transfer on restart. Endpoints from the command or the record are bounds-checked before being written into CONNECT_ADDRESS (strcpy_s is strcpy on POSIX), config access is serialized across the receive and main threads, the new validTo is published before the pending target so expiry cannot undo a fresh transfer, and a stale early-return flag is cleared when a new transfer applies or one is reverted. The Linux client was rebuilt with the shared header changes; the macOS side is not compiled here and still needs a build on a Mac. Co-Authored-By: deepseek-flash --- common/client_auth_state.h | 7 + common/host_endpoint.h | 12 +- common/host_transfer.h | 8 +- docs/Client_Capability_Matrix.md | 4 +- macos/main.mm | 323 ++++++++++++++++++++++++++++++- 5 files changed, 342 insertions(+), 12 deletions(-) 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 不能直接打日志,在这里补一行。