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
This commit is contained in:
yuanyuanxiangandDeepSeek-V4.1-Flash committed 2026-11-15 17:51:44 +01:00
1 parent 3ae54c808e
commit 1401ff0a4c
1 file changed
+335 -24
+335 -24
View File
@@ -11,6 +11,7 @@
#include <cstring>
#include <cinttypes>
#include <cstdio>
#include <ctime>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
@@ -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<std::mutex> lk(g_targetMu);
ip = g_serverIp;
port = g_serverPort;
}
static void SetServerTarget(const std::string& ip, int port)
{
std::lock_guard<std::mutex> 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<IOCPClient> client;
std::unique_ptr<ClientLogHandler> 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<IOCPClient> client;
std::unique_ptr<AndroidChatHandler> 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<IOCPClient> client;
std::unique_ptr<AndroidAudioHandler> 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<IOCPClient> 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<long long> g_transferValidTo{0}; // >0 = 处于转移状态(到期时刻)
static std::atomic<bool> g_transferPending{false}; // 接收线程已写下新目标,待主循环应用
static std::atomic<long long> g_transferAppliedAt{0}; // 切到转移目标的时刻,回退判据用
static std::atomic<bool> 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<std::mutex> 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<uint64_t> 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<IOCPClient> client = std::make_shared<IOCPClient>(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<std::mutex> 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;
}