From 1401ff0a4cf38e5412f285761e72e2b5a0ed8042 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Sun, 15 Nov 2026 17:51:44 +0100 Subject: [PATCH] Feat(android): support the assign-master command The Android client now handles COMMAND_ASSIGN_MASTER (SHARE_TYPE_YAMA_FOREVER) and reuses common/host_transfer.h for the parsing and for the on-disk record - the same code the Linux and macOS clients already use. Windows and Linux keep the main link where it is and spawn a second instance so the new master sees the host right away, moving the main link only on the next reconnect. Android cannot do that: the login state (ClientAuth verification, the heartbeat ACK watchdog, the main client handle, g_bExit) is process-wide, so a second login connection would reset the first one's verification and make it drop every command it receives. Sharing has the same problem and stays unimplemented. Android therefore switches immediately: change the target, disconnect, reconnect. The new master sees the host at once and the old one loses it at once. Four cases, each exercised against two real masters: not transferred, target elsewhere transfer not transferred, target is the original ignored - it would only cost a reconnect and leave a record that "expires back to itself" transferred, target elsewhere refused with a ClientMsg; this is what stops B from chaining the host to C, which would orphan the middle hop because expiry always restores to A transferred, target is the original early return: the expiry time is set to now and the verified expiry path does the restore, so a master can hand the host back instead of waiting out the term The record lives in filesDir/yama_transfer; the original master is captured once at init and never written back, because restoring from a record that points at the transfer target is a no-op loop. A target that stays unreachable for 60 s (and at least 3 attempts) reverts to the original master so a typo does not lose the host; the 60 s floor exists because a Wi-Fi hiccup would otherwise cancel a perfectly good transfer. Both the switch and the expiry are checked once a second rather than once per heartbeat. With the 30 s cycle a 0.001 day (86 s) transfer took effect 14 s late and restored 20 s late, measured; now both are under a second. g_serverIp/g_serverPort moved behind a mutex and every connect site takes a snapshot first: the transfer rewrites them at runtime while the screen, log, chat, audio and terminal threads read them to connect, and assigning a std::string frees the buffer another thread may still be holding. ClientMsg titles are ASCII. The controller decodes title/text as ANSI/GBK, so a Chinese literal from this UTF-8 source reaches the message pane as mojibake. Verified on an API 35 x86_64 emulator: 443 -> 6543 -> back, refused chaining, unreachable-target revert, natural expiry, and restart from a record. host_transfer.h is covered by a standalone test (24 assertions: with and without the transport field, share type rejected, port 0 / days 0 / empty IP / bad transport, record round-trip, expiry). Sharing is answered with "Android client does not support sharing a host" instead of being ignored. Co-Authored-By: DeepSeek-V4.1-Flash --- android/app/src/main/cpp/main.cpp | 359 ++++++++++++++++++++++++++++-- 1 file changed, 335 insertions(+), 24 deletions(-) diff --git a/android/app/src/main/cpp/main.cpp b/android/app/src/main/cpp/main.cpp index d88b084..9eb835c 100644 --- a/android/app/src/main/cpp/main.cpp +++ b/android/app/src/main/cpp/main.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -28,6 +29,7 @@ #include "ChatHandler.h" #include "AudioHandler.h" #include "common/PTYHandler.h" // 远程终端(COMMAND_SHELL):与 Linux/macOS 共用 PTY 实现 +#include "common/host_transfer.h" // 主机转移(COMMAND_ASSIGN_MASTER):与 Linux/macOS 共用解析与记录编解码 #define XXH_INLINE_ALL #include "common/xxhash.h" #include "common/logger.h" @@ -689,10 +691,29 @@ static LinuxActivity::ProbeResult ProbeActivityFromJava() return r; } -// 服务器连接参数 +// 服务器连接参数。平时只在 nativeInit 里写一次,但「转移主机」会在运行期改写它, +// 而抓屏/日志/交谈/音频/终端这些子连接线程都是在自己的循环里读它去建连——std::string +// 赋值会释放旧缓冲,别的线程正拿着 c_str() 就成了悬空读。所以读写统一走下面这对 +// 函数(持锁拷贝一份再连),不要直接碰这两个全局量。 +static std::mutex g_targetMu; static std::string g_serverIp; static int g_serverPort = 443; +// 取一份目标快照。子连接与主连接建连前都先拷一份,避免读到改写中的字符串。 +static void GetServerTarget(std::string& ip, int& port) +{ + std::lock_guard lk(g_targetMu); + ip = g_serverIp; + port = g_serverPort; +} + +static void SetServerTarget(const std::string& ip, int port) +{ + std::lock_guard lk(g_targetMu); + g_serverIp = ip; + g_serverPort = port; +} + // 设备信息(nativeInit 传入) static std::string g_androidId; static std::string g_deviceModel; @@ -825,7 +846,9 @@ static void ScreenSpyThread() LOGE("ScreenSpyThread: screen size not set after 5s, abort"); return; } - LOGI("ScreenSpyThread start → %s:%d size=%dx%d", g_serverIp.c_str(), g_serverPort, w, h); + std::string ip; int port; + GetServerTarget(ip, port); + LOGI("ScreenSpyThread start → %s:%d size=%dx%d", ip.c_str(), port, w, h); // 服务端只发一次 COMMAND_SCREEN_SPY 就等子连接,子连接失败必须自己重试 for (int attempt = 1; attempt <= 20 && S_CLIENT_NORMAL == g_bExit && g_running.load(); ++attempt) { @@ -840,8 +863,9 @@ static void ScreenSpyThread() // 配成 WS/WSS 时连不上反代(主连接在 ConnectionThread 里已经这么做了) client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - LOGI("SST[%d]: connecting %s:%d", attempt, g_serverIp.c_str(), g_serverPort); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + GetServerTarget(ip, port); // 转移主机后目标会变,每轮重取 + LOGI("SST[%d]: connecting %s:%d", attempt, ip.c_str(), port); + if (!client->ConnectServer(ip.c_str(), port)) { LOGI("ScreenSpyThread: connect failed (attempt %d/20), retry 2s", attempt); Sleep(2000); continue; @@ -898,7 +922,9 @@ static void ScreenSpyThread() // 被关掉的就是主连接本身(客户端当场掉线)。 static void ClientLogThread() { - LOGI("ClientLogThread start → %s:%d", g_serverIp.c_str(), g_serverPort); + std::string ip; int port; + GetServerTarget(ip, port); + LOGI("ClientLogThread start → %s:%d", ip.c_str(), port); for (int attempt = 1; attempt <= 3 && S_CLIENT_NORMAL == g_bExit && g_running.load(); ++attempt) { std::unique_ptr client; std::unique_ptr handler; @@ -907,7 +933,8 @@ static void ClientLogThread() client->EnableSubConnAuth(true, g_myClientID); // 同上:子连接必须继承配置的传输方式,否则 WS/WSS 部署下 get_client_log 连不上 client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + GetServerTarget(ip, port); + if (!client->ConnectServer(ip.c_str(), port)) { LOGE("ClientLogThread: connect failed (attempt %d/3)", attempt); Sleep(1000); continue; @@ -947,7 +974,9 @@ static void ChatThread() ~InFlightGuard() { g_chatInFlight.store(false); } } guard; - LOGI("ChatThread start → %s:%d", g_serverIp.c_str(), g_serverPort); + std::string ip; int port; + GetServerTarget(ip, port); + LOGI("ChatThread start → %s:%d", ip.c_str(), port); for (int attempt = 1; attempt <= 3 && S_CLIENT_NORMAL == g_bExit && g_running.load(); ++attempt) { std::unique_ptr client; std::unique_ptr handler; @@ -956,7 +985,8 @@ static void ChatThread() client->EnableSubConnAuth(true, g_myClientID); // 与屏幕/日志子连接相同:必须继承配置的传输方式,否则 WS/WSS 部署下连不上反代 client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + GetServerTarget(ip, port); + if (!client->ConnectServer(ip.c_str(), port)) { LOGE("ChatThread: connect failed (attempt %d/3)", attempt); Sleep(1000); continue; @@ -1015,7 +1045,9 @@ static void AudioThread() ~InFlightGuard() { g_audioInFlight.store(false); } } guard; - LOGI("AudioThread start → %s:%d", g_serverIp.c_str(), g_serverPort); + std::string ip; int port; + GetServerTarget(ip, port); + LOGI("AudioThread start → %s:%d", ip.c_str(), port); std::unique_ptr client; std::unique_ptr handler; bool started = false; @@ -1024,7 +1056,8 @@ static void AudioThread() client->EnableSubConnAuth(true, g_myClientID); // 与屏幕/日志/交谈子连接一致:必须继承配置的传输方式(WS/WSS 部署) client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + GetServerTarget(ip, port); + if (!client->ConnectServer(ip.c_str(), port)) { LOGE("AudioThread: connect failed"); return; } @@ -1083,13 +1116,16 @@ static void TerminalThread() ~InFlightGuard() { g_termInFlight.store(false); } } guard; - LOGI("TerminalThread start → %s:%d", g_serverIp.c_str(), g_serverPort); + std::string ip; int port; + GetServerTarget(ip, port); + LOGI("TerminalThread start → %s:%d", ip.c_str(), port); try { std::unique_ptr client(new IOCPClient(g_bExit, true)); client->EnableSubConnAuth(true, g_myClientID); // 与屏幕/日志/交谈子连接一致:继承配置的传输方式,WS/WSS 部署下直连会连不上反代 client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + GetServerTarget(ip, port); + if (!client->ConnectServer(ip.c_str(), port)) { LOGE("TerminalThread: connect failed"); return; } @@ -1315,6 +1351,11 @@ static void ScreenPreviewThread(ScreenPreviewReq req) // 所以统一截断后 memcpy。 static void sendClientMsg(const char* title, const char* text) { + // title / text 必须是纯 ASCII。ClientMsg 的两个字段在服务端按 ANSI(GBK) 解释 + // (2015RemoteDlg.cpp 的 `_L(msg->title)`),而本文件是 UTF-8 源码——直接传中文 + // 字面量过去,主控的消息栏里就是「杞Щ涓绘満」这种乱码。要发中文得先转 GBK, + // 而 Android 的 iconv 只在 API 28+ 才有,minSdk 21 上不能依赖它。 + // // Java 安装线程也会走这里;连接检查与发送必须用同一份句柄,否则中间被收掉就崩 auto mc = GetMainClient(); if (!mc || !mc->IsConnected()) return; @@ -1451,6 +1492,111 @@ static void RefreshLoginTls(LOGIN_INFOR& info) } #endif // YAMA_TLS_CHANNEL +// ============== 主机转移(COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA_FOREVER)============== +// 服务端「转移主机」下发的载荷是 host:port:days:shine[:transport](见 +// server/2015Remote/2015RemoteDlg.cpp assignFunction),解析与记录编解码在 +// common/host_transfer.h,与 Linux/macOS 共用同一份代码。 +// +// 与 Windows/Linux 的语义差别:那两个平台上主连接留在原主控不动、只在下次重连时 +// 才过去,另起一个实例让新主控「立刻」看到这台主机。Android 的连接状态 +// (ClientAuth 的校验态、心跳 ACK 看门狗、主连接句柄、g_bExit)全是进程级单例, +// 起第二条登录连接等于把这些全部参数化——这正是「分享主机」没做的原因。所以这里 +// 用「立即切换」:改目标 → 断开 → 按新地址重连。新主控立刻看到主机,代价是原主控 +// 立刻失去它;为防目标写错把主机彻底弄丢,持续一分钟连不上就退回原主控。 +// +// 原主控是出包时烘焙的地址,只存在内存里(g_transferOrig),绝不写回记录——恢复时 +// 读到的若还是转移目标,就成了原地打转(同 linux/main.cpp 的注释)。 +static std::atomic g_transferValidTo{0}; // >0 = 处于转移状态(到期时刻) +static std::atomic g_transferPending{false}; // 接收线程已写下新目标,待主循环应用 +static std::atomic g_transferAppliedAt{0}; // 切到转移目标的时刻,回退判据用 +static std::atomic g_transferEndEarly{false};// true = 目标主控提前归还,不是到期 +static std::mutex g_transferMu; +static HostTransfer::Target g_transferPendingTarget; +static HostTransfer::Endpoint g_transferOrig; // 烘焙的主控,到期/失败时恢复用 +static std::once_flag g_transferOrigOnce; +static int g_transferFailStreak = 0; // 仅连接线程访问,无需原子 + +// 回退判据:连续失败次数 + 已尝试时长**同时**满足才退回原主控。只看次数会被网络 +// 抖动误伤——Wi-Fi 卡一下就是连续几次失败,一次正常的转移会被无声撤销。加上 60 秒 +// 下限后,只有「持续一分钟都连不上」才认定目标不可用。 +static const int kTransferRevertAttempts = 3; +static const long long kTransferRevertGraceSec = 60; + +static std::string TransferRecordPath() +{ + return g_filesDir.empty() ? std::string() : g_filesDir + "/yama_transfer"; +} + +// 记录只有一行 ip:port:transport:headerEnc:valid_to(见 HostTransfer::EncodeRecord)。 +// 用文件而不是 SharedPreferences:native 侧没有 JNI 上下文,分组名也是这么存的。 +static void SaveTransferRecord(const HostTransfer::Target& t) +{ + const std::string path = TransferRecordPath(); + if (path.empty()) return; + FILE* f = fopen(path.c_str(), "w"); + if (!f) { LOGI("TRANSFER: cannot write %s", path.c_str()); return; } + fputs(HostTransfer::EncodeRecord(t).c_str(), f); + fclose(f); +} + +static void ClearTransferRecord() +{ + const std::string path = TransferRecordPath(); + if (!path.empty()) unlink(path.c_str()); +} + +// 把端点应用到连接参数:g_serverIp/Port 给建连用,g_SETTINGS.protoType 给子连接继承 +// (子连接在各自线程里 SetDefaultProto(g_SETTINGS.protoType))。Android 没有 SHINE/HELL +// 头加密,headerEnc 段忽略。 +static void ApplyEndpointToTarget(const HostTransfer::Endpoint& ep) +{ + SetServerTarget(ep.ip, ep.port); + if (ep.transport >= 0) + g_SETTINGS.protoType = (char)ep.transport; +} + +static void RestoreOrigTarget() +{ + ApplyEndpointToTarget(g_transferOrig); + LOGI("TRANSFER: restored to %s:%d", 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; +} + +// 启动时读记录:未过期就切到转移目标,过期/损坏就删掉。只在 nativeInit 调用。 +static void LoadTransferRecord() +{ + const std::string path = TransferRecordPath(); + if (path.empty()) return; + FILE* f = fopen(path.c_str(), "r"); + if (!f) return; + char buf[512] = {}; + const size_t n = fread(buf, 1, sizeof(buf) - 1, f); + fclose(f); + HostTransfer::Target t; + if (n == 0 || !HostTransfer::DecodeRecord(std::string(buf, n), t)) { + LOGI("TRANSFER: bad record, ignored and removed"); + ClearTransferRecord(); + return; + } + const long long now = (long long)time(nullptr); + if (!t.Active(now)) { + LOGI("TRANSFER: record expired at %lld, removed", t.validTo); + ClearTransferRecord(); + return; + } + g_transferValidTo.store(t.validTo, std::memory_order_relaxed); + g_transferAppliedAt.store(now, std::memory_order_relaxed); + ApplyEndpointToTarget(t.ep); + LOGI("TRANSFER: active, target %s:%d, %llds left", t.ep.ip.c_str(), t.ep.port, t.validTo - now); +} + // ------------------------------------------------------------------ DataProcess int DataProcess(void* /*user*/, PBYTE szBuffer, ULONG ulLength) { @@ -1693,6 +1839,90 @@ int DataProcess(void* /*user*/, PBYTE szBuffer, ULONG ulLength) } #endif + case COMMAND_ASSIGN_MASTER: { + // 「转移主机」:host:port:days:shine[:transport],解析见 common/host_transfer.h。 + // 同一个命令字节也承载「分享主机」(buf[1] = SHARE_TYPE_YAMA,见下面单独的 case)。 + if (ulLength < 3) { + LOGI("cmd: ASSIGN too short (%lu), ignored", (unsigned long)ulLength); + break; + } + if (szBuffer[1] != SHARE_TYPE_YAMA_FOREVER) { + LOGI("cmd: ASSIGN type=%d not supported on Android", (int)szBuffer[1]); + sendClientMsg("Share host", "Android client does not support sharing a host"); + break; + } + HostTransfer::Target t; + const long long now = (long long)time(nullptr); + if (!HostTransfer::ParseAssignCommand(szBuffer, ulLength, now, t)) { + // 载荷非法时什么都不做——绝不能把脏数据当成有效转移,否则一台上线中的 + // 主机就被改到一个不存在的地址上去了。 + LOGI("cmd: ASSIGN malformed payload, ignored"); + break; + } + // 有效期内拒绝再次转移,与 Windows KernelManager 的 now <= valid_to 判断一致。 + // 这条同时挡住了「转移目标主控再转一手」:主机被转移到 B 之后,和它相连的只有 B, + // 于是 B 发来的转移命令一律落在这里被丢掉——只有原主控(主机复原后才连回去的 + // 那一台)还有机会发起下一次转移。不这么挡的话,B 把主机转到 C,到期却按原主控 + // 复原,中间那一跳就成了谁也不认的孤儿。 + 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) { + // 唯一的例外:目标就是原主控。那是「提前归还」,不是再转一手——B 有权把 + // 主机还给 A,否则一旦转错或临时用完,只能干等到期。 + // 实现上不新增状态:把到期时刻设成「现在」,走心跳循环里那条已经验证过的 + // 复原路径(清记录 → 换回原地址 → 重连)。代价是 A 不可达时主机会一直重试 + // A,这与自然到期完全一致,没有引入新的失败形态。 + // + // 注意这里**丢弃**了命令里的天数(t.validTo):有效期描述的是「多久之后回到 + // 原主控」,已经回到原主控就没有倒计时可言了。服务端对话框强制天数 > 0, + // 所以操作员必然填了一个值,日志里把它记下来免得事后对不上。 + if (toOriginal) { + LOGI("cmd: ASSIGN back to original master %s:%d, ending transfer early " + "(requested validity %llds ignored)", + t.ep.ip.c_str(), t.ep.port, t.validTo - now); + g_transferEndEarly.store(true, std::memory_order_relaxed); + g_transferValidTo.store(now, std::memory_order_relaxed); + sendClientMsg("Transfer host", + "Transfer ended early, returning to original master (validity ignored)"); + break; + } + LOGI("cmd: ASSIGN ignored, already assigned until %lld", active); + char msg[128]; + snprintf(msg, sizeof(msg), + "Host is already transferred until %lld, ignored", active); + sendClientMsg("Transfer host", msg); + break; + } + // 当前没在转移,而目标就是原主控自己:无事可做。放行只会白白断线重连一次, + // 还留下一条「到期复原到自己」的记录。 + if (toOriginal) { + LOGI("cmd: ASSIGN target equals original master, ignored"); + break; + } + { + std::lock_guard lk(g_transferMu); + g_transferPendingTarget = t; + g_transferPending.store(true, std::memory_order_release); + } + // 先挡住后续重复下发,再落盘:落盘失败也不至于被第二条命令覆盖。 + g_transferValidTo.store(t.validTo, std::memory_order_relaxed); + SaveTransferRecord(t); + LOGI("cmd: ASSIGN → %s:%d for %llds", t.ep.ip.c_str(), t.ep.port, t.validTo - now); + PostStatus("transfer: switching master"); + break; + } + + case COMMAND_SHARE: + case COMMAND_SHARE_CANCEL: + // 「分享主机」/「取消分享」:Android 尚未实现。分享要在不改主连接的前提下 + // 再起一条**完整登录**的连接,而登录相关的状态(ClientAuth 校验态、心跳 ACK + // 看门狗、主连接句柄)都是进程级单例,第二条连接会把第一条的状态顶掉—— + // 要做得先把它们整体参数化,属另一件事。这里明确回一条消息,别让主控那边 + // 以为下发成功了(Windows 客户端在无权限时也是这么回的)。 + LOGI("cmd: SHARE not supported on Android (%d)", (int)szBuffer[0]); + sendClientMsg("Share host", "Android client does not support sharing a host"); + break; + default: LOGI("cmd: unhandled cmd=%d len=%lu", (int)szBuffer[0], (unsigned long)ulLength); break; @@ -1712,7 +1942,11 @@ static std::atomic g_connGeneration{0}; static void ConnectionThread(uint64_t gen) { - LOGI("ConnectionThread → %s:%d", g_serverIp.c_str(), g_serverPort); + { + std::string ip0; int port0; + GetServerTarget(ip0, port0); + LOGI("ConnectionThread → %s:%d", ip0.c_str(), port0); + } PostStatus("geo: fetching..."); std::string g_pubIp, g_location; @@ -1767,11 +2001,6 @@ static void ConnectionThread(uint64_t gen) std::shared_ptr client = std::make_shared(g_bExit, false); client->setManagerCallBack(nullptr, DataProcess, nullptr); SetMainClient(client); // 升级失败回报用;线程退出前撤回 - // 同 Linux/macOS:不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议必须显式喂进去, - // 否则配成 WS/WSS 也只会静默按明文 TCP 直连。Android 现已有 TLS 通道(OpenSSL),WSS - // 在有信任锚时正常握手,无锚时按明文 WS 回退、待服务端下发后升级(见 IOCPClient)。 - client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); - int g_connAttempt = 0; // 每次循环判断都带上代号:nativeStop 后 2 秒内进程被 nativeInit 重新拉起时, // g_bExit/g_running 会被新一轮重置成「运行中」,旧线程醒来会再连一条主连接 @@ -1780,17 +2009,54 @@ static void ConnectionThread(uint64_t gen) return gen == g_connGeneration.load(std::memory_order_acquire); }; while (S_CLIENT_NORMAL == g_bExit && g_running.load() && currentGen()) { + // 转移主机:接收线程只写「待应用」,地址切换必须在本线程做——g_serverIp 是 + // 建连用的全局量,只能在连接生命周期的持有线程改(同 linux/main.cpp)。 + // 上一轮的连接已由心跳循环 Disconnect 掉,这里换地址再连。 + if (g_transferPending.exchange(false, std::memory_order_acq_rel)) { + HostTransfer::Target t; + { + std::lock_guard lk(g_transferMu); + t = g_transferPendingTarget; + } + ApplyEndpointToTarget(t.ep); + g_transferFailStreak = 0; + g_transferAppliedAt.store((long long)time(nullptr), std::memory_order_relaxed); + LOGI("TRANSFER: applying %s:%d", t.ep.ip.c_str(), t.ep.port); + } + + std::string ip; int port; + GetServerTarget(ip, port); char connMsg[64]; - snprintf(connMsg, sizeof(connMsg), "connect #%d → %s:%d", - ++g_connAttempt, g_serverIp.c_str(), g_serverPort); + snprintf(connMsg, sizeof(connMsg), "connect #%d → %s:%d", ++g_connAttempt, ip.c_str(), port); PostStatus(connMsg); clock_t c = clock(); - if (!client->ConnectServer(g_serverIp.c_str(), g_serverPort)) { + // 传输方式每轮重喂。两个原因:一是不传 conn 的构造路径拿不到注入的 + // CONNECT_ADDRESS,协议不显式喂进去就会静默按明文 TCP 直连;二是转移主机 + // 可能把目标换成另一台主控,它的前端未必和原主控同构(本主控走反代的 WSS、 + // 对方直连设备端口时就得是 TCP)。 + client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); + if (!client->ConnectServer(ip.c_str(), port)) { snprintf(connMsg, sizeof(connMsg), "connect #%d failed errno=%d", g_connAttempt, errno); PostStatus(connMsg); + // 转移目标连不上:连续失败且已持续一分钟,才退回原主控并清掉记录,否则一个 + // 写错的地址会让这台主机彻底失联——原主控那边此时已经看不到它了。 + if (g_transferValidTo.load(std::memory_order_relaxed) > 0) { + ++g_transferFailStreak; + const long long tried = (long long)time(nullptr) + - g_transferAppliedAt.load(std::memory_order_relaxed); + if (g_transferFailStreak >= kTransferRevertAttempts && tried >= kTransferRevertGraceSec) { + LOGI("TRANSFER: unreachable for %llds (%d tries), reverting", tried, g_transferFailStreak); + g_transferValidTo.store(0, std::memory_order_relaxed); + g_transferFailStreak = 0; + ClearTransferRecord(); + RestoreOrigTarget(); + PostStatus("transfer: unreachable, reverted"); + } + } Sleep(5000); continue; } + g_transferFailStreak = 0; PostStatus("connected! sending login..."); ClientAuth::OnNewConnection(); @@ -1833,6 +2099,12 @@ static void ConnectionThread(uint64_t gen) PostStatus(dbg); break; } + // 转移主机与到期复原按 1 秒粒度判断。放在心跳周期(30 秒)之外是有原因的: + // 这两件事都是「到点就该动」的,等满一个周期会让 0.001 天(86 秒)这种短 + // 转移晚二十多秒才生效、晚二十多秒才复原。这里只 break,真正的断开与恢复 + // 由循环外的检查统一做(避免 Disconnect 被调两次)。 + if (g_transferPending.load(std::memory_order_acquire) || TransferExpired()) + break; Sleep(1000); } #ifdef YAMA_TLS_CHANNEL @@ -1845,6 +2117,31 @@ static void ConnectionThread(uint64_t gen) break; } #endif + // 转移主机:接收线程已写好新目标,先断开当前(原主控)连接,再由外层循环 + // 换地址重连。顺序不能反——地址必须在本线程、断开之后才改。 + if (g_transferPending.load(std::memory_order_acquire)) { + PostStatus("transfer: leaving current master"); + client->Disconnect(); + break; + } + // 转移结束:恢复出包时烘焙的主控。Windows/Linux 由 StartClient 的 assigned + // 分支做同一件事;Android 没有重启入口,就地改回并重连。 + // 两种情况都会走到这里:自然到期,以及目标主控「提前归还」(它把到期时刻设成 + // 了当时,见 DataProcess 的 COMMAND_ASSIGN_MASTER 分支)。 + { + const long long vt = g_transferValidTo.load(std::memory_order_relaxed); + if (TransferExpired()) { + const bool early = g_transferEndEarly.exchange(false, std::memory_order_relaxed); + LOGI("TRANSFER: %s at %lld, restoring original master", + early ? "ended early" : "expired", vt); + g_transferValidTo.store(0, std::memory_order_relaxed); + ClearTransferRecord(); + RestoreOrigTarget(); + PostStatus(early ? "transfer: returned by new master" : "transfer: expired, back to original"); + client->Disconnect(); + break; + } + } if (!client->IsRunning() || !client->IsConnected() || g_bExit != S_CLIENT_NORMAL || !g_running.load() || !currentGen()) break; @@ -1942,8 +2239,7 @@ Java_com_yama_client_YamaBridge_nativeInit( return s; }; - g_serverIp = g_SETTINGS.ServerIP(); - g_serverPort = g_SETTINGS.ServerPort(); + SetServerTarget(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort()); g_androidId = toStr(androidId); g_deviceModel = toStr(deviceModel); g_androidVersion = toStr(androidVersion); @@ -1956,6 +2252,17 @@ Java_com_yama_client_YamaBridge_nativeInit( g_versionCode = (int)versionCode; LoadGroupName(); // 若文件存在则覆盖 g_SETTINGS.szGroupName(优先级高于编译时 patch) + // 转移主机:先抓一次出包时烘焙的主控(只抓第一次——之后 g_SETTINGS.protoType 可能 + // 已被转移改写,再抓就把转移目标当成原主控了),再按落盘记录切到转移目标。 + // 顺序不能反:LoadTransferRecord 会改 g_SETTINGS.protoType。 + std::call_once(g_transferOrigOnce, []() { + g_transferOrig.ip = g_SETTINGS.ServerIP(); + g_transferOrig.port = g_SETTINGS.ServerPort(); + g_transferOrig.transport = (int)(unsigned char)g_SETTINGS.protoType; + g_transferOrig.headerEnc = g_SETTINGS.iHeaderEnc; + }); + LoadTransferRecord(); + #ifdef YAMA_TLS_CHANNEL // 信任锚目录注入 App 私有 filesDir,必须在连接线程首次 TlsEnabled() 之前。 if (!g_filesDir.empty()) TlsSetAnchorDir(g_filesDir); @@ -2111,7 +2418,11 @@ Java_com_yama_client_YamaBridge_nativeInit( // g_running 已在 CAS 中设为 true,不重复 store const uint64_t gen = g_connGeneration.fetch_add(1, std::memory_order_acq_rel) + 1; std::thread(ConnectionThread, gen).detach(); - LOGI("nativeInit OK server=%s:%d", g_serverIp.c_str(), g_serverPort); + { + std::string ip0; int port0; + GetServerTarget(ip0, port0); + LOGI("nativeInit OK server=%s:%d", ip0.c_str(), port0); + } return 0; }