// ********************************************************************************* // // Copyright (c) Microsoft Corporation // // Module Name: // // SystemInfo.cpp // // Abstract: // // This module displays the system information of local / remote system. // // Author: // // Sunil G.V.N. Murali (murali.sunil@wipro.com) 27-Dec-2000 // // Revision History: // // Sunil G.V.N. Murali (murali.sunil@wipro.com) 27-Dec-2000 : Created It. // // ********************************************************************************* #include "pch.h" #include "wmi.h" #include "SystemInfo.h" // // private function prototype(s) // BOOL TranslateLocaleCode( CHString& strLocale ); BOOL FormatNumber( LPCWSTR strValue, CHString& strFmtValue ); BOOL FormatNumberEx( LPCWSTR pwszValue, CHString& strFmtValue ); VOID PrintProgressMsg( HANDLE hOutput, LPCWSTR pwszMsg, const CONSOLE_SCREEN_BUFFER_INFO& csbi ); DWORD __cdecl wmain( IN DWORD argc, IN LPCTSTR argv[] ) /*++ // Routine Description: // This the entry point to this utility. // // Arguments: // [ in ] argc : argument(s) count specified at the command prompt // [ in ] argv : argument(s) specified at the command prompt // // Return Value: // The below are actually not return values but are the exit values // returned to the OS by this application // 0 : utility is successfull // 1 : utility failed --*/ { // local variables CSystemInfo sysinfo; BOOL bResult = FALSE; // initialize the systeminfo utility if ( sysinfo.Initialize() == FALSE ) { ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); EXIT_PROCESS( 1 ); } // now do parse the command line options if ( sysinfo.ProcessOptions( argc, argv ) == FALSE ) { ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); EXIT_PROCESS( 1 ); } // check whether usage has to be displayed or not if ( sysinfo.m_bUsage == TRUE ) { // show the usage of the utility sysinfo.ShowUsage(); // quit from the utility EXIT_PROCESS( 0 ); } // connect to the WMI bResult = sysinfo.Connect(); if ( bResult == FALSE ) { // show the error message ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); EXIT_PROCESS( 1 ); } // load the data if ( sysinfo.LoadData() == FALSE ) { // show the error message ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); EXIT_PROCESS( 1 ); } #ifdef _FAST_LIST // NOTE: for list for output will be shown while loading itself. // so show the output incase of table and csv formats only if ( (sysinfo.m_dwFormat & SR_FORMAT_MASK) != SR_FORMAT_LIST ) #endif // show the system configuration information sysinfo.ShowOutput(); // exit from the program EXIT_PROCESS( 0 ); } BOOL CSystemInfo::Connect() /*++ // Routine Description: // Connects to WMI // // Arguments: // None // // Return Value: // TRUE on success // FALSE oni failure --*/ { // local variables BOOL bResult = FALSE; BOOL bLocalSystem = FALSE; // connect to WMI bResult = ConnectWmiEx( m_pWbemLocator, &m_pWbemServices, m_strServer, m_strUserName, m_strPassword, &m_pAuthIdentity, m_bNeedPassword, WMI_NAMESPACE_CIMV2, &bLocalSystem ); // check the result of connection if ( bResult == FALSE ) { return FALSE; } // check the local credentials and if need display warning if ( GetLastError() == WBEM_E_LOCAL_CREDENTIALS ) { WMISaveError( WBEM_E_LOCAL_CREDENTIALS ); ShowLastErrorEx( stderr, SLE_TYPE_WARNING | SLE_INTERNAL ); // get the new screen co-ordinates if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } // check the remote system version and its compatiblity if ( bLocalSystem == FALSE ) { DWORD dwVersion = 0; dwVersion = GetTargetVersionEx( m_pWbemServices, m_pAuthIdentity ); if ( IsCompatibleOperatingSystem( dwVersion ) == FALSE ) { SetReason( ERROR_REMOTE_INCOMPATIBLE ); return FALSE; } } // return the result return bResult; } BOOL CSystemInfo::LoadData() /*++ // Routine Description: // Loads the system data // // Arguments: // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables BOOL bResult = FALSE; // // load os information bResult = LoadOSInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // Host Name, OS Name, OS Version, OS Manufacturer // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_HOSTNAME, CI_OS_MANUFACTURER ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // // load computer information bResult = LoadComputerInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // OS Configuration, OS Build Type, Registered Owner, // Registered Organization, Product ID, Original Install Date // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_OS_CONFIG, CI_INSTALL_DATE ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // // load systemuptime information from perf data bResult = LoadPerformanceInfo(); if ( bResult == FALSE ) { // return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // System Up Time, System Manufacturer, System Model, System type // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_SYSTEM_UPTIME, CI_SYSTEM_TYPE ); if ( m_hOutput != NULL ) GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } #endif // // load processor information bResult = LoadProcessorInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // Processor(s) // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_PROCESSOR, CI_PROCESSOR ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // // load bios information bResult = LoadBiosInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // BIOS Version, Windows Directory, System Directory, Boot Device, System Locale // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_BIOS_VERSION, CI_SYSTEM_LOCALE ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // // load input locale information from keyboard class bResult = LoadKeyboardInfo(); if ( bResult == FALSE ) { return FALSE; } // // load timezone information bResult = LoadTimeZoneInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // Input Locale, Time Zone, Total Physical Memory, Available Physical Memory, // Virtual Memory: Max Size, Virtual Memory: Available, Virtual Memory: In Use // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_INPUT_LOCALE, CI_VIRTUAL_MEMORY_INUSE ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // load the logon server information bResult = LoadProfileInfo(); if ( bResult == FALSE ) { return FALSE; } // // load pagefile information bResult = LoadPageFileInfo(); if ( bResult == FALSE ) { return FALSE; } // // load hotfix information from quick fix engineering class bResult = LoadHotfixInfo(); if ( bResult == FALSE ) { return FALSE; } // // load n/w card information from network adapter class bResult = LoadNetworkCardInfo(); if ( bResult == FALSE ) { return FALSE; } #ifdef _FAST_LIST // *********************************************** // show the paritial output .. only in list format // *********************************************** // Columns Shown here: // Page File Location(s), Domain, Logon Server, Hotfix(s), NetWork Card(s) // *********************************************** if ( (m_dwFormat & SR_FORMAT_MASK) == SR_FORMAT_LIST ) { // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); ShowOutput( CI_PAGEFILE_LOCATION, CI_NETWORK_CARD ); if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } } #endif // erase the last status message PrintProgressMsg( m_hOutput, NULL, m_csbi ); // return return TRUE; } BOOL CSystemInfo::LoadOSInfo() /*++ // Routine Description: // Loads OS information // // Arguments: None // // Return Value: // TRUE on success // FALSE on failure --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; CHString strInstallDate; CHString strVirtualMemoryInUse; // totalvirtualmemorysize - freevirtualmemory IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; // property values CHString strHostName; // csname CHString strName; // caption CHString strVersion; // version CHString strServicePack; // csdversion CHString strBuildNumber; // buildnumber CHString strManufacturer; // manufacturer CHString strBuildType; // buildtype CHString strOwner; // registereduser CHString strOrganization; // organization CHString strSerialNumber; // serialnumber CHString strWindowsDir; // windowsdirectory CHString strSystemDir; // systemdirectory CHString strBootDevice; // bootdevice CHString strFreePhysicalMemory; // freephysicalmemory CHString strTotalVirtualMemory; // totalvirtualmemorysize CHString strFreeVirtualMemory; // freevirtualmemory CHString strLocale; // locale SYSTEMTIME systimeInstallDate; // installdate // display the status message PrintProgressMsg( m_hOutput, MSG_OSINFO, m_csbi ); try { // enumerate the instances of Win32_OperatingSystem class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_OPERATINGSYSTEM ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_CAPTION, strName ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_CSNAME, strHostName ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_VERSION, strVersion ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_CSDVERSION, strServicePack ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_BUILDNUMBER, strBuildNumber ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_MANUFACTURER, strManufacturer ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_BUILDTYPE, strBuildType ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_REGUSER, strOwner ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_ORGANIZATION, strOrganization ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_SERIALNUMBER, strSerialNumber ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_WINDOWSDIR, strWindowsDir ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_SYSTEMDIR, strSystemDir ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_BOOTDEVICE, strBootDevice ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_LOCALE, strLocale ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_FREEPHYSICALMEMORY, strFreePhysicalMemory ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_TOTALVIRTUALMEMORY, strTotalVirtualMemory ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_FREEVIRTUALMEMORY, strFreeVirtualMemory ); PropertyGet( pWbemObject, WIN32_OPERATINGSYSTEM_P_INSTALLDATE, systimeInstallDate ); // relase the interfaces SAFE_RELEASE( pWbemEnum ); SAFE_RELEASE( pWbemObject ); // // do the needed formatting the information obtained // // convert the system locale into appropriate code TranslateLocaleCode( strLocale ); // // format the version info try { // sub-local variable CHString str; // attach the service pack info str = strVersion; if ( strServicePack.IsEmpty() == FALSE ) { str.Format( L"%s %s", strVersion, strServicePack ); } // attach the build number strVersion.Format( FMT_OSVERSION, str, strBuildNumber ); } catch( ... ) { SetLastError((DWORD) E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // // get the formatted date and time { // sub-local variables LCID lcid; CHString strTime; CHString strDate; BOOL bLocaleChanged = FALSE; // verify whether console supports the current locale 100% or not lcid = GetSupportedUserLocale( &bLocaleChanged ); // get the formatted date try { // get the size of buffer that is needed DWORD dwCount = 0; dwCount = GetDateFormat( lcid, 0, &systimeInstallDate, ((bLocaleChanged == TRUE) ? L"MM/dd/yyyy" : NULL), NULL, 0 ); // get the required buffer LPWSTR pwszTemp = NULL; pwszTemp = strDate.GetBufferSetLength( dwCount + 1 ); // now format the date GetDateFormat( lcid, 0, &systimeInstallDate, ((bLocaleChanged == TRUE) ? L"MM/dd/yyyy" : NULL), pwszTemp, dwCount ); // release the buffer strDate.ReleaseBuffer(); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // get the formatted time try { // get the size of buffer that is needed DWORD dwCount = 0; dwCount = GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systimeInstallDate, ((bLocaleChanged == TRUE) ? L"HH:mm:ss" : NULL), NULL, 0 ); // get the required buffer LPWSTR pwszTemp = NULL; pwszTemp = strTime.GetBufferSetLength( dwCount + 1 ); // now format the date GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systimeInstallDate, ((bLocaleChanged == TRUE) ? L"HH:mm:ss" : NULL), pwszTemp, dwCount ); // release the buffer strTime.ReleaseBuffer(); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // prepare the try { // prepare the datetime strInstallDate.Format( L"%s, %s", strDate, strTime ); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } } // format the numeric data try { // sub-local variables CHString str; WCHAR wszBuffer[ 33 ] = L"\0"; // // first determine the virtual memory in use ULONGLONG ullAvailablePhysicalMemory = 0; ULONGLONG ullTotal = 0; ULONGLONG ullFree = 0; ULONGLONG ullInUse = 0; ullFree = (ULONGLONG) ( ((( float ) _wtoi64( strFreeVirtualMemory )) / 1024.0f) + 0.5f ); ullTotal = (ULONGLONG) ( ((( float ) _wtoi64( strTotalVirtualMemory )) / 1024.0f) + 0.5f ); ullAvailablePhysicalMemory = (ULONGLONG) ( ((( float ) _wtoi64( strFreePhysicalMemory )) / 1024.0f) + 0.5f ); ullInUse = ullTotal - ullFree; // // format the virtual memory in use _ui64tow( ullInUse, wszBuffer, 10 ); // convert the ulonglong value into string if ( FormatNumberEx( wszBuffer, str ) == FALSE ) { return FALSE; } // ... strVirtualMemoryInUse.Format( FMT_MEGABYTES, str ); // // format the available physical memory _ui64tow( ullAvailablePhysicalMemory, wszBuffer, 10 ); // convert the ulonglong value into string if ( FormatNumberEx( wszBuffer, str ) == FALSE ) return FALSE; // ... strFreePhysicalMemory.Format( FMT_MEGABYTES, str ); // // format the virtual memory max. _ui64tow( ullTotal, wszBuffer, 10 ); // convert the ulonglong value into string if ( FormatNumberEx( wszBuffer, str ) == FALSE ) return FALSE; // ... strTotalVirtualMemory.Format( FMT_MEGABYTES, str ); // // format the virtual memory free _ui64tow( ullFree, wszBuffer, 10 ); // convert the ulonglong value into string if ( FormatNumberEx( wszBuffer, str ) == FALSE ) { return FALSE; } // ... strFreeVirtualMemory.Format( FMT_MEGABYTES, str ); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // // save the info in dynamic array DynArraySetString2( m_arrData, 0, CI_HOSTNAME, strHostName, 0 ); DynArraySetString2( m_arrData, 0, CI_OS_NAME, strName, 0 ); DynArraySetString2( m_arrData, 0, CI_OS_VERSION, strVersion, 0 ); DynArraySetString2( m_arrData, 0, CI_OS_MANUFACTURER, strManufacturer, 0 ); DynArraySetString2( m_arrData, 0, CI_OS_BUILDTYPE, strBuildType, 0 ); DynArraySetString2( m_arrData, 0, CI_REG_OWNER, strOwner, 0 ); DynArraySetString2( m_arrData, 0, CI_REG_ORG, strOrganization, 0 ); DynArraySetString2( m_arrData, 0, CI_PRODUCT_ID, strSerialNumber, 0 ); DynArraySetString2( m_arrData, 0, CI_INSTALL_DATE, strInstallDate, 0 ); DynArraySetString2( m_arrData, 0, CI_WINDOWS_DIRECTORY, strWindowsDir, 0 ); DynArraySetString2( m_arrData, 0, CI_SYSTEM_DIRECTORY, strSystemDir, 0 ); DynArraySetString2( m_arrData, 0, CI_BOOT_DEVICE, strBootDevice, 0 ); DynArraySetString2( m_arrData, 0, CI_SYSTEM_LOCALE, strLocale, 0 ); DynArraySetString2( m_arrData, 0, CI_AVAILABLE_PHYSICAL_MEMORY, strFreePhysicalMemory, 0 ); DynArraySetString2( m_arrData, 0, CI_VIRTUAL_MEMORY_MAX, strTotalVirtualMemory, 0 ); DynArraySetString2( m_arrData, 0, CI_VIRTUAL_MEMORY_AVAILABLE, strFreeVirtualMemory, 0 ); DynArraySetString2( m_arrData, 0, CI_VIRTUAL_MEMORY_INUSE, strVirtualMemoryInUse, 0 ); // return success return TRUE; } BOOL CSystemInfo::LoadComputerInfo() /*++ // Routine Description: // Loads computer information // // Arguments: // None // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; CHString strDomainRole; CHString strTotalPhysicalMemory; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; // property values CHString strModel; DWORD dwDomainRole; CHString strDomain; CHString strSystemType; CHString strManufacturer; ULONGLONG ullTotalPhysicalMemory; // display the status message PrintProgressMsg( m_hOutput, MSG_COMPINFO, m_csbi ); try { // enumerate the instances of Win32_ComputerSystem class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_COMPUTERSYSTEM ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_MODEL, strModel ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_DOMAIN, strDomain ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_USERNAME, m_strLogonUser ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_DOMAINROLE, dwDomainRole ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_SYSTEMTYPE, strSystemType ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_MANUFACTURER, strManufacturer ); PropertyGet( pWbemObject, WIN32_COMPUTERSYSTEM_P_TOTALPHYSICALMEMORY, ullTotalPhysicalMemory ); // relase the interfaces SAFE_RELEASE( pWbemEnum ); SAFE_RELEASE( pWbemObject ); // // do the needed formatting the information obtained // // convert the total physical memory from KB into MB try { // NOTE: // ---- // The max. value of // (2 ^ 64) - 1 = "18,446,744,073,709,600,000 K" (29 chars). // = "18,014,398,509,482,031 M" (22 chars). // // so, the buffer size to store the number is fixed as 32 characters // which is more than the 29 characters in actuals // sub-local variables CHString str; WCHAR wszBuffer[ 33 ] = L"\0"; // convert the value first ( take care of rounding ) ullTotalPhysicalMemory = (ULONGLONG) (( ((float) ullTotalPhysicalMemory) / (1024.0f * 1024.0f)) + 0.5f); // now ULONGLONG to string _ui64tow( ullTotalPhysicalMemory, wszBuffer, 10 ); // get the formatted number if ( FormatNumberEx( wszBuffer, str ) == FALSE ) return FALSE; // ... strTotalPhysicalMemory.Format( FMT_MEGABYTES, str ); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // map the domain role from numeric value to appropriate text value try { // // Mapping information of Win32_ComputerSystem's DomainRole property // NOTE: Refer to the _DSROLE_MACHINE_ROLE enumeration values in DsRole.h header file switch( dwDomainRole ) { case DsRole_RoleStandaloneWorkstation: strDomainRole = VALUE_STANDALONEWORKSTATION; break; case DsRole_RoleMemberWorkstation: strDomainRole = VALUE_MEMBERWORKSTATION; break; case DsRole_RoleStandaloneServer: strDomainRole = VALUE_STANDALONESERVER; break; case DsRole_RoleMemberServer: strDomainRole = VALUE_MEMBERSERVER; break; case DsRole_RoleBackupDomainController: strDomainRole = VALUE_BACKUPDOMAINCONTROLLER; break; case DsRole_RolePrimaryDomainController: strDomainRole = VALUE_PRIMARYDOMAINCONTROLLER; break; } } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // // save the info in dynamic array DynArraySetString2( m_arrData, 0, CI_DOMAIN, strDomain, 0 ); DynArraySetString2( m_arrData, 0, CI_SYSTEM_MODEL, strModel, 0 ); DynArraySetString2( m_arrData, 0, CI_OS_CONFIG, strDomainRole, 0 ); DynArraySetString2( m_arrData, 0, CI_SYSTEM_TYPE, strSystemType, 0 ); DynArraySetString2( m_arrData, 0, CI_SYSTEM_MANUFACTURER, strManufacturer, 0 ); DynArraySetString2( m_arrData, 0, CI_TOTAL_PHYSICAL_MEMORY, strTotalPhysicalMemory, 0 ); // return success return TRUE; } BOOL CSystemInfo::LoadBiosInfo() /*++ // Routine Description: // Loads BIOS information // // Arguments: // None // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; // property values CHString strVersion; // display the status message PrintProgressMsg( m_hOutput, MSG_BIOSINFO, m_csbi ); try { // enumerate the instances of Win32_BIOS class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_BIOS ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_BIOS_P_VERSION, strVersion ); // relase the interfaces SAFE_RELEASE( pWbemEnum ); SAFE_RELEASE( pWbemObject ); // // save the info in dynamic array DynArraySetString2( m_arrData, 0, CI_BIOS_VERSION, strVersion, 0 ); // return success return TRUE; } BOOL CSystemInfo::LoadTimeZoneInfo() /*++ // Routine Description: // Loads time-zone information // // Arguments: None // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; // property values CHString strCaption; // display the status message PrintProgressMsg( m_hOutput, MSG_TZINFO, m_csbi ); try { // enumerate the instances of Win32_TimeZone class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_TIMEZONE ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_TIMEZONE_P_CAPTION, strCaption ); // relase the interfaces SAFE_RELEASE( pWbemEnum ); SAFE_RELEASE( pWbemObject ); // // save the info in dynamic array DynArraySetString2( m_arrData, 0, CI_TIME_ZONE, strCaption, 0 ); // return success return TRUE; } BOOL CSystemInfo::LoadPageFileInfo() /*++ // Routine Description: // Loads page file information // // Arguments: none // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; TARRAY arrValues = NULL; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; BOOL bNoBreak = TRUE; // property values CHString strCaption; // display the status message PrintProgressMsg( m_hOutput, MSG_PAGEFILEINFO, m_csbi ); try { // enumerate the instances of Win32_PageFile class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_PAGEFILE ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. do { hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( hr == (HRESULT) WBEM_S_FALSE ) { bNoBreak = FALSE; // we've reached the end of enumeration .. go out of the loop break; } else if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_PAGEFILE_P_NAME, strCaption ); // release the current object SAFE_RELEASE( pWbemObject ); // add the values to the data if ( arrValues == NULL ) { arrValues = DynArrayItem2( m_arrData, 0, CI_PAGEFILE_LOCATION ); if ( arrValues == NULL ) { SetLastError((DWORD) E_UNEXPECTED ); SaveLastError(); SAFE_RELEASE( pWbemEnum ); return FALSE; } // remove all the existing entries DynArrayRemoveAll( arrValues ); } // add the data DynArrayAppendString( arrValues, strCaption, 0 ); } while ( TRUE == bNoBreak ); // release the enumerated object SAFE_RELEASE( pWbemEnum ); // return return TRUE; } BOOL CSystemInfo::LoadProcessorInfo() /*++ // Routine Description: // Loads processor information // // Arguments:none // // Return Value: // FALSE on failure // TRUE on success --*/ { // local variables HRESULT hr; CHString str; DWORD dwCount = 0; ULONG ulReturned = 0; TARRAY arrValues = NULL; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; BOOL bNoBreak = TRUE; // property values DWORD dwClockSpeed; CHString strCaption; CHString strManufacturer; // display the status message PrintProgressMsg( m_hOutput, MSG_PROCESSORINFO, m_csbi ); try { // enumerate the instances of Win32_Processor class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_PROCESSOR ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information try { do { hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( hr == (HRESULT) WBEM_S_FALSE ) { bNoBreak = FALSE; // we've reached the end of enumeration .. go out of the loop break; } else if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // update the counter dwCount++; // get the propert information PropertyGet( pWbemObject, WIN32_PROCESSOR_P_CAPTION, strCaption ); PropertyGet( pWbemObject, WIN32_PROCESSOR_P_MANUFACTURER, strManufacturer ); PropertyGet( pWbemObject, WIN32_PROCESSOR_P_CURRENTCLOCKSPEED, dwClockSpeed ); // check whether we got the clock speed correctly or not // if not, get the max. clock speed if ( dwClockSpeed == 0 ) PropertyGet( pWbemObject, WIN32_PROCESSOR_P_MAXCLOCKSPEED, dwClockSpeed ); // release the current object SAFE_RELEASE( pWbemObject ); // add the values to the data if ( arrValues == NULL ) { arrValues = DynArrayItem2( m_arrData, 0, CI_PROCESSOR ); if ( arrValues == NULL ) { SetLastError( (DWORD)E_UNEXPECTED ); SaveLastError(); SAFE_RELEASE( pWbemEnum ); return FALSE; } // remove all the existing entries DynArrayRemoveAll( arrValues ); } // // prepare the processor info str.Format( FMT_PROCESSOR_INFO, dwCount, strCaption, strManufacturer, dwClockSpeed ); // add the data DynArrayAppendString( arrValues, str, 0 ); } while ( TRUE == bNoBreak ); // release the enumerated object SAFE_RELEASE( pWbemEnum ); // update the total no. of processors info if ( arrValues != NULL ) { // NOTE: this should appear at the first line str.Format( FMT_PROCESSOR_TOTAL, dwCount ); DynArrayInsertString( arrValues, 0, str, 0 ); } } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // return return TRUE; } BOOL CSystemInfo::LoadKeyboardInfo() /*++ // Routine Description: // Loads keyboard information // // Arguments: none // // Return Value: // FALSE on failure // TRUE on success --*/ { // local variables HRESULT hr; ULONG ulReturned = 0; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; // property values CHString strLayout; // display the status message PrintProgressMsg( m_hOutput, MSG_INPUTLOCALEINFO, m_csbi ); try { // enumerate the instances of Win32_Keyboard class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_KEYBOARD ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the propert information PropertyGet( pWbemObject, WIN32_KEYBOARD_P_LAYOUT, strLayout ); // relase the interfaces SAFE_RELEASE( pWbemEnum ); SAFE_RELEASE( pWbemObject ); // convert the code page into appropriate text TranslateLocaleCode( strLayout ); // // save the info in dynamic array DynArraySetString2( m_arrData, 0, CI_INPUT_LOCALE, strLayout, 0 ); // return return TRUE; } BOOL CSystemInfo::LoadHotfixInfo() /*++ // Routine Description: // Loads hot fix information // // Arguments: None // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; CHString str; DWORD dwCount = 0; ULONG ulReturned = 0; TARRAY arrValues = NULL; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; BOOL bNoBreak = TRUE; // property values CHString strHotFix; CHString strComments; // display the status message PrintProgressMsg( m_hOutput, MSG_HOTFIXINFO, m_csbi ); try { // enumerate the instances of Win32_QuickFixEngineering class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_QUICKFIXENGINEERING ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information try { do { hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( hr == (HRESULT) WBEM_S_FALSE ) { bNoBreak = FALSE; // we've reached the end of enumeration .. go out of the loop break; } else if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // update the counter dwCount++; // get the propert information PropertyGet( pWbemObject, WIN32_QUICKFIXENGINEERING_P_HOTFIXID, strHotFix ); PropertyGet( pWbemObject, WIN32_QUICKFIXENGINEERING_P_FIXCOMMENTS, strComments ); // release the current object SAFE_RELEASE( pWbemObject ); // add the values to the data if ( arrValues == NULL ) { arrValues = DynArrayItem2( m_arrData, 0, CI_HOTFIX ); if ( arrValues == NULL ) { SetLastError( (DWORD)E_UNEXPECTED ); SaveLastError(); SAFE_RELEASE( pWbemEnum ); return FALSE; } // remove all the existing entries DynArrayRemoveAll( arrValues ); } // check if fix comments were available or not // if available, append that to the the hot fix number if ( strComments.GetLength() != 0 ) strHotFix += L" - " + strComments; // prepare the hot fix info str.Format( FMT_HOTFIX_INFO, dwCount, strHotFix ); // add the data DynArrayAppendString( arrValues, str, 0 ); } while ( TRUE == bNoBreak ); // release the enumerated object SAFE_RELEASE( pWbemEnum ); // update the total no. of hotfix's info if ( arrValues != NULL ) { // NOTE: this should appear at the first line str.Format( FMT_HOTFIX_TOTAL, dwCount ); DynArrayInsertString( arrValues, 0, str, 0 ); } } catch( ... ) { SetLastError((DWORD) E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // return return TRUE; } BOOL CSystemInfo::LoadPerformanceInfo() /*++ // Routine Description: // Loads performance information // // Arguments: None // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; CHString strUpTime; ULONG ulReturned = 0; ULONGLONG ullSysUpTime = 0; ULONGLONG ullElapsedTime = 0; ULONGLONG ullFrequencyObject = 0; ULONGLONG ullTimestampObject = 0; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; DWORD dwDays = 0, dwHours = 0, dwMinutes = 0, dwSeconds = 0; // display the status message PrintProgressMsg( m_hOutput, MSG_PERFINFO, m_csbi ); try { // enumerate the instances of Win32_PerfRawData_PerfOS_System class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_PERFRAWDATA_PERFOS_SYSTEM ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information // NOTE: This needs to be traversed only one time. hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the performance information PropertyGet( pWbemObject, WIN32_PERFRAWDATA_PERFOS_SYSTEM_P_SYSUPTIME, ullSysUpTime ); PropertyGet( pWbemObject, WIN32_PERFRAWDATA_PERFOS_SYSTEM_P_TIMESTAMP, ullTimestampObject ); PropertyGet( pWbemObject, WIN32_PERFRAWDATA_PERFOS_SYSTEM_P_FREQUENCY, ullFrequencyObject ); // release the interfaces SAFE_RELEASE( pWbemObject ); SAFE_RELEASE( pWbemEnum ); // ( performance_time_object - system_up_time ) / frequency_object = elapsed_time // NOTE: take care of divide by zero errors. if ( ullFrequencyObject == 0 ) { SetLastError( (DWORD)STG_E_UNKNOWN ); SaveLastError(); return FALSE; } // ... ullElapsedTime = ( ullTimestampObject - ullSysUpTime ) / ullFrequencyObject; // // in calculations currently assuming as differences will not cross 2 ^ 32 value // // no. of days = elapsed_time / 86400 // update with elapsed_time %= 86400 dwDays = (DWORD) (ullElapsedTime / 86400); ullElapsedTime %= 86400; // no. of hours = elapsed_time / 3600 // update with elapsed_time %= 3600 dwHours = (DWORD) (ullElapsedTime / 3600); ullElapsedTime %= 3600; // no. of minutes = elapsed_time / 60 // no. of seconds = elapsed_time % 60 dwMinutes = (DWORD) (ullElapsedTime / 60); dwSeconds = (DWORD) (ullElapsedTime % 60); try { // now prepare the system up time information strUpTime.Format( FMT_UPTIME, dwDays, dwHours, dwMinutes, dwSeconds ); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // save the info DynArraySetString2( m_arrData, 0, CI_SYSTEM_UPTIME, strUpTime, 0 ); // return return TRUE; } BOOL CSystemInfo::LoadNetworkCardInfo() /*++ // Routine Description: // Loads network card information // // Arguments: none // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables HRESULT hr; CHString str; DWORD dwCount = 0; DWORD dwNicCount = 0; DWORD dwStatus = 0; BOOL bResult = FALSE; ULONG ulReturned = 0; TARRAY arrValues = NULL; IWbemClassObject* pWbemObject = NULL; IEnumWbemClassObject* pWbemEnum = NULL; BOOL bNoBreak = TRUE; // property values DWORD dwIndex = 0; CHString strConnection; CHString strDescription; // display the status message PrintProgressMsg( m_hOutput, MSG_NICINFO, m_csbi ); try { // enumerate the instances of Win32_NetworkAdapter class hr = m_pWbemServices->CreateInstanceEnum( _bstr_t( WIN32_NETWORKADAPTER ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemEnum ); // check the result of enumeration if ( FAILED( hr ) ) { WMISaveError( hr ); return FALSE; } } catch( _com_error& e ) { WMISaveError( e ); return FALSE; } // set the security on the obtained interface hr = SetInterfaceSecurity( pWbemEnum, m_pAuthIdentity ); if ( FAILED( hr ) ) { WMISaveError( hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the enumerated objects information try { do { hr = pWbemEnum->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ); if ( hr == (HRESULT) WBEM_S_FALSE ) { bNoBreak = FALSE; // we've reached the end of enumeration .. go out of the loop break; } else if ( FAILED( hr ) ) { // some error has occured ... oooppps WMISaveError( (DWORD) hr ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // get the property information // NOTE: get the result of getting status property information PropertyGet( pWbemObject, WIN32_NETWORKADAPTER_P_INDEX, dwIndex ); PropertyGet( pWbemObject, WIN32_NETWORKADAPTER_P_DESCRIPTION, strDescription ); PropertyGet( pWbemObject, WIN32_NETWORKADAPTER_P_NETCONNECTIONID, strConnection ); bResult = PropertyGet( pWbemObject, WIN32_NETWORKADAPTER_P_STATUS, dwStatus, 0 ); // release the current object SAFE_RELEASE( pWbemObject ); // add the values to the data // NOTE: do this only if either we couldn't find the property or status is not -1 // FOR WINDOWS 2000 MACHINES 'NetConnectionStatus' PROPERT IS NOT EXISTED IN // WMI 'Win32_NetworkAdapter' CLASS. SO WE WILL BE DISPLAYING THE N/W CARD // INFORMATION IF PROPERTY DOESN'T EXIST OR IF EXISTS AND THE STATUS IS NOT -1 if ( bResult == FALSE || dwStatus != 0 ) { // update the counter dwCount++; if ( arrValues == NULL ) { arrValues = DynArrayItem2( m_arrData, 0, CI_NETWORK_CARD ); if ( arrValues == NULL ) { SetLastError( (DWORD)E_UNEXPECTED ); SaveLastError(); SAFE_RELEASE( pWbemEnum ); return FALSE; } // remove all the existing entries DynArrayRemoveAll( arrValues ); } // prepare the n/w card info str.Format( FMT_NIC_INFO, dwCount, strDescription ); // add the data DynArrayAppendString( arrValues, str, 0 ); // now check the status in detail ... only if the property exists if ( bResult == TRUE ) { // // property do exists ... so determine the status // display the status of the NIC except it is connected // if the NIC is connected, display the ipaddress and its other information // add the connection name str.Format( FMT_CONNECTION, strConnection ); DynArrayAppendString( arrValues, str, 0 ); // ... if ( dwStatus != 2 ) { // sub-local variables CHString strValues[] = { VALUE_DISCONNECTED, VALUE_CONNECTING, VALUE_CONNECTED, VALUE_DISCONNECTING, VALUE_HWNOTPRESENT, VALUE_HWDISABLED, VALUE_HWMALFUNCTION, VALUE_MEDIADISCONNECTED, VALUE_AUTHENTICATING, VALUE_AUTHSUCCEEDED, VALUE_AUTHFAILED }; // prepare the status info if ( dwStatus > 0 && dwStatus < SIZE_OF_ARRAY( strValues ) ) { // ... str.Format( FMT_NIC_STATUS, strValues[ dwStatus ] ); // save the info DynArrayAppendString( arrValues, str, 0 ); } } else { // // get the adapter configuration // sub-local variables CHString strTemp; CHString strDhcpServer; DWORD dwDhcpEnabled = 0; TARRAY arrIPAddress = NULL; // create the ipaddress array arrIPAddress = CreateDynamicArray(); if ( arrIPAddress == NULL ) { WMISaveError( E_OUTOFMEMORY ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // prepare the object path str.Format( WIN32_NETWORKADAPTERCONFIGURATION_GET, dwIndex ); // get the nic config info object hr = m_pWbemServices->GetObject( _bstr_t( str ), WBEM_FLAG_RETURN_WBEM_COMPLETE, NULL, &pWbemObject, NULL ); // check the result .. proceed furthur only if successfull if ( SUCCEEDED( hr ) ) { // get the needed property values PropertyGet( pWbemObject, WIN32_NETWORKADAPTERCONFIGURATION_P_IPADDRESS, arrIPAddress ); PropertyGet( pWbemObject, WIN32_NETWORKADAPTERCONFIGURATION_P_DHCPSERVER, strDhcpServer ); PropertyGet( pWbemObject, WIN32_NETWORKADAPTERCONFIGURATION_P_DHCPENABLED, dwDhcpEnabled ); // check and add the dhcp information // NOTE: CIM_BOOLEAN -> TRUE = -1, FALSE = 0 strTemp = FMT_DHCP_STATUS; str.Format( strTemp, ( ( dwDhcpEnabled == -1 ) ? VALUE_YES : VALUE_NO ) ); DynArrayAppendString( arrValues, str, 0 ); // add the dhcp server info ( if needed ) if ( dwDhcpEnabled == -1 ) { str.Format( FMT_DHCP_SERVER, strDhcpServer ); DynArrayAppendString( arrValues, str, 0 ); } // // add the IP Address information DynArrayAppendString( arrValues, FMT_IPADDRESS_TOTAL, 0 ); dwNicCount = DynArrayGetCount( arrIPAddress ); for( DWORD dw = 0; dw < dwNicCount; dw++ ) { // get the info LPCWSTR pwsz = NULL; pwsz = DynArrayItemAsString( arrIPAddress, dw ); if ( pwsz == NULL ) continue; // prepare and add the info str.Format( FMT_IPADDRESS_INFO, dw + 1, pwsz ); DynArrayAppendString( arrValues, str, 0 ); } } // release the object SAFE_RELEASE( pWbemObject ); // destroy the dynamic array created for storing ip address info DestroyDynamicArray( &arrIPAddress ); } } } } while ( TRUE == bNoBreak ); // release the enumerated object SAFE_RELEASE( pWbemEnum ); // update the total no. of hotfix's info if ( arrValues != NULL ) { // NOTE: this should appear at the first line str.Format( FMT_NIC_TOTAL, dwCount ); DynArrayInsertString( arrValues, 0, str, 0 ); } } catch( ... ) { WMISaveError( (DWORD)E_OUTOFMEMORY ); SAFE_RELEASE( pWbemObject ); SAFE_RELEASE( pWbemEnum ); return FALSE; } // return success return TRUE; } BOOL CSystemInfo::LoadProfileInfo() /*++ // Routine Description: // Loads profile information // // Arguments:none // // Return Value: // FALSE on failure // TRUE on success // --*/ { // local variables BOOL bResult = FALSE; CHString strLogonServer; LPCWSTR pwszPassword = NULL; IWbemServices* pDefaultNamespace = NULL; // display the status message PrintProgressMsg( m_hOutput, MSG_PROFILEINFO, m_csbi ); // determine the password with which connection to default name has to be made pwszPassword = NULL; if ( m_pAuthIdentity != NULL ) { pwszPassword = m_pAuthIdentity->Password; } // we need to establish connection to the remote system's registry // for this connect to the default namespace of the WMI using the credentials available with us bResult = ConnectWmi( m_pWbemLocator, &pDefaultNamespace, m_strServer, m_strUserName, pwszPassword, &m_pAuthIdentity, FALSE, WMI_NAMESPACE_DEFAULT ); if ( bResult == FALSE ) { return FALSE; } // get the value of the LOGONSERVER RegQueryValueWMI( pDefaultNamespace, WMI_HKEY_CURRENT_USER, SUBKEY_VOLATILE_ENVIRONMENT, KEY_LOGONSERVER, strLogonServer ); // release the interface SAFE_RELEASE( pDefaultNamespace ); // // save the info DynArraySetString2( m_arrData, 0, CI_LOGON_SERVER, strLogonServer, 0 ); // return return TRUE; } VOID PrintProgressMsg( IN HANDLE hOutput, IN LPCWSTR pwszMsg, IN const CONSOLE_SCREEN_BUFFER_INFO& csbi ) /*++ // Routine Description: // Prints the message on console // // Arguments: // [in] hOutput : output handle // [in] pwszMsg : Message to be printed // [in] csbi : console screen buffer structure // // // Return Value: none // --*/ { // local variables COORD coord; DWORD dwSize = 0; WCHAR wszSpaces[ 80 ] = L""; // check the handle. if it is null, it means that output is being redirected. so return if ( hOutput == NULL ) { return; } // set the cursor position coord.X = 0; coord.Y = csbi.dwCursorPosition.Y; // first erase contents on the current line SecureZeroMemory( wszSpaces, SIZE_OF_ARRAY(wszSpaces) ); SetConsoleCursorPosition( hOutput, coord ); WriteConsoleW( hOutput, Replicate( wszSpaces, L" ", 79, 79 ), 79, &dwSize, NULL ); // now display the message ( if exists ) SetConsoleCursorPosition( hOutput, coord ); if ( pwszMsg != NULL ) { WriteConsoleW( hOutput, pwszMsg, StringLength( pwszMsg, 0 ), &dwSize, NULL ); } } BOOL TranslateLocaleCode( CHString& strLocale ) /*++ // Routine Description: // Translates locale code // // Arguments: // [in] strLocale : locale // // Return Value: // TRUE on success // FALSE on failure // --*/ { // local variables CHString str; HKEY hKey = NULL; DWORD dwSize = 0; LONG lRegReturn = 0; HKEY hMainKey = NULL; WCHAR wszValue[ 64 ] = L"\0"; // // THIS IS A TYPICAL THING WHICH WE ARE DOING HERE // BECAUSE WE DONT KNOW WHAT LANGUAGE TARGET MACHINE IS USING // SO WE GET THE LOCALE CODE PAGE BEING USED BY THE TARGET MACHINE // AND GET THE APPROPRIATE NAME FOR THAT LOCALE FROM THE CURRENT SYSTEM // REGISTRY DATABASE. IF THE REGISTRY IS CORRUPTED THEN THERE IS NO WAY // TO JUDGE THE OUTPUT THAT DISPLAYED BY THIS UTILITY IS VALID OR INVALID // try { // get the reference to the promary hive lRegReturn = RegConnectRegistry( NULL, HKEY_CLASSES_ROOT, &hMainKey ); if ( lRegReturn != ERROR_SUCCESS ) { SaveLastError(); return FALSE; } else if ( hMainKey == NULL ) { // THIS IS MEANING LESS IN DOING // BUT JUST TO AVOID PREfix BUG THIS PART IS WRITTEN SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // now get the reference to the database path lRegReturn = RegOpenKeyEx( hMainKey, LOCALE_PATH, 0, KEY_QUERY_VALUE, &hKey); if ( lRegReturn != ERROR_SUCCESS ) { switch( lRegReturn ) { case ERROR_FILE_NOT_FOUND: SetLastError( ERROR_REGISTRY_CORRUPT ); break; default: // save the error information and return FAILURE SetLastError( lRegReturn ); break; } // close the key and return SaveLastError(); RegCloseKey( hMainKey ); return FALSE; } else if ( hKey == NULL ) { // THIS IS MEANING LESS IN DOING // BUT JUST TO AVOID PREfix BUG THIS PART IS WRITTEN SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // we are interested in the last 4 characters of the code page info str = strLocale.Right( 4 ); //copy the last four charecters in to the string to get the locale dwSize = SIZE_OF_ARRAY( wszValue ); lRegReturn = RegQueryValueExW( hKey, str, NULL, NULL, ( LPBYTE ) wszValue, &dwSize); // first close the registry handles if ( NULL != hKey ) { RegCloseKey( hKey ); } if ( NULL != hMainKey ) { RegCloseKey( hMainKey ); } // now check the return value if( lRegReturn != ERROR_SUCCESS ) return FALSE; // save the value strLocale = wszValue; } catch( ... ) { WMISaveError( E_OUTOFMEMORY ); // release the registry handles if ( NULL != hKey ) { RegCloseKey( hKey ); hKey = NULL; } if ( NULL != hMainKey ) { RegCloseKey( hMainKey ); hMainKey = NULL; } return FALSE; } // return return TRUE; } BOOL FormatNumber( IN LPCWSTR pwszValue, IN CHString& strFmtValue ) /*++ // Routine Description: // // Arguments: // [in] pwszValue : value // [in] strFmtValue : format value // // Return Value: // TRUE on success // FALSE on failure // --*/ { try { // get the size of buffer that is needed DWORD dwCount = 0; if( NULL == pwszValue ) { SetLastError( ERROR_INVALID_PARAMETER ); SaveLastError(); return FALSE; } dwCount = GetNumberFormat( LOCALE_USER_DEFAULT, 0, pwszValue, NULL, L"", 0 ); // get the required buffer LPWSTR pwszTemp = NULL; pwszTemp = strFmtValue.GetBufferSetLength( dwCount + 1 ); // now format the date dwCount = GetNumberFormat( LOCALE_USER_DEFAULT, 0, pwszValue, NULL, pwszTemp, dwCount ); if( 0 == dwCount ) { SaveLastError(); return FALSE; } // release the buffer strFmtValue.ReleaseBuffer(); } catch( ... ) { SetLastError((DWORD) E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // return return TRUE; } BOOL FormatNumberEx( IN LPCWSTR pwszValue, OUT CHString& strFmtValue ) /*++ // Routine Description: // Formats the number // // Arguments: // [in] pwszValue: Value string // [in] strFmtValue : format value // // Return Value: // TRUE on success // FALSE on failure // --*/ { // local variables CHString str; LONG lTemp = 0; NUMBERFMTW nfmtw; DWORD dwGroupSep = 0; LPWSTR pwszTemp = NULL; CHString strGroupThousSep; try { // // get the group seperator character lTemp = GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_SGROUPING, NULL, 0 ); if ( lTemp == 0 ) { // we don't know how to resolve this return FALSE; } else { // get the group seperation character pwszTemp = str.GetBufferSetLength( lTemp + 2 ); SecureZeroMemory( pwszTemp, ( lTemp + 2 ) * sizeof( WCHAR ) ); GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_SGROUPING, pwszTemp, lTemp ); // change the group info into appropriate number lTemp = 0; dwGroupSep = 0; while ( lTemp < str.GetLength() ) { if ( AsLong( str.Mid( lTemp, 1 ), 10 ) != 0 ) dwGroupSep = dwGroupSep * 10 + AsLong( str.Mid( lTemp, 1 ), 10 ); // increment by 2 lTemp += 2; } } // // get the thousand seperator character lTemp = GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, NULL, 0 ); if ( lTemp == 0 ) { // we don't know how to resolve this return FALSE; } else { // get the thousand sepeartion charactor pwszTemp = strGroupThousSep.GetBufferSetLength( lTemp + 2 ); SecureZeroMemory( pwszTemp, ( lTemp + 2 ) * sizeof( WCHAR ) ); GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, pwszTemp, lTemp ); } // release the CHStrig buffers str.ReleaseBuffer(); strGroupThousSep.ReleaseBuffer(); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // format the number try { nfmtw.NumDigits = 0; nfmtw.LeadingZero = 0; nfmtw.NegativeOrder = 0; nfmtw.Grouping = dwGroupSep; nfmtw.lpDecimalSep = L""; nfmtw.lpThousandSep = strGroupThousSep.GetBuffer( strGroupThousSep.GetLength() ); // get the size of buffer that is needed lTemp = GetNumberFormatW( LOCALE_USER_DEFAULT, 0, pwszValue, &nfmtw, NULL, 0 ); // get/allocate the required buffer pwszTemp = strFmtValue.GetBufferSetLength( lTemp + 1 ); // now format the date GetNumberFormat( LOCALE_USER_DEFAULT, 0, pwszValue, &nfmtw, pwszTemp, lTemp ); // release the buffer strFmtValue.ReleaseBuffer(); } catch( ... ) { SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); return FALSE; } // return return TRUE; }