WMI 获取操作系统名称和版本

SysInfo.cpp

#pragma once
#include <string>
#include <iostream>
#include <windows.h>
#include <iphlpapi.h>
#include <comdef.h>
#include <Wbemidl.h>
#include <math.h>

class SysInfo
{
public:
    SysInfo();
    virtual ~SysInfo();

    bool init_wmi();
    void uninit_wmi();


    double get_memory_size();
    std::string get_os_name();
    std::string get_host_name();
    int get_file_flag(std::string file_name);
    std::string get_area(std::string ip);
    std::string wstring_to_string(wchar_t* data);


protected:
private:
    bool m_init_wmi = false;

    IWbemServices *pSvc = NULL;
    IWbemLocator *pLoc = NULL;

    HRESULT hres = NULL;
};

Sysinfo.cpp

#include "SysInfo.h"



#pragma comment(lib, "wbemuuid.lib")

#pragma comment(lib, "iphlpapi.lib")

#pragma warning(disable: 4996) // avoid GetVersionEx to be warned


#define  GBYTES  1073741824
#define  MBYTES  1048576
#define  KBYTES  1024
#define  DKBYTES 1024.0

SysInfo::SysInfo()
{
    m_init_wmi = init_wmi();
}

SysInfo::~SysInfo()
{
    uninit_wmi();
}

bool SysInfo::init_wmi()
{

    hres = CoInitializeEx(0, COINIT_MULTITHREADED);
    if (FAILED(hres))
    {
        return false;
    }

    hres = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
    if (FAILED(hres))
    {
        CoUninitialize();
        return false;
    }


    hres = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *)&pLoc);
    if (FAILED(hres))
    {
        CoUninitialize();
        return false;
    }


    hres = pLoc->ConnectServer(_bstr_t(L"ROOT\\CIMV2"), NULL, NULL, 0, NULL, 0, 0, &pSvc);
    if (FAILED(hres))
    {
        pLoc->Release();
        CoUninitialize();
        return false;
    }

    hres = CoSetProxyBlanket(pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);
    if (FAILED(hres))
    {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return false;
    }
    return true;
}

void SysInfo::uninit_wmi()
{

    pSvc->Release();
    pLoc->Release();
    CoUninitialize();
}


//Win32_PhysicalMemory

double SysInfo::get_memory_size()
{

    double mem_size = 0;

    IEnumWbemClassObject* pEnumerator = NULL;
    hres = pSvc->ExecQuery(bstr_t("WQL"), bstr_t("SELECT * FROM Win32_PhysicalMemory")
        , WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator);
    if (FAILED(hres))
    {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return -1;
    }

    IWbemClassObject *pclsObj = NULL;
    ULONG uReturn = 0;
    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
        if (0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;
        hr = pclsObj->Get(L"Capacity", 0, &vtProp, 0, 0);



        std::string data = wstring_to_string(vtProp.bstrVal);

        mem_size += ::atof(data.c_str());
        VariantClear(&vtProp);
        pclsObj->Release();
    }
    pEnumerator->Release();

    double mem_total = mem_size / 1024 / 1024 / 1024;

    return floor(mem_total * 100) / 100;
}



std::string SysInfo::get_os_name()
{
    std::string res_data;
    IEnumWbemClassObject* pEnumerator = NULL;
    hres = pSvc->ExecQuery(bstr_t("WQL"), bstr_t("SELECT * FROM win32_operatingsystem")
        , WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator);
    if (FAILED(hres))
    {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return res_data;
    }

    IWbemClassObject *pclsObj = NULL;
    ULONG uReturn = 0;
    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
        if (0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;
        hr = pclsObj->Get(L"name", 0, &vtProp, 0, 0);
        std::string data = wstring_to_string(vtProp.bstrVal);
        data = data.substr(0, data.find('\|'));

        hr = pclsObj->Get(L"Version", 0, &vtProp, 0, 0);
        res_data = wstring_to_string(vtProp.bstrVal);
        std::string temp = "[";
        temp += res_data;
        temp += "] ";
        temp += data;
        res_data = temp;
        //printf("%s\n", data.c_str());

        VariantClear(&vtProp);
        pclsObj->Release();
    }
    pEnumerator->Release();

    return res_data;

}




std::string SysInfo::get_host_name()
{
    std::string host_name;

    char buf[MAX_PATH] = { 0 };
    DWORD length = MAX_PATH;
    if (::GetComputerNameA(buf, &length)) {
        host_name = buf;
    }
    return host_name;
}


int SysInfo::get_file_flag(std::string file_name)
{
    return 0;
}

std::string SysInfo::get_area(std::string ip)
{
    std::string area;

    return area;
}

std::string SysInfo::wstring_to_string(wchar_t* data)
{
    std::string res_data;
    int iSize;
    char* pszMultiByte;
    iSize = WideCharToMultiByte(CP_ACP, 0, data, -1, NULL, 0, NULL, NULL);
    char* pCapacity = (char*)malloc(iSize * sizeof(char));
    pCapacity[0] = 0;
    WideCharToMultiByte(CP_ACP, 0, data, -1, pCapacity, iSize, NULL, NULL);
    res_data = pCapacity;
    free(pCapacity);
    return res_data;
}