Вывод на экран информации о жестком диске

//------------------------------------------------------------------------------
#include <sstream>
#include <Wbemcli.h>
#include <string>
//------------------------------------------------------------------------------
//#define USE_PREFIX
 
#ifdef USE_PREFIX
#define PREFIX(root, name) #root "." #name "="
#else
#define PREFIX(root, name) ""
#endif
 
#define ADD_L(x) L##x
#define READ_WMI(root, name) \
hr = pclsObj->Get(ADD_L(#name), 0, &vtProp, 0, 0);\
if (FAILED(hr))\
{\
    info << PREFIX(root, name) << std::endl;\
}\
else\
{\
    if (V_VT(&vtProp) == VT_BSTR)\
    {\
        info << PREFIX(root, name) << vtProp.bstrVal << std::endl;\
    }\
    else\
    {\
        VARIANT tmp;\
        VariantInit(&tmp);\
        HRESULT hr = VariantChangeType(&tmp, &vtProp, 0, VT_BSTR);\
        if (hr != S_OK)\
        {\
            info<< PREFIX(root, name) << std::endl;\
        }\
        else\
        {\
            info << PREFIX(root, name) << tmp.bstrVal << std::endl;\
        }\
        VariantClear(&tmp);\
    }\
}\
VariantClear(&vtProp);
//------------------------------------------------------------------------------
std::string get_device_number(const std::string &device_letter)
{
    char buffer[64];
    sprintf(buffer, "\\\\.\\%s:", device_letter.c_str());
 
    std::string res;
 
    HANDLE driveHandle;
    driveHandle = CreateFile(
        buffer,
        0,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        0);
    if (driveHandle != INVALID_HANDLE_VALUE)
    {
        STORAGE_DEVICE_NUMBER sdn;
        DWORD bytesReturned;
 
        if (DeviceIoControl(
            driveHandle,
            IOCTL_STORAGE_GET_DEVICE_NUMBER,
            0, 0,
            &sdn, sizeof(sdn), &bytesReturned,
            0))
        {
            sprintf(buffer, "\\\\.\\PHYSICALDRIVE%i", (int)sdn.DeviceNumber);
            res = buffer;
        }
        else
        {
            VOLUME_DISK_EXTENTS vde;
 
            if (DeviceIoControl(
                driveHandle,
                IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
                0, 0,
                &vde, sizeof(vde), &bytesReturned,
                0) && vde.NumberOfDiskExtents)
            {
                sprintf(buffer, "\\\\.\\PHYSICALDRIVE%i", (int)vde.Extents[0].DiskNumber);
                res = buffer;
            }
        }
    }
 
    CloseHandle(driveHandle);
 
    return res;
}
 
std::wstring get_disk_drive_desc(const std::wstring &device_number)
{
    HRESULT hr;
 
    hr =  CoInitializeEx(0, COINIT_MULTITHREADED);
    if (FAILED(hr))
    {
        //return L"";
    }
 
    hr =  CoInitializeSecurity(
        0,
        -1,
        0,
        0,
        RPC_C_AUTHN_LEVEL_DEFAULT,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        0,
        EOAC_NONE,
        0);
    if (FAILED(hr))
    {
        //CoUninitialize();
 
        //return L"";
    }
 
    IWbemLocator *pLoc;
    hr = CoCreateInstance(
        CLSID_WbemLocator,
        0,
        CLSCTX_INPROC_SERVER,
        IID_IWbemLocator, (LPVOID *)&pLoc);
    if (FAILED(hr))
    {
        //CoUninitialize();
 
        return L"";
    }
 
    IWbemServices *pSvc;
    hr = pLoc->ConnectServer(
         L"ROOT\\CIMV2",
         0,
         0,
         0,
         0,
         0,
         0,
         &pSvc);
    if (FAILED(hr))
    {
        pLoc->Release();
        //CoUninitialize();
 
        return L"";
    }
 
    hr = CoSetProxyBlanket(
       pSvc,
       RPC_C_AUTHN_WINNT,
       RPC_C_AUTHZ_NONE,
       0,
       RPC_C_AUTHN_LEVEL_CALL,
       RPC_C_IMP_LEVEL_IMPERSONATE,
       0,
       EOAC_NONE
    );
    if (FAILED(hr))
    {
        pSvc->Release();
        pLoc->Release();
        //CoUninitialize();
 
        return L"";
    }
 
    std::wstringstream info;
 
    IEnumWbemClassObject* pEnumerator;
 
    hr = pSvc->ExecQuery(
        L"WQL",
        L"SELECT * FROM Win32_DiskDrive",
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        0,
        &pEnumerator);
    if (FAILED(hr))
    {
        pSvc->Release();
        pLoc->Release();
        //CoUninitialize();
 
        return L"";
    }
 
    hr = CoSetProxyBlanket(
       pEnumerator,
       RPC_C_AUTHN_WINNT,
       RPC_C_AUTHZ_NONE,
       0,
       RPC_C_AUTHN_LEVEL_CALL,
       RPC_C_IMP_LEVEL_IMPERSONATE,
       0,
       EOAC_NONE
    );
    if (FAILED(hr))
    {
        pEnumerator->Release();
        pSvc->Release();
        pLoc->Release();
        //CoUninitialize();
 
        return L"";
    }
 
    bool found = false;
 
    while (pEnumerator)
    {
        IWbemClassObject *pclsObj;
        ULONG uReturn;
        hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
        if (FAILED(hr))
        {
            break;
        }
        if (!uReturn)
        {
            break;
        }
 
        VARIANT vtProp;
 
        hr = pclsObj->Get(L"DeviceId", 0, &vtProp, 0, 0);
        if (FAILED(hr))
        {}
        else
        {
            found = device_number == vtProp.bstrVal;
 
            if (found)
            {
                READ_WMI(DiskDrive, Model)
                READ_WMI(DiskDrive, SerialNumber)
            }
        }
 
        VariantClear(&vtProp);
 
        pclsObj->Release();
 
        if (found) break;
    }
 
    if (!found)
    {
        info << PREFIX(DiskDrive, Model) << std::endl;
        info << PREFIX(DiskDrive, SerialNumber) << std::endl;
    }
 
    pEnumerator->Release();
 
    pSvc->Release();
    pLoc->Release();
    //CoUninitialize();
 
    return info.str();
}