record.cpp

数据加密算法

#include "pch.h"
#include "util.h"
#include "main.h"
#include "doc.h"
#include "message.h"
#include "debug.h"
#include "record.h"
#include "watch.h"

ParamBlock::ParamBlock ( )
{
	m_pBlock = NULL ;
	m_dwSize = 0 ;
}

ParamBlock::~ParamBlock ( )
{
	if ( m_pBlock ) 
		delete [ ] m_pBlock ;

	RELEASE_PTR_ARRAY ( m_arStruct , ParamBlock ) ;
}

void ParamBlock::Present ( CTreeCtrl& ctrl , HTREEITEM hParent )
{
	int img = 1 ;

	if ( m_bFunction ) img = 0 ;
	else if ( m_bStruct ) img = 2 ;

	HTREEITEM h = ctrl.InsertItem ( m_strMsg , img , img , hParent ) ;

	int i , n = m_arStruct.GetSize ( ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		ParamBlock* p = ( ParamBlock* ) m_arStruct [ i ] ;
		p->Present ( ctrl , h ) ;
	}
}

Dispatch::Dispatch ( )
{
	m_bPending = TRUE ;
	m_bPostInvalid = FALSE ;
	m_bWillDeleted = FALSE ;

	m_pParamBlock = NULL ;
	m_pParamBlockPost = NULL ;

	m_pType = NULL ;
	m_pReg = NULL ;
	m_pRegPost = NULL ;
}

Dispatch::~Dispatch ( )
{
	if ( m_pReg ) delete m_pReg ;
	if ( m_pRegPost ) delete m_pRegPost ;

	if ( m_pParamBlock ) delete m_pParamBlock ;
	if ( m_pParamBlockPost ) delete m_pParamBlockPost ;
}

CRecordManager::CRecordManager ( )
{
	InitializeCriticalSection ( &m_csSync ) ;
}

CRecordManager::~CRecordManager ( )
{
	RELEASE_PTR_ARRAY ( m_arRecord , Record ) ;
	DeleteCriticalSection ( &m_csSync ) ;
}

void CRecordManager::Start ( )
{
	// start recording

	CMainApp* p = ( CMainApp* ) AfxGetApp ( ) ;

	if ( p->m_appOption.m_bDumpFile == TRUE )
	{
		m_pFile = fopen ( m_pDancerDoc->m_strDumpName , "w" ) ;
		if ( m_pFile == NULL )
		{
			AfxMessageBox ( IDS_MSG_DUMP_FAIL , MB_ICONINFORMATION ) ;
			p->m_appOption.m_bDumpFile = FALSE ;

			return ;
		}
	}
	else m_pFile = NULL ;

	Dispose ( ) ;
	m_dwBaseTime = GetTickCount ( ) ;
}

void CRecordManager::Stop ( )
{
	// stop recording

	if ( m_pFile != NULL )
	{
		Dump ( ) ;
		fclose ( m_pFile ) ;
	}

	CMainApp* p = ( CMainApp* ) AfxGetApp ( ) ;
	if ( p->m_appOption.m_bDisplay == TRUE )
		Update ( ) ;

	int i , n = m_arRecord.GetSize ( ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		Record* p = ( Record* ) m_arRecord [ i ] ;
		if ( p->m_nType != HOOK_MSG ) continue ;
		if ( p->m_pDispatch->m_bPending == FALSE ) continue ;

		p->m_pDispatch->m_bPostInvalid = TRUE ;
		CompleteMsg ( p->m_pDispatch ) ;
	}
}

void CRecordManager::AttachTo ( CDancerDoc* pDancerDoc )
{
	m_pDancerDoc = pDancerDoc ;
}

void CRecordManager::Dispose ( )
{
	CListCtrl& ctrl = m_pDancerDoc->m_pMessageView->GetListCtrl ( ) ;
	ctrl.DeleteAllItems ( ) ;
	m_dwUpdated = 0 ;
	m_dwUpdated2 = 0 ;

	RELEASE_PTR_ARRAY ( m_arRecord , Record ) ;
}

void CRecordManager::ClearAll ( )
{
	EnterCriticalSection ( &m_csSync ) ;

	CListCtrl& ctrl = m_pDancerDoc->m_pMessageView->GetListCtrl ( ) ;
	ctrl.DeleteAllItems ( ) ;
	m_dwUpdated = 0 ;

	int i , n = m_arRecord.GetSize ( ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		Record* p = ( Record* ) m_arRecord [ i ] ;
		if ( p->m_nType == HOOK_MSG &&
			 p->m_pDispatch->m_bPending == TRUE ) // not finishing calling
		{
			p->m_pDispatch->m_bWillDeleted = TRUE ; 
		}
		else
		{
			delete p ;
		}
	}
	m_arRecord.RemoveAll ( ) ;

	LeaveCriticalSection ( &m_csSync ) ;
}

void CRecordManager::AddDebugMsg ( const CString& msg , UINT nIcon )
{
	EnterCriticalSection ( &m_csSync ) ;

	Record* p = new Record ;

	p->m_strMsg =  msg;
	p->m_nType = DEBUG_MSG ;
	p->m_nIconID = nIcon ;

	CMainApp* pp = ( CMainApp* ) AfxGetApp ( ) ;
	if ( pp->m_appOption.m_bRecordDebugMsg == TRUE )
		AddMsg ( p ) ;

	LeaveCriticalSection ( &m_csSync ) ;
}

void CRecordManager::AddExtraMsg ( const CString& msg , UINT nIcon )
{
	EnterCriticalSection ( &m_csSync ) ;

	Record* p = new Record ;

	p->m_strMsg = msg ;
	p->m_nType = EXTRA_MSG ;
	p->m_nIconID = nIcon ;

	CMainApp* pp = ( CMainApp* ) AfxGetApp ( ) ;
	if ( pp->m_appOption.m_bRecordExtraMsg == TRUE )
		AddMsg ( p ) ;

	LeaveCriticalSection ( &m_csSync ) ;
}

void CRecordManager::AddMsg ( Record* pRecord )
{
	CMainApp* p = ( CMainApp* ) AfxGetApp ( ) ;

	pRecord->m_dwTime = GetTickCount ( ) - m_dwBaseTime ;

	DWORD n = m_arRecord.Add ( pRecord ) ;
	
	DWORD n2 = n + 1 , i ;
	if ( p->m_appOption.m_bDisplay == TRUE )
	{
		if ( n2 > p->m_appOption.m_dwMaxDisplay )
		{
			if ( m_pFile != NULL ) 
				Dump ( ) ;

			CListCtrl& ctrl = m_pDancerDoc->m_pMessageView->GetListCtrl ( ) ;
			for ( i = 0 ; i < 100 ; i++ )
			{
				ctrl.DeleteItem ( 0 ) ;

				Record* p = ( Record* ) m_arRecord [ 0 ] ;
				if ( p->m_nType == HOOK_MSG &&
					 p->m_pDispatch->m_bPending == TRUE )
				{
					p->m_pDispatch->m_bWillDeleted = TRUE ;
				}
				else
				{
					delete p ;
				}
				m_arRecord.RemoveAt ( 0 ) ;
			}
			m_dwUpdated -= 100 ;

			CString msg ; msg.LoadString ( IDS_EXTRA_DISPOSE ) ; // pending
			AddExtraMsg ( msg , 0 ) ;
		}
	}

	if ( pRecord->m_nType == HOOK_MSG )
	{
		pRecord->m_pDispatch->m_dwListItem = n ;
	}

	n = m_arRecord.GetSize ( ) ;

	if ( p->m_appOption.m_bDisplay == TRUE )
	{
		if ( p->m_appOption.m_bDisplay == TRUE &&
			 ( p->m_appOption.m_bDisplaySync == TRUE ||
			 n - m_dwUpdated >= UPDATE_INTERVAL ) )
		{
			Update ( ) ;
		}
	}
	if ( p->m_appOption.m_bDumpFile == TRUE ) // need to dump to log file
	{
		BOOL f = FALSE ;
		int i , n = m_arRecord.GetSize ( ) ;
		for ( i = m_dwUpdated2 ; i < n ; i++ )
		{
			Record* p = ( Record* ) m_arRecord [ i ] ;
			if ( p->m_nType == HOOK_MSG && 
				 p->m_pDispatch->m_bPending == TRUE )
			{
				f = TRUE ;
				break ;
			}
		}
		if ( f == FALSE )
		{
			Dump ( ) ;
		}
	}
}

void CRecordManager::Update ( ) 
{
	EnterCriticalSection ( &m_csSync ) ;

	CMainApp* pp = ( CMainApp* ) AfxGetApp ( ) ;
	if ( pp->m_appOption.m_bDisplay == TRUE )
	{
		int i , n1 = m_arRecord.GetSize ( ) ;
		if ( ( DWORD ) n1 == m_dwUpdated ) 
		{
			LeaveCriticalSection ( &m_csSync ) ;
			return ;
		}

		CListCtrl& ctrl = m_pDancerDoc->m_pMessageView->GetListCtrl ( ) ;
		ctrl.ShowWindow ( SW_HIDE ) ;
		
		int n2 = ctrl.GetItemCount ( ) ;
		for ( i = m_dwUpdated ; i < n1 ; i++ )
		{
			Record* p = ( Record* ) m_arRecord [ i ] ;

			ctrl.InsertItem ( 
				LVIF_PARAM , 
				n2++ , 
				NULL ,
				0 ,
				0 ,
				0 ,
				( LPARAM ) p ) ;
		}

		ctrl.ShowWindow ( SW_NORMAL ) ;

		ctrl.EnsureVisible ( n1 - 1 , TRUE ) ;
		ctrl.SetItemState ( n1 - 1 , LVIS_SELECTED , LVIS_SELECTED ) ;
	}
	m_dwUpdated = m_arRecord.GetSize ( ) ;

	LeaveCriticalSection ( &m_csSync ) ;
}

Record* CRecordManager::AddHookMsg ( Dispatch* pDispatch )
{
	EnterCriticalSection ( &m_csSync ) ;

	Record* p = new Record ;

	p->m_dwTime = 0 ;
	p->m_nIconID = 0 ;
	p->m_nType = HOOK_MSG ;
	p->m_pDispatch = pDispatch ;
	p->m_strMsg.Empty ( ) ;

	pDispatch->m_dwTime1 = GetTickCount ( ) - m_dwBaseTime ;
	AddMsg ( p ) ;

	CMainApp* pp = ( CMainApp* ) AfxGetApp ( ) ;
	if ( pp->m_appOption.m_bNotify == TRUE )
	{
		Update ( ) ;
		
		CWatchDialog* pd = new CWatchDialog ( m_pDancerDoc , TRUE ) ;
		if ( pd->DoModal ( ) == IDC_PAUSE )
		{
			m_pDancerDoc->m_pDebugControl->Pause ( ) ;
		}
		delete pd ;
	}

	LeaveCriticalSection ( &m_csSync ) ;

	return p ;
}

void CRecordManager::CompleteMsg ( Dispatch* pDispatch )
{
	EnterCriticalSection ( &m_csSync ) ;

	pDispatch->m_bPending = FALSE ;
	pDispatch->m_dwTime2 = GetTickCount ( ) - m_dwBaseTime ;

	CListCtrl& ctrl = m_pDancerDoc->m_pMessageView->GetListCtrl ( ) ;
	if ( ( DWORD ) ctrl.GetItemCount ( ) <= pDispatch->m_dwListItem )
		Update ( ) ;

	ctrl.Update ( pDispatch->m_dwListItem ) ;

	LeaveCriticalSection ( &m_csSync ) ;
}

void CRecordManager::Dump ( Record* pRecord )
{
	if ( m_pFile == NULL )
	{
		m_pFile = fopen ( m_pDancerDoc->m_strDumpName , "w" ) ;
		if ( m_pFile == NULL )
		{
			AfxMessageBox ( IDS_MSG_DUMP_FAIL , MB_ICONINFORMATION ) ;

			CMainApp* p = ( CMainApp* ) AfxGetApp ( ) ;
			p->m_appOption.m_bDumpFile = FALSE ;

			return ;
		}
	}

	if ( pRecord->m_nType != HOOK_MSG )
	{
		fprintf ( m_pFile , "%s\n" , pRecord->m_strMsg ) ;
	}
	else
	{
		CString msg ;

		msg.Format ( "%d" , pRecord->m_pDispatch->m_dwListItem ) ;
		fprintf ( m_pFile , "%-7s" , msg ) ;

		msg.Format ( "%d" , pRecord->m_pDispatch->m_dwDepth ) ;
		fprintf ( m_pFile , "%-8s" , msg ) ;

		msg.Format ( "%s" , pRecord->m_pDispatch->m_strImportName ) ;
		fprintf ( m_pFile , "%-20s" , msg ) ;

		msg.Format ( "%s" , pRecord->m_pDispatch->m_strExportName ) ;
		fprintf ( m_pFile , "%-20s" , msg ) ;

		if ( pRecord->m_pDispatch->m_bHasName == TRUE )
		{
			msg.Format ( "%s" , pRecord->m_pDispatch->m_strFunction ) ;
		}
		else
		{
			msg.Format ( "%08X\t" , pRecord->m_pDispatch->m_wOrdinal ) ;
		}
		fprintf ( m_pFile , "%-20s" , msg ) ;
		
		if ( pRecord->m_pDispatch->m_bPending == FALSE )
		{
			msg.Format ( "%08X" , pRecord->m_pDispatch->m_dwReturn ) ;
		}
		else
		{
			msg.LoadString ( IDS_INVALID ) ;
		}
		fprintf ( m_pFile , "%-20s\n" , msg ) ;
	}
}

void CRecordManager::Dump ( )
{
	int i , n = m_arRecord.GetSize ( ) ;
	for ( i = m_dwUpdated2 ; i < n ; i++ )
	{
		Dump ( ( Record* ) m_arRecord [ i ] ) ;
	}
	m_dwUpdated2 = n ;
}