windows/sysinfo.cpp

Go to the documentation of this file.

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
 
#include <Wbemidl.h>
#include <cstdio>
#define _WIN32_DCOM
#include <comdef.h>
 
 
#include <stdexcept>
#include <string>
#include <vector>
 
#include <kiplatform/sysinfo.h>
 
#include <algorithm>
#include <sstream>
#include <vector>
 
#include <wx/string.h>
#include <wx/msw/registry.h>
 
#include "d3d9.h"
#include "dxgi.h"
 
 
namespace KIPLATFORM
{
namespace
{
 /*
 * Helper functions from https://stackoverflow.com/questions/6284524/bstr-to-stdstring-stdwstring-and-vice-versa
 * Licensed CC BY-SA 3.0
 */
 std::string ConvertWCSToMBS( const wchar_t* pstr, long wslen )
 {
 int len = ::WideCharToMultiByte( CP_ACP, 0, pstr, wslen, NULL, 0, NULL, NULL );
 
 std::string dblstr( len, '\0' );
 len = ::WideCharToMultiByte( CP_ACP, 0 /* no flags */, pstr,
 wslen /* not necessary NULL-terminated */, &dblstr[0], len, NULL,
 NULL /* no default char */ );
 
 return dblstr;
 }
 
 
 std::string ConvertBSTRToMBS( BSTR bstr )
 {
 int wslen = ::SysStringLen( bstr );
 return ConvertWCSToMBS( (wchar_t*) bstr, wslen );
 }
 
 
 BSTR ConvertMBSToBSTR( const std::string& str )
 {
 int wsLen = ::MultiByteToWideChar( CP_ACP, 0 /* no flags */, str.data(), str.length(), NULL,
 0 );
 
 BSTR wsData = ::SysAllocStringLen( NULL, wsLen );
 if( ::MultiByteToWideChar( CP_ACP, 0 /* no flags */,
 str.data(),
 str.length(),
 wsData,
 wsLen ) == 0 )
 {
 // conversion failure
 ::SysFreeString( wsData );
 wsData = NULL;
 }
 
 return wsData;
 }
}
 
 
SYSINFO::SYSINFO()
{
 openWmi();
}
 
 
SYSINFO::~SYSINFO()
{
 freeWmi();
}
 
 
HRESULT SYSINFO::openWmi()
{
 HRESULT hres;
 
 // We assume wxwidgets is handling calling of CoInitializeEx and CoInitializeSecurity
 hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator,
 (LPVOID*) &m_pLoc );
 
 if( FAILED( hres ) )
 {
 throw std::runtime_error( "Failed to create IWbemLocator object." );
 return hres;
 }
 
 // Connect to the root\cimv2 namespace with
 // the current user and obtain pointer pSvc
 // to make IWbemServices calls.
 hres = m_pLoc->ConnectServer( ConvertMBSToBSTR( "ROOT\\CIMV2" ), // Object path of WMI namespace
 NULL, // User name. NULL = current user
 NULL, // User password. NULL = current
 0, // Locale. NULL indicates current
 0, // Security flags.
 0, // Authority (for example, Kerberos)
 0, // Context object
 &m_pSvc // pointer to IWbemServices proxy
 );
 
 if( FAILED( hres ) )
 {
 m_pLoc->Release();
 throw std::runtime_error( "Could not connect to root\\cimv2." );
 return hres;
 }
 
 hres = CoSetProxyBlanket( m_pSvc, // Indicates the proxy to set
 RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
 RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
 NULL, // Server principal name
 RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
 RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
 NULL, // client identity
 EOAC_NONE // proxy capabilities
 );
 
 if( FAILED( hres ) )
 {
 m_pSvc->Release();
 m_pLoc->Release();
 throw std::runtime_error( "Could not set proxy blanket." );
 return hres;
 }
 
 return hres;
}
 
 
HRESULT SYSINFO::freeWmi()
{
 HRESULT hres = 0;
 
 if( m_pSvc != nullptr )
 {
 hres = m_pSvc->Release();
 }
 
 if( m_pLoc != nullptr )
 {
 hres = m_pLoc->Release();
 }
 
 if( m_pEnumerator != nullptr )
 {
 hres = m_pEnumerator->Release();
 }
 
 return hres;
}
 
 
std::string SYSINFO::improveDriverVersion( const std::string& aManufacturer,
 const std::string& aVersion )
{
 if( aManufacturer.find( "NVIDIA" ) != std::string::npos
 || aManufacturer.find( "Nvidia" ) != std::string::npos )
 {
 std::istringstream versionStream( aVersion );
 std::string s;
 std::vector<std::string> versionBits;
 while( getline( versionStream, s, '.' ) )
 {
 versionBits.push_back( s );
 }
 
 if( versionBits.size() == 4 )
 {
 unsigned int numChars2 = versionBits[2].length();
 unsigned int numChars3 = versionBits[2].length();
 if( numChars2 >= 1 && numChars3 >= 2 )
 {
 if( numChars3 < 4 )
 {
 versionBits[3].insert( 0, ( 4 - versionBits[3].size() ), '0' );
 numChars3 = 4;
 }
 }
 
 std::string major1 = versionBits[2].substr( numChars2 - 1, numChars2 - 1 );
 std::string major2 = versionBits[3].substr( 0, 1 );
 std::string major = major1 + major2;
 std::string minor = versionBits[3].substr( 2, numChars3 - 1 );
 
 
 return major + "." + minor;
 }
 }
 
 return aVersion;
}
 
 
bool SYSINFO::GetMemoryInfo( MEMORY_INFO& aMemoryInfo )
{
 MEMORYSTATUSEX statex;
 
 statex.dwLength = sizeof( statex );
 
 if( GlobalMemoryStatusEx( &statex ) != 0 )
 {
 aMemoryInfo.Usage = statex.dwMemoryLoad;
 aMemoryInfo.TotalPhysical = statex.ullTotalPhys;
 aMemoryInfo.FreePhysical = statex.ullAvailPhys;
 aMemoryInfo.TotalPaging = statex.ullTotalPageFile;
 aMemoryInfo.FreePaging = statex.ullAvailPageFile;
 aMemoryInfo.TotalVirtual = statex.ullTotalVirtual;
 aMemoryInfo.FreeVirtual = statex.ullAvailVirtual;
 
 return true;
 }
 
 return false;
}
 
 
bool SYSINFO::GetCPUInfo( std::vector<CPU_INFO>& aCpuInfos )
{
 HRESULT hres;
 DWORD returned = 0;
 
 IWbemClassObject* processors[2];
 hres = m_pSvc->ExecQuery(
 ConvertMBSToBSTR( "WQL" ), ConvertMBSToBSTR( "SELECT * FROM Win32_Processor" ),
 WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 0, &m_pEnumerator );
 
 if( SUCCEEDED( hres ) )
 {
 hres = m_pEnumerator->Next( WBEM_INFINITE, 2, processors, &returned );
 if( FAILED( hres ) || returned == 0 )
 {
 return false;
 }
 }
 
 VARIANT var;
 VariantInit( &var );
 
 std::string chRetValue = "";
 for( UINT ctrlIndex = 0; ctrlIndex < returned; ctrlIndex++ )
 {
 IWbemClassObject* processor = processors[ctrlIndex];
 
 CPU_INFO cpuInfo;
 hres = processor->Get( ConvertMBSToBSTR( "Name" ), 0, &var, NULL, NULL );
 if( SUCCEEDED( hres ) )
 {
 variantToString( &var, chRetValue );
 cpuInfo.Name = chRetValue;
 
 VariantClear( &var );
 processor->Get( ConvertMBSToBSTR( "Manufacturer" ), 0, &var, NULL, NULL );
 variantToString( &var, chRetValue );
 cpuInfo.Manufacturer = chRetValue;
 
 VariantClear( &var );
 processor->Get( ConvertMBSToBSTR( "NumberOfCores" ), 0, &var, NULL, NULL );
 variantToString( &var, chRetValue );
 long long cores = atoll( chRetValue.c_str() );
 cpuInfo.NumberCores = cores;
 
 VariantClear( &var );
 processor->Get( ConvertMBSToBSTR( "NumberOfLogicalProcessors" ), 0, &var, NULL, NULL );
 variantToString( &var, chRetValue );
 long long logical = atoll( chRetValue.c_str() );
 cpuInfo.NumberLogical = logical;
 
 
 aCpuInfos.push_back( cpuInfo );
 }
 
 VariantClear( &var );
 }
 
 
 return true;
}
 
 
bool SYSINFO::getVersionFromDXRegistry( int64_t aAdapterLuid, std::string& aDriverVersion )
{
 wxString baseKeyName = "SOFTWARE\\Microsoft\\DirectX";
 wxRegKey key( wxRegKey::HKLM, baseKeyName );
 HKEY tmpKey;
 
 if( key.HasSubkeys() )
 {
 wxString adapterGuid;
 long index = 0;
 for( bool cont = key.GetFirstKey( adapterGuid, index ); cont;
 cont = key.GetNextKey( adapterGuid, index ) )
 {
 wxString subKeyName = baseKeyName + "\\" + adapterGuid;
 
 LSTATUS status;
 status = ::RegOpenKeyEx(
 (HKEY) HKEY_LOCAL_MACHINE, subKeyName.t_str(), 0, KEY_READ, &tmpKey );
 
 ULONGLONG adapterLuid;
 DWORD dwType, dwSize = sizeof(ULONGLONG);
 status = ::RegQueryValueEx((HKEY)tmpKey, L"AdapterLuid",
 0,
 &dwType, (LPBYTE)&adapterLuid, &dwSize);
 
 if (status != ERROR_SUCCESS)
 {
 ::RegCloseKey(tmpKey);
 continue;
 }
 
 //access error, target ended up weirdly the wrong type
 if ( dwType != REG_QWORD_LITTLE_ENDIAN && dwType != REG_QWORD ) {
 ::RegCloseKey(tmpKey);
 continue;
 }
 
 if (adapterLuid != aAdapterLuid)
 {
 ::RegCloseKey(tmpKey);
 continue;
 }
 
 ULONGLONG driverVersion;
 status = ::RegQueryValueEx((HKEY)tmpKey, L"DriverVersion",
 0,
 &dwType, (LPBYTE)&driverVersion, &dwSize);
 
 if (status != ERROR_SUCCESS)
 {
 ::RegCloseKey(tmpKey);
 continue;
 }
 
 //access error, target ended up weirdly the wrong type
 if ( dwType != REG_QWORD_LITTLE_ENDIAN && dwType != REG_QWORD ) {
 ::RegCloseKey(tmpKey);
 continue;
 }
 
 std::stringstream fmt;
 fmt << ( ( driverVersion >> 48 ) & 0xFFFF ) << "."
 << ( ( driverVersion >> 32 ) & 0xFFFF ) << "."
 << std::to_string( ( driverVersion >> 16 ) & 0xFFFF ) << "."
 << std::to_string( driverVersion & 0xFFFF );
 aDriverVersion = fmt.str();
 
 ::RegCloseKey(tmpKey);
 return true;
 }
 }
 
 return false;
}
 
 
bool SYSINFO::gpuFromDirectX( std::vector<GPU_INFO>& aGpuInfos )
{
 typedef HRESULT( WINAPI * LPCREATEDXGIFACTORY )( REFIID, void** );
 LPCREATEDXGIFACTORY pCreateDXGIFactory = NULL;
 HMODULE hDXGI = NULL;
 
 hDXGI = LoadLibrary( L"dxgi.dll" );
 //
 if( NULL == hDXGI )
 {
 return false;
 }
 
 IID iid_IDXGIFactory;
 
 //to avoid having to link dxgi.dll, we also hardcode the guid of the interface
 IIDFromString( L"{7b7166ec-21c7-44ae-b21a-c9ae321ae369}", &iid_IDXGIFactory );
 
 IDXGIAdapter* pAdapter = NULL;
 pCreateDXGIFactory = (LPCREATEDXGIFACTORY) GetProcAddress( hDXGI, "CreateDXGIFactory" );
 if( pCreateDXGIFactory )
 {
 IDXGIFactory* pDXGIFactory;
 HRESULT hr = pCreateDXGIFactory( iid_IDXGIFactory, (void**) &pDXGIFactory );
 if( SUCCEEDED( hr ) )
 {
 UINT adapter = 0;
 while( pDXGIFactory->EnumAdapters( adapter, &pAdapter ) != DXGI_ERROR_NOT_FOUND )
 {
 DXGI_ADAPTER_DESC desc;
 hr = pAdapter->GetDesc( &desc );
 if( SUCCEEDED( hr ) )
 {
 // Microsoft Basic Render Driver that will always show up
 if( desc.VendorId == 5140 && desc.DeviceId == 140 )
 {
 adapter++;
 continue;
 }
 GPU_INFO gpuInfo;
 
 char descriptionBuffer[260];
 char defaultChar = ' ';
 WideCharToMultiByte( CP_ACP, 0, desc.Description, -1, descriptionBuffer,
 sizeof( descriptionBuffer ), &defaultChar, NULL );
 
 gpuInfo.Name = descriptionBuffer;
 // Names are generally formatted with Manu<space>Model
 gpuInfo.Manufacturer = gpuInfo.Name.substr( 0, gpuInfo.Name.find( " " ) );
 ;
 gpuInfo.MemorySize = desc.DedicatedVideoMemory;
 
 int64_t luid = ( ( (int64_t) desc.AdapterLuid.HighPart ) << 32 )
 | desc.AdapterLuid.LowPart;
 
 if( getVersionFromDXRegistry( luid, gpuInfo.DriverVersion ) )
 {
 improveDriverVersion( gpuInfo.Manufacturer, gpuInfo.DriverVersion );
 }
 
 aGpuInfos.push_back( gpuInfo );
 }
 
 adapter++;
 }
 
 pDXGIFactory->Release();
 }
 }
 
 FreeLibrary( hDXGI );
 
 return true;
}
 
 
bool SYSINFO::GetGPUInfo( std::vector<GPU_INFO>& aGpuInfos )
{
 if (gpuFromDirectX(aGpuInfos))
 {
 return true;
 }
 
 return false;
}
 
 
void SYSINFO::variantToString( const LPVARIANT aVar, std::string& aReturnString ) const
{
 HRESULT hr;
 char returnBuffer[256];
 
 switch( aVar->vt )
 {
 case VT_BSTR:
 {
 aReturnString = ConvertBSTRToMBS( aVar->bstrVal );
 }
 break;
 case VT_BOOL:
 {
 if( VARIANT_TRUE == aVar->boolVal )
 aReturnString = "true";
 else
 aReturnString = "false";
 }
 break;
 case VT_I4:
 {
 sprintf_s( returnBuffer, sizeof( returnBuffer ) - 1, "%u", aVar->uintVal );
 
 aReturnString = returnBuffer;
 }
 break;
 case VT_UI1:
 {
 sprintf_s( returnBuffer, sizeof( returnBuffer ) - 1, "%u", aVar->uintVal );
 aReturnString = returnBuffer;
 }
 break;
 case VT_UI4:
 {
 sprintf_s( returnBuffer, sizeof( returnBuffer ) - 1, "%u", aVar->uintVal );
 aReturnString = returnBuffer;
 }
 break;
 case VT_BSTR | VT_ARRAY:
 {
 VARIANT* raw;
 hr = SafeArrayAccessData( aVar->parray, (void**) &raw );
 
 const _bstr_t bstr( raw[0] );
 hr = SafeArrayUnaccessData( aVar->parray );
 
 aReturnString = ConvertBSTRToMBS( bstr );
 }
 break;
 case VT_I4 | VT_ARRAY:
 {
 BYTE HUGEP* pBuf;
 LONG low, high;
 SafeArrayGetLBound( aVar->parray, 1, &low );
 SafeArrayGetUBound( aVar->parray, 1, &high );
 
 hr = SafeArrayAccessData( aVar->parray, (void HUGEP**) &pBuf );
 hr = SafeArrayUnaccessData( aVar->parray );
 std::string strTmp;
 high = std::min( high, (long) MAX_PATH * 2 - 1 );
 for( LONG i = low; i <= high; ++i )
 {
 sprintf_s( returnBuffer, sizeof( returnBuffer ) - 1, "%02X", pBuf[i] );
 aReturnString += returnBuffer;
 }
 }
 break;
 default: break;
 }
}
 
} // namespace KIPLATFORM