911 lines
24 KiB
C++
911 lines
24 KiB
C++
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include <psapi.h>
|
|
#include <process.h>
|
|
|
|
#include <string>
|
|
#include <list>
|
|
|
|
#include "../../include/framework/ArcadiaFramework.h"
|
|
#include "../../include/toolkit/ProcessUsage.h"
|
|
#include "../../include/toolkit/XConsole.h"
|
|
#include "../../include/toolkit/XStringUtil.h"
|
|
#include "../../include/toolkit/XEnv.h"
|
|
#include "../../include/toolkit/nsl.h"
|
|
#include "../../include/toolkit/XThreadMonitor.h"
|
|
#include "../../include/logging/FileLog.h"
|
|
#include "../../include/network/IAcceptor.h"
|
|
#include "../../include/network/XSyncStreamConnection.h"
|
|
#include "../../include/network/XNetworkUtil.h"
|
|
#include "../../include/toolkit/XThread.h"
|
|
#include "../../include/dump/XExceptionHandler.h"
|
|
#include "../../include/cipher/XStrZlibWithSimpleCipherUtil.h"
|
|
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
|
|
extern ArcadiaFrameworkIntf* pArcadiaFrameworkIntf;
|
|
extern XConsole & GetMainConsole();
|
|
extern std::list< std::string > listCommand;
|
|
|
|
static volatile bool s_bStatUsageUpdate;
|
|
static volatile int s_nCPULoad;
|
|
static volatile int s_nKernelLoad;
|
|
static volatile int s_nUserLoad;
|
|
static volatile int s_nCurrentMem;
|
|
static volatile int s_nPeakMem;
|
|
static volatile int s_nCurrentPagedMem;
|
|
static volatile int s_nPeakPagedMem;
|
|
|
|
SYSTEMTIME g_startTime;
|
|
|
|
static IAcceptor* s_pAcceptor;
|
|
static std::vector< XSocket > s_vSocketList;
|
|
static XCriticalSection s_connectionLock( "ArcadiaConnectionLock" );
|
|
|
|
unsigned __stdcall RemoteChannelProc( void * pArg );
|
|
unsigned __stdcall RemoteChannelAcceptor( void * pArg );
|
|
unsigned __stdcall StatUpdater( void * pArg );
|
|
|
|
struct _SocketWriter : ArcadiaCommandResultReceiver
|
|
{
|
|
bool onWrite( const char * szString, ... )
|
|
{
|
|
char p[2048];
|
|
va_list ap;
|
|
va_start(ap, szString);
|
|
s_vsprintf(p, _countof(p), szString, ap);
|
|
va_end(ap);
|
|
std::string result = p;
|
|
XStringUtil::Replace( result, "\n", "\r\n" );
|
|
if( pConnection->Write( result.c_str(), (unsigned)result.size() ) <= 0 ) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool onEnd()
|
|
{
|
|
if( pConnection->Write( "\0", 1 ) <= 0 ) return false;
|
|
return true;
|
|
}
|
|
|
|
XSyncStreamConnection *pConnection;
|
|
};
|
|
|
|
struct TelnetConnection : XSyncStreamConnection
|
|
{
|
|
enum TelnetNegotiationCode
|
|
{
|
|
ECHO = 1, HALF = 3, STATUS = 5, TIMING_MARK = 6, TERMINAL_TYPE = 24, WINDOW_SIZE = 31, SPEED = 32, FLOW_CONTROL = 33, LINEMODE = 34, ENV_VAR = 36, SE = 240, NOP = 241, DM = 242, BRK = 243, IP = 244, AO = 245, AYT = 246, EC = 247, EL = 248, GA = 249, SB = 250, WILL = 251, WONT = 252, DO = 253, DONT = 254, IAC = 255
|
|
};
|
|
|
|
TelnetConnection()
|
|
{
|
|
m_bPasswordMode = true;
|
|
m_bLineFeed = m_bUseEcho = m_bLineMode = m_bUseDelimiter = false;
|
|
m_cDelimiter = 0;
|
|
m_nPasswordTryCount = 0;
|
|
}
|
|
|
|
TelnetConnection( XSocket sock ) : XSyncStreamConnection( sock )
|
|
{
|
|
m_bPasswordMode = true;
|
|
m_bLineFeed = m_bUseEcho = m_bLineMode = m_bUseDelimiter = false;
|
|
m_cDelimiter = 0;
|
|
m_nPasswordTryCount = 0;
|
|
m_bIsConnected = true;
|
|
}
|
|
|
|
virtual ~TelnetConnection()
|
|
{
|
|
if( strBuffer.empty() == false )
|
|
{
|
|
const XAddr& peerAddr = GetPeerAddress();
|
|
_cprint( "%s console remain string: %s\n", peerAddr.GetAddr(), strBuffer.c_str() );
|
|
_cprint( "%s console remain string: %s", peerAddr.GetAddr(), strBuffer.c_str() );
|
|
}
|
|
}
|
|
|
|
void SetPeerAddr( const XAddr& peerAddr )
|
|
{
|
|
m_peerAddr = peerAddr;
|
|
}
|
|
|
|
bool onRead( char * pData, int nLen, ArcadiaCommandResultReceiver & receiver );
|
|
bool procCommand( char * pData, int nLen, ArcadiaCommandResultReceiver & receiver );
|
|
void TelnetNegotiationAck( unsigned char * cCode, int nLen );
|
|
void TelnetNegotiation( ArcadiaCommandResultReceiver & receiver );
|
|
|
|
private:
|
|
|
|
int m_nPasswordTryCount;
|
|
std::string strBuffer;
|
|
std::vector<char> vBuffer;
|
|
bool m_bPasswordMode;
|
|
bool m_bLineFeed;
|
|
bool m_bUseEcho;
|
|
bool m_bLineMode;
|
|
bool m_bUseDelimiter;
|
|
char m_cDelimiter;
|
|
};
|
|
|
|
static std::string & getUpTime()
|
|
{
|
|
static std::string uptime;
|
|
|
|
SYSTEMTIME stm;
|
|
GetLocalTime( &stm );
|
|
|
|
unsigned __int64 tm1, tm2;
|
|
SystemTimeToFileTime( &g_startTime, (LPFILETIME)&tm1 );
|
|
SystemTimeToFileTime( &stm, (LPFILETIME)&tm2 );
|
|
|
|
tm2 -= tm1;
|
|
|
|
FileTimeToSystemTime( (LPFILETIME)&tm2, &stm );
|
|
|
|
stm.wYear -= 1601;
|
|
stm.wMonth--;
|
|
stm.wDayOfWeek--;
|
|
stm.wDay--;
|
|
|
|
std::string strTmp;
|
|
char szTmp[64];
|
|
if( stm.wMonth ) { s_sprintf( szTmp, _countof( szTmp ), "%d Month ", stm.wMonth ); strTmp += szTmp; }
|
|
if( stm.wDay ) { s_sprintf( szTmp, _countof( szTmp ), "%d Day ", stm.wDay ); strTmp += szTmp; }
|
|
if( stm.wHour ) { s_sprintf( szTmp, _countof( szTmp ), "%d Hour ", stm.wHour ); strTmp += szTmp; }
|
|
if( stm.wMinute ) { s_sprintf( szTmp, _countof( szTmp ), "%d Minute ", stm.wMinute ); strTmp += szTmp; }
|
|
s_sprintf( szTmp, _countof( szTmp ), "%d Second", stm.wSecond); strTmp += szTmp;
|
|
|
|
uptime = strTmp;
|
|
|
|
return uptime;
|
|
}
|
|
|
|
bool InitArcadiaCommandProc()
|
|
{
|
|
if( !XNetworkUtil::InitNetwork() ) return false;
|
|
|
|
GetLocalTime( &g_startTime );
|
|
char szBuf[128];
|
|
s_sprintf( szBuf, _countof( szBuf ), "%04d/%02d/%02d-%02d:%02d:%02d", g_startTime.wYear, g_startTime.wMonth, g_startTime.wDay, g_startTime.wHour, g_startTime.wMinute, g_startTime.wSecond );
|
|
ENV().Set( "process.start", szBuf );
|
|
|
|
s_pAcceptor = new IAcceptor;
|
|
|
|
if( !s_pAcceptor->StartAccept( XAddr( ENV().GetString( "console.ip", "0.0.0.0" ).c_str(), ENV().GetInt( "console.port", 4515 ) ) ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
unsigned id;
|
|
HANDLE hThread;
|
|
s_bStatUsageUpdate = true;
|
|
hThread = reinterpret_cast<HANDLE>( _beginthreadex( NULL, 0, StatUpdater, NULL, 0, &id ) );
|
|
CloseHandle( hThread );
|
|
|
|
hThread = reinterpret_cast<HANDLE>( _beginthreadex( NULL, 0, RemoteChannelAcceptor, NULL, 0, &id ) );
|
|
CloseHandle( hThread );
|
|
|
|
return true;
|
|
}
|
|
|
|
void DeInitArcadiaCommandProc()
|
|
{
|
|
s_pAcceptor->EndAccept();
|
|
delete s_pAcceptor;
|
|
|
|
s_bStatUsageUpdate = false;
|
|
while( !s_bStatUsageUpdate ) Sleep( 100 );
|
|
}
|
|
|
|
bool ArcadiaCommandResultReceiver::onWrite( const char * szString, ... )
|
|
{
|
|
char szBuf[1024];
|
|
va_list va;
|
|
va_start( va, szString );
|
|
s_vsprintf( szBuf, _countof(szBuf), szString, va );
|
|
va_end( va );
|
|
|
|
GetMainConsole().Write( szBuf );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ArcadiaCommandResultReceiver::onEnd()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static void onSet( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( vToken.size() >= 3 )
|
|
{
|
|
ENV().Set( vToken[1], vToken[2] );
|
|
rcv.onWrite( " SET %s : %s\n", vToken[1].c_str(), vToken[2].c_str() );
|
|
}
|
|
}
|
|
|
|
static void onGet( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( vToken.size() > 1 )
|
|
{
|
|
std::string str = ENV().GetString( vToken[1] );
|
|
rcv.onWrite( "%s : %s\n", vToken[1].c_str(), str.c_str() );
|
|
}
|
|
}
|
|
|
|
static void onClear( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( vToken.size() > 1 )
|
|
{
|
|
if( ENV().Remove( vToken[1] ) )
|
|
{
|
|
rcv.onWrite( "DELETE %s\n", vToken[1].c_str() );
|
|
}
|
|
else
|
|
{
|
|
rcv.onWrite( "CAN'T DELETE %s\n", vToken[1].c_str() );
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onHistory( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( listCommand.empty() ) return;
|
|
|
|
unsigned cnt = 0;
|
|
for( std::list< std::string >::iterator it = listCommand.begin(); it != listCommand.end(); ++it )
|
|
{
|
|
cnt++;
|
|
rcv.onWrite( "%3d : %s\n", cnt, it->c_str() );
|
|
}
|
|
|
|
}
|
|
|
|
static void onDelete( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( vToken.size() > 1 )
|
|
{
|
|
if( ENV().IsExist( vToken[1] ) && ENV().IsContainer( vToken[1] ) )
|
|
{
|
|
rcv.onWrite( "%s is container! can't delete. (use clear command)\n", vToken[1].c_str() );
|
|
}
|
|
else
|
|
{
|
|
if( ENV().Remove( vToken[1] ) )
|
|
{
|
|
rcv.onWrite( "DELETE %s\n", vToken[1].c_str() );
|
|
}
|
|
else
|
|
{
|
|
rcv.onWrite( "CAN'T DELETE %s\n", vToken[1].c_str() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onTerminate( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
bool bForce = false;
|
|
int nSecond = 10;
|
|
|
|
if( vToken.size() > 2 ) nSecond = atoi( vToken[2].c_str() );
|
|
else if( vToken.size() > 1 ) nSecond = atoi( vToken[1].c_str() );
|
|
|
|
if( vToken.size() > 1 )
|
|
{
|
|
if( _stricmp( vToken[1].c_str(), "-f" ) == 0 ) bForce = true;
|
|
}
|
|
|
|
for( int i = 0; i < nSecond; ++i )
|
|
{
|
|
Beep( 1000, 100 );
|
|
rcv.onWrite( "\nWARNING : It will be terminated after %d seconds.", nSecond - i );
|
|
Sleep( 1000 );
|
|
}
|
|
|
|
rcv.onWrite( "\nTerminating..." );
|
|
if( bForce ) TerminateProcess( GetCurrentProcess(), 1 );
|
|
else exit(-1);
|
|
}
|
|
|
|
static void onList( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
char *szKey = "*";
|
|
if( vToken.size() > 1 ) szKey = const_cast< char* >( vToken[1].c_str() );
|
|
|
|
struct _M : XEnvStruct::XEnvFunctor
|
|
{
|
|
_M( ArcadiaCommandResultReceiver *p ) { pReceiver = p; nCnt = 0; }
|
|
|
|
void onString( const std::string & strKey, const std::string & strData )
|
|
{
|
|
if( !strKey.empty() && strKey[0] == '_' ) return;
|
|
nCnt++;
|
|
pReceiver->onWrite( "%-20s : %s\n", strKey.c_str(), strData.c_str() );
|
|
}
|
|
|
|
int nCnt;
|
|
ArcadiaCommandResultReceiver * pReceiver;
|
|
};
|
|
|
|
_M fo( &rcv );
|
|
|
|
ENV().DoEachData( fo, szKey, true );
|
|
|
|
rcv.onWrite( "Total %d value.\n", fo.nCnt );
|
|
}
|
|
|
|
static void onWatch( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
if( vToken.size() < 2 ) return;
|
|
|
|
if( ArcadiaFrameworkIntf::IsExistWatchList( vToken[1] ) )
|
|
{
|
|
ArcadiaFrameworkIntf::DelWatchList( vToken[1] );
|
|
rcv.onWrite( "remove '%s' from watch list\n", vToken[1].c_str() );
|
|
}
|
|
else
|
|
{
|
|
ArcadiaFrameworkIntf::AddWatchList( vToken[1] );
|
|
rcv.onWrite( "add to watch list '%s'\n", vToken[1].c_str() );
|
|
}
|
|
}
|
|
|
|
static void onMem( ArcadiaCommandResultReceiver & rcv, std::vector< std::string > & vToken )
|
|
{
|
|
DWORD processID = GetCurrentProcessId();
|
|
|
|
if( vToken.size() > 1 )
|
|
{
|
|
processID = atoi( vToken[1].c_str() );
|
|
}
|
|
|
|
HANDLE hProcess;
|
|
PROCESS_MEMORY_COUNTERS pmc;
|
|
|
|
// Print the process identifier.
|
|
rcv.onWrite( "Process ID : %u\n", processID );
|
|
|
|
// Print information about the memory usage of the process.
|
|
|
|
hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
|
|
PROCESS_VM_READ,
|
|
FALSE, processID );
|
|
if (NULL == hProcess)
|
|
{
|
|
rcv.onWrite( "Can't open process %d\n", processID );
|
|
return;
|
|
}
|
|
|
|
if ( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) )
|
|
{
|
|
rcv.onWrite( "PageFaultCount : %d\n", pmc.PageFaultCount );
|
|
rcv.onWrite( "PeakWorkingSetSize : %d (%d kB)\n", pmc.PeakWorkingSetSize, pmc.PeakWorkingSetSize>>10 );
|
|
rcv.onWrite( "WorkingSetSize : %d (%d kB)\n", pmc.WorkingSetSize, pmc.WorkingSetSize>>10 );
|
|
rcv.onWrite( "QuotaPeakPagedPoolUsage : %d\n", pmc.QuotaPeakPagedPoolUsage );
|
|
rcv.onWrite( "QuotaPagedPoolUsage : %d\n", pmc.QuotaPagedPoolUsage );
|
|
rcv.onWrite( "QuotaPeakNonPagedPoolUsage : %d\n", pmc.QuotaPeakNonPagedPoolUsage );
|
|
rcv.onWrite( "QuotaNonPagedPoolUsage : %d\n", pmc.QuotaNonPagedPoolUsage );
|
|
rcv.onWrite( "PagefileUsage : %d (%d kB)\n", pmc.PagefileUsage, pmc.PagefileUsage>>10 );
|
|
rcv.onWrite( "PeakPagefileUsage : %d (%d kB)\n", pmc.PeakPagefileUsage, pmc.PagefileUsage>>10 );
|
|
}
|
|
|
|
CloseHandle( hProcess );
|
|
}
|
|
|
|
void onCwd( ArcadiaCommandResultReceiver & rcv )
|
|
{
|
|
char buf[1024];
|
|
GetCurrentDirectory( 1024, buf );
|
|
rcv.onWrite( "Current Working Directory : %s\n", buf );
|
|
}
|
|
|
|
void ArcadiaFrameworkIntf::ProcCommand( const char* szTarget, const char* szFrom, const char *szFullCommand, ArcadiaCommandResultReceiver & rcv )
|
|
{
|
|
std::vector< std::string > vToken;
|
|
XStringUtil::Split( szFullCommand, vToken );
|
|
|
|
if( FileLogHandler::GetFileLogHandler() ) FileLogHandler::GetFileLogHandler()->LogStringEx( NULL, "Command", "%s(%s)\t%s", szTarget, szFrom, szFullCommand );
|
|
|
|
if( !vToken.empty() && !pArcadiaFrameworkIntf->onCommand( szTarget, szFrom, szFullCommand, vToken, rcv ) )
|
|
{
|
|
if ( vToken[0] == "terminal") ArcadiaFrameworkIntf::SetViewMode( ArcadiaFrameworkIntf::VIEW_CONSOLE );
|
|
else if( vToken[0] == "about" ) ArcadiaFrameworkIntf::SetViewMode( ArcadiaFrameworkIntf::VIEW_ABOUT );
|
|
else if( vToken[0] == "status" ) ArcadiaFrameworkIntf::SetViewMode( ArcadiaFrameworkIntf::VIEW_STATUS );
|
|
else if( vToken[0] == "log" ) ArcadiaFrameworkIntf::SetViewMode( ArcadiaFrameworkIntf::VIEW_LOG );
|
|
else if( vToken[0] == "set" ) onSet( rcv, vToken );
|
|
else if( vToken[0] == "clear" ) onClear( rcv, vToken );
|
|
else if( vToken[0] == "terminate" ) onTerminate( rcv, vToken );
|
|
else if( vToken[0] == "list" ) onList( rcv, vToken );
|
|
else if( vToken[0] == "history" ) onHistory( rcv, vToken );
|
|
else if( vToken[0] == "mem" ) onMem( rcv, vToken );
|
|
else if( vToken[0] == "get" ||
|
|
vToken[0] == "show" ) onGet( rcv, vToken );
|
|
else if( vToken[0] == "del" ||
|
|
vToken[0] == "delete" ||
|
|
vToken[0] == "remove" ) onDelete( rcv, vToken );
|
|
else if( vToken[0] == "watch" ) onWatch( rcv, vToken );
|
|
else if( vToken[0] == "getcwd" ) onCwd( rcv );
|
|
else if( vToken[0] == "suicide" ) XSEH::InvokeUnhandledException( 0xC000000DL );
|
|
else rcv.onWrite( "Invalid command...\n" );
|
|
}
|
|
|
|
rcv.onWrite( "> " );
|
|
rcv.onEnd();
|
|
}
|
|
|
|
unsigned __stdcall RemoteChannelProc( void * pArg )
|
|
{
|
|
XSetThreadName( -1, "AdminChannel" );
|
|
|
|
TelnetConnection *pConnection = reinterpret_cast< TelnetConnection* >( pArg );
|
|
|
|
_SocketWriter myWriter;
|
|
myWriter.pConnection = pConnection;
|
|
|
|
pConnection->TelnetNegotiation( myWriter );
|
|
|
|
myWriter.onWrite( "[%s] remote control session.\nPassword:", ENV().GetString( "app.name", "ARF" ).c_str() );
|
|
myWriter.onEnd();
|
|
|
|
char buf[2048];
|
|
while( true )
|
|
{
|
|
ZeroMemory( buf, sizeof(buf) );
|
|
int len = pConnection->Read( buf, sizeof(buf)-1 );
|
|
|
|
if( !pConnection->onRead( buf, len, myWriter ) ) break;
|
|
}
|
|
|
|
s_connectionLock.Lock();
|
|
for( unsigned i = 0; i < s_vSocketList.size(); i++ )
|
|
{
|
|
if( pConnection->GetXSocket().GetSocketHandle() != s_vSocketList[i].GetSocketHandle() ) continue;
|
|
s_vSocketList.erase( s_vSocketList.begin() + i );
|
|
break;
|
|
}
|
|
s_connectionLock.UnLock();
|
|
|
|
const XAddr& peerAddr = pConnection->GetPeerAddress();
|
|
_cprint( "%s console disconnect.\n", peerAddr.GetAddr() );
|
|
FILELOG( "%s console disconnect.", peerAddr.GetAddr() );
|
|
|
|
delete pConnection;
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned __stdcall RemoteChannelAcceptor( void * pArg )
|
|
{
|
|
XSetThreadName( -1, "AdminAcceptor" );
|
|
|
|
XAddr peerAddr;
|
|
XSocket mySock;
|
|
HANDLE hThread;
|
|
unsigned id;
|
|
while( true )
|
|
{
|
|
mySock = s_pAcceptor->Accept( peerAddr );
|
|
|
|
if( !mySock.IsValidSocket() ) break;
|
|
|
|
_cprint( "IP(%s) connected console.\n", peerAddr.GetAddr() );
|
|
FILELOG( "IP(%s) connected console.", peerAddr.GetAddr() );
|
|
|
|
bool bIsAllowIP = false;
|
|
std::string strIPMask = ENV().GetString( "console.allow_ip", "*" );
|
|
if( !strIPMask.empty() )
|
|
{
|
|
std::vector< std::string > vToken;
|
|
XStringUtil::Split( strIPMask.c_str(), vToken, ";", false );
|
|
|
|
std::vector< std::string >::iterator it;
|
|
for( it = vToken.begin(); it != vToken.end(); ++it )
|
|
{
|
|
if( nsl::wildcmp( (*it).c_str(), peerAddr.GetAddr() ) )
|
|
{
|
|
bIsAllowIP = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bIsAllowIP == false )
|
|
{
|
|
_cprint( "IP(%s) is not allow console ip.\n", peerAddr.GetAddr() );
|
|
FILELOG( "IP(%s) is not allow console ip.", peerAddr.GetAddr() );
|
|
|
|
mySock.Destroy();
|
|
continue;
|
|
}
|
|
|
|
TelnetConnection *pConnection = new TelnetConnection( mySock );
|
|
if( pConnection == NULL )
|
|
{
|
|
mySock.Destroy();
|
|
continue;
|
|
}
|
|
|
|
pConnection->SetPeerAddr( peerAddr );
|
|
|
|
s_connectionLock.Lock();
|
|
s_vSocketList.push_back( mySock );
|
|
s_connectionLock.UnLock();
|
|
|
|
hThread = reinterpret_cast<HANDLE>( _beginthreadex( NULL, 0, RemoteChannelProc, reinterpret_cast<void*>( pConnection ), 0, &id ) );
|
|
CloseHandle( hThread );
|
|
}
|
|
|
|
s_connectionLock.Lock();
|
|
for( unsigned i = 0; i < s_vSocketList.size(); i++ ) s_vSocketList[i].Destroy();
|
|
s_connectionLock.UnLock();
|
|
|
|
return 0;
|
|
}
|
|
|
|
void setExecuteFileChecksum()
|
|
{
|
|
char exeFileName[ MAX_PATH ] = {0,};
|
|
char szFileTime[256] = {0,};
|
|
unsigned checksum = 0;
|
|
unsigned fs = 0;
|
|
FILETIME fwTime, flTime;
|
|
SYSTEMTIME flsTime;
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
|
|
if( !GetModuleFileName( NULL, exeFileName, _countof( exeFileName ) ) )
|
|
{
|
|
s_sprintf( szFileTime, _countof( szFileTime ), "Can't retrieve module file name" );
|
|
}
|
|
else if ( ( hFile = CreateFile( exeFileName, GENERIC_READ | READ_CONTROL, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL ) ) == INVALID_HANDLE_VALUE )
|
|
{
|
|
s_sprintf( szFileTime, _countof( szFileTime ), "Can't open file %s", exeFileName );
|
|
}
|
|
else
|
|
{
|
|
char buf[1024];
|
|
DWORD byte;
|
|
|
|
while ( true )
|
|
{
|
|
if ( !ReadFile( hFile, buf, 1024, &byte, NULL ) )
|
|
{
|
|
if( GetLastError() == ERROR_HANDLE_EOF ) break;
|
|
}
|
|
if ( !byte ) break;
|
|
fs += byte;
|
|
for ( unsigned i = 0 ; i < byte; i ++ )
|
|
{
|
|
checksum += buf[i];
|
|
}
|
|
}
|
|
|
|
if ( !GetFileTime( hFile, NULL, NULL, &fwTime ) )
|
|
{
|
|
s_sprintf( szFileTime, _countof( szFileTime ), "Can't get file time" );
|
|
}
|
|
else
|
|
{
|
|
FileTimeToLocalFileTime( &fwTime, &flTime );
|
|
FileTimeToSystemTime( &flTime, &flsTime );
|
|
s_sprintf( szFileTime, _countof( szFileTime ), "%02d/%02d/%02d-%02d:%02d:%02d", flsTime.wYear, flsTime.wMonth, flsTime.wDay, flsTime.wHour, flsTime.wMinute, flsTime.wSecond );
|
|
}
|
|
|
|
CloseHandle( hFile );
|
|
}
|
|
|
|
char szChecksum[ 10 ];
|
|
s_sprintf( szChecksum, _countof( szChecksum ), "%08X", checksum );
|
|
|
|
ENV().Set( "app.checksum", szChecksum );
|
|
ENV().Set( "app.filetime", szFileTime );
|
|
ENV().Set( "app.filesize", (int) fs );
|
|
}
|
|
|
|
// 시스템 상태를 세팅하기 위해 계속 수행되는 쓰레드.
|
|
// 초당 1회씩 깨어나서 변수들을 업데이트 한다.
|
|
unsigned __stdcall StatUpdater( void * pArg )
|
|
{
|
|
XSetThreadName( -1, "StatUpdater" );
|
|
|
|
// { XEnv 에바인딩 해 놓는다.
|
|
ENV().Bind( "process.load", (int*)&s_nCPULoad );
|
|
ENV().Bind( "process.load_kernel", (int*)&s_nKernelLoad );
|
|
ENV().Bind( "process.load_user", (int*)&s_nUserLoad );
|
|
ENV().Bind( "process.memory", (int*)&s_nCurrentMem );
|
|
ENV().Bind( "process.memory_peak", (int*)&s_nPeakMem );
|
|
ENV().Bind( "process.paged_memory", (int*)&s_nCurrentPagedMem );
|
|
ENV().Bind( "process.paged_memory_peak", (int*)&s_nPeakPagedMem );
|
|
ENV().Bind( "process.uptime", getUpTime );
|
|
// }
|
|
|
|
// PID 세팅
|
|
ENV().Set( "process.id", (int) GetCurrentProcessId() );
|
|
|
|
ProcessUsage cUsage;
|
|
cUsage.Open( GetCurrentProcessId() );
|
|
|
|
// { 실행파일 체크섬
|
|
setExecuteFileChecksum();
|
|
// }
|
|
|
|
while( s_bStatUsageUpdate )
|
|
{
|
|
XThreadMonitor::UpdateThreadCPU();
|
|
|
|
ProcessUsage::T_CPU_USAGE_INFO tCPUInfo = cUsage.GetCPU();
|
|
ProcessUsage::T_MEMORY_USAGE_INFO tMemoryUsage = cUsage.GetMemory();
|
|
|
|
// 메모리 사용량을 KB 단위로 변환
|
|
s_nCurrentMem = (int)( tMemoryUsage.WorkingSetSize >> 10 );
|
|
s_nPeakMem = (int)( tMemoryUsage.PeakWorkingSetSize >> 10 );
|
|
s_nCurrentPagedMem = (int)( tMemoryUsage.PrivateUsage >> 10 );
|
|
s_nPeakPagedMem = (int)( tMemoryUsage.PeakPrivateUsage >> 10 );
|
|
|
|
// CPU 사용량을 % 단위로 변환
|
|
s_nCPULoad = (int)tCPUInfo.dTotal;
|
|
s_nKernelLoad = (int)tCPUInfo.dKernel;
|
|
s_nUserLoad = (int)tCPUInfo.dUser;
|
|
|
|
// 만약 화면모드가 서버 상황보기 상태라면 화면 업데이트 메세지 전송
|
|
if( ArcadiaFrameworkIntf::GetViewMode() == ArcadiaFrameworkIntf::VIEW_STATUS ||
|
|
ArcadiaFrameworkIntf::GetViewMode() == ArcadiaFrameworkIntf::VIEW_LOG )
|
|
{
|
|
InvalidateRect( ArcadiaFrameworkIntf::GetViewWindow(), NULL, false );
|
|
}
|
|
|
|
// 1초간 Sleep() 했다가 재시도 한다.
|
|
for( int lc = 0; lc< 10 && s_bStatUsageUpdate; ++lc )
|
|
{
|
|
Sleep( 100 );
|
|
}
|
|
}
|
|
|
|
cUsage.Close();
|
|
s_bStatUsageUpdate = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
bool TelnetConnection::onRead( char * pData, int nLen, ArcadiaCommandResultReceiver & receiver )
|
|
{
|
|
if ( nLen <= 0 )
|
|
return false;
|
|
|
|
// 제어 문자 처리
|
|
unsigned char * pControl = (unsigned char *)pData;
|
|
if ( pControl[0] == 255 )
|
|
{
|
|
TelnetNegotiationAck( pControl, nLen );
|
|
return true;
|
|
}
|
|
|
|
bool bFlag = true;
|
|
|
|
// 에코 처리
|
|
if ( m_bUseEcho )
|
|
{
|
|
if ( m_bPasswordMode )
|
|
{
|
|
for ( int i = 0 ; i < nLen ; i++ )
|
|
{
|
|
if ( pData[i] == '\r' )
|
|
{
|
|
if ( pData[i+1] == '\n' )
|
|
{
|
|
m_bLineFeed = false;
|
|
Write( "\r\n", 2 );
|
|
}
|
|
}
|
|
else if ( pData[i] == '\n' || pData[i] == '\0' )
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
Write( "*", 1 );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0 ; i < nLen ; i++ )
|
|
{
|
|
if ( pData[i] != '\n' && pData[i] != '\r' ) Write( &pData[i], 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// 수신 메세지 처리
|
|
if ( !m_bUseDelimiter )
|
|
{
|
|
bFlag = procCommand( pData, nLen, receiver );
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0 ; i < nLen ; i++ )
|
|
{
|
|
if ( pData[i] == m_cDelimiter )
|
|
{
|
|
vBuffer.push_back( '\0' );
|
|
bFlag = procCommand( &vBuffer.front(), (int)vBuffer.size(), receiver );
|
|
vBuffer.clear();
|
|
|
|
if( !bFlag ) break;
|
|
|
|
continue;
|
|
}
|
|
|
|
if ( pData[i] == '\n' || pData[i] == '\0' )
|
|
continue;
|
|
|
|
vBuffer.push_back( pData[i] );
|
|
}
|
|
}
|
|
|
|
return bFlag;
|
|
}
|
|
|
|
void TelnetConnection::TelnetNegotiation( ArcadiaCommandResultReceiver & receiver )
|
|
{
|
|
char szBuffer[4];
|
|
|
|
// ECHO 여부를 확인한다.
|
|
s_sprintf(szBuffer, _countof( szBuffer ), "%c%c%c", IAC, WILL, ECHO);
|
|
receiver.onWrite( szBuffer );
|
|
|
|
// LINEMODE 여부를 확인한다.
|
|
s_sprintf(szBuffer, _countof( szBuffer ), "%c%c%c", IAC, DO, LINEMODE);
|
|
receiver.onWrite( szBuffer );
|
|
}
|
|
|
|
void TelnetConnection::TelnetNegotiationAck( unsigned char * cCode, int nLen )
|
|
{
|
|
int nStep = 0;
|
|
unsigned char * pCur = cCode;
|
|
unsigned char cCommand = 0;
|
|
|
|
for ( int i = 0; i < nLen; i++, pCur++ )
|
|
{
|
|
if ( *pCur == IAC )
|
|
{
|
|
nStep = 1;
|
|
continue;
|
|
}
|
|
|
|
if ( *pCur == DO || *pCur == DONT )
|
|
{
|
|
nStep = 2;
|
|
cCommand = *pCur;
|
|
continue;
|
|
}
|
|
|
|
if ( nStep == 2 )
|
|
{
|
|
switch ( *pCur )
|
|
{
|
|
case ECHO:
|
|
if ( cCommand == DO )
|
|
{
|
|
m_bUseEcho = true;
|
|
}
|
|
else
|
|
{
|
|
m_bUseEcho = false;
|
|
}
|
|
break;
|
|
|
|
case LINEMODE:
|
|
// 아직 처리 안함.
|
|
if ( cCommand == DO )
|
|
{
|
|
m_bLineMode = true;
|
|
}
|
|
else
|
|
{
|
|
m_bLineMode = false;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
nStep = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TelnetConnection::procCommand( char * pData, int nLen, ArcadiaCommandResultReceiver & receiver )
|
|
{
|
|
bool bFlag = true;
|
|
|
|
strBuffer.append( pData, strlen(pData) );
|
|
while( strBuffer.find('\r') != std::string::npos || strBuffer.find('\n') != std::string::npos )
|
|
{
|
|
std::string strCommand;
|
|
strCommand = strBuffer.substr( 0, strBuffer.find('\n') );
|
|
if( strCommand.empty() )
|
|
{
|
|
strCommand = strBuffer.substr( 0, strBuffer.find('\r') );
|
|
strBuffer.erase( 0, strCommand.size() + 1 );
|
|
}
|
|
else strBuffer.erase( 0, strCommand.size() + 1 );
|
|
|
|
XStringUtil::Replace( strCommand, "\r", "" );
|
|
XStringUtil::Replace( strCommand, "\n", "" );
|
|
XStringUtil::Trim( strCommand );
|
|
|
|
if( strCommand.empty() )
|
|
continue;
|
|
|
|
//_SocketWriter myWriter;
|
|
//receiver.pConnection = this;
|
|
receiver.onWrite( "\n" );
|
|
|
|
if( m_bPasswordMode )
|
|
{
|
|
std::string strPassword = "genius";
|
|
std::string strEncrypt = ENV().GetString( "console._password", "" );
|
|
|
|
if( pArcadiaFrameworkIntf != NULL )
|
|
{
|
|
const std::string& file_name = pArcadiaFrameworkIntf->GetConsoleEopFileName();
|
|
if( file_name.empty() == false )
|
|
{
|
|
XEnvStruct temp_loader;
|
|
temp_loader.LoadFromFile( file_name.c_str(), "*", true ); // 우선 암호화로 로드 시도
|
|
temp_loader.LoadFromFile( file_name.c_str() ); // 비암호화로 로드 시도
|
|
|
|
strEncrypt = temp_loader.GetString( "console._password", "" );
|
|
}
|
|
}
|
|
|
|
if( strEncrypt.empty() == false )
|
|
{
|
|
strPassword = XStrZlibWithSimpleCipherUtil::Decrypt( strEncrypt.c_str() );
|
|
}
|
|
|
|
if( strPassword == strCommand.c_str() )
|
|
{
|
|
const XAddr& peerAddr = GetPeerAddress();
|
|
_cprint( "%s console logined.\n", peerAddr.GetAddr() );
|
|
FILELOG( "%s console logined.", peerAddr.GetAddr() );
|
|
|
|
m_bPasswordMode = false;
|
|
receiver.onWrite( "Welcome.\n> " );
|
|
receiver.onEnd();
|
|
}
|
|
else
|
|
{
|
|
_cprint( "Password(%s) is not console password.\n", strCommand.c_str() );
|
|
FILELOG( "Password(%s) is not console password.", strCommand.c_str() );
|
|
|
|
m_nPasswordTryCount++;
|
|
if( m_nPasswordTryCount > 3 ) bFlag = false;
|
|
receiver.onWrite( "Invalid password.\nPassword:" );
|
|
receiver.onEnd();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( strCommand == "quit" )
|
|
{
|
|
bFlag = false;
|
|
}
|
|
else
|
|
{
|
|
if( !strCommand.empty() )
|
|
{
|
|
const XAddr& peerAddr = GetPeerAddress();
|
|
ArcadiaFrameworkIntf::ProcCommand( "@system_console", peerAddr.GetAddr(), strCommand.c_str(), receiver );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bFlag;
|
|
}
|