#include "stdafx.h" #if SERVER_CODE || CODE_TEST(__MOLA_IwASM_CMD_SERVER_CODE_TEST__) //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ // DWORD ISecureQueryProcessor::ms_dwWORK_KEY_INC = ISecureQueryProcessor::MOLA_WORK_KEY_LBND; static DWORD sINITIAL_KEYs[7] = { MOLA_RCG_012, MOLA_RCG_011, MOLA_RCG_052, MOLA_RCG_093, MOLA_RCG_024, MOLA_RCG_055, MOLA_RCG_076 }; static DWORD sWORKING_KEYs[7] = { 0, }; DWORD* ISecureQueryProcessor::ms_pGLOBAL_RND_KEY = sWORKING_KEYs; ISecureQueryProcessor::ISecureQueryProcessor() { RNGKEY_InsertKeys(); RNDKEY_CALC(); } ISecureQueryProcessor::~ISecureQueryProcessor() { } QUERIED_LIST_IT ISecureQueryProcessor::FindMolaQueriedMsg( QUERIED_LIST& IN rLIST, const DWORD dwWorkKey ) { QUERIED_LIST_IT end = rLIST.end(); for( QUERIED_LIST_IT it=rLIST.begin() ; it!=rLIST.end() ; ++it ) { MOLA_QUERY_MSG& rMSG = *it; if( dwWorkKey == rMSG.m_dwWorkKey ) return it; } return end; } VOID ISecureQueryProcessor::DeleteUser( DWORD dwUserKey ) { QUERIED_INFO_MAP_IT itFIND = m_QueriedTable.find( dwUserKey ); if( itFIND != m_QueriedTable.end() ) { QUERIED_LIST& rLIST = itFIND->second; QUERIED_LIST_IT end = rLIST.end(); for( QUERIED_LIST_IT it=rLIST.begin() ; it!=rLIST.end() ; ++it ) { MOLA_QUERY_MSG& rMSG = *it; if( rMSG.m_pBackupMsg ) MolaTAllocFree(rMSG.m_pBackupMsg); } m_QueriedTable.erase( itFIND ); } } DWORD ISecureQueryProcessor::RegisterQueriedMsg( MOLA_QUERY_MSG* IN pARG ) { // pARG != NULL DWORD dwWorkKey = GetNewWorkKey(); QUERIED_LIST& IN rLIST = GetQueriedList( pARG->m_dwUserKey ); pARG->m_dwWorkKey = dwWorkKey; rLIST.push_back( *pARG ); return dwWorkKey; } static sSERVER_QUERY_LINKER s_sSERVER_QUERY_LINKER_EMPTY = { eSECURE_QUERY::NON_OPERATION, 0, NULL }; sSERVER_QUERY_LINKER& ISecureQueryProcessor::GetRandomQueryInfo( eSECURE_QUERY::IDX_T queryT ) { if( (eSECURE_QUERY::NON_OPERATION == queryT) || !(eSECURE_QUERY::MAX_SECURE_PACKET > (DWORD)queryT) ) return s_sSERVER_QUERY_LINKER_EMPTY; static DWORD dwRandKey = _RNDFN_F1( GetTickCount(), GetTickCount(), GetTickCount() ); QUERY_VECTOR& rLIST = m_QueryTable[queryT]; DWORD dwSZnIDX = (DWORD)rLIST.size(); if( dwSZnIDX ) { dwRandKey = _RNDFN_F0( SHA32_T3(dwRandKey), GetTickCount(), MOLA_RCG_T1_002 ); dwSZnIDX = dwRandKey%dwSZnIDX; sSERVER_QUERY_LINKER& rINFO = rLIST[dwSZnIDX]; return rINFO; } return s_sSERVER_QUERY_LINKER_EMPTY; } // // //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ ////////////////////////////////////////////////////////////////////////// // #undef MAKE_RND_DWORD_BASE_KEY #define MAKE_RND_DWORD_BASE_KEY( a, b, c, d, e, f, g ) \ ( _RNDFN32_OUT0(b, c, d, e, f, a, g) + _RNDFN32_OUT1(c, d, e, f, a, b, g) \ + _RNDFN32_OUT2(d, e, f, a, b, c, g) + _RNDFN32_OUT3(e, f, a, b, c, d, g) ) VOID ISecureQueryProcessor::RNGKEY_InsertKeys() { BOOST_STATIC_ASSERT(_countof(sINITIAL_KEYs) == _countof(sWORKING_KEYs)); CopyMemory(sWORKING_KEYs, sINITIAL_KEYs, sizeof(sWORKING_KEYs)); } VOID ISecureQueryProcessor::RNDKEY_ROLKeys() { DWORD temp[_countof(sWORKING_KEYs)]; CopyMemory(temp, &sWORKING_KEYs[1], sizeof(sWORKING_KEYs) - sizeof(sWORKING_KEYs[0])); temp[_countof(temp) - 1] = sWORKING_KEYs[0]; CopyMemory(sWORKING_KEYs, temp, sizeof(sWORKING_KEYs)); } DWORD ISecureQueryProcessor::RNDKEY_CALC() { sWORKING_KEYs[0] = MAKE_RND_DWORD_BASE_KEY(\ sWORKING_KEYs[0], sWORKING_KEYs[1], sWORKING_KEYs[2], sWORKING_KEYs[3], sWORKING_KEYs[4], sWORKING_KEYs[5], sWORKING_KEYs[6]); RNDKEY_ROLKeys(); return sWORKING_KEYs[0]; } //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ // DWORD ISecureWorkNode::QueryProcess( MOLA_QUERY_MSG* pARG ) { __DEBUGGING_OUTPUT0( __FUNCTION__ ); if( pARG ) { DWORD dwKEY = pARG->m_dwUserKey; eSECURE_QUERY::IDX_T eSQT = pARG->m_eSQT; if( eSECURE_QUERY::NON_OPERATION == eSQT ) return 0; WzASM_VMCore& rIVMCORE = VMCORE_INTERFACE; ISecureQueryProcessor& rSQP = VM_SQP; QUERIED_LIST& rLIST = rSQP.GetQueriedList( dwKEY ); switch( eSQT ) { case eSECURE_QUERY::SIMPLEX_PATTERN_SNK: break; case eSECURE_QUERY::QUERY_MOLA: break; case eSECURE_QUERY::CONFIGURE_MOLA: break; case eSECURE_QUERY::DUPLEX_PATTERN_SNK: break; case eSECURE_QUERY::RESOURCE_CHECK: break; case eSECURE_QUERY::BUILTIN_QUERY: { ISecureQueryProcessor& rISQP = VM_SQP; IWzASM_PROC uRES = rIVMCORE.FindGResHandlerInfo( GResHASH::NETWORK_SENDPACKET_TO_GAMESERVER ); MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_CMD* pMsgCMD = MolaTAllocNew(MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_CMD)(); DWORD dwRndKey = rISQP.RNDKEY_CALC(); DWORD dwIdx = (dwRndKey%1024); *(DWORD*)&(pMsgCMD->m_dwBuiltinCMD[0]) = (WORD)(dwIdx); *(DWORD*)&(pMsgCMD->m_dwBuiltinCMD[4]) = dwRndKey; uREG_NODE rARG; rARG.EXA[0].PTR = pMsgCMD; rARG.EXA[1].EX = sizeof(*pMsgCMD); uRES.RESFUNC( &rARG ); // 결과값 저장 if( GET_ARRAY_SIZE(BuiltinQueryFunc, BUILTIN_QUERY_FUNCs) > dwIdx ) { BuiltinQueryFunc func = BUILTIN_QUERY_FUNCs[dwIdx]; dwRndKey = func( dwRndKey ); } BOOST_STATIC_ASSERT(_countof(pMsgCMD->m_dwBuiltinCMD) == 8); ;{ const BYTE* src_it = reinterpret_cast(&dwRndKey); const BYTE* const src_end = reinterpret_cast(&dwRndKey) + sizeof(dwRndKey); WORD* dest_it = reinterpret_cast(pMsgCMD->m_dwBuiltinCMD); for (; src_it != src_end; ++src_it, ++dest_it) { *dest_it = *src_it; }; }; MOLA_QUERY_MSG molaMSG( dwKEY, eSECURE_QUERY::BUILTIN_QUERY, 0, 0, (BYTE*)pMsgCMD, sizeof(*pMsgCMD) ); return rISQP.RegisterQueriedMsg( &molaMSG ); } break; //case eSECURE_QUERY::MAX_SECURE_PACKET: case eSECURE_QUERY::FIND_INFO_BY_WORK_KEY: case eSECURE_QUERY::DEL_INFO_BY_WORK_KEY: case eSECURE_QUERY::POP_INFO_BY_WORK_KEY: { DWORD dwWorkKey = pARG->m_dwWorkKey; QUERIED_LIST_IT itFIND = rSQP.FindMolaQueriedMsg( rLIST, dwWorkKey ); if( itFIND != rLIST.end() ) { MOLA_QUERY_MSG& rMSG = *itFIND; if( eSECURE_QUERY::DEL_INFO_BY_WORK_KEY != eSQT ) CopyMemory( pARG, &rMSG, sizeof(MOLA_QUERY_MSG) ); if( eSECURE_QUERY::FIND_INFO_BY_WORK_KEY != eSQT ) rLIST.erase( itFIND ); if( eSECURE_QUERY::DEL_INFO_BY_WORK_KEY == eSQT ) return TRUE; return dwWorkKey; } return FALSE; } break; case eSECURE_QUERY::DEL_USER: { rSQP.DeleteUser( dwKEY ); return TRUE; } break; } } return FALSE; } DWORD ISecureWorkNode::OnRecvPacket( MOLA_QUERY_MSG* IN OUT pARG ) { __DEBUGGING_OUTPUT0( __FUNCTION__ ); # define ADD_HANDLER_INFO_MOLA( c, p, accptablePHASE ) const WORD c##p = MAKEWORD(c, p); //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ ADD_HANDLER_INFO_MOLA(CG_SYNC, CG_SECURE_POLICY_PATTERN01_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_SYNC, CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_ITEM, CG_SECURE_POLICY_PATTERN03_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_TRADE, CG_SECURE_POLICY_PATTERN04_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_VENDOR, CG_SECURE_POLICY_PATTERN05_QUERY_MOLA_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_WAREHOUSE, CG_SECURE_POLICY_PATTERN06_CONFIGURE_MOLA_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_PARTY, CG_SECURE_POLICY_PATTERN07_CONFIGURE_HEARTBEAT_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_STATUS, CG_SECURE_POLICY_PATTERN08_DUPLEX_SNK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_CONNECTION, CG_SECURE_QUERY_BUILTIN_CHK_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_CONNECTION, CG_SECURE_QUERY_RESOURCE_CHK_T1_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_CHARINFO, CG_SECURE_QUERY_RESOURCE_CHK_T2_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_MAP, CG_SECURE_QUERY_RESOURCE_CHK_NTF1_SYN, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_BATTLE, CG_SECURE_QUERY_RESOURCE_CHK_T3_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_STYLE, CG_SECURE_QUERY_RESOURCE_CHK_T4_ACK, PHASE_UNLIMITED) ADD_HANDLER_INFO_MOLA(CG_STYLE, CG_SECURE_QUERY_RESOURCE_CHK_NTF2_SYN, PHASE_UNLIMITED) # undef ADD_HANDLER_INFO_MOLA if( !(pARG && pARG->m_pBackupMsg) ) return FALSE; MSG_BASE* pBASE = (MSG_BASE*)pARG->m_pBackupMsg; WORD wPROTOCOL = MAKEWORD(pBASE->m_byCategory, pBASE->m_byProtocol); switch( wPROTOCOL ) { # define ADD_HANDLER_INFO_MOLA( c, p, accptablePHASE ) case c##p: //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ ADD_HANDLER_INFO_MOLA(CG_SYNC, CG_SECURE_POLICY_PATTERN01_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_SYNC, CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_ITEM, CG_SECURE_POLICY_PATTERN03_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_TRADE, CG_SECURE_POLICY_PATTERN04_SIMPLEX_SNK_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_VENDOR, CG_SECURE_POLICY_PATTERN05_QUERY_MOLA_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_WAREHOUSE, CG_SECURE_POLICY_PATTERN06_CONFIGURE_MOLA_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_PARTY, CG_SECURE_POLICY_PATTERN07_CONFIGURE_HEARTBEAT_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_STATUS, CG_SECURE_POLICY_PATTERN08_DUPLEX_SNK_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_CONNECTION, CG_SECURE_QUERY_BUILTIN_CHK_ACK, PHASE_UNLIMITED) { __DEBUGGING_OUTPUT0( "CG_SECURE_QUERY_BUILTIN_CHK_ACK" ); DWORD dwSuccess = FALSE; DWORD dwBuiltinWorkKey = pARG->m_dwWorkKeyB; if( dwBuiltinWorkKey ) { MOLA_QUERY_MSG rARG( pARG->m_dwUserKey, eSECURE_QUERY::POP_INFO_BY_WORK_KEY, dwBuiltinWorkKey ); DWORD dwRet = QueryProcess( &rARG ); if( dwRet == dwBuiltinWorkKey ) { MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_CMD* pSRC = (MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_CMD*)rARG.m_pBackupMsg; MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_ACK* pMSG = (MSGINTER_CG_SECURE_QUERY_BUILTIN_CHK_ACK*)pARG->m_pBackupMsg; if( rARG.m_pBackupMsg ) // chunked memory { if( 0 == memcmp( pSRC->m_dwBuiltinCMD, pMSG->m_dwBuiltinACK, sizeof(pSRC->m_dwBuiltinCMD) ) ) dwSuccess = 2; MolaTAllocFree(rARG.m_pBackupMsg); } } } return dwSuccess; } break; ADD_HANDLER_INFO_MOLA(CG_CONNECTION, CG_SECURE_QUERY_RESOURCE_CHK_T1_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_CHARINFO, CG_SECURE_QUERY_RESOURCE_CHK_T2_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_MAP, CG_SECURE_QUERY_RESOURCE_CHK_NTF1_SYN, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_BATTLE, CG_SECURE_QUERY_RESOURCE_CHK_T3_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_STYLE, CG_SECURE_QUERY_RESOURCE_CHK_T4_ACK, PHASE_UNLIMITED) { } break; ADD_HANDLER_INFO_MOLA(CG_STYLE, CG_SECURE_QUERY_RESOURCE_CHK_NTF2_SYN, PHASE_UNLIMITED) { } break; # undef ADD_HANDLER_INFO_MOLA } // end switch return FALSE; } // SERVER PVOID ISecureWorkNode::MakePacketForClient( const BYTE byCate, const BYTE byProto, BYTE*& pSendingMsg, WORD& wSendingSize ) { __DEBUGGING_OUTPUT0( "ISecureWorkNode::MakePacketForClient" ); #if CODE_BACKUP static DWORD dwRndKey = MAKE_SNK_RND_NEXT_KEY( MAKEDWORD(byCate, byProto) ); WORD wCmd = MAKEWORD(byCate, byProto); switch( wCmd ) { case MAKEWORD(CG_SYNC, CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_CMD): { MSGINTER_CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_CMD* pMsgCMD = new (s_ISecureWorkNodeStream->m_bySendPacketStream) MSGINTER_CG_SECURE_POLICY_PATTERN02_SIMPLEX_SNK_CMD; pMsgCMD->m_BASE.bySecureType = SECURE_QUERY_SIMPLEX_PATTERN02_SNK; dwRndKey = MAKE_SNK_RND_NEXT_KEY( dwRndKey ); pMsgCMD->m_TOKEN.uDWORD = MAKE_SNK_RND_NEXT_KEY( dwRndKey ); pSendingMsg = (BYTE*)pMsgCMD; wSendingSize = (WORD)sizeof(*pMsgCMD); return &pMsgCMD->m_TOKEN; } break; }; #endif //CODE_BACKUP return NULL; } //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ // // // #pragma pack(push, 1) #define BUILTIN_CMD_VAR(name) sISecureBC_##name #define BUILTIN_CMD_TYPE(name) name##_T #define BUILTIN_CMD_DECL(name) \ typedef ISecureQueryCmdStreamBuiltinCmd BUILTIN_CMD_TYPE(name); \ static BUILTIN_CMD_TYPE(name) BUILTIN_CMD_VAR(name); // QUERY_MOLA_CMD LIST // BUILTIN_CMD_DECL(sBUILTIN_001_A_PLUS_B_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_PLUS_D_RET) // #pragma pack(pop) // // //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ // // MODULE_HANDLER_IMPL(REGISTER_QUERY_MOLA_CMD) { # undef BUILTIN_CMD_DECL # define BUILTIN_CMD_DECL(name) { wTypeKey, wIndex++, &BUILTIN_CMD_VAR(name) }, # define BUILTIN_CMD_REGISTER_HEADER(size) \ do { \ QUERY_VECTOR& rLIST = rMAP[wTypeKey]; \ sSERVER_QUERY_LINKER rITEMS[size] = { # define BUILTIN_CMD_REGISTER_TAIL(size) \ }; \ for( INT i=0 ; i cmd; //WzASM_VMCore& rCORE = VMCORE_INTERFACE; ISecureQueryProcessor& rISQP = VM_SQP; QUERY_INFO_MAP& rMAP = rISQP.QueryTable(); WORD wTypeKey = eSECURE_QUERY::QUERY_MOLA; WORD wIndex = 0; #if CODE_BACKUP QUERY_VECTOR& rLIST = rMAP[wIndex]; sSERVER_QUERY_LINKER rITEMS[3] = { // BUILTIN CMD STREAM LIST // BUILTIN_CMD_DECL(sBUILTIN_001_A_PLUS_B_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_PLUS_D_RET) // }; for( INT i=0 ; i<3 ; ++i ) rLIST.push_back( rITEMS[i] ); #endif //CODE_BACKUP ////////////////////////////////////////////////////////////////////////// // wTypeKey = eSECURE_QUERY::QUERY_MOLA; wIndex = 0; BUILTIN_CMD_REGISTER_HEADER(3) // BUILTIN CMD STREAM LIST // BUILTIN_CMD_DECL(sBUILTIN_001_A_PLUS_B_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_RET) BUILTIN_CMD_DECL(sBUILTIN_002_A_PLUS_B_PLUS_C_PLUS_D_RET) // BUILTIN_CMD_REGISTER_TAIL(3); return TRUE; } // //━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ #endif //SERVER_CODE #if CODE_TEST(__MOLA_IwASM_CMD_TEST__) MODULE_HANDLER_IMPL(UNIT_TEST) { uREG_NODE uARG; do { //sBUILTIN_001_A_PLUS_B_RET sBUILTIN_001_A_PLUS_B_RET sBBB; SET_PASSING_ARG( uARG, 10, 200, 0, 0 ); sBBB.SetArgument( &uARG ); sRETURN_PTR_SZ sRET = sBBB.GetResult(); WzASM_EIP sEIP; sEIP.Init( (BYTE*)&sBBB, sizeof(sBBB) ); uREG_NODE uRET = sEIP.Execute(); if( uRET.EX != sRET.RET_EX ) { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); __asm { int 3 }; } else { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); } } while(0); do { //sBUILTIN_001_A_PLUS_B_RET sBUILTIN_002_A_PLUS_B_PLUS_C_RET sBBB; SET_PASSING_ARG( uARG, 10, 200, 3000, 0 ); sBBB.SetArgument( &uARG ); sRETURN_PTR_SZ sRET = sBBB.GetResult(); WzASM_EIP sEIP; #if CODE_BACKUP sBUILTIN_002_A_PLUS_B_PLUS_C_RET* pInstance = sEIP.InitInstance(); pInstance->SetArgument( (PARGB_T)dwARG ); #endif sEIP.Init( (BYTE*)&sBBB, sizeof(sBBB) ); uREG_NODE uRET = sEIP.Execute(); if( uRET.EX != sRET.RET_EX ) { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); __asm { int 3 }; } else { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); } } while(0); do { //sBUILTIN_001_A_PLUS_B_RET sBUILTIN_002_A_PLUS_B_PLUS_C_PLUS_D_RET sBBB; SET_PASSING_ARG( uARG, 10, 200, 3000, 40000 ); sBBB.SetArgument( &uARG ); sRETURN_PTR_SZ sRET = sBBB.GetResult(); WzASM_EIP sEIP; sEIP.Init( (BYTE*)&sBBB, sizeof(sBBB) ); uREG_NODE uRET = sEIP.Execute(); if( uRET.EX != sRET.RET_EX ) { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); __asm { int 3 }; } else { printf( "UNIT TEST SUCESS {%u==%u}\n", sRET.RET_EX, uRET.EX ); } } while(0); //printf( "call exit\n" ); //exit(0); return TRUE; } #endif //CODE_TEST(__MOLA_IwASM_CMD_TEST__)