www.pudn.com > ÍøÂç¶Ë¿Ú¼àÊÓ.rar > ApplicationScope.cpp

//--------------------------------------------------------------------------- 
// 
// ApplicationScope.cpp 
// 
// SUBSYSTEM:    
//              Monitoring process creation and termination   
//				 
// MODULE:       
//              Main interface of the user-mode app 
//              
// DESCRIPTION:  
//              A class that wraps up different implementations and provide  
//              single interface 
// 				 
// AUTHOR:		Ivo Ivanov 
// 
//--------------------------------------------------------------------------- 
 
//--------------------------------------------------------------------------- 
// 
// Includes 
// 
//--------------------------------------------------------------------------- 
#include "stdafx.h" 
#include "WinUtils.h" 
#include "NtDriverController.h" 
#include "QueueContainer.h" 
#include "ApplicationScope.h" 
 
//--------------------------------------------------------------------------- 
// 
// Static memeber declarations 
// 
//--------------------------------------------------------------------------- 
CApplicationScope* CApplicationScope::sm_pInstance = NULL; 
 
//--------------------------------------------------------------------------- 
// 
// Constructor 
// 
//--------------------------------------------------------------------------- 
CApplicationScope::CApplicationScope( 
	CCallbackHandler* pHandler       // User-supplied object for handling notifications 
	): 
	m_pDriverCtl(NULL), 
	m_bIsActive(FALSE), 
	m_pQueueManager(NULL) 
{ 
	m_pQueueManager = new CQueueContainer(pHandler);	 
	// 
	// An instance of the class responsible for loading and unloading 
	// the kernel driver 
	// 
	m_pDriverCtl = new CNtDriverController(); 
 
	assert( m_pDriverCtl && m_pDriverCtl->IsDrvStarted() ); 
} 
 
//--------------------------------------------------------------------------- 
// 
// Destructor  
// 
//--------------------------------------------------------------------------- 
CApplicationScope::~CApplicationScope() 
{ 
	StopMonitoring(); 
 
	delete m_pDriverCtl; 
	delete m_pQueueManager; 
} 
 
//--------------------------------------------------------------------------- 
// 
// Copy constructor 
// 
//--------------------------------------------------------------------------- 
CApplicationScope::CApplicationScope(const CApplicationScope& rhs) 
{ 
} 
 
//--------------------------------------------------------------------------- 
// 
// Assignment operator 
// 
//--------------------------------------------------------------------------- 
CApplicationScope& CApplicationScope::operator=(const CApplicationScope& rhs) 
{ 
	if (this == &rhs)  
		return *this; 
 
	return *this; // return reference to left-hand object 
} 
 
 
 
//--------------------------------------------------------------------------- 
// GetInstance 
// 
// Implements the "double-checking" locking pattern combined with  
// Scott Meyers single instance 
// For more details see -  
// 1. "Modern C++ Design" by Andrei Alexandrescu - 6.9 Living in a  
//     Multithreaded World 
// 2. "More Effective C++" by Scott Meyers - Item 26 
//--------------------------------------------------------------------------- 
CApplicationScope& CApplicationScope::GetInstance( 
	CCallbackHandler* pHandler       // User-supplied object for handling notifications 
	)  
{ 
	VerifyIsWindowsNtRequired(); 
	if (!sm_pInstance) 
	{ 
		//CSingleLock guard(&g_AppSingeltonLock, TRUE); 
		if (!sm_pInstance) 
		{ 
			assert( NULL != pHandler ); 
			static CApplicationScope instance(pHandler); 
			sm_pInstance = &instance; 
		} 
	} // if 
 
	return *sm_pInstance; 
} 
 
// 
// Activate/deactivate the monitoring process 
// 
BOOL CApplicationScope::SetActive(BOOL bActive) 
{ 
	BOOL bResult     = FALSE; 
	// 
	// Verify the system hasn't been activate before 
	// 
	if (m_bIsActive != bActive) 
	{ 
		if (bActive) 
		{ 
			bResult = m_pQueueManager->StartMonitor(); 
		} 
		else 
		{ 
			m_pQueueManager->StopMonitor(); 
			bResult = TRUE; 
		} 
 
		if( bResult ) 
		{ 
			m_bIsActive = bActive; 
		} 
	} // if 
 
	return bResult; 
} 
 
// 
// Initiates process of monitoring process creation/termination 
// 
BOOL CApplicationScope::StartMonitoring( 
	PVOID pvParam        // Pointer to a parameter value passed to the object  
	) 
{ 
	CSingleLock guard(&m_csLock, TRUE); 
	BOOL bResult = FALSE; 
	// 
	// Verify the system hasn't been activate before 
	// 
	if (!m_bIsActive) 
	{ 
		m_pQueueManager->SetExternalParam( pvParam ); 
		// 
		// Activate the monitoring process 
		// 
		bResult = SetActive( TRUE );  
	} // if 
	 
	return bResult; 
} 
 
// 
// Ends up the whole process of monitoring 
// 
void CApplicationScope::StopMonitoring() 
{ 
	CSingleLock guard(&m_csLock, TRUE); 
	// 
	// Deactivate the monitoring process 
	// 
	SetActive( FALSE ); 
	return; 
} 
 
//----------------------------End of the file -------------------------------