[C++\Wmi] Get MOTHERBOARD\GPU\CPU

[Крайслер]

Получаем "модели" материнской платы, процессора и видеокарты используя сервис Wmi

WinType.h

#pragma once
#ifndef _WINTYPE_H__
#define _WINTYPE_H__



#include <string>
#include <conio.h>
#include <iostream>
#include <comdef.h>

 

#include <Wbemidl.h>
#pragma comment(lib, "wbemuuid.lib")


//template <typename T> void RELEASE(T* &p){p->Release();p = nullptr;}
#define   _DELETE(lpUnk)      if ((lpUnk) != nullptr) { delete lpUnk;     lpUnk = nullptr;  }
#define  _RELEASE(lpUnk)      if ((lpUnk) != nullptr) { lpUnk->Release(); lpUnk  = nullptr; }


#if defined(_UNICODE)
#define _T(x) L ##x
typedef std::wstring MyString;
#else
typedef std::string  MyString;
#define _T(x) x
#endif




#endif // !_WINTYPE_H__

cHardwareInfo.h

#pragma once
#include "WinType.h"
#include <vector>
#include <map>
#include <utility>


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


    virtual bool  getSystemInformation();
    virtual void  CPU();
    virtual void  GPU();
    virtual void  MOTHERBOARD();
    std::map<std::string, std::string> mData;
private:
    MyString Convert(BSTR bstr)
    {
        int wslen = ::SysStringLen(bstr);
#if defined(_UNICODE)
 return std::wstring dblstr(bstr, wslen);
#else
        int len = ::WideCharToMultiByte(CP_ACP, 0, (wchar_t*)bstr, wslen, NULL, 0, NULL, NULL);
        std::string dblstr(len, '\0');
        len = ::WideCharToMultiByte(CP_ACP, 0, (wchar_t*)bstr, wslen, &dblstr[0], len, NULL, NULL);
        return dblstr;
#endif   
    }
    
    IWbemServices *m_pSvc;
    IWbemLocator  *m_pLoc;
};

cHardwareInfo.cpp

#include "cHardwareInfo.h"
#include "cLog.h"


cHardwareInfo::cHardwareInfo()
{
     m_pSvc = nullptr;
     m_pLoc = nullptr;
    
    
}
bool cHardwareInfo::getSystemInformation()
{
    


    HRESULT hResult = CoInitializeEx(0, COINIT_MULTITHREADED);
    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::CoInitializeEx::   0x%X", __FUNCTION__, hResult);
        return false;
    }

    hResult = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);


    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::CoInitializeSecurity::   0x%X", __FUNCTION__, hResult);
        CoUninitialize();
        return false;
    }
 
    hResult = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *)&this->m_pLoc);

    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::CoCreateInstance::   0x%X", __FUNCTION__, hResult);
        CoUninitialize();
        return false;
    }

    hResult = this->m_pLoc->ConnectServer(bstr_t(L"ROOT\\CIMV2"), NULL, NULL, 0, NULL, 0, 0, &this->m_pSvc);

    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::ConnectServer::   0x%X", __FUNCTION__, hResult);
        this->m_pLoc->Release();
        CoUninitialize();
        return false;               
    }

    //cout << "Connected to ROOT\\CIMV2 WMI" << endl;
 
    hResult = CoSetProxyBlanket(this->m_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(hResult))
    {
        LOG(lERROR, "%s::CoSetProxyBlanket::   0x%X", __FUNCTION__, hResult);
        this->m_pSvc->Release();
        this->m_pLoc->Release();
        CoUninitialize();
        return false;
    }
    
     CPU();
     GPU();
     MOTHERBOARD();


    return true;
}


void cHardwareInfo::CPU( )
{
    IEnumWbemClassObject* pEnumerator = nullptr;
    HRESULT hResult = this->m_pSvc->ExecQuery(bstr_t(L"WQL"), bstr_t(L"SELECT * FROM Win32_Processor"),WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,NULL,&pEnumerator);

    if (FAILED(hResult))
    {
         LOG(lERROR, "%s::ExecQuery::   0x%X", __FUNCTION__, hResult);
         this->m_pSvc->Release();
         this->m_pLoc->Release();
         CoUninitialize();

    }
    IWbemClassObject *pclsObj = nullptr;
    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);
        mData.insert(std::make_pair("CPU", Convert(vtProp.bstrVal)));
        LOG(lNORMAL, "%s::   %s", __FUNCTION__, Convert(vtProp.bstrVal).c_str());
        
        VariantClear(&vtProp);
        pclsObj->Release();
    }
    pEnumerator->Release();
}
void cHardwareInfo::GPU()
{
    IEnumWbemClassObject *pEnumerator = nullptr;
    HRESULT hResult = this->m_pSvc->ExecQuery(bstr_t("WQL"),bstr_t("SELECT * FROM Win32_VideoController"),WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,NULL,&pEnumerator);
    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::ExecQuery::   0x%X", __FUNCTION__, hResult);
        this->m_pSvc->Release();
        this->m_pLoc->Release();
        CoUninitialize();
    }
    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);       
        mData.insert(std::make_pair("GPU", Convert(vtProp.bstrVal)));
        LOG(lNORMAL, "%s::   %s", __FUNCTION__, Convert(vtProp.bstrVal).c_str());
        
        VariantClear(&vtProp);
        pclsObj->Release();
    }
    pEnumerator->Release();
}
void cHardwareInfo::MOTHERBOARD()
{
    IEnumWbemClassObject* pEnumerator = nullptr;
 
    HRESULT hResult = this->m_pSvc->ExecQuery(bstr_t("WQL"),bstr_t("SELECT * FROM Win32_BaseBoard"),WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,NULL,&pEnumerator);
    if (FAILED(hResult))
    {
        LOG(lERROR, "%s::ExecQuery::   0x%X", __FUNCTION__, hResult);
        this->m_pSvc->Release();
        this->m_pLoc->Release();
        CoUninitialize();
    }
    IWbemClassObject *pclsObj = nullptr;
    ULONG uReturn = 0;

    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,&pclsObj, &uReturn);
        if (0 == uReturn)   
            break;
        
        VARIANT vtProp;

        hr = pclsObj->Get(L"Manufacturer", 0, &vtProp, 0, 0);
    
        MyString manufacturer = Convert(vtProp.bstrVal);
        hr = pclsObj->Get(L"Product", 0, &vtProp, 0, 0);
        mData.insert(std::make_pair("MB", (manufacturer + Convert(vtProp.bstrVal))));
      
        LOG(lNORMAL, "%s::   %s %s", __FUNCTION__, Convert(vtProp.bstrVal).c_str(), Convert(vtProp.bstrVal).c_str());
        VariantClear(&vtProp);
        pclsObj->Release();
    }
    pEnumerator->Release();
}


cHardwareInfo::~cHardwareInfo()
{
    _RELEASE(this->m_pSvc);
    _RELEASE(this->m_pLoc);
    CoUninitialize();   
    std::wcout << L"~cHardwareInfo" << std::endl;
}

Ex:

class cKey :
    public cHardwareInfo
{
public:
    friend class cHardwareInfo;
    cKey()
    {
        m_pHardwareInfo = new cHardwareInfo;
        m_pHardwareInfo->getSystemInformation();
    }
    virtual void PrintData()
    {
        for (auto it = m_pHardwareInfo->mData.begin(); it != m_pHardwareInfo->mData.end(); ++it)
        {
            LOG(lNORMAL, "%s::   %s", it->first.c_str(), it->second.c_str());
        
        }
    }
    virtual ~cKey()
    {
        delete m_pHardwareInfo;
    }

private:
    cHardwareInfo *m_pHardwareInfo;
};

cKey *m_pKey = new cKey();
    m_pKey->PrintData();
    delete m_pKey;

ResultLog:

2015-08-26 05:55:18 *NORMAL* cHardwareInfo::MOTHERBOARD:: ASUSTeK Computer INC. M5A78L-M LX3
2015-08-26 07:54:51 *NORMAL* cHardwareInfo::CPU:: AMD FX(tm)-4350 Quad-Core Processor
2015-08-26 07:54:51 *NORMAL* cHardwareInfo::GPU:: AMD Radeon HD 7700 Series

PS: Не работает для длл))) почему это так? - читайте о Wmi и методах ее иницализации