#pragma once
#ifndef __USERINFO_SECURE_H__
#define __USERINFO_SECURE_H__


#include <PacketStruct_CG.h>
#include <CryptManager.h>
#include <ITimeout.h>
//

//#include "AgentServer.h"
#include "TimeCheck/HeartbeatChecker.h"
#include "TimeCheck/heartbeatManager.h"
#include "TimeCheck/TickSpeedChecker.h" //_NA_20100802_SPEED_HACK_DETECTION
#include "./UserInfo.SecureXignCode.h" // USING_XIGNCODE
#include "GameGuard/ggsrv30.h"  // USING_GAMEGUARD

class User;
class UserManager;

//==================================================================================================
// <TYPE DEFINITIONs><sSECURE_CONTROL_STATUS REVISION>
// <sSECURE_FLAG>
//==================================================================================================
// <TYPE DEFINITIONs><sSECURE_CONTROL_STATUS REVISION>
// <sSECURE_FLAG>
class sSECURE_FLAG
{
public:
    struct ControlInfo
    {
        DWORD flag; // Control Field
        DWORD trans_tick; // Transaction Start Tick
    };

    //根据当前玩家状态的处理区分用
    enum eSTATUS
    {
        STAT_NOCONTROL      = 0x00000000,
        STAT_USERINIT       = 0x00000002, //乱键交换完成的情况
        STAT_CRYPTED        = 0x00000004, //查询对象
        STAT_CRYPTING       = 0x00000008, //正在等待查询的响应
        STAT_MASK_STATUS    = 0x0000007F, //STAT_TRANSACTION除外的口罩
        STAT_TRANSACTION    = 0x00000080, //考虑到像约翰间移动这样的客户端的回答不恰当的情况。
    };

    //当前正在执行的安全查询类型
    //存在值本身就是一种趋势
    enum eQUERY_TRANS
    {
        TRANS_NOTRANS           = (0x00000000),
        TRANS_DEFAULT_TRANS     = (0x00008000), //[1]最顶级的节奏是预约好的

#define SHL_VALUE(val) (((val) << 8) | TRANS_DEFAULT_TRANS)
        TRANS_DUPLEX_SNK        = SHL_VALUE(0x10), // In MOLA, Duplex Query
        TRANS_DUPLEX_SNK_T1     = SHL_VALUE(0x11), // In Client, Cooperating
        TRANS_SIMPLEX_SNK       = SHL_VALUE(0x20), // In MOLA, Simplex Query
        TRANS_SIMPLEX_SNK_T1    = SHL_VALUE(0x21), // In MOLA, Simplex Query
        TRANS_SIMPLEX_SNK_T2    = SHL_VALUE(0x22), // In MOLA, Simplex Query
        TRANS_SIMPLEX_SNK_T3    = SHL_VALUE(0x23), // In MOLA, Simplex Query
        TRANS_SIMPLEX_SNK_T4    = SHL_VALUE(0x24), // In MOLA, Simplex Query
        TRANS_MOLA_QUERY        = SHL_VALUE(0x31), // In MOLA, 
        TRANS_MOLA_CONFIG       = SHL_VALUE(0x32), // In MOLA, 
        TRANS_MOLA_HEARTBEAT    = SHL_VALUE(0x33), // In MOLA, 
        TRANS_GRES_CHECK        = SHL_VALUE(0x40), // In MOLA,
        TRANS_ARMORKIT          = SHL_VALUE(0x51), // In MOLA,
        //__NA000000_070913_HACKSHIELD_INSTALLATION__
        TRANS_HACKSHIELD        = SHL_VALUE(0x52), 
        TRANS_GAMEGUARD         = SHL_VALUE(0x53),
        //如果在查询事务中遇到此事务，则不执行任何操作。
        //必须存在于Crypting List
        TRANS_FORCEDCLOSING     = SHL_VALUE(0x60),
        TRANS_MASK_QUERY        = (0x0000FF00),
#undef SHL_VALUE

        //例外事项，该BUILTIN QUERY必须在特定时刻发动，并且正常情况下
        //指必须收到的查询。与一般的查询事务无关。
        TRANS_BUILTIN_QUERY     = (0x01000000), //ASSERT! 在启动此操作时，其他查询正在未执行中。
    };

    //当前正在执行的安全查询失败时，要处理的错误类型
    //例如，不满足条件或被暂停时，
    //安全查询局域网即使转换为TRANS_FORCEDCLOSING状态，也要将强制终止的事由打到最后
    enum eQUERY_ERRCTRL
    {
        ERR_NOERR           = (0x00000000),
        ERR_DEFAULT_TRANS   = (0x00800000), //[1]最顶级的节奏是预约好的

#define SHL_VALUE(val) (((val) << 16) | ERR_DEFAULT_TRANS)
        ERR_DUPLEX_SNK          = SHL_VALUE(0x10), // In MOLA, Duplex Query
        ERR_DUPLEX_SNK_T1       = SHL_VALUE(0x11), // In Client, Cooperating
        ERR_SIMPLEX_SNK         = SHL_VALUE(0x20), // In MOLA, Simplex Query
        ERR_SIMPLEX_SNK_T1      = SHL_VALUE(0x21), // In MOLA, Simplex Query
        ERR_SIMPLEX_SNK_T2      = SHL_VALUE(0x22), // In MOLA, Simplex Query
        ERR_SIMPLEX_SNK_T3      = SHL_VALUE(0x23), // In MOLA, Simplex Query
        ERR_SIMPLEX_SNK_T4      = SHL_VALUE(0x24), // In MOLA, Simplex Query
        ERR_MOLA_QUERY          = SHL_VALUE(0x31), // In MOLA, 
        ERR_MOLA_CONFIG         = SHL_VALUE(0x32), // In MOLA, 
        ERR_MOLA_HEARTBEAT      = SHL_VALUE(0x33), // In MOLA, 
        ERR_GRES_CHECK          = SHL_VALUE(0x40), // In MOLA,
        ERR_ARMORKIT            = SHL_VALUE(0x51), // In MOLA,
        //__NA000000_070913_HACKSHIELD_INSTALLATION__
        ERR_HACKSHIELD          = SHL_VALUE(0x52), 
        ERR_HACKSHIELD_DETECT   = SHL_VALUE(0x53),
        ERR_GAMEGUARD_QUERY     = SHL_VALUE(0x54),
        //上层事务错误在发生查询时设置为默认值
        //如果上面的状态满足了特定的条件，就会像下面的Transportion Air一样被分解.
        ERR_FORCEDCLOSING       = SHL_VALUE(0x60),
        ERR_CLOSE_BY_MASTER     = SHL_VALUE(0x61),
        ERR_CORRUPTED_PACKET    = SHL_VALUE(0x62), // In MOLA,
        ERR_VIOLATION_FLOW_SEQ  = SHL_VALUE(0x63), // In MOLA,
        ERR_INITIAL_KEY_EXCHG   = SHL_VALUE(0x64),
        ERR_BUILTIN_QUERY       = SHL_VALUE(0x65),
        ERR_HACKSHIELD_VERSION  = SHL_VALUE(0x66), //__NA001083_080609_ABUSING_LOGICAL_DETECTION_ANAL_AND_IMPL_V2__
        ERR_MASK_QUERY          = (0x00FF0000),
#undef SHL_VALUE
    };

    //----------------------------------------------------------------------------------------------
    // <FIELDs>
public:
    sSECURE_FLAG();
    DWORD& FLAG();
    DWORD& TRANS_TICK();

	bool IsEnableQuerying() const;
    void ClearFields();
    //----------------------------------------------------------------------------------------------
private:
    ControlInfo control_info_;

public:
    struct sSTATUS
    {
        DWORD& FLAG();
        DWORD& TRANS_TICK();

        sSTATUS(ControlInfo& control_info);

        void SetStatus(eSTATUS status_value);
        eSTATUS GetStatus() const;
        void TransEnter();
        void TransLeave();
        //根据状态控制{CHAR_SELECT|（状态为约翰间移动状态）}
        bool IsTransaction() const;
        DWORD GetTransTime() const;
        //
        ControlInfo& control_info_;
    } STATUS;

    struct sQUERY
    {
        DWORD& FLAG();
        sQUERY(ControlInfo& control_info);
        void TransEnter(eQUERY_TRANS trans_value);
        eQUERY_TRANS TransType() const;
        void TransLeave();

		bool IsTransaction() const;

		ControlInfo& control_info_;
    } QUERY;

    struct sQUERYBUILTIN
    {
        DWORD& FLAG();
        sQUERYBUILTIN(ControlInfo& control_info);
        void TransEnter();
        void TransLeave();

		bool IsTransaction() const;

		ControlInfo& control_info_;
    } QUERYBUILTIN;
};

//==================================================================================================

inline sSECURE_FLAG::sSECURE_FLAG()
    : STATUS(control_info_)
    , QUERY(control_info_)
    , QUERYBUILTIN(control_info_)
{
    ClearFields();
}

inline DWORD& sSECURE_FLAG::FLAG() {
    return control_info_.flag;
}

inline DWORD& sSECURE_FLAG::TRANS_TICK() {
    return control_info_.trans_tick;
}

inline bool sSECURE_FLAG::IsEnableQuerying() const
{
    bool querying = ((STAT_CRYPTED & control_info_.flag) && (!STATUS.IsTransaction()));
    return querying;
}
////当前发生CS安全违反时，其差错控制
//static bool IsFault(DWORD& eREF) { return (bool)!!(ERR_FAULT&eREF); }

inline void sSECURE_FLAG::ClearFields()
{
    control_info_.flag = 0;
    control_info_.trans_tick = 0;
    //ITIMOUT基本无限
}

//==================================================================================================

inline DWORD& sSECURE_FLAG::sSTATUS::FLAG() {
    return control_info_.flag;
}

inline DWORD& sSECURE_FLAG::sSTATUS::TRANS_TICK() {
    return control_info_.trans_tick;
}

inline sSECURE_FLAG::sSTATUS::sSTATUS(ControlInfo& control_info)
    : control_info_(control_info)
{
}

inline void sSECURE_FLAG::sSTATUS::SetStatus(eSTATUS status_value)
{
    control_info_.flag = (eSTATUS)((control_info_.flag & (~STAT_MASK_STATUS)) |
                                   (STAT_MASK_STATUS & status_value));
}

inline sSECURE_FLAG::eSTATUS sSECURE_FLAG::sSTATUS::GetStatus() const
{
    return (eSTATUS)(STAT_MASK_STATUS & control_info_.flag);
}

inline void sSECURE_FLAG::sSTATUS::TransEnter()
{
    control_info_.flag |= STAT_TRANSACTION;
    control_info_.trans_tick = GetTickCount();
}

inline void sSECURE_FLAG::sSTATUS::TransLeave()
{
    control_info_.flag = control_info_.flag & (~STAT_TRANSACTION);
    control_info_.trans_tick = 0;
}

//根据状态控制{CHAR_SELECT|（状态为约翰间移动状态）}
inline bool sSECURE_FLAG::sSTATUS::IsTransaction() const {
    return (control_info_.flag & STAT_TRANSACTION) == 0 ? false : true;
}

inline DWORD sSECURE_FLAG::sSTATUS::GetTransTime() const
{
    if (IsTransaction()) {
        return GetTickCount() - control_info_.trans_tick;
    }
    else {
        return 0;
    }
}

//==================================================================================================

inline DWORD& sSECURE_FLAG::sQUERY::FLAG() {
    return control_info_.flag;
}

inline sSECURE_FLAG::sQUERY::sQUERY(ControlInfo& control_info)
    : control_info_(control_info)
{
}

inline void sSECURE_FLAG::sQUERY::TransEnter(eQUERY_TRANS trans_value)
{
    control_info_.flag = (eQUERY_TRANS)((control_info_.flag & (~TRANS_MASK_QUERY)) |
                                        (TRANS_MASK_QUERY & trans_value));
}

inline sSECURE_FLAG::eQUERY_TRANS sSECURE_FLAG::sQUERY::TransType() const
{
    return (eQUERY_TRANS)(TRANS_MASK_QUERY & control_info_.flag);
}

inline void sSECURE_FLAG::sQUERY::TransLeave()
{
    control_info_.flag = (control_info_.flag & (~TRANS_MASK_QUERY));
}


inline bool sSECURE_FLAG::sQUERY::IsTransaction() const {
    return (control_info_.flag & TRANS_DEFAULT_TRANS) == 0 ? false : true;
}

//==================================================================================================

inline DWORD& sSECURE_FLAG::sQUERYBUILTIN::FLAG() {
    return control_info_.flag;
}

inline sSECURE_FLAG::sQUERYBUILTIN::sQUERYBUILTIN(ControlInfo& control_info)
    : control_info_(control_info)
{
}

inline void sSECURE_FLAG::sQUERYBUILTIN::TransEnter()
{
    control_info_.flag = (eQUERY_TRANS)((control_info_.flag & (~TRANS_BUILTIN_QUERY)) |
                                        (TRANS_BUILTIN_QUERY));
}

inline void sSECURE_FLAG::sQUERYBUILTIN::TransLeave()
{
    control_info_.flag = (control_info_.flag & (~TRANS_BUILTIN_QUERY));
}

inline bool sSECURE_FLAG::sQUERYBUILTIN::IsTransaction() const {
    return (control_info_.flag & TRANS_BUILTIN_QUERY) == 0 ? false : true;
}

//==================================================================================================
// <RANDOM TIME UTILITY>
class RandomTimeUtil
{
public:
    static const DWORD SECOND = 1000;
    static const DWORD MINUTE = 60 * SECOND;

    // <设置查询后的等待时间>
    // 在LIVE模式下{基准Time out 180sec}
    // USE : GetRandomTimeDelay_ByMinMaxBoundary
    // RANGE: { 180sec +/- 30sec }
    static DWORD SECURE_KEYEXCHANGE_TIMEOUT_POLE ;
    static DWORD SECURE_KEYEXCHANGE_TIMEOUT_MINMAX_BOUNDARY ;
    // RANGE: { dwFlagTick-dwMin ~ dwFlagTick+dwMax }
    static DWORD GetPostQueryTimeout(DWORD dwFlagTick, DWORD dwMinMax /* {+/-} dword */);
    // RANGE: { dwFlagTick ~ dwFlagTick+dwMax }
    static DWORD GetPostQueryTimeoutOver(DWORD dwFlagTick, DWORD dwMax /* {+} dword */);

    // <设置成为下一个查询对象的时间>
    // USE : GetRandomTimeDelay
    // RANGE: { MIN 5 ~ MAX 7 }概率在5~7分钟之间.
    static DWORD SECURE_NEXT_CHECK_INTERVAL_POLE ;
    static DWORD SECURE_NEXT_CHECK_INTERVAL_MINMAX_BOUNDARY ;
    //static DWORD GetNextQueryTargetTick(DWORD dwFlagTick, DWORD dwMinMax /* {+/-} dword */)
    //{ GetPostQueryTimeout(dwFlagTick, dwMinMax); }

    // <终止等待状态延迟>
    // USE : GetRandomTimeDelay
    // RANGE: { MIN 13 ~ MAX 26 } 概率在13~20秒之间
    static DWORD SECURE_FAIL_CLOSING_INTERVAL_POLE ;
    static DWORD SECURE_FAIL_CLOSING_INTERVAL_MINMAX_BOUNDARY ;
    //static DWORD GetCloseWaitTick(DWORD dwFlagTick, DWORD dwMinMax /* {+/-} dword */)
    //{ GetPostQueryTimeout(dwFlagTick, dwMinMax); }

    // <随机数获取> - DWORD { 0 ~ DWORD_MAX }
    static DWORD GetRandomNumber();
    // <随机数获取> - 取值于最小值和最大值之间.
    static DWORD GetRandomNumber(DWORD dwMin, DWORD dwUpperBound);

    //
    //
    //
    static DWORD SECURE_MANAGER_UPDATE_INTERVAL() { return cSECURE_MANAGER_UPDATE_INTERVAL; }
    static DWORD USER_KEYCHANGE_TIMEOUT() { return cUSER_KEYCHANGE_TIMEOUT; }

    static void Initialize(DWORD dwSERVER_MODE);
    //////////////////////////////////////////////////////////////////////////
    static DWORD cSECURE_MANAGER_UPDATE_INTERVAL ;
    // <基本值>安全查询后等待响应时间
    static DWORD cUSER_KEYCHANGE_TIMEOUT ;
};



//==================================================================================================
//分组加密相关对象包
class CryptPack4Packet
{
    //////////////////////////////////////////////////////////////////////////
    // <FIELDs>
private:
    ServerSNKey seq_number_;
    CryptManager crypt_manager_;

    //////////////////////////////////////////////////////////////////////////
    // <METHODs>
public:
    CryptPack4Packet() { }
    CryptPack4Packet(const CryptPack4Packet& backup);
    ~CryptPack4Packet() { }

    ServerSNKey& GetServerSNKey() { return seq_number_; }
    CryptManager& GetCryptManager() { return crypt_manager_; }
    // About SNKey
    void NextRoundSNKey4Send() { seq_number_.NextRoundSNKey4Send(); };
    void NextRoundSNKey4Recv() { seq_number_.NextRoundSNKey4Recv(); };

    BYTE GetSendSNKey() { return seq_number_.GetSendSNKey(RandomSNKey::SNKEY_BASE); };
    BYTE GetSendPairSNKey() { return seq_number_.GetSendSNKey(RandomSNKey::SNKEY_PAIR); };
    BYTE GetRecvSNKey() { return seq_number_.GetRecvSNKey(RandomSNKey::SNKEY_BASE); };
    BYTE GetRecvPairSNKey() { return seq_number_.GetRecvSNKey(RandomSNKey::SNKEY_PAIR); };

    // Cryptography
    BYTE GetCryptAlgorithmInfo(BYTE bySNKey, BYTE* pbyCryptKeyBlock, DWORD _dwUserKey);
    void InitCryptInfo(DWORD dwUserKey, BYTE byProtoMajorVer, BYTE byProtoMinorVer);
};


//==================================================================================================

class SecurePackNode4User;

struct SecureTransaction
{
    SecureTransaction(User* user);
    ~SecureTransaction();
};

//==================================================================================================

class MOLAControl
{
public:
    MOLAControl() : mola_work_key_(0), mola_builtin_work_key_(0) {}
    // 
    BOOL SendQueryRelease(User* user);
    // Builtin Query
    BOOL SendQueryBuiltinCMD(User* user);
    // Normal Query
    BOOL SendQuery(User* user, eSECURE_QUERY::IDX_T queryT, MSG_BASE* pMsg = NULL, WORD wSize = 0);
    BOOL RecvQuery(User* user, MSG_BASE* pMsg, WORD wSize);

    DWORD& WorkKey() { return mola_work_key_; }
    DWORD& WorkKeyBuiltin() { return mola_builtin_work_key_; }
private:
    //需要一份目前正在工作的目录.
    //否则会记录违反事项。.
    DWORD mola_work_key_;
    DWORD mola_builtin_work_key_;
};

//==================================================================================================
//每个User对象都存在的包加密和安全相关的包
class SecurePackNode4User : public util::__LList<SecurePackNode4User>
{
public:
    //
    void Init();
    void Release();
    void EnableHeartbeats(BOOL flag);

    //----------------------------------------------------------------------------------------------
    // <CRYPT PACKET CONTROL>
    //是否正在使用分组加密?
    bool IsUsePacketCrypt() const { return use_cryptography_; }
    //分组加密设置用
    void SetEnablePacketCrypt();
    void InitCryptInfo(DWORD dwUserKey, BYTE byProtoMajorVer, BYTE byProtoMinorVer);
    //提取分组加密密钥信息
    BYTE GetCryptAlgorithmInfo(BYTE bySNKey, BYTE* pbyCryptInfo, DWORD _dwUserKey);
    // About SNKey
    void NextRoundSNKey4Send() { crypt_packet_info_for_active_.NextRoundSNKey4Send(); };
    void NextRoundSNKey4Recv() { crypt_packet_info_for_active_.NextRoundSNKey4Recv(); };
    BYTE GetSendSNKey() { return crypt_packet_info_for_active_.GetSendSNKey(); };
    BYTE GetSendPairSNKey() { return crypt_packet_info_for_active_.GetSendPairSNKey(); };
    BYTE GetRecvSNKey() { return crypt_packet_info_for_active_.GetRecvSNKey(); };
    BYTE GetRecvPairSNKey() { return crypt_packet_info_for_active_.GetRecvPairSNKey(); };

public:
    sSECURE_FLAG& SECURE_FLAG() { return secure_control_flag_; }
    //
    CryptPack4Packet& ACTIVE_CRYPT_PACKET_INFO() { return crypt_packet_info_for_active_; }
    CryptPack4Packet& BACKUP_CRYPT_PACKET_INFO() { return crypt_packet_info_for_backup_; }
    //
#if USING_HACKSHIELD
    AHNHS_CLIENT_HANDLE HANDLEofClientHS() { return handle_for_hackshield_; }
#elif USING_XIGNCODE
#elif USING_FROST
#elif USING_GAMEGUARD
#endif
    MOLAControl& MOLAController() { return mola_control_; }
    //
    HeartbeatChecker& HEARTBEAT() { return heartbeat_checker_; }
#ifdef _NA_20100802_SPEED_HACK_DETECTION
    TickSpeedChecker& TICKSPEED() { return tick_speed_checker_; }
#endif
    //----------------------------------------------------------------------------------------------
    // <SECURE LOGIC QUERY&REPLY CONTROL>
    void SECURE_ROUTINE_CHANGE_OBJECT();
    void SECURE_ROUTINE_CHANGE_SNKEY_PATTERN_DUPLEX();

    //----------------------------------------------------------------------------------------------
    // <PACKET ENCRYPTION & DECRYPTION>
    //分组加密
    bool EncryptPacket(BYTE* IN OUT pEncryptingMsg, const INT iSize, BYTE& OUT byCRC);
    //分组解密
    bool DecryptPacket(BYTE* IN OUT pEncryptedMsg, const INT iSize, BYTE IN byCRC);
    sSECURE_FLAG::eQUERY_ERRCTRL GetErrStatus() const;
    void SetErrStatus(sSECURE_FLAG::eQUERY_ERRCTRL status);

    //----------------------------------------------------------------------------------------------
    // <CRYPTOGRAPHY CONTROL>
    // <TEMP USER>
    BOOL SendPacket_KEYINFO_KEY(UserSession* pCurrSession, UserSession* pPostSession);
    BOOL SendPacket_KEYINFO_CMD(UserSession* pCurrSession, UserSession* pPostSession);
    // <USER REPLY PROCESSING>
    BOOL OnRecvCG_CRYPTOGRAPHY_ACK(User* user);
    BOOL OnRecvCG_CRYPTOGRAPHY_NAK(User* user);
    BOOL OnRecvCG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_ACK(User* user,
        MSG_CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_ACK* pMsgACK);
    BOOL OnRecvCG_CONNECTION_HEARTBEAT_SYN(User* user);
    // <CRYPTING USER QUERY>
    BOOL Query_CRYPTOGRAPHY_SNK_KEY(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    BOOL Query_ARMORKIT_SEED_TEST_CMD(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    BOOL Query_SIMPLEX_SNK_CMD(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    //
    BOOL ForcedDisconnectProcess(User* user);
#if USING_HACKSHIELD
    BOOL Query_HACKSHIELD_SERVER_EX_QUERY_CMD(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    BOOL OnRecvCG_HACKSHIELD_SERVER_EX_QUERY_ACK(User* user,
        MSG_CG_HACKSHIELD_SERVER_EX_QUERY_ACK* pMsgACK, WORD wSize);
#elif USING_XIGNCODE
    bool XignCode_Init();
    bool XignCode_Release();
    BOOL Query_XIGNCODE_SERVER_QUERY_CMD(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    BOOL OnRecvXIGNCODE_SERVER_QUERY_ACK(User* user,
        MSG_CG_XIGNCODE_SERVER_QUERY_ACK* pMsgACK, WORD wSize);
#elif USING_FROST
#elif USING_GAMEGUARD
    BOOL Query_GAMEGUARD_SERVER_QUERY_CMD(User* user, sSECURE_FLAG::eQUERY_TRANS& eSTAT);
    BOOL OnRecv_GAMEGUARD_SERVER_QUERY_ACK(User* user, MSG_BASE* packet, WORD wSize);

    BOOL OnRecv_GAMEGUARD_HACKDATA_CMD(User* user, MSG_BASE* packet, WORD size);
#endif
private:
    //----------------------------------------------------------------------------------------------
    // <FIELDs>
    struct
    {
        bool use_cryptography_; //设置为false
        ITimeout secure_user_timeout_; //客体暂停者
    };

    // <MAIN PACKET CRYPTOGRAPHY INFORMATION BLOCK> ACK掉下来的话设置
    CryptPack4Packet crypt_packet_info_for_active_;
    // Secure Info Structure
    sSECURE_FLAG secure_control_flag_;

    sSECURE_FLAG::eQUERY_ERRCTRL error_flags_; //等待暂停时，寻找正确的错误原因
#if USING_HACKSHIELD
    struct
    {
        AHNHS_CLIENT_HANDLE handle_for_hackshield_;
    };
#endif
#if USING_XIGNCODE
    ns_secure::XignCode xigncode_;
#endif
#if USING_FROST
#endif
#if USING_GAMEGUARD
    CCSAuth3 gameguard_csauth_;
#endif //USING_GAMEGUARD

    MOLAControl mola_control_;
    // <HEARTBEAT CONTROL>
    HeartbeatChecker heartbeat_checker_;
#ifdef _NA_20100802_SPEED_HACK_DETECTION
    TickSpeedChecker tick_speed_checker_;
#endif
    CryptPack4Packet crypt_packet_info_for_backup_; //发送CMD时设置
    //----------------------------------------------------------------------------------------------
    friend class SecureManager;
    friend class MOLAControl;
};


inline bool SecurePackNode4User::EncryptPacket(
    BYTE* IN OUT pEncryptingMsg, const INT iSize, BYTE& OUT byCRC)
{
    CryptManager* crypt_manager = &crypt_packet_info_for_active_.GetCryptManager();
    return crypt_manager->Encrypt(pEncryptingMsg, iSize, byCRC) != false;
}

//分组解密
inline bool SecurePackNode4User::DecryptPacket(
    BYTE* IN OUT pEncryptedMsg, const INT iSize, BYTE IN byCRC)
{
    CryptManager* crypt_manager = &crypt_packet_info_for_active_.GetCryptManager();
    return crypt_manager->Decrypt(pEncryptedMsg, iSize, byCRC) != false;
}

inline sSECURE_FLAG::eQUERY_ERRCTRL SecurePackNode4User::GetErrStatus() const {
    return error_flags_;
}

inline void SecurePackNode4User::SetErrStatus(sSECURE_FLAG::eQUERY_ERRCTRL status)
{
    //ASSERT((sSECURE_FLAG::MASK & status) == status);
    error_flags_ = status;
}


//==================================================================================================
// <SecureManager>
//周期动作管理
class SecureManager : public IWorkNode
{
public:
    static const DWORD MAX_PROCESSING_USERS_IN_ONE_CYCLE = 200; //每个周期可处理安全查询的最大数量限制
    //
    SecureManager();
    ~SecureManager() {}

    //之后将User等设置的信息移动到这里.
    void SetInformation(DWORD dwUpdateInterval, DWORD dwUserTimeout4ACK);
    //----------------------------------------------------------------------------------------------
    // <IWORKNODE INTERFACEs>
    virtual BOOL DoInit();
    virtual BOOL DoProcess();
    virtual BOOL IsComplete();
    virtual BOOL DoRelease();

    virtual void OnMsg(sSIG_MSG* pSIG_MSG);

public:
    //----------------------------------------------------------------------------------------------
    // <LIST MANAGEMENT>
    static SecurePackNode4User* GetCryptedUserListEntry() { return static_cast<SecurePackNode4User*>(&sCryptedUserListEntry); }
    static SecurePackNode4User* GetCryptingUserListEntry() { return static_cast<SecurePackNode4User*>(&sCryptingUserListEntry); }

	static void AddCryptedUser(User* user);
    static void AddCryptedUser(SecurePackNode4User* pNode);

	static SecurePackNode4User* RemoveCryptedUser(User* user);
    static SecurePackNode4User* RemoveCryptedUser(SecurePackNode4User* pNode);

	static void AddCryptingUser(User* user, sSECURE_FLAG::eQUERY_TRANS eStat);
    static void AddCryptingUser(SecurePackNode4User* pNode, sSECURE_FLAG::eQUERY_TRANS eStat);

	static SecurePackNode4User* RemoveCryptingUser(User* user);
    static SecurePackNode4User* RemoveCryptingUser(SecurePackNode4User* pNode);

private:
    void ProcessCryptedUsers();
    void ProcessCryptingUsers();
    BOOL ProcessQuery(User* user, SecurePackNode4User& rSECURE, sSECURE_FLAG::eQUERY_TRANS& eSTAT);

    //----------------------------------------------------------------------------------------------
    // <LIST MANAGEMENT><NODE CONTROL>
    struct Fields
    {
        DWORD m_dwStatus;
        // CHANGES: f101101.1L, change timer
        ITimerBase update_timer_;
        DWORD m_dwUpdateInterval;
        DWORD m_dwUserTimeout4ACK;
    };

    struct Util
    {
        Fields& m_rFields;
        Util(Fields& rFields) : m_rFields(rFields) {}

        SecurePackNode4User* GetNextNode(SecurePackNode4User* pNode) { return pNode->next; }
        SecurePackNode4User* GetPrevNode(SecurePackNode4User* pNode) { return pNode->prev; }
        // WARNING:此方法仅用于SecureManager中的列表控件.
        //SecurePackNode4User* GetSecurePackNode4User(util::PListNode node) {
        //    return reinterpret_cast<SecurePackNode4User*>(node);
        //}
    };

    //----------------------------------------------------------------------------------------------
    // <FIELDs>
private:
    static util::__LList<SecurePackNode4User> sCryptedUserListEntry; //加密设置的用户列表基准点
    static util::__LList<SecurePackNode4User> sCryptingUserListEntry; //加密设置中的用户列表起始点(no TempUser)
    static util::__LList<SecurePackNode4User> sReleasingUserListEntry;//加密ACK超时用户列表

    Util UTIL;
    Fields FIELD;
    //
    friend class User;
    __DISABLE_COPY(SecureManager);
};

#endif //__USERINFO_SECURE_H__