/***************************************************************************** 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 pOperatingSystemEnumInst; CComPtr pProcessorEnumInst; CComPtr pLogicalMemConfigEnumInst; CComPtr pPageFileEnumInst; CComPtr 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 ; }