MachineInfo.cpp

#include "stdafx.h"
#include "MachineInfo.h"

using Microsoft::WRL::ComPtr;

namespace DX
{
    // Helper class for COM exceptions
    class com_exception : public std::exception
    {
    public:
        com_exception(HRESULT hr) noexcept : result(hr) {}

        const char* what() const override
        {
            static char s_str[64] = {};
            sprintf_s(s_str, "Failure with HRESULT of %08X", static_cast<unsigned int>(result));
            return s_str;
        }

    private:
        HRESULT result;
    };

    // Helper utility converts D3D API failures into exceptions.
    inline void ThrowIfFailed(HRESULT hr)
    {
        if (FAILED(hr))
        {
            throw com_exception(hr);
        }
    }
}

void MachineInfo::SetOSInfo() {
    double osver = 0.0;

    NTSTATUS(WINAPI * RtlGetVersion)(LPOSVERSIONINFOEXW);

    OSVERSIONINFOEXW osInfo;

    *(FARPROC*)&RtlGetVersion = GetProcAddress(GetModuleHandleA("ntdll"), "RtlGetVersion");

    if (NULL != RtlGetVersion)
    {
        osInfo.dwOSVersionInfoSize = sizeof(osInfo);
        RtlGetVersion(&osInfo);
        osver = osInfo.dwMajorVersion;
    }

    std::ostringstream stream;
    stream <<  osInfo.dwMajorVersion << "." << osInfo.dwMinorVersion  << " Build: " << osInfo.dwBuildNumber;

    OSName.append(stream.str());
    
    DEBUG_PRINT("\n")
    DEBUG_PRINT("Major Version: " + osInfo.dwMajorVersion)
    DEBUG_PRINT("Minor Version: " + osInfo.dwMinorVersion)
    DEBUG_PRINT("Build Number: " + osInfo.dwBuildNumber)
    

}

void MachineInfo::SetCPUInfo() {
    // 4 is essentially hardcoded due to the __cpuid function requirements.
    // NOTE: Results are limited to whatever the sizeof(int) * 4 is...
    std::array<int, 4> integerBuffer = {};
    constexpr size_t sizeofIntegerBuffer = sizeof(int) * integerBuffer.size();

    std::array<char, 64> charBuffer = {};

    // The information you wanna query __cpuid for.
    // https://docs.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex?view=vs-2019
    constexpr std::array<int, 3> functionIds = {
        // Manufacturer
        //  EX: "Intel(R) Core(TM"
        0x8000'0002,
        // Model
        //  EX: ") i7-8700K CPU @"
        0x8000'0003,
        // Clockspeed
        //  EX: " 3.70GHz"
        0x8000'0004
    };


    for (int id : functionIds)
    {
        __cpuid(integerBuffer.data(), id);
        std::memcpy(charBuffer.data(), integerBuffer.data(), sizeofIntegerBuffer);
        CPU += string(charBuffer.data());
    }

}

void MachineInfo::SetVideoCardInfo() {
    ComPtr<IDXGIFactory1> dxgiFactory;
    DX::ThrowIfFailed(
        CreateDXGIFactory1(IID_PPV_ARGS(dxgiFactory.ReleaseAndGetAddressOf()))
    );

    ComPtr<IDXGIAdapter1> adapter;
    for (UINT adapterIndex = 0;
        SUCCEEDED(dxgiFactory->EnumAdapters1(
            adapterIndex,
            adapter.ReleaseAndGetAddressOf()));
        adapterIndex++)
    {
        DXGI_ADAPTER_DESC1 desc;
        DX::ThrowIfFailed(adapter->GetDesc1(&desc));

        if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
        {
            // Don't select the Basic Render Driver adapter.
            continue;
        }
        
        size_t i;
        const size_t BUFFER_SIZE = 256;
        char tempStdChar[BUFFER_SIZE];
        wcstombs_s(&i, tempStdChar, (size_t)BUFFER_SIZE, desc.Description, (size_t)BUFFER_SIZE);
        Videocard = tempStdChar;
        // desc.VendorId: VID
        // desc.DeviceId: PID
        // desc.Description: name string seen above
    }
}

void MachineInfo::SetMOBOInfo() {
    std::wstring regSubKey;
    #ifdef _WIN64 // Manually switching between 32bit/64bit for the example. Use dwFlags instead.
    regSubKey = L"HARDWARE\\WOW6432Node\\DESCRIPTION\\System\\BIOS\\";
    #else
    regSubKey = L"HARDWARE\\DESCRIPTION\\System\\BIOS\\";
    #endif
    std::wstring regValue(L"BaseBoardProduct");
    std::wstring valueFromRegistry;
    try
    {
        valueFromRegistry = GetStringValueFromHKLM(regSubKey, regValue);
    }
    catch (std::exception& e)
    {
        string errorString = e.what();
        DEBUG_PRINT(errorString)
    }
    #ifdef _DEBUG
    DEBUG_PRINT("Motherboard info: ")
    OutputDebugStringW(valueFromRegistry.c_str());
    OutputDebugString("\n");
    #endif
    
    size_t i;
    const int bufferSize = 256;
    char temp[bufferSize];

    //wcstombs(temp, desc.Description, bufferSize);
    //wcstombs_s(&i, tempStdChar, (size_t)BUFFER_SIZE, desc.Description, (size_t)BUFFER_SIZE);

    wcstombs_s(&i, temp, bufferSize, valueFromRegistry.c_str(), bufferSize);

    Motherboard = temp;
}

void MachineInfo::SetMachineInfo() {
    GetSystemInfo(&siSysInfo);

    std::ostringstream stream;
    stream << "OEM ID: " << siSysInfo.dwOemId;
    
    stream << "  Number of processors: " << siSysInfo.dwNumberOfProcessors << "\n";
    stream << "  Page size: " << siSysInfo.dwPageSize << "\n";
    stream << "  Processor type: " << siSysInfo.dwProcessorType << "\n";
    stream << "  Minimum application address: " << siSysInfo.lpMinimumApplicationAddress << "\n";
    stream << "  Maximum application address: " << siSysInfo.lpMaximumApplicationAddress << "\n";
    stream << "  Active processor mask: " << siSysInfo.dwActiveProcessorMask << "\n";

    DEBUG_PRINT(stream.str())

    //CPU.append(stream.str());
}

void MachineInfo::CreateJSON() {
    //UserMachineID: UserMachineID @relation(name: "MI_HWID")
    //BenchmarkDatasets: [BenchmarkDataset!] @relation(name: "dataSetOwnerMI")
    MachineInfoJSON["UserMachineInfo"]["OperatingSystem"] = OSName;
    MachineInfoJSON["UserMachineInfo"]["CPU"] = CPU;
    MachineInfoJSON["UserMachineInfo"]["Videocard"] = Videocard;
    //Drive : String
    //Memory : String
    MachineInfoJSON["UserMachineInfo"]["Motherboard"] = Motherboard;
    //DisplayMonitor : String

}

void MachineInfo::ExportData(string path) {
    std::ofstream exportData;
    exportData.open(path + "\\MachineInfo.json");

    if (exportData.is_open()) {
        exportData << MachineInfoJSON;
        m_bDataExported = true;
    }
    else {
        DEBUG_PRINT("Error exporting machineInfo file.")
    }

    exportData.close();
}

std::wstring MachineInfo::GetStringValueFromHKLM(const std::wstring& regSubKey, const std::wstring& regValue)
{
    size_t bufferSize = 0xFFF; // If too small, will be resized down below.
    std::wstring valueBuf; // Contiguous buffer since C++11.
    valueBuf.resize(bufferSize);
    auto cbData = static_cast<DWORD>(bufferSize * sizeof(wchar_t));
    auto rc = RegGetValueW(
        HKEY_LOCAL_MACHINE,
        regSubKey.c_str(),
        regValue.c_str(),
        RRF_RT_REG_SZ,
        nullptr,
        (void*)(valueBuf.data()),
        &cbData
    );
    while (rc == ERROR_MORE_DATA)
    {
        // Get a buffer that is big enough.
        cbData /= sizeof(wchar_t);
        if (cbData > static_cast<DWORD>(bufferSize))
        {
            bufferSize = static_cast<size_t>(cbData);
        }
        else
        {
            bufferSize *= 2;
            cbData = static_cast<DWORD>(bufferSize * sizeof(wchar_t));
        }
        valueBuf.resize(bufferSize);
        rc = RegGetValueW(
            HKEY_LOCAL_MACHINE,
            regSubKey.c_str(),
            regValue.c_str(),
            RRF_RT_REG_SZ,
            nullptr,
            (void*)(valueBuf.data()),
            &cbData
        );
    }
    if (rc == ERROR_SUCCESS)
    {
        cbData /= sizeof(wchar_t);
        valueBuf.resize(static_cast<size_t>(cbData - 1)); // remove end null character
        return valueBuf;
    }
    else
    {
        throw std::runtime_error("Windows system error code: " + to_string(rc));
    }
}