ethernetspydoc.cpp

网卡驱动相关实例 这是和网卡NT KMD驱动程序有关的一些资料和例子。主要是以下三方面内容: 3.1 article 一些有用的文档 3.2 Canberra 网络诊听工具Ethern

// 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;
}