www.pudn.com > EthernetSpy.zip > EthernetSpyDoc.cpp

// EthernetSpyDoc.cpp : implementation of the CEthernetSpyDoc class 
// 
 
#include "stdafx.h" 
#include "EthernetSpy.h" 
 
#include "Packet32.h" 
 
#include "EthernetSpyReader.h" 
#include "filter.h" 
 
#include "EthernetSpyHeaderFilterDlg.h" 
#include "EthernetSpyTwoTalkFltDlg.h" 
#include "EthernetSpyGlobStatsDlg.h" 
#include "EthernetSpyPckTypeDlg.h" 
#include "EthernetSpyDlg.h" 
#include "EthernetSpyOptionsDlg.h" 
#include "EthernetSpyDoc.h" 
#include "EthernetSpyFiltersDlg.h" 
#include "EthernetSpyAboutDlg.h" 
 
#include "filter.h" 
 
#include "ntddndis.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
#define FILTER_NONE			0 
#define FILTER_HEADER		1 
#define FILTER_TWO_TALKING  2 
 
extern "C" HANDLE hReadingThread; 
 
///////////////////////////////////////////////////////////////////////////// 
// CEthernetSpyDoc 
 
IMPLEMENT_DYNCREATE(CEthernetSpyDoc, CDocument) 
 
BEGIN_MESSAGE_MAP(CEthernetSpyDoc, CDocument) 
	//{{AFX_MSG_MAP(CEthernetSpyDoc)     
	ON_COMMAND(ID_NETCARD_STARTREADING, OnNetcardStartreading) 
	ON_COMMAND(ID_NETCARD_STOPREADING, OnNetcardStopreading) 
	ON_COMMAND(ID_NETCARD_SETPRIORITY_ABOVENORMAL, OnNetcardSetpriorityAbovenormal) 
	ON_COMMAND(ID_NETCARD_SETPRIORITY_HIGHEST, OnNetcardSetpriorityHighest) 
	ON_COMMAND(ID_NETCARD_SETPRIORITY_IDLE, OnNetcardSetpriorityIdle) 
	ON_COMMAND(ID_NETCARD_SETPRIORITY_NORMAL, OnNetcardSetpriorityNormal) 
	ON_COMMAND(ID_NETCARD_SETPRIORITY_TIMECRITICAL, OnNetcardSetpriorityTimecritical) 
	ON_COMMAND(ID_NETCARD_SHOWGLOBALSTATISTICS, OnNetcardShowglobalstatistics) 
	ON_COMMAND(ID_NETCARD_SHOWPACKETTYPESSTATISTICS, OnNetcardShowpackettypesstatistics) 
	ON_COMMAND(ID_NETCARD_SHOWSPYDIALOG, OnNetcardShowspydialog) 
	ON_COMMAND(ID_NETCARD_RESUMEREADING, OnNetcardResumereading) 
	ON_COMMAND(ID_NETCARD_SUSPEDREADING, OnNetcardSuspedreading) 
	ON_COMMAND(ID_NETCARD_OPTIONS, OnNetcardOptions) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_STARTREADING, OnUpdateNetcardStartreading) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_STOPREADING, OnUpdateNetcardStopreading) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_RESUMEREADING, OnUpdateNetcardResumereading) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_SUSPEDREADING, OnUpdateNetcardSuspedreading) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_OPTIONS, OnUpdateNetcardOptions) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_SHOWSPYDIALOG, OnUpdateNetcardShowspydialog) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_SHOWGLOBALSTATISTICS, OnUpdateNetcardShowglobalstatistics) 
	ON_UPDATE_COMMAND_UI(ID_NETCARD_SHOWPACKETTYPESSTATISTICS, OnUpdateNetcardShowpackettypesstatistics) 
	ON_COMMAND(ID_NETCARD_HEADERFILTER, OnNetcardHeaderfilter) 
	ON_COMMAND(ID_NETCARD_TWOTALKINGFILTER, OnNetcardTwotalkingfilter) 
	ON_COMMAND(ID_NETCARD_SOFTWAREFILTER_NONE, OnNetcardSoftwarefilterNone) 
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout) 
	ON_COMMAND(ID_NETCARD_HARDWAREFILTER, OnNetcardHardwarefilter) 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CEthernetSpyDoc construction/destruction 
 
CEthernetSpyDoc::CEthernetSpyDoc() 
{ 
	FilterType = FILTER_NONE; 
	HeaderFilter = new EthernetHeaderFilter (_T(""),_T(""),_T(""), &SpyReader); 
	TwoTalkFlt = new TwoTalkingComputersFilter (_T(""),_T(""), &SpyReader); 
	 
	pGlobStatsDlg = (CEthernetSpyGlobStatsDlg*)NULL; 
	pPckTypeDlg = (CEthernetSpyPckTypeDlg*)NULL; 
	pSpyDlg = (CEthernetSpyDlg*)NULL; 
		 
	CurrentCheckedFilterItem = ID_NETCARD_SETFILTER_NOFILTER; 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_IDLE; 
 
	ThreadIsRunning = FALSE; 
	ThreadIsSuspended = FALSE; 
 
	IsSpyDlgActive = FALSE; 
	IsGlobStatsDlgOpen = FALSE; 
	IsPckTypeDlgOpen = FALSE; 
} 
 
CEthernetSpyDoc::~CEthernetSpyDoc() 
{ 
	delete HeaderFilter; 
	delete TwoTalkFlt; 
 
	if( pSpyDlg != NULL ) 
	{ 
		delete pSpyDlg; 
	} 
	if( pGlobStatsDlg != NULL ) 
	{ 
		delete pGlobStatsDlg; 
	} 
	if( pPckTypeDlg != NULL ) 
	{ 
		delete pPckTypeDlg; 
	} 
} 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CEthernetSpyDoc diagnostics 
 
#ifdef _DEBUG 
void CEthernetSpyDoc::AssertValid() const 
{ 
	CDocument::AssertValid(); 
} 
 
void CEthernetSpyDoc::Dump(CDumpContext& dc) const 
{ 
	CDocument::Dump(dc); 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CEthernetSpyDoc commands 
 
void CEthernetSpyDoc::OnNetcardStartreading()  
{ 
	POSITION pos = GetFirstViewPosition(); 
	CView* view = GetNextView( pos ); 
 
//	SpyReader.InitializeNetData(view); 
	SpyReader.StartReading(); 
 
	OnNetcardSetpriorityIdle(); 
 
	ThreadIsRunning = TRUE; 
} 
 
void CEthernetSpyDoc::OnNetcardStopreading()  
{ 
	if( pSpyDlg != NULL ) 
	{ 
		pSpyDlg->DestroyWindow(); 
		delete pSpyDlg; 
		pSpyDlg = NULL; 
	} 
	 
	IsSpyDlgActive = FALSE; 
 
	if( pGlobStatsDlg != NULL ) 
	{ 
		pGlobStatsDlg->DestroyWindow(); 
		delete pGlobStatsDlg; 
		pGlobStatsDlg = NULL; 
	} 
	 
	IsGlobStatsDlgOpen = FALSE; 
	 
	if( pPckTypeDlg != NULL ) 
	{ 
		pPckTypeDlg->DestroyWindow(); 
		delete pPckTypeDlg; 
		pPckTypeDlg = NULL; 
	} 
	 
	IsPckTypeDlgOpen = FALSE; 
	 
	SpyReader.StopReading(TRUE); 
 
	ThreadIsRunning = FALSE; 
	ThreadIsSuspended = FALSE; 
} 
 
void CEthernetSpyDoc::OnNetcardSetpriorityAbovenormal()  
{ 
	SpyReader.SetReadingPriority(THREAD_PRIORITY_ABOVE_NORMAL); 
 
	Check_UnCheck_Item(ID_NETCARD_SETPRIORITY_ABOVENORMAL, CurrentCheckedPrioItem); 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_ABOVENORMAL; 
} 
 
void CEthernetSpyDoc::OnNetcardSetpriorityHighest()  
{ 
	SpyReader.SetReadingPriority(THREAD_PRIORITY_HIGHEST); 
 
	Check_UnCheck_Item(ID_NETCARD_SETPRIORITY_HIGHEST, CurrentCheckedPrioItem); 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_HIGHEST; 
} 
 
void CEthernetSpyDoc::OnNetcardSetpriorityIdle()  
{ 
	SpyReader.SetReadingPriority(THREAD_PRIORITY_IDLE); 
 
	Check_UnCheck_Item(ID_NETCARD_SETPRIORITY_IDLE, CurrentCheckedPrioItem); 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_IDLE; 
} 
 
void CEthernetSpyDoc::OnNetcardSetpriorityNormal()  
{ 
	SpyReader.SetReadingPriority(THREAD_PRIORITY_NORMAL); 
 
	Check_UnCheck_Item(ID_NETCARD_SETPRIORITY_NORMAL, CurrentCheckedPrioItem); 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_NORMAL; 
} 
 
void CEthernetSpyDoc::OnNetcardSetpriorityTimecritical()  
{ 
	SpyReader.SetReadingPriority(THREAD_PRIORITY_TIME_CRITICAL); 
 
	Check_UnCheck_Item(ID_NETCARD_SETPRIORITY_TIMECRITICAL, CurrentCheckedPrioItem); 
	CurrentCheckedPrioItem = ID_NETCARD_SETPRIORITY_TIMECRITICAL; 
} 
 
void CEthernetSpyDoc::Check_UnCheck_Item( UINT ItemID, UINT UnItemID ) 
{ 
	CMenu* pMenu = AfxGetApp()->m_pMainWnd->GetMenu(); 
	 
	pMenu->CheckMenuItem( UnItemID, MF_UNCHECKED ); 
	pMenu->CheckMenuItem( ItemID, MF_CHECKED ); 
} 
 
 
void CEthernetSpyDoc::OnNetcardShowglobalstatistics()  
{ 
	POSITION pos = GetFirstViewPosition(); 
	CView* view = GetNextView( pos ); 
 
	pGlobStatsDlg = new CEthernetSpyGlobStatsDlg(&SpyReader, view); 
	 
	pGlobStatsDlg->Create(CEthernetSpyGlobStatsDlg::IDD); 
	pGlobStatsDlg->ShowWindow(SW_SHOW);	 
 
	IsGlobStatsDlgOpen = TRUE; 
} 
 
void CEthernetSpyDoc::OnNetcardShowpackettypesstatistics()  
{ 
	POSITION pos = GetFirstViewPosition(); 
	CView* view = GetNextView( pos ); 
 
	pPckTypeDlg = new CEthernetSpyPckTypeDlg(&SpyReader, view); 
	 
	pPckTypeDlg->Create(CEthernetSpyPckTypeDlg::IDD); 
	pPckTypeDlg->ShowWindow(SW_SHOW);	 
 
	IsPckTypeDlgOpen = TRUE; 
} 
 
void CEthernetSpyDoc::OnNetcardShowspydialog()  
{	 
	POSITION pos = GetFirstViewPosition(); 
	CView* view = GetNextView( pos ); 
 
	pSpyDlg = new CEthernetSpyDlg(&SpyReader, view); 
	 
	pSpyDlg->Create(CEthernetSpyDlg::IDD); 
	pSpyDlg->ShowWindow(SW_SHOW);	 
 
	IsSpyDlgActive = TRUE; 
} 
 
void CEthernetSpyDoc::OnNetcardResumereading()  
{ 
	SpyReader.ResumeReading(); 
	ThreadIsSuspended = FALSE; 
} 
 
 
void CEthernetSpyDoc::OnNetcardSuspedreading()  
{ 
	SpyReader.SuspendReading(); 
	ThreadIsSuspended = TRUE; 
} 
 
void CEthernetSpyDoc::OnNetcardOptions()  
{ 
	pOptionsDlg = new CEthernetSpyOptionsDlg(&SpyReader); 
	pOptionsDlg->DoModal(); 
	delete pOptionsDlg; 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardStartreading(CCmdUI* pCmdUI)  
{ 
	if( ThreadIsRunning == TRUE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		pCmdUI->Enable(TRUE); 
	} 
} 
 
 
void CEthernetSpyDoc::OnUpdateNetcardStopreading(CCmdUI* pCmdUI)  
{ 
	if( ThreadIsRunning == FALSE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		pCmdUI->Enable(TRUE); 
	} 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardResumereading(CCmdUI* pCmdUI)  
{ 
	if( ThreadIsSuspended == FALSE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		pCmdUI->Enable(TRUE); 
	} 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardSuspedreading(CCmdUI* pCmdUI)  
{ 
	if( ThreadIsRunning == FALSE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		if( ThreadIsSuspended == TRUE ) 
		{ 
			pCmdUI->Enable(FALSE); 
		} 
		else 
		{ 
			pCmdUI->Enable(TRUE); 
		} 
	} 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardOptions(CCmdUI* pCmdUI)  
{ 
	if( ThreadIsRunning == TRUE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		pCmdUI->Enable(TRUE); 
	} 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardShowspydialog(CCmdUI* pCmdUI)  
{ 
	if( IsSpyDlgActive == TRUE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		if( ThreadIsRunning == FALSE ) 
		{ 
			pCmdUI->Enable(FALSE); 
		} 
		else 
		{	 
			pCmdUI->Enable(TRUE); 
		} 
	} 
} 
 
void CEthernetSpyDoc::OnSpyDlgClose() 
{ 
	IsSpyDlgActive = FALSE; 
} 
/*
void CEthernetSpyDoc::OnTerminatedThread(void)
{	 
	ThreadIsRunning = FALSE; 
	ThreadIsSuspended = FALSE; 
}
*/ 
void CEthernetSpyDoc::OnGlobStatsDlgClose()
{
	IsGlobStatsDlgOpen = FALSE;
}

void CEthernetSpyDoc::OnPckTypeDlgClose()
{
	IsPckTypeDlgOpen = FALSE;
}
 
void CEthernetSpyDoc::OnUpdateNetcardShowglobalstatistics(CCmdUI* pCmdUI)  
{ 
	if( IsGlobStatsDlgOpen == TRUE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		if( ThreadIsRunning == FALSE ) 
		{ 
			pCmdUI->Enable(FALSE); 
		} 
		else 
		{	 
			pCmdUI->Enable(TRUE); 
		} 
	} 
} 
 
void CEthernetSpyDoc::OnUpdateNetcardShowpackettypesstatistics(CCmdUI* pCmdUI)  
{ 
	if( IsPckTypeDlgOpen == TRUE ) 
	{ 
		pCmdUI->Enable(FALSE); 
	} 
	else 
	{ 
		if( ThreadIsRunning == FALSE ) 
		{ 
			pCmdUI->Enable(FALSE); 
		} 
		else 
		{	 
			pCmdUI->Enable(TRUE); 
		} 
	} 
} 
 
void CEthernetSpyDoc::OnNetcardHeaderfilter()  
{ 
	CEthernetSpyHeaderFilterDlg* pFilterDlg = new CEthernetSpyHeaderFilterDlg(HeaderFilter); 
	pFilterDlg->DoModal(); 
	delete pFilterDlg; 
 
	FilterType = FILTER_HEADER; 
	SpyReader.SetSoftwareFilter (HeaderFilter); 
 
	CMenu* pMenu = AfxGetApp()->m_pMainWnd->GetMenu(); 
	 
	pMenu->CheckMenuItem( ID_NETCARD_SOFTWAREFILTER_NONE, MF_UNCHECKED ); 
	pMenu->CheckMenuItem( ID_NETCARD_HEADERFILTER, MF_CHECKED ); 
	pMenu->CheckMenuItem( ID_NETCARD_TWOTALKINGFILTER, MF_UNCHECKED ); 
} 
 
 
void CEthernetSpyDoc::OnNetcardTwotalkingfilter()  
{ 
	CEthernetSpyTwoTalkFltDlg* pFilterDlg =  new CEthernetSpyTwoTalkFltDlg(TwoTalkFlt); 
	pFilterDlg->DoModal(); 
	delete pFilterDlg; 
 
	FilterType = FILTER_TWO_TALKING; 
	SpyReader.SetSoftwareFilter (TwoTalkFlt); 
 
	CMenu* pMenu = AfxGetApp()->m_pMainWnd->GetMenu(); 
 
	pMenu->CheckMenuItem( ID_NETCARD_SOFTWAREFILTER_NONE, MF_UNCHECKED ); 
	pMenu->CheckMenuItem( ID_NETCARD_HEADERFILTER, MF_UNCHECKED ); 
	pMenu->CheckMenuItem( ID_NETCARD_TWOTALKINGFILTER, MF_CHECKED );	 
} 
 
 
void CEthernetSpyDoc::OnNetcardSoftwarefilterNone()  
{ 
	FilterType = FILTER_NONE; 
	SpyReader.SetSoftwareFilter (NULL); 
	 
	CMenu* pMenu = AfxGetApp()->m_pMainWnd->GetMenu(); 
 
	pMenu->CheckMenuItem( ID_NETCARD_SOFTWAREFILTER_NONE, MF_CHECKED ); 
	pMenu->CheckMenuItem( ID_NETCARD_HEADERFILTER, MF_UNCHECKED ); 
    pMenu->CheckMenuItem( ID_NETCARD_TWOTALKINGFILTER, MF_UNCHECKED );	 
} 
 
void CEthernetSpyDoc::OnCloseDocument()  
{ 
	SpyReader.StopReading(TRUE); 
	 
	CDocument::OnCloseDocument(); 
} 
 
void CEthernetSpyDoc::OnAppAbout()  
{ 
	CEthernetSpyAboutDlg About(&SpyReader); 
	About.DoModal(); 
} 
 
void CEthernetSpyDoc::OnNetcardHardwarefilter()  
{ 
	ULONG Filter = SpyReader.HardwareFilter; 
 
	CEthernetSpyFiltersDlg* pFilterDlg = new CEthernetSpyFiltersDlg(&Filter); 
	pFilterDlg->DoModal(); 
 
	SpyReader.SetHardwareFilter (Filter); 
 
	delete pFilterDlg; 
}