|
|
/*****************************************************************************
Copyright (c) 1999 Microsoft Corporation
Module Name: .PCH_SysInfo.CPP
Abstract: WBEM provider class implementation for PCH_SysInfo class. 1. This class gets the foll. properties from Win32_OperatingSystem Class: "OSName", "Version" and sets "PCH_SysInfo.OsName" property. 2. Gets the foll. properties from Win32_Processor Class: "Manufacturer", "Description" and sets "PCH_SysInfo.Processor" property. 3. Gets the foll. properties from Win32_LogicalMemoryConfiguration Class: "TotalPhysicalMemory" and sets "PCH_SysInfo.RAM" property. 4. Gets the foll. properties from Win32_PageFile Class: "Name", "FreeSpace", "FSName" and sets PCH_SysInfo.SwapFile Property. 5. Sets the "Change" property to "Snapshot" always Revision History:
Ghim Sim Chua (gschua ) 04/27/99 - Created Kalyani Narlanka (kalyanin) 05/03/99 - Added properties
*******************************************************************************/
#include "pchealth.h"
#include "PCH_Sysinfo.h"
///////////////////////////////////////////////////////////////////////////////
// Begin Tracing stuff
//
#ifdef THIS_FILE
#undef THIS_FILE
#endif
static char __szTraceSourceFile[] = __FILE__;#define THIS_FILE __szTraceSourceFile
#define TRACE_ID DCID_SYSINFO
//
// End Tracing stuff
///////////////////////////////////////////////////////////////////////////////
CPCH_Sysinfo MyPCH_SysinfoSet (PROVIDER_NAME_PCH_SYSINFO, PCH_NAMESPACE) ;
///////////////////////////////////////////////////////////////////////////////
// Different types of Installation
#define IDS_SKU_NET "network"
#define IDS_SKU_CD_UPGRADE "CD"
#define IDS_SKU_FLOPPY_UPGRADE "Floppy"
#define IDS_SKU_FLOPPY_FULL "Full Floppy"
#define IDS_SKU_SELECT_FLOPPY "floppy"
#define IDS_SKU_SELECT_CD "Select CD"
#define IDS_SKU_OEM_DISKMAKER "OEM"
#define IDS_SKU_OEM_FLOPPY "OEM floppy"
#define IDS_SKU_OEM_CD "OEM CD"
#define IDS_SKU_MS_INTERNAL "Microsoft Internal"
#define IDS_SKU_CD_FULL "Full CD"
#define IDS_SKU_WEB "Web"
#define IDS_SKU_MSDN_CD "MSDN CD"
#define IDS_SKU_OEM_CD_FULL "Full OEM CD"
#define IDS_SKU_OEM_PREINST_KIT "OEM Preinstall Kit"
#define MAX_LEN 20
#define ONEK 1024
#define HALFK 512
//....Properties of PCHSysInfo Class
//
const static WCHAR* pOSLanguage = L"OSLanguage";const static WCHAR* pManufacturer = L"Manufacturer";const static WCHAR* pModel = L"Model";const static WCHAR* pTimeStamp = L"TimeStamp" ; const static WCHAR* pChange = L"Change" ; const static WCHAR* pIEVersion = L"IEVersion" ; const static WCHAR* pInstall = L"Install" ;const static WCHAR* pMode = L"Mode" ;const static WCHAR* pOSName = L"OSName" ;const static WCHAR* pOSVersion = L"OSVersion";const static WCHAR* pProcessor = L"Processor" ;const static WCHAR* pClockSpeed = L"ClockSpeed" ;const static WCHAR* pRAM = L"RAM" ;const static WCHAR* pSwapFile = L"SwapFile" ;const static WCHAR* pSystemID = L"SystemID" ;const static WCHAR* pUptime = L"Uptime" ;const static WCHAR* pOSBuildNumber = L"OSBuildNumber";
//*****************************************************************************
//
// Function Name : CPCH_SysInfo::EnumerateInstances
//
// Input Parameters : pMethodContext : Pointer to the MethodContext for
// communication with WinMgmt.
//
// lFlags : Long that contains the flags described
// in IWbemServices::CreateInstanceEnumAsync
// Note that the following flags are handled
// by (and filtered out by) WinMgmt:
// WBEM_FLAG_DEEP
// WBEM_FLAG_SHALLOW
// WBEM_FLAG_RETURN_IMMEDIATELY
// WBEM_FLAG_FORWARD_ONLY
// WBEM_FLAG_BIDIRECTIONAL
// Output Parameters : None
//
// Returns : WBEM_S_NO_ERROR
//
//
// Synopsis : All instances of this class on the machine are returned.
// If there are no instances returns WBEM_S_NO_ERROR.
// It is not an error to have no instances.
//
//
//*****************************************************************************
HRESULT CPCH_Sysinfo::EnumerateInstances(MethodContext* pMethodContext, long lFlags){ TraceFunctEnter("CPCH_Sysinfo::EnumerateInstances");
// Begin Declarations...................................................
//
HRESULT hRes = WBEM_S_NO_ERROR;
// Instances
CComPtr<IEnumWbemClassObject> pOperatingSystemEnumInst; CComPtr<IEnumWbemClassObject> pProcessorEnumInst; CComPtr<IEnumWbemClassObject> pLogicalMemConfigEnumInst; CComPtr<IEnumWbemClassObject> pPageFileEnumInst; CComPtr<IEnumWbemClassObject> pComputerSystemEnumInst;
// CInstance *pPCHSysInfoInstance;
// WBEM Objects
IWbemClassObjectPtr pOperatingSystemObj; // BUGBUG : WMI asserts if we use CComPtr
IWbemClassObjectPtr pProcessorObj; // BUGBUG : WMI asserts if we use CComPtr
IWbemClassObjectPtr pLogicalMemConfigObj; // BUGBUG : WMI asserts if we use CComPtr
IWbemClassObjectPtr pPageFileObj; // BUGBUG : WMI asserts if we use CComPtr
IWbemClassObjectPtr pComputerSystemObj; // BUGBUG : WMI asserts if we use CComPtr
// Variants
CComVariant varValue; CComVariant varCaption; CComVariant varVersion; CComVariant varSnapshot = "Snapshot"; CComVariant varRam; CComVariant varPhysicalMem;
// Return Values
ULONG ulOperatingSystemRetVal; ULONG ulProcessorRetVal; ULONG ulLogicalMemConfigRetVal; ULONG ulPageFileRetVal; ULONG ulComputerSystemRetVal;
LONG lRegKeyRet; LONG lSystemID;
// Query Strings
CComBSTR bstrOperatingSystemQuery = L"Select Caption, Version, Name, OSLanguage, BuildNumber FROM Win32_OperatingSystem"; CComBSTR bstrProcessorQuery = L"Select DeviceID, Name, Manufacturer, CurrentClockSpeed FROM Win32_Processor"; CComBSTR bstrLogicalMemConfigQuery = L"Select Name, TotalPhysicalMemory FROM Win32_LogicalMemoryConfiguration"; CComBSTR bstrPageFileQuery = L"Select Name, FreeSpace, FSName FROM Win32_PageFile"; CComBSTR bstrComputerSystemQuery = L"Select Name, BootupState, Manufacturer, Model FROM Win32_ComputerSystem"; CComBSTR bstrQueryString;
CComBSTR bstrProperty; CComBSTR bstrVersion = L"Version"; CComBSTR bstrCaption = L"Caption"; CComBSTR bstrManufacturer = L"Manufacturer"; CComBSTR bstrModel = L"Model"; CComBSTR bstrOSLanguage = L"OSLanguage"; CComBSTR bstrName = L"Name"; CComBSTR bstrFreeSpace = L"FreeSpace"; CComBSTR bstrFSName = L"FSName"; CComBSTR bstrBuildNumber = L"BuildNumber"; CComBSTR bstrSemiColon = L" ; "; LPCTSTR lpctstrSpaces = " "; LPCTSTR lpctstrCleanInstall = _T("Clean Install Using"); LPCTSTR lpctstrUpgradeInstall = _T("Upgrade Using");
CComBSTR bstrProcessor; CComBSTR bstrOSName; CComBSTR bstrSwapFile;
// Registry Hive where IE info is stored
LPCTSTR lpctstrIEHive = _T("Software\\Microsoft\\windows\\currentversion"); LPCTSTR lpctstrSystemIDHive = _T("Software\\Microsoft\\PCHealth\\MachineInfo");
LPCTSTR lpctstrUpgrade = _T("Upgrade"); LPCTSTR lpctstrProductType = _T("ProductType"); LPCTSTR lpctstrCommandLine = _T("CommandLine"); LPCTSTR lpctstrIEVersion = _T("Plus! VersionNumber"); LPCWSTR lpctstrVersion = L"Version"; LPCWSTR lpctstrBootupState = L"BootupState"; LPCWSTR lpctstrTotalPhysicalMemory = L"TotalPhysicalMemory"; LPCTSTR lpctstrComputerName = _T("ComputerName"); LPCTSTR lpctstrCurrentUser = _T("Current User"); LPCTSTR lpctstrMBFree = _T(" MB Free "); LPCWSTR lpctstrClockSpeed = L"CurrentClockSpeed"; LPCWSTR lpctstrCaption = L"Name"; // Format Strings
LPCTSTR lpctstrSystemIDFormat = _T("On \"%s\" as \"%s\""); LPCTSTR lpctstrOSNameFormat = _T("%s %s"); LPCTSTR lpctstrInstallFormat = _T("%s %s %s"); LPCTSTR lpctstrUptimeFormat = _T("%d:%02d:%02d:%02d");
LPCSTR lpctstrInstallHive = "Software\\Microsoft\\Windows\\CurrentVersion\\Setup"; LPCSTR lpctstrCurrentVersionHive = "Software\\Microsoft\\Windows\\CurrentVersion"; LPCSTR lpctstrControlHive = "System\\CurrentControlSet\\Control"; LPCTSTR lpctstrPID = _T("PID"); LPCTSTR lpctstrNoSystemID = _T("NoSystemID");
// Other Strings
TCHAR tchIEVersionValue[MAX_LEN];
TCHAR tchCommandLineValue[MAX_PATH]; TCHAR tchProductTypeValue[MAX_LEN]; TCHAR tchCurrentUserValue[MAX_PATH]; TCHAR tchComputerNameValue[MAX_PATH]; TCHAR tchSystemID[MAX_PATH]; TCHAR tchOSName[MAX_PATH]; TCHAR tchInstallStr[3*MAX_PATH]; TCHAR tchUptimeStr[MAX_PATH]; TCHAR tchInstall[MAX_PATH];
TCHAR tchProductType[MAX_PATH];
// Time
SYSTEMTIME stUTCTime;
// DWORD
DWORD dwSize = MAX_PATH; DWORD dwType; // Key
HKEY hkeyIEKey; HKEY hkeyInstallKey; HKEY hkeyCurrentVersionKey; HKEY hkeyComputerKey; HKEY hkeyComputerSubKey; HKEY hkeyControlKey; HKEY hkeySystemIDKey;
BYTE bUpgradeValue; int nProductTypeValue; int nStrLen; int nDays, nHours, nMins, nSecs; int nRam, nRem;
float dRam;
BOOL fCommit = FALSE; // End Declarations...................................................
// Initializations
tchIEVersionValue[0] = 0; tchCommandLineValue[0] = 0; tchProductTypeValue[0] = 0; tchProductType[0] = 0; tchCurrentUserValue[0] = 0; tchComputerNameValue[0] = 0; tchSystemID[0] = 0; tchInstallStr[0] = 0;
varValue.Clear(); varCaption.Clear(); varVersion.Clear(); //
// Get the date and time This is required for the TimeStamp field
GetSystemTime(&stUTCTime);
// Create a new instance of PCH_SysInfo Class based on the
// passed-in MethodContext
CInstancePtr pPCHSysInfoInstance(CreateNewInstance(pMethodContext), false);
// Created a New Instance of PCH_SysInfo Successfully.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// TIME STAMP //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
hRes = pPCHSysInfoInstance->SetDateTime(pTimeStamp, WBEMTime(stUTCTime)); if (FAILED(hRes)) { // Could not Set the Time Stamp
// Continue anyway
ErrorTrace(TRACE_ID, "SetDateTime on Timestamp Field failed."); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CHANGE //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
hRes = pPCHSysInfoInstance->SetVariant(pChange, varSnapshot); if (FAILED(hRes)) { // Could not Set the Change Property
// Continue anyway
ErrorTrace(TRACE_ID, "Set Variant on Change Field failed."); }
// To fix the Bug : 100158 : the system ID property should not contain any privacy info.
// In its place we generate some random number;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SYSTEMID //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The SystemID can be obtained from HKLM\SYSTEM\CURRENTCONTROLSET\CONTROL\COMPUTERNAME\COMPUTERNAME
// The username can be obtained from HKLM\SYSTEM\CURRENTCONTROLSET\CONTROL\CURRENTUSER
//
/*
lRegKeyRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpctstrControlHive, 0, KEY_READ, &hkeyControlKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the Control Key
// Open the Computer System sub key under hkeyControlKey
lRegKeyRet = RegOpenKeyEx(hkeyControlKey, lpctstrComputerName, 0, KEY_READ, &hkeyComputerKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the ComputerNameSub Key
// Open the
// Open the CompterNameSubSubKey key under ComputerNameSub Key
lRegKeyRet = RegOpenKeyEx(hkeyComputerKey, lpctstrComputerName, 0, KEY_READ, &hkeyComputerSubKey); if(lRegKeyRet == ERROR_SUCCESS) { // Read the ComputerName Value
dwSize = MAX_PATH; lRegKeyRet = RegQueryValueEx(hkeyComputerSubKey, lpctstrComputerName, NULL, &dwType, (LPBYTE)tchComputerNameValue, &dwSize); if (lRegKeyRet != ERROR_SUCCESS) { // Could not get the ComputerName
ErrorTrace(TRACE_ID, "Cannot get the ComputerName"); } // Close the ComputerName Sub Sub Key
lRegKeyRet = RegCloseKey(hkeyComputerSubKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } } // Close the ComputerName Sub Key
lRegKeyRet = RegCloseKey(hkeyComputerKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } }
// Read the CurrentUser Value
dwSize = MAX_PATH; lRegKeyRet = RegQueryValueEx(hkeyControlKey, lpctstrCurrentUser, NULL, &dwType, (LPBYTE)tchCurrentUserValue, &dwSize); if (lRegKeyRet != ERROR_SUCCESS) { // Could not get the UserName
ErrorTrace(TRACE_ID, "Cannot get the UserName"); } // Close the Control Key
lRegKeyRet = RegCloseKey(hkeyControlKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); }
// Got the ComputerName and CurrentUser, Format the string for systemID.
nStrLen = wsprintf(tchSystemID,lpctstrSystemIDFormat, tchComputerNameValue, tchCurrentUserValue);
lSystemID = long(GetTickCount()); _ltot(lSystemID, tchSystemID, 10); // Set the SystemID Property
varValue = tchSystemID; if (FAILED(pPCHSysInfoInstance->SetVariant(pSystemID, varValue))) { // Set SystemID Field Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on OSName Field failed."); } else { fCommit = TRUE; } }
*/
/*
lSystemID = long(GetTickCount()); _ltot(lSystemID, tchSystemID, 10); */
// To fix Bug 100268 , get the system ID from the Registry.
// The Registry key to read is :
// HKLM\SW\MS\PCHealth\MachineInfo\PID
lRegKeyRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpctstrSystemIDHive, 0, KEY_READ, &hkeySystemIDKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the SystemID Hive
// Read the PID Value
dwSize = MAX_PATH; lRegKeyRet = RegQueryValueEx(hkeySystemIDKey, lpctstrPID, NULL, &dwType, (LPBYTE)tchSystemID, &dwSize); if (lRegKeyRet != ERROR_SUCCESS) { _tcscpy(tchSystemID,lpctstrNoSystemID); // Could not get the PID
ErrorTrace(TRACE_ID, "Cannot get the PID"); } // Close the SystemID Key
lRegKeyRet = RegCloseKey(hkeySystemIDKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } } // Set the SystemID Property
varValue = tchSystemID; if (FAILED(pPCHSysInfoInstance->SetVariant(pSystemID, varValue))) { // Set SystemID Field Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on OSName Field failed."); } else { fCommit = TRUE; } /////////////////////////////////////////////////////////////////////////////////////////////////////////////
// OSNAME //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Execute the query to get "Caption", "Version", "Name" from Win32_OperatingSystem Class.
// Although "Name" is not required to set PCH_SysInfo.OSName property
// we need to query for it as its the "Key" property of the class.
// pOperatingSystemEnumInst contains a pointer to the list of instances returned.
//
hRes = ExecWQLQuery(&pOperatingSystemEnumInst, bstrOperatingSystemQuery); if (SUCCEEDED(hRes)) { // Query on Win32_OperatingSystem Class Succeeded
// Enumerate the instances of Win32_OperatingSystem Class
// from pOperatingSystemEnumInst.
// Get the next instance into pOperatingSystemObj object.
hRes = pOperatingSystemEnumInst->Next(WBEM_INFINITE, 1, &pOperatingSystemObj, &ulOperatingSystemRetVal); if(hRes == WBEM_S_NO_ERROR) { // Copy property "caption" to "OSName"
CopyProperty(pOperatingSystemObj, lpctstrCaption, pPCHSysInfoInstance, pOSName);
// Copy property "Version" to "Version"
CopyProperty(pOperatingSystemObj, lpctstrVersion, pPCHSysInfoInstance, pOSVersion);
// Copy property "OSLangauge" to "OSLangauge"
CopyProperty(pOperatingSystemObj, bstrOSLanguage, pPCHSysInfoInstance, pOSLanguage);
// Copy property "BuildNumber" to "BuildNumber"
CopyProperty(pOperatingSystemObj, bstrBuildNumber, pPCHSysInfoInstance, pOSBuildNumber);
} //end of if WBEM_S_NO_ERROR
} // end of if SUCCEEDED(hRes)
else { // Operating system Query did not succeed.
ErrorTrace(TRACE_ID, "Query on win32_OperatingSystem Field failed."); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// UPTIME //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Get uptime using GetTickCount()
dwSize = GetTickCount();
/* There is a bug in the server side because of the fix and so this needs to be reverted again.
// GetTickCount returns uptime in milliseconds. Divide this by 1000 to get seconds.
dwSize = dwSize/1000.0;
// To fix the bug of inconsistent time formats, change the seconds to days::hours::mins::secs.
// Get the number of days.
nDays = dwSize/(60*60*24); dwSize = dwSize%(60*60*24);
// Get the Number of hours.
nHours = dwSize/(60*60); dwSize = dwSize%(60*60);
//Get the Number of Mins.
nMins = dwSize/(60);
//Get the Number of Secs.
nSecs = dwSize%60;
nStrLen = wsprintf(tchUptimeStr,lpctstrUptimeFormat, nDays, nHours, nMins, nSecs); varValue = tchUptimeStr;
*/
// varValue = (long)dwSize;
varValue.vt = VT_I4; varValue.lVal = (long)dwSize;
// Set the UpTime Property
if (FAILED(pPCHSysInfoInstance->SetVariant(pUptime, varValue))) { // Set UpTime Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on UpTime Field failed."); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// INSTALL //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The Install info is obtained from the Registry
// Get "Upgrade" regvalue from HKLM\Software\Microsoft\Windows\CurrentVersion\Setup
// if Upgrade == 0, then it is "Clean Install" otherwise its a "Upgrade"
dwSize = MAX_PATH; lRegKeyRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpctstrInstallHive, 0, KEY_READ, &hkeyInstallKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the Install Key
// Read the upgrade Value
dwSize = 1; lRegKeyRet = RegQueryValueEx(hkeyInstallKey, lpctstrUpgrade, NULL, &dwType, &bUpgradeValue, &dwSize); if (lRegKeyRet == ERROR_SUCCESS) { // Compare Install Value with "00"
if (bUpgradeValue == 0) { // Clean Install
_tcscpy(tchInstall, lpctstrCleanInstall); } else { _tcscpy(tchInstall, lpctstrUpgradeInstall); } } // Read the CommandLine Value
dwSize = MAX_PATH; lRegKeyRet = RegQueryValueEx(hkeyInstallKey, lpctstrCommandLine, NULL, &dwType, (LPBYTE)tchCommandLineValue, &dwSize); lRegKeyRet = RegCloseKey(hkeyInstallKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } }
// Get "ProductType" regvalue from HKLM\Software\Microsoft\Windows\CurrentVersion
dwSize = MAX_PATH; lRegKeyRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpctstrCurrentVersionHive, 0, KEY_READ, &hkeyCurrentVersionKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the CurrentVersion Key
// Read the ProductType Value
lRegKeyRet = RegQueryValueEx(hkeyCurrentVersionKey, lpctstrProductType, NULL, &dwType, (LPBYTE)tchProductTypeValue, &dwSize); if (lRegKeyRet == ERROR_SUCCESS) { // Compare ProductType Value with known codes
// Convert the productType value to an int
nProductTypeValue = atoi(tchProductTypeValue);
switch(nProductTypeValue) { case 100: { _tcscpy(tchProductType, IDS_SKU_MS_INTERNAL); break; } case 101: { _tcscpy(tchProductType, IDS_SKU_CD_FULL); break; } case 102: { _tcscpy(tchProductType, IDS_SKU_CD_UPGRADE); break; } case 103: { _tcscpy(tchProductType,IDS_SKU_FLOPPY_FULL); break; } case 104: { _tcscpy(tchProductType,IDS_SKU_FLOPPY_UPGRADE); break; } case 105: { _tcscpy(tchProductType,IDS_SKU_WEB); break; } case 110: { _tcscpy(tchProductType, IDS_SKU_SELECT_CD); break; } case 111: { _tcscpy(tchProductType, IDS_SKU_MSDN_CD); break; } case 115: { _tcscpy(tchProductType, IDS_SKU_OEM_CD_FULL); break; } case 116: { _tcscpy(tchProductType,IDS_SKU_OEM_CD); break; } case 120: { _tcscpy(tchProductType, IDS_SKU_OEM_PREINST_KIT); break; } case 1: { _tcscpy(tchProductType, IDS_SKU_NET); break; } case 5: { _tcscpy(tchProductType, IDS_SKU_SELECT_FLOPPY); break; } case 7: { _tcscpy(tchProductType, IDS_SKU_OEM_DISKMAKER); break; } case 8: { _tcscpy(tchProductType, IDS_SKU_OEM_FLOPPY); break; } default: { // Cannot figure out the type of installation
} }
} // RegCloseKey(hkeyCurrentVersionKey);
lRegKeyRet = RegCloseKey(hkeyCurrentVersionKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } }
nStrLen = wsprintf(tchInstallStr,lpctstrInstallFormat, tchInstall, tchProductType, tchCommandLineValue); varValue = tchInstallStr; // Set the Install Property
if (FAILED(pPCHSysInfoInstance->SetVariant(pInstall, varValue))) { // Set Install Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on OSName Field failed."); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IEVERSION //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IE Version can be obtained from the Registry under the following hive.
// HKLM\Software\Microsoft\Windows\Current Version
// Version is available in the field "Plus!VersionNumber"
// "Internet Explorer" Key is in "hkeyIEKey"
lRegKeyRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpctstrIEHive, 0, KEY_READ, &hkeyIEKey); if(lRegKeyRet == ERROR_SUCCESS) { // Opened the Internet Explorer key.
// Read the Version Value
dwSize = MAX_PATH; lRegKeyRet = RegQueryValueEx(hkeyIEKey, lpctstrIEVersion, NULL, &dwType, (LPBYTE) tchIEVersionValue, &dwSize); if (lRegKeyRet == ERROR_SUCCESS) { try { // Got the version as a string.
// Update the IE Version Property
varValue = tchIEVersionValue; // Set the IEVersion Property
hRes = pPCHSysInfoInstance->SetVariant(pIEVersion, varValue); if (hRes == ERROR_SUCCESS) { // Set IEVersion Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on IEVersion Field failed."); } } catch(...) { lRegKeyRet = RegCloseKey(hkeyIEKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } throw; } } // end of if RegQueryValueEx == ERROR_SUCCESS
lRegKeyRet = RegCloseKey(hkeyIEKey); if(lRegKeyRet != ERROR_SUCCESS) { // Could not close the key.
ErrorTrace(TRACE_ID, "Cannot Close the Key"); } } // end of if RegOpenKeyEx == ERROR_SUCCESS
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MODE //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Execute the query to get Name, BootUpstate FROM Win32_ComputerSystem
// Class.
// pComputerSystemEnumInst contains a pointer to the instance returned.
hRes = ExecWQLQuery(&pComputerSystemEnumInst, bstrComputerSystemQuery); if (SUCCEEDED(hRes)) { // Query Succeeded!
// Get the instance Object.
if((pComputerSystemEnumInst->Next(WBEM_INFINITE, 1, &pComputerSystemObj, &ulComputerSystemRetVal)) == WBEM_S_NO_ERROR) {
// Get the BootupState
CopyProperty(pComputerSystemObj, lpctstrBootupState, pPCHSysInfoInstance, pMode);
// Get the Manufacturer
CopyProperty(pComputerSystemObj, bstrManufacturer, pPCHSysInfoInstance, pManufacturer);
// Get the Model
CopyProperty(pComputerSystemObj, bstrModel, pPCHSysInfoInstance, pModel); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PROCESSOR //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Execute the query to get "DeviceID", "Manufacturer", "Name", "CurrentClockSpeed"
// from Win32_Processor Class.
// Although "DeviceID" is not required to set PCH_SysInfo.Processor property
// we need to query for it as its the "Key" property of the class.
// pProcessorEnumInst contains a pointer to the list of instances returned.
//
hRes = ExecWQLQuery(&pProcessorEnumInst, bstrProcessorQuery); if (SUCCEEDED(hRes)) { // Query on Win32_Processor Class Succeeded
// Enumerate the instances of Win32_Processor Class
// from pProcessorEnumInst.
// Get the instance into pProcessorObj object.
if(WBEM_S_NO_ERROR == pProcessorEnumInst->Next(WBEM_INFINITE, 1, &pProcessorObj, &ulProcessorRetVal)) { //Get the Manufacturer
if (FAILED(pProcessorObj->Get(bstrManufacturer, 0, &varValue, NULL, NULL))) { // Could not get the Manufacturer
ErrorTrace(TRACE_ID, "GetVariant on Win32_Processor:Manufacturer Field failed."); } else { // Got the Manufacturer
// varValue set to Manufacturer. Copy this to bstrResult
hRes = varValue.ChangeType(VT_BSTR, NULL); if(SUCCEEDED(hRes)) { bstrProcessor.Append(V_BSTR(&varValue));
// Put some spaces before appending the string.
bstrProcessor.Append(lpctstrSpaces); }
}
// Get the Name
if (FAILED(pProcessorObj->Get(bstrName, 0, &varValue, NULL, NULL))) { // Could not get the Name
ErrorTrace(TRACE_ID, "GetVariant on Win32_Processor:Name Field failed."); } else { // Got the Name
// varValue set to Name. Append this to bstrResult
hRes = varValue.ChangeType(VT_BSTR, NULL); if(SUCCEEDED(hRes)) { bstrProcessor.Append(V_BSTR(&varValue));
// Put some spaces before appending the string.
bstrProcessor.Append(lpctstrSpaces); } }
// Set the Processor Property
varValue.vt = VT_BSTR; varValue.bstrVal = bstrProcessor.Detach(); hRes = pPCHSysInfoInstance->SetVariant(pProcessor, varValue); if (FAILED(hRes)) { // Set Processor Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on Processor Field failed."); }
// Copy Property Clock speed
CopyProperty(pProcessorObj, lpctstrClockSpeed, pPCHSysInfoInstance, pClockSpeed);
} //end of if WBEM_S_NO_ERROR
} // end of if SUCCEEDED(hRes))
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// RAM //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Execute the query to get "Name", "TotalPhysicalMemory"
// from Win32_LogicalMemoryConfiguration Class.
// Although "Name" is not required to set PCH_SysInfo.RAM property
// we need to query for it as its the "Key" property of the class.
// pLogicalMemConfigEnumInst contains a pointer to the list of instances returned.
//
hRes = ExecWQLQuery(&pLogicalMemConfigEnumInst, bstrLogicalMemConfigQuery); if (SUCCEEDED(hRes)) { // Query on Win32_LogicalMemoryConfiguration Class Succeeded
// Enumerate the instances of Win32_LogicalMemoryConfiguration Class
// from pEnumInst.
// Get the next instance into pLogicalMemConfigObj object.
//
if(WBEM_S_NO_ERROR == pLogicalMemConfigEnumInst->Next(WBEM_INFINITE, 1, &pLogicalMemConfigObj, &ulLogicalMemConfigRetVal)) { //Get the TotalPhysicalMemory
if (FAILED(pLogicalMemConfigObj->Get(lpctstrTotalPhysicalMemory, 0, &varPhysicalMem, NULL, NULL))) { // Could not get the RAM
ErrorTrace(TRACE_ID, "GetVariant on Win32_LogicalMemoryConfiguration:TotalPhysicalMemory Field failed."); } else { // Got the TotalPhysicalMemory
// varRAM set to TotalPhysicalMemory. Copy this to bstrResult
nRam = varPhysicalMem.lVal; nRem = nRam % ONEK; nRam = nRam/ONEK; if (nRem > HALFK) { nRam++; } varRam = nRam; hRes = pPCHSysInfoInstance->SetVariant(pRAM, varRam); { // Set RAM Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on RAM Field failed."); } }
} } // end of else FAILED(hRes)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SWAPFILE //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Execute the query to get "Name", "FreeSpace", "FSName"
// from Win32_PageFile.
// pPageFileEnumInst contains a pointer to the list of instances returned.
//
hRes = ExecWQLQuery(&pPageFileEnumInst, bstrPageFileQuery); if (SUCCEEDED(hRes)) { // Query on Win32_PageFile Class Succeeded
// Enumerate the instances of Win32_PageFile Class
// from pEnumInst.
// Get the next instance into pObj object.
//
// Initialize bstrResult to NULL;
if(WBEM_S_NO_ERROR == pPageFileEnumInst->Next(WBEM_INFINITE, 1, &pPageFileObj, &ulPageFileRetVal)) { //Get the Name
if (FAILED(pPageFileObj->Get(bstrName, 0, &varValue, NULL, NULL))) { // Could not get the Name
ErrorTrace(TRACE_ID, "GetVariant on Win32_PageFile:Name Field failed."); } else { // Got the Name.
// varValue set to Name. Copy this to bstrResult
hRes = varValue.ChangeType(VT_BSTR, NULL); if(SUCCEEDED(hRes)) { bstrSwapFile.Append(V_BSTR(&varValue));
// Put some spaces in between the two strings.
bstrSwapFile.Append(lpctstrSpaces); } }
// Get the FreeSpace
if (FAILED(pPageFileObj->Get(bstrFreeSpace, 0, &varValue, NULL, NULL))) { // Could not get the FreeSpace
ErrorTrace(TRACE_ID, "GetVariant on Win32_PageFile:FreeSpace Field failed."); } else { // Got the FreeSpace
// varValue set to FreeSpace. Append this to bstrResult
hRes = varValue.ChangeType(VT_BSTR, NULL); if(SUCCEEDED(hRes)) { bstrSwapFile.Append(V_BSTR(&varValue));
// Put some spaces in between the two strings.
bstrSwapFile.Append(lpctstrSpaces);
bstrSwapFile.Append(lpctstrMBFree);
} }
// Get the FSName
if (FAILED(pPageFileObj->Get(bstrFSName, 0, &varValue, NULL, NULL))) { // Could not get the FSName
ErrorTrace(TRACE_ID, "GetVariant on Win32_PageFile:FSName Field failed."); } else { // Got the FSName
// varValue set to FSName. Append this to bstrResult
hRes = varValue.ChangeType(VT_BSTR, NULL); if(SUCCEEDED(hRes)) { bstrSwapFile.Append(V_BSTR(&varValue)); } }
// Set the SwapFile Property
// varValue = bstrSwapFile;
varValue.vt = VT_BSTR; varValue.bstrVal = bstrSwapFile.Detach();
hRes = pPCHSysInfoInstance->SetVariant(pSwapFile, varValue); { // Set SwapFile Failed.
// Proceed anyway
ErrorTrace(TRACE_ID, "SetVariant on SwapFile Field failed."); } } //end of if WBEM_S_NO_ERROR
} // end of else FAILED(hRes)
// All the properties are set.
if(fCommit) { hRes = pPCHSysInfoInstance->Commit(); if (FAILED(hRes)) { ErrorTrace(TRACE_ID, "Commit on Instance failed."); } } TraceFunctLeave(); return hRes ;}
|
