DLL 得到电脑的硬件信息

#include <iostream>
#include <winioctl.h>
#include <intrin.h>
#define  MAX_IDE_DRIVES  16

 

char HardDriveSerialNumber[1024];
char HardDriveModelNumber[1024];

char * flipAndCodeBytes(const char * str,
    int pos,
    int flip,
    char * buf)
{
    int i;
    int j = 0;
    int k = 0;

    buf[0] = '\0';
    if (pos <= 0)
        return buf;

    if (!j)
    {
        char p = 0;

        // First try to gather all characters representing hex digits only.
        j = 1;
        k = 0;
        buf[k] = 0;
        for (i = pos; j && str[i] != '\0'; ++i)
        {
            char c = tolower(str[i]);

            if (isspace(c))
                c = '0';

            ++p;
            buf[k] <<= 4;

            if (c >= '0' && c <= '9')
                buf[k] |= (unsigned char)(c - '0');
            else if (c >= 'a' && c <= 'f')
                buf[k] |= (unsigned char)(c - 'a' + 10);
            else
            {
                j = 0;
                break;
            }

            if (p == 2)
            {
                if (buf[k] != '\0' && !isprint(buf[k]))
                {
                    j = 0;
                    break;
                }
                ++k;
                p = 0;
                buf[k] = 0;
            }

        }
    }

    if (!j)
    {
        // There are non-digit characters, gather them as is.
        j = 1;
        k = 0;
        for (i = pos; j && str[i] != '\0'; ++i)
        {
            char c = str[i];

            if (!isprint(c))
            {
                j = 0;
                break;
            }

            buf[k++] = c;
        }
    }

    if (!j)
    {
        // The characters are not there or are not printable.
        k = 0;
    }

    buf[k] = '\0';

    if (flip)
        // Flip adjacent characters
        for (j = 0; j < k; j += 2)
        {
            char t = buf[j];
            buf[j] = buf[j + 1];
            buf[j + 1] = t;
        }

    // Trim any beginning and end space
    i = j = -1;
    for (k = 0; buf[k] != '\0'; ++k)
    {
        if (!isspace(buf[k]))
        {
            if (i < 0)
                i = k;
            j = k;
        }
    }

    if ((i >= 0) && (j >= 0))
    {
        for (k = i; (k <= j) && (buf[k] != '\0'); ++k)
            buf[k - i] = buf[k];
        buf[k - i] = '\0';
    }

    return buf;
}

CString ReadPhysicalDriveInNTWithZeroRights(void)
{
    int done = FALSE;
    int drive = 0;
    CString hao;
    for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
    {
        HANDLE hPhysicalDriveIOCTL = 0;

        //  Try to get a handle to PhysicalDrive IOCTL, report failure
        //  and exit if can't.
        TCHAR driveName[256];
        wsprintf(driveName, TEXT("\\\\.\\PhysicalDrive%d"), drive);

        //  Windows NT, Windows 2000, Windows XP - admin rights not required
        hPhysicalDriveIOCTL = CreateFile(driveName, 0,
            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
            OPEN_EXISTING, 0, NULL);
        if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
        {
            return "0";
        }
        else
        {
            STORAGE_PROPERTY_QUERY query;
            DWORD cbBytesReturned = 0;
            char local_buffer[10000];

            memset((void *)& query, 0, sizeof(query));
            query.PropertyId = StorageDeviceProperty;
            query.QueryType = PropertyStandardQuery;

            memset(local_buffer, 0, sizeof(local_buffer));

            if (DeviceIoControl(hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
                &query,
                sizeof(query),
                &local_buffer[0],
                sizeof(local_buffer),
                &cbBytesReturned, NULL))
            {
                STORAGE_DEVICE_DESCRIPTOR * descrip = (STORAGE_DEVICE_DESCRIPTOR *)& local_buffer;
                char serialNumber[1000];
                char modelNumber[1000];
                char vendorId[1000];
                char productRevision[1000];

                flipAndCodeBytes(local_buffer,
                    descrip->VendorIdOffset,
                    0, vendorId);
                flipAndCodeBytes(local_buffer,
                    descrip->ProductIdOffset,
                    0, modelNumber);
                flipAndCodeBytes(local_buffer,
                    descrip->ProductRevisionOffset,
                    0, productRevision);
                flipAndCodeBytes(local_buffer,
                    descrip->SerialNumberOffset,
                    1, serialNumber);

                if (isalnum(serialNumber[0]))
                {
                    // 这就表明获取到了合法的硬盘序列号
                    // 硬盘序列号在serialNumber数组中
                    // 硬盘型号在modelNumber数组中
                    // 硬盘厂商编号在vendorId中
                    // 硬盘固件版本号在productRevision中
                     hao=serialNumber;
                     CloseHandle(hPhysicalDriveIOCTL);
                     return hao;
                    
                    

                }

            }
            else
            {
                DWORD err = GetLastError();
            }
            CloseHandle(hPhysicalDriveIOCTL);
        }
    }
     return "0";
}

 

以上资料来源于网络，如有重复，请与我联系，会自动删除。