able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/winmgmt/adap/adapreg.cpp

1413 lines
41 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1999-2001 Microsoft Corporation
Module Name:
ADAPREG.CPP
Abstract:
History:
--*/
#include "precomp.h"
#include <stdio.h>
#include <wtypes.h>
#include <oleauto.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
#include <tchar.h>
#include <process.h>
#include <arrtempl.h>
#include <cominit.h>
#include <winmgmtr.h>
#include <wbemcli.h>
#include <throttle.h>
#include <psapi.h>
#include "adapreg.h"
#include "perflibschema.h"
#include "WMIBroker.h"
#include "adaputil.h"
#include "winuser.h"
#include <comdef.h>
// Performance library processing list
// ===================================
CPerfLibList g_PerfLibList;
HANDLE g_hAbort = NULL;
/////////////////////////////////////////////////////////////////////////////
//
// returns the PID (the first found if many are there) if success
// returns ZERO if fails
//
/////////////////////////////////////////////////////////////////////////////
#define MAX_ITERATION 8
#define MAX_MODULE (1024)
DWORD GetExecPid()
{
DWORD ThisProc = 0;
LONG lRet = 0;
HKEY hKey;
lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"Software\\Microsoft\\WBEM\\CIMOM",
NULL,
KEY_READ,
&hKey);
if (ERROR_SUCCESS == lRet)
{
DWORD dwType;
DWORD dwSize = sizeof(DWORD);
RegQueryValueEx(hKey,
L"ProcessID",
NULL,
&dwType,
(BYTE*)&ThisProc,
&dwSize);
RegCloseKey(hKey);
}
return ThisProc;
/*
if (!ExecName){
return 0;
}
DWORD i=1;
DWORD ThisProc = 0;
DWORD Size = i*MAX_MODULE;
DWORD cbReturned = 0;
DWORD * pProcId = new DWORD[Size];
do {
if (pProcId && EnumProcesses(pProcId,Size*sizeof(DWORD),&cbReturned)){
break;
} else {
i++;
delete [] pProcId;
Size = i*MAX_MODULE;
pProcId = new DWORD[Size];
}
} while ( (i<=8) );
cbReturned /= sizeof(DWORD);
if (pProcId && cbReturned) {
DWORD SizeModules = MAX_MODULE;
HMODULE * pModules = new HMODULE[SizeModules];
if (pModules){
for (DWORD j=0;j<cbReturned;j++)
{
HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
PROCESS_VM_READ,
FALSE, pProcId[j] );
DWORD cbRetModules = 0;
if (hProcess &&
EnumProcessModules(hProcess,pModules,sizeof(DWORD)*SizeModules,&cbRetModules))
{
WCHAR ModuleName[MAX_PATH];
if (GetModuleBaseNameW(hProcess,
pModules[0], // first module is executable
ModuleName,
sizeof(ModuleName)/sizeof(WCHAR)))
{
if (0 == _wcsicmp(ExecName,ModuleName))
{
ThisProc = pProcId[j];
CloseHandle(hProcess);
hProcess = NULL;
break;
}
};
}
if (hProcess)
{
CloseHandle(hProcess);
hProcess = NULL;
}
}
delete [] pModules;
}
}
if (pProcId){
delete [] pProcId;
}
return ThisProc;
*/
}
void DoResyncPerf( BOOL bDelta, BOOL bThrottle )
{
DEBUGTRACE((LOG_WINMGMT,"ADAP Resync has started\n"));
g_hAbort = CreateEventW( NULL, TRUE, FALSE, L"ADAP_ABORT");
CCloseMe cmAbort( g_hAbort );
if ( NULL != g_hAbort )
{
HRESULT hr = WBEM_S_NO_ERROR;
CAdapRegPerf regPerf(!bDelta);
// Process each perflib that is registered on the system
// =====================================================
hr = regPerf.Initialize( bDelta, bThrottle );
if ( SUCCEEDED( hr ) )
{
hr = regPerf.Dredge( bDelta, bThrottle );
}
if ( FAILED( hr ) )
{
CAdapUtility::NTLogEvent( EVENTLOG_WARNING_TYPE, WBEM_MC_ADAP_PROCESSING_FAILURE, CHex( hr ) );
}
}
DEBUGTRACE((LOG_WINMGMT,"ADAP Resync has completed\n"));
return;
}
void DoClearADAP()
{
DEBUGTRACE((LOG_WINMGMT,"ADAP registry reset has started\n"));
CAdapRegPerf regPerf(FALSE);
regPerf.Clean();
DEBUGTRACE((LOG_WINMGMT,"ADAP registry reset has completed\n"));
return;
}
HRESULT DoReverseAdapterMaintenance( BOOL bThrottle );
/*
{
ERRORTRACE((LOG_WMIADAP,"DoReverseAdapterDredge called"));
return WBEM_NO_ERROR;
};
*/
///////////////////////////////////////////////////////////////////////////////
//
// Entry Point
// ===========
//
///////////////////////////////////////////////////////////////////////////////
int WINAPI WinMain(
HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR szCmdLine, // command line
int nCmdShow // show state
)
{
try
{
// Ensure that we are NT5 or better
// ================================
OSVERSIONINFO OSVer;
OSVer.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
if ( GetVersionEx( &OSVer ) )
{
if ( ! ( ( VER_PLATFORM_WIN32_NT == OSVer.dwPlatformId ) && ( 5 <= OSVer.dwMajorVersion ) ) )
return 0;
}
else
{
return 0;
}
// To avoid messy dialog boxes...
// ==============================
SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX );
// Initialize COM.
// ===============
InitializeCom();
CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
EOAC_NONE, NULL );
// Get the Winmgmt service PID
// ===========================
DWORD dwPID = GetExecPid();
// The semaphore is used so that no more that two copies are running at any time.
// ==============================================================================
WCHAR wszObjName[256];
HANDLE hSemaphore;
swprintf(wszObjName, L"WMI_SysEvent_Semaphore_%d", dwPID);
hSemaphore = CreateSemaphoreW(NULL, 2, 2, wszObjName);
if(hSemaphore == NULL)
return 0;
CCloseMe cm1(hSemaphore);
DWORD dwRet = WaitForSingleObject(hSemaphore, 0);
if(dwRet != WAIT_OBJECT_0)
return 0;
// The mutex makes sure that multiple copies are sequential.
// =========================================================
HANDLE hMutex;
hMutex = CreateMutexW( NULL, FALSE, L"ADAP_WMI_ENTRY" );
if(hMutex == NULL)
return 0;
CCloseMe cm2(hMutex);
switch ( WaitForSingleObject( hMutex, 400000) )
{
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
{
BOOL bThrottle = FALSE;
BOOL bFull = FALSE;
BOOL bDelta = FALSE;
BOOL bReverse = FALSE;
BOOL bClear = FALSE;
/*
{
char pBuff[64];
sprintf(pBuff,"(ADAP) cmdline: %s\n",szCmdLine);
OutputDebugStringA(szCmdLine);
}
*/
if (szCmdLine)
{
while (*szCmdLine)
{
while(*szCmdLine && isspace((UCHAR)*szCmdLine)){
szCmdLine++;
};
if (*szCmdLine == '-' || *szCmdLine == '/')
{
szCmdLine++;
if (toupper((UCHAR)*szCmdLine) == 'T'){
bThrottle = TRUE;
} else if (toupper((UCHAR)*szCmdLine) == 'R') {
bReverse = TRUE;
} else if (toupper((UCHAR)*szCmdLine) == 'F') {
bFull = TRUE;
} else if (toupper((UCHAR)*szCmdLine) == 'D') {
bDelta = TRUE;
} else if (toupper((UCHAR)*szCmdLine) == 'C') {
bClear = TRUE;
}
}
// move to the next white space
while(*szCmdLine && !isspace(*szCmdLine)){
szCmdLine++;
}
}
}
if (bClear) // ClearADAP and/or ReverseAdap
{
DoClearADAP();
if (bReverse)
DoReverseAdapterMaintenance( bThrottle );
}
else
{
if (!bFull && !bDelta && !bReverse)
{
// no options, use Delta NO-THROTTLE
DoResyncPerf(TRUE,FALSE);
}
else
{
if (bFull) {
DoResyncPerf(FALSE,bThrottle);
}
if (bDelta && !bFull) {
DoResyncPerf(TRUE,bThrottle);
}
if (bReverse)
DoReverseAdapterMaintenance( bThrottle );
}
}
ReleaseMutex( hMutex );
}break;
}
CoUninitialize();
long l;
ReleaseSemaphore(hSemaphore, 1, &l);
}
catch(...)
{
// <Gasp> We have been betrayed... try to write something to the error log
// =======================================================================
CriticalFailADAPTrace( "An unhandled exception has been thrown in the main thread." );
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
//
// CPerfLibList
//
////////////////////////////////////////////////////////////////////////////////
HRESULT CPerfLibList::AddPerfLib( WCHAR* wszPerfLib )
{
HRESULT hr = WBEM_S_NO_ERROR;
try
{
EnterCriticalSection( &m_csPerfLibList );
{
WCHAR* wszNew = NULL;
// Compute the size of the new buffer
// ==================================
DWORD dwListSize = 0;
if ( NULL != m_wszPerfLibList )
{
dwListSize += wcslen( m_wszPerfLibList );
dwListSize += wcslen( ADAP_EVENT_MESSAGE_DELIM );
}
if ( NULL != wszPerfLib )
{
dwListSize += wcslen( wszPerfLib );
}
// Create the new buffer, and initialize the content
// =================================================
wszNew = new WCHAR[dwListSize + 1];
// Copy the old buffer if required
// ===============================
if ( NULL != m_wszPerfLibList )
{
swprintf( wszNew, L"%s%s%s", m_wszPerfLibList, ADAP_EVENT_MESSAGE_DELIM, wszPerfLib );
delete [] m_wszPerfLibList;
}
else
{
swprintf( wszNew, L"%s", wszPerfLib );
}
// And assign it to the static member
// ==================================
m_wszPerfLibList = wszNew;
}
LeaveCriticalSection( &m_csPerfLibList );
}
catch( unsigned int n )
{
// Handle the case where EnterCriticalSection() has throw an exception
// ===================================================================
if ( n == STATUS_INVALID_HANDLE )
hr = WBEM_E_FAILED;
else
throw;
}
catch(...)
{
LeaveCriticalSection( &m_csPerfLibList );
hr = WBEM_E_FAILED;
}
return hr;
}
HRESULT CPerfLibList::HandleFailure()
{
HRESULT hr = WBEM_S_NO_ERROR;
try
{
char szMessage[ADAP_EVENT_MESSAGE_LENGTH];
EnterCriticalSection( &m_csPerfLibList );
{
DWORD dwMessageLen = strlen( ADAP_EVENT_MESSAGE_PREFIX );
if ( NULL != m_wszPerfLibList )
{
dwMessageLen += wcslen( m_wszPerfLibList );
}
if ( ADAP_EVENT_MESSAGE_LENGTH > dwMessageLen )
{
sprintf( szMessage, "%s%S\n", ADAP_EVENT_MESSAGE_PREFIX, (NULL != m_wszPerfLibList) ? m_wszPerfLibList : L"<NULL>" );
}
}
LeaveCriticalSection( &m_csPerfLibList );
CriticalFailADAPTrace( szMessage );
}
catch( unsigned int n )
{
// Handle the case where EnterCriticalSection() has throw an exception
// ===================================================================
if ( n == STATUS_INVALID_HANDLE )
hr = WBEM_E_FAILED;
else
throw;
}
catch(...)
{
LeaveCriticalSection( &m_csPerfLibList );
hr = WBEM_E_FAILED;
}
return hr;
}
////////////////////////////////////////////////////////////////////////////////
//
// Static Members
//
////////////////////////////////////////////////////////////////////////////////
LONG CAdapRegPerf::AdapUnhandledExceptionFilter( LPEXCEPTION_POINTERS lpexpExceptionInfo )
{
// TODO: language specification
g_PerfLibList.HandleFailure();
return EXCEPTION_CONTINUE_SEARCH;
}
////////////////////////////////////////////////////////////////////////////////
//
// CAdapRegPerf
//
////////////////////////////////////////////////////////////////////////////////
CAdapRegPerf::CAdapRegPerf(BOOL bFull)
: m_pLocaleCache( NULL ),
m_fQuit( FALSE ),
m_dwPID( 0 ),
m_pADAPStatus( NULL ),
m_pRootDefault( NULL ),
m_hRegChangeEvent( NULL ),
m_hPerflibKey( NULL ),
m_pKnownSvcs(NULL),
m_bFull(bFull)
{
for ( DWORD dwType = 0; dwType < WMI_ADAP_NUM_TYPES; dwType++ )
m_apMasterClassList[dwType] = NULL;
}
CAdapRegPerf::~CAdapRegPerf()
{
// Status: COMPLETE
// ================
SetADAPStatus( eADAPStatusFinished);
//
// Add TimeStamp to registry if FULL
//
if (m_bFull)
{
FILETIME FileTime;
GetSystemTimeAsFileTime(&FileTime);
LONG lRet;
HKEY hKey;
lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"Software\\Microsoft\\WBEM\\CIMOM",
NULL,
KEY_WRITE,
&hKey);
if (ERROR_SUCCESS == lRet)
{
RegSetValueEx(hKey,
ADAP_TIMESTAMP_FULL,
NULL,
REG_BINARY,
(BYTE*)&FileTime,
sizeof(FILETIME));
RegCloseKey(hKey);
}
}
if (m_pKnownSvcs)
{
m_pKnownSvcs->Save();
m_pKnownSvcs->Release();
}
// Cleanup
// =======
for ( DWORD dwType = 0; dwType < WMI_ADAP_NUM_TYPES; dwType++ )
{
if ( NULL != m_apMasterClassList[dwType] )
{
m_apMasterClassList[dwType]->Release();
}
}
if ( NULL != m_pLocaleCache )
{
m_pLocaleCache->Release();
}
if ( NULL != m_pRootDefault )
{
m_pRootDefault->Release();
}
if ( NULL != m_pADAPStatus )
{
m_pADAPStatus->Release();
}
if ( NULL != m_hPerflibKey )
{
RegCloseKey( m_hPerflibKey );
}
if ( NULL != m_hRegChangeEvent )
{
CloseHandle( m_hRegChangeEvent );
}
SetEvent( m_hTerminationEvent );
}
HRESULT CAdapRegPerf::Initialize(BOOL bDelta, BOOL bThrottle)
///////////////////////////////////////////////////////////////////////////////
//
// Initialize is responsible for setting up the dredging environment. The
// unhandled exception filter is set to handle any exceptions throw and not
// handled by perforance libraries. The termination event is a signal used
// to identify when the process is being abnormally terminated. The
// GoGershwin thread is suitably named since it is something to watch over
// over the main process. The locale cache is a cache of all locales
// available in the performance domain (enumeration of the names' database
// subkeys). The master class lists for both the cooked and the raw classes
// represent the state of the performance objects in WMI.
//
// Parameters:
// none
//
///////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = WBEM_NO_ERROR;
// Initialize the root\default pointer. This will be used to track our status
// ==========================================================================
GetADAPStatusObject();
// Set the filter for handling unhandled exceptions thrown in threads generated by the perflibs
// ============================================================================================
SetUnhandledExceptionFilter( CAdapRegPerf::AdapUnhandledExceptionFilter );
// ADAP termination event
// ======================
m_hTerminationEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if ( NULL == m_hTerminationEvent )
{
hr = WBEM_E_FAILED;
}
// Open the registry key to be monitored
// =====================================
if ( SUCCEEDED( hr ) )
{
if ( ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, _T("Software\\Microsoft\\Windows NT\\CurrentVersion\\Perflib"), 0, KEY_NOTIFY, &m_hPerflibKey ) )
{
hr = WBEM_E_FAILED;
}
}
// Create the registry change event
// ================================
if ( SUCCEEDED( hr ) )
{
m_hRegChangeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if ( NULL == m_hRegChangeEvent )
{
hr = WBEM_E_FAILED;
}
}
// Create the names' database change notification
// ==============================================
// Note that we are only looking for subkeys being added or deleted. We do
// not want to monitor the registry values since the status and signature
// values may be changing throughout the course of the dredge, and we do
// not want to cause a re-cache unless a performance library is added
// (i.e. a performance subkey is added
if ( SUCCEEDED( hr ) )
{
if ( ERROR_SUCCESS != RegNotifyChangeKeyValue( m_hPerflibKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, m_hRegChangeEvent, TRUE ) )
{
hr = WBEM_E_FAILED;
}
}
// Get the WinMgmt Service PID
// ===========================
if ( SUCCEEDED( hr ) )
{
m_dwPID = GetExecPid();
}
// Create the "Someone to watch over me" thread
// ============================================
if ( SUCCEEDED( hr ) )
{
UINT nThreadID = 0;
m_hSyncThread = ( HANDLE ) _beginthreadex( NULL, 0, CAdapRegPerf::GoGershwin, (void*) this, 0, &nThreadID );
DEBUGTRACE ( ( LOG_WMIADAP, "The Monitor thread ID is 0x%x\n", nThreadID ) );
if ( (HANDLE)-1 == m_hSyncThread )
{
hr = WBEM_E_FAILED;
}
}
// Set up the locale cache
// =======================
if ( SUCCEEDED( hr ) )
{
m_pLocaleCache = new CLocaleCache( );
if ( NULL == m_pLocaleCache )
{
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
hr = m_pLocaleCache->Initialize();
}
}
//
//
m_pKnownSvcs = new CKnownSvcs();
if (m_pKnownSvcs)
m_pKnownSvcs->Load();
// Set up the master class lists for the raw classes
// =================================================
if ( SUCCEEDED( hr ) )
{
m_apMasterClassList[WMI_ADAP_RAW_CLASS] = new CMasterClassList( m_pLocaleCache, m_pKnownSvcs );
if ( NULL != m_apMasterClassList[WMI_ADAP_RAW_CLASS] )
{
hr = m_apMasterClassList[WMI_ADAP_RAW_CLASS]->BuildList( ADAP_PERF_RAW_BASE_CLASS, bDelta, bThrottle );
}
else
{
hr = WBEM_E_OUT_OF_MEMORY;
}
}
// Set up the master class lists for the cooked classes
// ====================================================
if ( SUCCEEDED( hr ) )
{
m_apMasterClassList[WMI_ADAP_COOKED_CLASS] = new CMasterClassList( m_pLocaleCache, m_pKnownSvcs );
if ( NULL != m_apMasterClassList[WMI_ADAP_COOKED_CLASS] )
{
m_apMasterClassList[WMI_ADAP_COOKED_CLASS]->BuildList( ADAP_PERF_COOKED_BASE_CLASS, bDelta, bThrottle );
}
else
{
hr = WBEM_E_OUT_OF_MEMORY;
}
}
#ifdef _DUMP_LIST
m_apMasterClassList[WMI_ADAP_RAW_CLASS]->Dump();
m_apMasterClassList[WMI_ADAP_COOKED_CLASS]->Dump();
#endif
return hr;
}
HRESULT CAdapRegPerf::Dredge( BOOL bDelta, BOOL bThrottle )
///////////////////////////////////////////////////////////////////////////////
//
// This is the entry point method which dredges the registry for performance
// counters and registers the classes in WMI. This method enumerates all of
// the service keys looking for 'Performance' subkeys which indicate
// performance libraries. If a library is discovered, then it is sent to
// the ProcessLibrary method for, you guessed it, processing.
//
// Parameters:
// none
//
///////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = WBEM_S_NO_ERROR;
WString wstrServiceKey,
wstrPerformanceKey;
if ( SUCCEEDED( hr ) )
{
// Status: PROCESSING
// ==================
SetADAPStatus( eADAPStatusProcessLibs);
// Open the services key
// =====================
long lError = Open( HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Services" );
if ( CNTRegistry::no_error == lError )
{
// Iterate through the services list
// =================================
DWORD dwIndex = 0;
DWORD dwBuffSize = 0;
WCHAR* pwcsServiceName = NULL;
while ( ( CNTRegistry::no_error == lError ) && ( !m_fQuit ) )
{
// Reset the processing status
// ===========================
hr = WBEM_NO_ERROR;
if ( WAIT_OBJECT_0 == WaitForSingleObject( m_hRegChangeEvent, 0 ) )
{
m_pLocaleCache->Reset();
dwIndex = 0;
// Reset the event and reset the change notification
ResetEvent( m_hRegChangeEvent );
RegNotifyChangeKeyValue( m_hPerflibKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, m_hRegChangeEvent, TRUE );
}
// For each service name, we will check for a performance
// key and if it exists, we will process the library
// ======================================================
lError = Enum( dwIndex, &pwcsServiceName , dwBuffSize );
if (bThrottle)
{
HRESULT hrThr = Throttle(THROTTLE_USER|THROTTLE_IO,
ADAP_IDLE_USER,
ADAP_IDLE_IO,
ADAP_LOOP_SLEEP,
ADAP_MAX_WAIT);
if (THROTTLE_FORCE_EXIT == hrThr)
{
//OutputDebugStringA("(ADAP) Unthrottle command received\n");
bThrottle = FALSE;
UNICODE_STRING BaseUnicodeCommandLine = NtCurrentPeb()->ProcessParameters->CommandLine;
WCHAR * pT = wcschr(BaseUnicodeCommandLine.Buffer,L't');
if (0 == pT)
pT = wcschr(BaseUnicodeCommandLine.Buffer,L'T');
if (pT)
{
*pT = L' ';
pT--;
*pT = L' ';
}
}
}
if ( CNTRegistry::no_error == lError )
{
try
{
// Create the perfomance key path
// ==============================
wstrServiceKey = L"SYSTEM\\CurrentControlSet\\Services\\";
wstrServiceKey += pwcsServiceName;
wstrPerformanceKey = wstrServiceKey;
wstrPerformanceKey += L"\\Performance";
}
catch( ... )
{
hr = WBEM_E_OUT_OF_MEMORY;
}
if ( SUCCEEDED( hr ) )
{
CNTRegistry reg;
// Atempt to open the performance registry key for the service
// ===========================================================
long lPerfError = reg.Open( HKEY_LOCAL_MACHINE, wstrPerformanceKey );
if ( CNTRegistry::no_error == lPerfError )
{
// If we can open it, then we have found a perflib! Process it
// unless it is the reverse provider perflib
// =============================================================
if ( 0 != _wcsicmp( pwcsServiceName, WMI_ADAP_REVERSE_PERFLIB ) )
{
hr = ProcessLibrary( pwcsServiceName, bDelta );
}
}
else if ( CNTRegistry::access_denied == lPerfError )
{
ServiceRec * pSvcRec = NULL;
if (0 == m_pKnownSvcs->Get(pwcsServiceName,&pSvcRec))
{
if (!pSvcRec->IsELCalled())
{
CAdapUtility::NTLogEvent( EVENTLOG_WARNING_TYPE,
WBEM_MC_ADAP_PERFLIB_REG_VALUE_FAILURE,
(LPCWSTR)wstrPerformanceKey, L"Access Denied" );
pSvcRec->SetELCalled();
}
}
}
else
{
// Otherwise, it is not a perflib service
// ======================================
}
}
}
else if ( CNTRegistry::no_more_items != lError )
{
if ( CNTRegistry::out_of_memory == lError )
{
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
hr = WBEM_E_FAILED;
}
}
dwIndex++;
}
// Cleanup the service name buffer
// ===============================
if ( NULL != pwcsServiceName )
{
delete [] pwcsServiceName;
pwcsServiceName = NULL;
}
}
else if ( CNTRegistry::access_denied == lError )
{
CAdapUtility::NTLogEvent( EVENTLOG_WARNING_TYPE, WBEM_MC_ADAP_PERFLIB_REG_VALUE_FAILURE, L"SYSTEM\\CurrentControlSet\\Services\\", L"Access Denied" );
hr = WBEM_E_FAILED;
}
else
{
hr = WBEM_E_FAILED;
}
// Now that we have a master class list that contains updated
// data from all of the perflibs, commit any changes to WMI
// ==========================================================
if ( SUCCEEDED ( hr ) && ( !m_fQuit ) )
{
// Status: COMMIT
// ==============
SetADAPStatus( eADAPStatusCommit );
for ( DWORD dwType = 0; dwType < WMI_ADAP_NUM_TYPES; dwType++ )
{
m_apMasterClassList[dwType]->Commit(bThrottle);
}
}
}
if ( SUCCEEDED( hr ) )
{
DEBUGTRACE( ( LOG_WMIADAP, "CAdapRegPerf::Dredge() for %S succeeded.\n", (WCHAR *)wstrServiceKey ) );
}
else
{
ERRORTRACE( ( LOG_WMIADAP, "CAdapRegPerf::Dredge() failed: %X.\n", hr ) );
}
return hr;
}
HRESULT CAdapRegPerf::Clean()
////////////////////////////////////////////////////////////////////////////////
//
// This method enumerates all of the keys from the
// HLM\System\CurrentControlSet\Services and searches for a performance subkey.
// If a performance subkey is discovered, then any information that was placed
// in the key by ADAP is deleted.
//
// Parameters:
// none
//
////////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = WBEM_S_NO_ERROR;
WString wstrServiceKey, // The path to the service key
wstrPerformanceKey; // The path to the performance subkey
CNTRegistry regOuter; // The registry object for the services enumeration
// Open the services key
// =====================
long lError = regOuter.Open( HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Services" );
if ( CNTRegistry::no_error == lError )
{
// Iterate through the services list
// =================================
DWORD dwIndex = 0;
DWORD dwBuffSize = 0;
WCHAR* pwcsServiceName = NULL;
while ( CNTRegistry::no_error == lError )
{
// Reset the processing status
// ===========================
hr = WBEM_NO_ERROR;
// For each service name, we will check for a performance
// key and if it exists, we will process the library
// ======================================================
lError = regOuter.Enum( dwIndex, &pwcsServiceName , dwBuffSize );
if ( CNTRegistry::no_error == lError )
{
try
{
// Create the perfomance key path
// ==============================
wstrServiceKey = L"SYSTEM\\CurrentControlSet\\Services\\";
wstrServiceKey += pwcsServiceName;
wstrPerformanceKey = wstrServiceKey;
wstrPerformanceKey += L"\\Performance";
}
catch( ... )
{
hr = WBEM_E_OUT_OF_MEMORY;
}
if ( SUCCEEDED( hr ) )
{
CNTRegistry regInner; // The registry object for the performance subkey
// Atempt to open the performance registry key for the service
// ===========================================================
long lPerfError = regInner.Open( HKEY_LOCAL_MACHINE, wstrPerformanceKey );
if ( CNTRegistry::no_error == lPerfError )
{
// If we can open it, then we have found a perflib! Clean it!
// =============================================================
regInner.DeleteValue( ADAP_PERFLIB_STATUS_KEY );
regInner.DeleteValue( ADAP_PERFLIB_SIGNATURE );
regInner.DeleteValue( ADAP_PERFLIB_SIZE );
regInner.DeleteValue( ADAP_PERFLIB_TIME );
}
else if ( CNTRegistry::access_denied == lPerfError )
{
CAdapUtility::NTLogEvent( EVENTLOG_WARNING_TYPE,
WBEM_MC_ADAP_PERFLIB_REG_VALUE_FAILURE,
(LPCWSTR)wstrPerformanceKey, L"Access Denied" );
}
else
{
// Otherwise, it is not a perflib service
// ======================================
}
}
}
else if ( CNTRegistry::no_more_items != lError )
{
if ( CNTRegistry::out_of_memory == lError )
{
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
hr = WBEM_E_FAILED;
}
}
dwIndex++;
}
// Cleanup the service name buffer
// ===============================
if ( NULL != pwcsServiceName )
{
delete [] pwcsServiceName;
pwcsServiceName = NULL;
}
}
else if ( CNTRegistry::access_denied == lError )
{
CAdapUtility::NTLogEvent( EVENTLOG_WARNING_TYPE, WBEM_MC_ADAP_PERFLIB_REG_VALUE_FAILURE, L"SYSTEM\\CurrentControlSet\\Services\\", L"Access Denied" );
hr = WBEM_E_FAILED;
}
else
{
hr = WBEM_E_FAILED;
}
if ( SUCCEEDED( hr ) )
{
DEBUGTRACE( ( LOG_WMIADAP, "CAdapRegPerf::Clean() succeeded.\n" ) );
}
else
{
ERRORTRACE( ( LOG_WMIADAP, "CAdapRegPerf::Clean() failed: %X.\n", hr ) );
}
return hr;
}
HRESULT CAdapRegPerf::ProcessLibrary( WCHAR* pwcsServiceName, BOOL bDelta )
///////////////////////////////////////////////////////////////////////////////
//
// Once a performance library has been discovered, then it's schema must be
// retrieved and the performance library's class list compared to what is
// already in the WMI repository. The comparison is achieved in the "Merge"
// method of the master class list which extracts any classes from the perf
// lib's class list that are not already in the master class list. The
// comparison occurs for both the raw and the cooked classes.
//
// Parameters:
// pwcsServiceName - The name of the service to be processed
//
///////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = WBEM_NO_ERROR;
try
{
// Add the name of the performance library to the perflib list
// ===========================================================
// The list is used for book keeping purposses to track processing
// in the event of a perflib failure
g_PerfLibList.AddPerfLib( pwcsServiceName );
// Construct and initialize the schema for the perflib
// ===================================================
DWORD LoadStatus = EX_STATUS_UNLOADED;
CPerfLibSchema Schema( pwcsServiceName, m_pLocaleCache );
hr = Schema.Initialize( bDelta, &LoadStatus );
DEBUGTRACE(( LOG_WMIADAP,"CPerfLibSchema::Initialize for %S hr %08x\n",pwcsServiceName,hr));
if ( !bDelta || ( bDelta && ( hr != WBEM_S_ALREADY_EXISTS ) ) )
{
// Update raw and cooked classes
// =============================
for ( DWORD dwType = 0; ( dwType < WMI_ADAP_NUM_TYPES ) && SUCCEEDED( hr ); dwType++ )
{
// Get the class list for classes from the perflib's schema
// ========================================================
CClassList* pClassList = NULL;
hr = Schema.GetClassList( dwType, &pClassList );
CAdapReleaseMe rmClassList( pClassList );
DEBUGTRACE(( LOG_WMIADAP,"GetClassList for %S hr %08x\n",pwcsServiceName,hr));
if ( SUCCEEDED( hr ) )
{
// Merge the raw classes obtained from the perflib into the master class list
// ==========================================================================
hr = m_apMasterClassList[dwType]->Merge( pClassList, bDelta );
DEBUGTRACE(( LOG_WMIADAP,"m_apMasterClassList[%d]->Merge for %S hr %08x\n",dwType,pwcsServiceName,hr));
}
//if (bDelta && FAILED(hr)){
// // the class was not in the repository if we are here
// LoadStatus = EX_STATUS_UNLOADED;
//}
}
};
if (FAILED(hr) && (LoadStatus != EX_STATUS_LOADABLE))
{
for ( DWORD dwType = 0; ( dwType < WMI_ADAP_NUM_TYPES ) ; dwType++ )
{
DEBUGTRACE((LOG_WMIADAP,"ProcessLibrary ForceStatus for %S hr = %08x\n",pwcsServiceName,hr));
DWORD NewStatus = ADAP_OBJECT_IS_DELETED;
if (LoadStatus == EX_STATUS_UNLOADED)
{
NewStatus |= ADAP_OBJECT_IS_TO_BE_CLEARED;
}
m_apMasterClassList[dwType]->ForceStatus(pwcsServiceName,TRUE,NewStatus);
}
}
}
catch(...)
{
hr = WBEM_E_OUT_OF_MEMORY;
}
return hr;
}
unsigned int CAdapRegPerf::GoGershwin( void* pParam )
///////////////////////////////////////////////////////////////////////////////
//
// The monitoring thread entry point
//
///////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = WBEM_S_NO_ERROR;
try
{
CAdapRegPerf* pThis = (CAdapRegPerf*)pParam;
HANDLE ahHandles[2];
// If we don't have an initialized PID, then find one from WMI
// ===========================================================
if ( 0 == pThis->m_dwPID )
{
pThis->m_dwPID = GetExecPid();
}
// Get the process handle and wait for a signal
// ============================================
if ( SUCCEEDED( hr ) && ( 0 != pThis->m_dwPID ) )
{
ahHandles[0] = OpenProcess( SYNCHRONIZE, FALSE, pThis->m_dwPID );
CCloseMe cmProcess( ahHandles[0] );
ahHandles[1] = pThis->m_hTerminationEvent;
DWORD dwRet = WaitForMultipleObjects( 2, ahHandles, FALSE, INFINITE );
switch ( dwRet )
{
case WAIT_FAILED: // Something is wierd
case WAIT_OBJECT_0: // The service process
{
pThis->m_fQuit = TRUE; // Set the termination flag
} break;
case ( WAIT_OBJECT_0 + 1 ): // The completion event
{
// continue
}break;
}
}
}
catch(...)
{
// <Gasp> We have been betrayed... try to write something to the error log
// =======================================================================
CriticalFailADAPTrace( "An unhandled exception has been thrown in the WMI monitoring thread." );
}
return 0;
}
HRESULT CAdapRegPerf::GetADAPStatusObject( void )
{
IWbemLocator* pLocator = NULL;
HRESULT hr = CoCreateInstance( CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator,
(void**) &pLocator );
CReleaseMe rm( pLocator );
if ( SUCCEEDED( hr ) )
{
BSTR bstrNameSpace = SysAllocString( L"root\\default" );
BSTR bstrInstancePath = SysAllocString( L"__ADAPStatus=@" );
CSysFreeMe sfm1( bstrNameSpace );
CSysFreeMe sfm2( bstrInstancePath );
if ( NULL != bstrNameSpace && NULL != bstrInstancePath )
{
// Connect to Root\default and get hold of the status object
hr = pLocator->ConnectServer( bstrNameSpace, // NameSpace Name
NULL, // UserName
NULL, // Password
NULL, // Locale
0L, // Security Flags
NULL, // Authority
NULL, // Wbem Context
&m_pRootDefault // Namespace
);
if ( SUCCEEDED( hr ) )
{
// Set Interface security
hr = WbemSetProxyBlanket( m_pRootDefault, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
RPC_C_AUTHN_LEVEL_PKT,RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
if ( SUCCEEDED( hr ) )
{
hr = m_pRootDefault->GetObject( bstrInstancePath, 0L, NULL, &m_pADAPStatus, NULL );
if ( SUCCEEDED( hr ) )
{
SetADAPStatus( eADAPStatusRunning );
}
}
}
}
else
{
hr = WBEM_E_OUT_OF_MEMORY;
}
} // IF got locator
return hr;
}
// Gets the time in the popular DMTF format
void CAdapRegPerf::GetTime( LPWSTR Buff )
{
SYSTEMTIME st;
int Bias=0;
char cOffsetSign = '+';
GetLocalTime( &st );
TIME_ZONE_INFORMATION ZoneInformation;
DWORD dwRet = GetTimeZoneInformation(&ZoneInformation);
if(dwRet != TIME_ZONE_ID_UNKNOWN)
Bias = -ZoneInformation.Bias;
if(Bias < 0)
{
cOffsetSign = '-';
Bias = -Bias;
}
swprintf(Buff, L"%4d%02d%02d%02d%02d%02d.%06d%c%03d",
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute,
st.wSecond, st.wMilliseconds*1000, cOffsetSign, Bias);
}
// Sets the status back in WMI
void CAdapRegPerf::SetADAPStatus( eADAPStatus status )
{
// Make sure we've got both our pointers
if ( NULL != m_pRootDefault && NULL != m_pADAPStatus )
{
// We only need 25 characters for this
WCHAR wcsTime[32];
_variant_t var;
// legacy fastprox behavior
WCHAR pNum[16];
wsprintfW(pNum,L"%u",status);
var = pNum;
HRESULT hr = m_pADAPStatus->Put( L"Status", 0L, &var, 0 );//CIM_UINT32 );
if ( SUCCEEDED( hr ) )
{
// Set the time property if necessary
if ( status == eADAPStatusRunning || status == eADAPStatusFinished )
{
GetTime( wcsTime );
// This can fail
try
{
var = wcsTime;
}
catch(...)
{
hr = WBEM_E_OUT_OF_MEMORY;
}
if ( SUCCEEDED( hr ) )
{
hr = ( status == eADAPStatusRunning ?
m_pADAPStatus->Put( L"LastStartTime", 0L, &var, CIM_DATETIME ) :
m_pADAPStatus->Put( L"LastStopTime", 0L, &var, CIM_DATETIME ) );
}
}
if ( SUCCEEDED( hr ) )
{
hr = m_pRootDefault->PutInstance( m_pADAPStatus, 0L, NULL, NULL );
}
} // Set the Status property
} // Make sure we've got both pointers
}
Reference in a new issue Copy permalink