C++获取CPU和硬盘系列号的源代码

天云上人 · 发表于 2008-1-6 19:59:06

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号

5 D$ R5 ?! C6 W
#include "StdAfx.h"
! _2 G& a2 h6 e4 Q
#include ".\puiddisk.h"
. D- ~" M2 |$ \+ C
#define _WIN32_DCOM% x7 i1 S# d9 D4 D8 v4 C& B: w
#include <iostream>
8 R9 X D& V8 n) k3 X) n
using namespace std;8 l8 s- `6 a/ s
#include <comdef.h>
6 h$ o7 q2 M* B! ~) Y6 u
#include <Wbemidl.h>
4 B& }: A6 X% a
% M+ ?2 S! Z, S1 }2 ?2 y( R: j; R
# pragma comment(lib, "wbemuuid.lib")
; W- f) t5 E) \* g& o% T, Z
CpuIDDisk::CpuIDDisk(void)
; ~! V& W- N! q x
{* y) ?5 O8 N9 S3 w- Q( p
GetInfomation();
0 d8 R$ C+ A1 q* i
}( d( K' E9 N' w$ I
, t6 ~1 U4 Q3 |
CpuIDDisk::~CpuIDDisk(void). k, ]$ K+ {9 x+ w* {1 R4 `
{
5 ]5 D& R, @; K( F6 R& O
}
% o+ w+ J5 N5 |- d1 f+ u
int CpuIDDisk::GetInfomation(void)' N {: y$ ]1 l: ?9 A& s
{6 R+ z. @# y4 H2 k) @
HRESULT hres;
1 O5 x/ D1 X! s; D) t
//步骤1：不是必须的，COM只须也只能初始化一次) Y. g0 s5 a V4 S, q& T, A, I9 f
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
: E L; Z- Y6 s2 W; c
if (FAILED(hres))5 H+ {7 J6 w0 v; y2 Q" o& R* o. r( |' ^
{. h2 D* {: o3 o; t
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
' P: m( P9 n1 b- H( t( W
}
) l3 ~2 d, u) X! B5 _
//步骤2：不是必须的，COM只须也只能设置一次
/ m* Y- T1 y \$ C8 [
//Set general COM security levels
& |4 G4 U+ O. T9 }3 l, b
hres = CoInitializeSecurity(/ P+ }6 W! \, ]7 B
NULL, + R6 Q0 b& v% G3 v& b
-1, // COM authentication4 f7 t. b' ?7 ^' v7 v/ Y: m' O
NULL, // Authentication services# y* \5 {9 r4 t/ \
NULL, // Reserved
# [0 h; ], t4 d; O! y b q
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication # n+ Q- K9 c: M
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation ! ~! B1 _& \& n
NULL, // Authentication info
* A2 E( F% p8 G6 p6 E
EOAC_NONE, // Additional capabilities
7 q! G6 b$ r/ {6 c' z- `
NULL // Reserved5 j# x! l4 S( {
);
# U$ T( }0 [3 g: O, i1 d1 a8 d7 p
6 q, F' ?; ?3 l U! F, i* u9 M% j" y
if (FAILED(hres))
/ d1 {; x) ^( Q
{
! {$ V, g( u: K2 D
CoUninitialize(); }% b. C( q f9 F: f+ p- k
return 1; // Program has failed., s4 c) l1 w% N
}* q2 _* V. f5 L" T! k5 `4 c
; K; {$ g$ j$ q, b2 b* K
//以上不是必须的，若已有“::COMInit();”，则要跳过
# u: k. C0 n ?
//步骤3： Obtain the initial locator to WMI
' ?* b# W- a" [9 b
IWbemLocator *pLoc = NULL;
/ p! O: u" p; h7 b
hres = CoCreateInstance(8 s2 I8 @# q) s. ]
CLSID_WbemLocator, . \# u0 |: p4 F0 _7 y, }: a
0,
7 O, ~9 s+ u+ B# Z- s
CLSCTX_INPROC_SERVER, - l3 T6 `" Q( P8 z6 J# I" [" o5 E
IID_IWbemLocator, (LPVOID *) &pLoc);
e8 L( p' y7 S* ]. r* `& L
) v i6 q4 x2 x
if (FAILED(hres)) F2 S4 b) S+ S+ Z {
{
+ M. X6 x7 v ?& A7 j$ F3 T
CoUninitialize();
" i& l6 M; ~/ W9 j- Z9 V0 Y
return 1;//Failed to create IWbemLocator object- {- b& O. ^) F0 J4 K6 k" o
}/ e( E8 n: a% A/ u, n
, U, b$ ^7 v+ h" e. Q: o$ Q
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
5 i6 P g; Q3 }4 w4 \8 E4 m
IWbemServices *pSvc = NULL;
" \6 |9 ?5 c" s9 ~# }. [+ \
hres = pLoc->ConnectServer(
& G E# I1 \( n! ~! a
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
/ R5 a1 l: k! b, K8 E, w8 U4 y
NULL, // User name. NULL = current user) D l3 ?5 A1 F
NULL, // User password. NULL = current
( n, V1 i ^4 l, F$ l( P
0, // Locale. NULL indicates current
0 Q% [4 { @- ^* a, X/ a" R5 d
NULL, // Security flags.
$ a2 q: |0 n% Q8 E; I; `
0, // Authority (e.g. Kerberos)
7 t- n N1 _9 F! F, s2 {
0, // Context object
! C' E. K9 D+ y m$ ?& c
&pSvc // pointer to IWbemServices proxy
$ D% u7 f' p4 c& X! T& M& n
);
( ]9 g* W( p$ i6 j' |( S
( i; l5 x Z9 q
if (FAILED(hres))
' L R* m1 i! B# X
{' O% \; C6 {. b0 I$ X
pLoc->Release();
5 z5 Y: Q' j! K. R+ n# l9 n
CoUninitialize();4 K/ U8 E9 w4 a
return 1; // Program has failed.# a' s( _0 m/ c' d6 `
}
) G- G3 g* d$ f, E- A( D9 t: \
// 步骤5： Set security levels on the proxy& \5 E" m' X2 q& [ B' H, k- S$ M
hres = CoSetProxyBlanket(
( ]" z* H- c, z3 h& b3 K3 h
pSvc, // Indicates the proxy to set; o1 G) a( H4 v. {: {
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
. r) G1 \/ Y. [" {
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx% _0 J5 ?" \$ r+ i8 \, C/ Z
NULL, // Server principal name % _0 d2 O3 Z& l" D
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx ! U% K9 I) p8 D' s) u$ E5 x/ i) q
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx8 Q+ ?2 g" z. U) e
NULL, // client identity
) t+ e1 n/ F# |4 w' X: ^
EOAC_NONE // proxy capabilities - b0 l: ?+ u& \, U2 o" |
);
9 F d8 w8 i# F& T; s( t
+ |5 Y: g) m: R' \) L9 E7 `0 C) _# ]
if (FAILED(hres))' Z( m1 U" k" Z7 ?( e6 N4 P* f# ?0 [
{
; Z; s( b9 Q5 _+ ]# X
pSvc->Release();
+ o5 d `# }2 Z+ e1 m. q; e
pLoc->Release(); 2 v+ H8 Y8 P, x8 B8 r |
CoUninitialize();
9 Q: H" ?' m- Y% N( x' `! o
return 1; ' O; D# L4 F: h2 v" Y
}4 J! ^% d O5 f5 A
- g$ {$ }/ U; f
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
, T/ C. N- A0 _! `8 t" f6 b
IEnumWbemClassObject* pEnumerator = NULL;
& M& Y: Q2 Z2 d. x% r, i
//计算CPUID- ]" h9 }: X1 K; ?' ~
hres = pSvc->ExecQuery(" w/ @9 R4 n% ?8 `3 }# }7 m$ f2 a4 {
bstr_t("WQL"), . q% g% V6 d. N( D! r$ D6 X1 g
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
1 A' G- ~" W* L- p; @$ P
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, * B# L# L" f$ H; O) L
NULL,' w$ D' x. {1 X5 ~
&pEnumerator);
( b$ a# r1 V5 M! H1 X7 ~2 x, y
{2 x4 W* q* w/ v: g- K1 F
if (FAILED(hres))0 u! n# V- h; o2 ]( [! |. t
{
2 Y# f7 R" D% t _9 G
pSvc->Release();
+ {. o. k* `3 G
pLoc->Release();
9 G8 {7 U- x9 U5 X8 B; f
CoUninitialize();
2 o) x) c/ g) `+ L# g6 Y
return 1;
8 L ~. @% ]4 O- p9 ?* @/ U5 t7 C
}0 g2 S/ b1 M* O& I$ l( s) g
// 步骤7：Get the data from the query 7 D8 i. @- P' n# J
IWbemClassObject *pclsObj; P: m% T( x9 E) I) T* W
ULONG uReturn = 0;: l9 i8 L5 A' t4 B: a
while (pEnumerator)
1 R" a+ _6 M- u- l( X' K
{' Q; ~7 C& W0 L0 c; j L
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
# N5 |; Y: E0 w3 f
&pclsObj, &uReturn);3 l- \( W8 R! T
; C0 O6 N) @: d9 v0 w
if(0 == uReturn)
# C; \% s" d5 F
{" Y# z3 \- g1 g2 C
break;
3 W# D$ P0 ^' {9 c U; X; r8 A
}
( ~6 I Y+ N, Q p6 f6 u, W* C
VARIANT vtProp;$ t3 p! Q( k6 t6 C
VariantInit(&vtProp);
* Z; @. @; t2 b @% }
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
# P F' |0 _6 I, F% a9 y
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
5 R7 z4 q' U* x% `7 L, Z& V# K
}- a/ C7 M5 O; D' h
# N. z3 R- `/ X; y2 R4 @5 q3 M
//计算硬盘系列号4 x+ C" q# s6 B5 E" W
hres = pSvc->ExecQuery(
4 ?) D5 G, n5 A7 o
bstr_t("WQL"), 5 I$ d/ ~. y* N7 t; w- [% U ]
bstr_t("SELECT * FROM Win32_DiskDrive"),
- R2 H6 A# x" q0 f/ h
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
" @- V0 @! y# E9 e5 D- S8 v
NULL,
9 Q$ G. E1 D' o7 n7 C; v& o
&pEnumerator);
( E$ E1 t( J! ]4 S" }8 B
9 B1 ]2 d' s; S: V' Y! _) |
if (FAILED(hres))$ c6 T' X" f' h0 e4 w
{$ t5 h+ X; D' ^. G9 p
pSvc->Release();
0 {0 B; \2 J$ Z: P. ^8 I
pLoc->Release();
; v, a" u" o$ q# I, N4 G
CoUninitialize();
1 H+ a0 i, x7 k1 \0 o1 S4 q, Y
return 1;
, r& ]0 X! s5 V. W3 f' r* m
}
! o+ u) Q$ e6 n- f- q1 S9 W1 N
while (pEnumerator)4 b8 @2 B& `: R9 g( T
{+ C- x4 d+ h# b) M4 l; a
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
& Q: `- {& F8 ~; u
&pclsObj, &uReturn);
6 K0 b0 d k/ R
9 a J, n* [9 Y* T% q7 V( b
if(0 == uReturn)5 C% r% U/ q* q: q3 b' n/ `
{% G$ o- J: w$ }6 L3 B" u5 N0 |. F, m
break;
; u! d5 ?8 R. U& \4 V' ]8 r% k1 C
}
# N# Q# o$ Z# J' G
( p- W- e- b: `9 j7 H
VARIANT vtProp; k) M* E, ~4 x& b: x9 G$ `
VariantInit(&vtProp);
! C$ H x; R _& e" R
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
$ j* G$ ]8 ]! A& o: O7 l. k9 V
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);% N3 _8 |% S3 [/ g5 J3 v
}
$ Z2 ^ d: z: Z. y
2 d) W0 W4 L# x; f! n/ w
pSvc->Release();7 [, x5 w& O, i6 \( Z7 i
pLoc->Release();8 [" {5 y' o9 D8 p6 h' E
pEnumerator->Release();3 A1 ~8 R H: e5 E% Z
pclsObj->Release();( s: _7 v% ?( z0 F' T
CoUninitialize();# v( y# E9 O4 o% e6 `) V- l
& S2 ^# L* d% S
return 0; / R, _3 K3 h/ x1 Q7 r
}8 h( f/ B) h7 o' i; |3 W8 n

复制代码

天云上人 · 发表于 2010-10-11 19:21:05

本文代码经ccrun(老妖)在Win2k下试验成功.

#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS    GETVERSIONINPARAMS
#define DFP_GET_VERSION       SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA    SMART_RCV_DRIVE_DATA

const WORD IDE_ATAPI_IDENTIFY = 0xA1; // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY = 0xEC; // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
const DWORD FILE_DEVICE_SCSI          = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT       = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
{
ULONG HeaderLength;
UCHAR Signature[8];
ULONG Timeout;
ULONG ControlCode;
ULONG ReturnCode;
ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
      PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
      BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
      BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
switch(Win32Platform)
{
      case VER_PLATFORM_WIN32_WINDOWS:
         ReadPhysicalDriveOnW9X(pSerList, pModeList);
         break;
      case VER_PLATFORM_WIN32_NT:
         ReadPhysicalDriveOnNT(pSerList, pModeList);
         break;
      default:
         break;
}
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
static char szResBuf[1024];
int nIndex = 0;
int nPosition = 0;

// Each integer has two characters stored in it backwards
for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
{
      // Get high BYTE for 1st character
      szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
      nPosition++;

      // Get low BYTE for 2nd character
      szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
      nPosition++;
}

// End the string
szResBuf[nPosition] = '\0';

// Cut off the trailing blanks
for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
      szResBuf[nIndex] = '\0';

return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
// 输出参数
BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
{
      HANDLE hPhysicalDriveIOCTL;
      char szDriveName[32];

      sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
      hPhysicalDriveIOCTL = CreateFile(szDriveName,
                     GENERIC_READ | GENERIC_WRITE,
                     FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                     OPEN_EXISTING, 0, NULL);

      if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
      {
         DWORD dwBytesReturned = 0;
         GETVERSIONOUTPARAMS gvopVersionParams;

         // Get the version, etc of PhysicalDrive IOCTL
         ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

         if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                  NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                  &dwBytesReturned, NULL))
         {
            continue;
         }

         if(gvopVersionParams.bIDEDeviceMap > 0)
         {
            // IDE or ATAPI IDENTIFY cmd
            BYTE btIDCmd = 0;
            SENDCMDINPARAMS InParams;
            // Now, get the ID sector for all IDE devices in the system.
            // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
            // otherwise use the IDE_ATA_IDENTIFY command
            // 具体所得结果请参考头文件中的说明
            btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                     IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
            ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
            ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

            if(DoIdentify(hPhysicalDriveIOCTL,
                  &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                  (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
            {
                  DWORD dwDiskData[256];
                  USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                  char szSerialNumber[21];
                  char szModelNumber[41];

                  pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                  for(int i=0; i < 256; i++)
                     dwDiskData[i] = pIDSector[i];
                  // 取系列号
                  ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                  strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                  // 取模型号
                  ZeroMemory(szModelNumber, sizeof(szModelNumber));
                  strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                  pSerList->Add(szSerialNumber);
                  pModeList->Add(szModelNumber);
            }
         }
         CloseHandle (hPhysicalDriveIOCTL);
      }
}
}
//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
            PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
            PDWORD pdwBytesReturned)
{
// Set up data structures for IDENTIFY command.
pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
pSCIP->irDriveRegs.bFeaturesReg = 0;
pSCIP->irDriveRegs.bSectorCountReg  = 1;
pSCIP->irDriveRegs.bSectorNumberReg = 1;
pSCIP->irDriveRegs.bCylLowReg  = 0;
pSCIP->irDriveRegs.bCylHighReg = 0;

// Compute the drive number.（主盘和从盘所对应的值是不一样的）
pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

// The command can either be IDE identify or ATAPI identify.
pSCIP->irDriveRegs.bCommandReg = btIDCmd;
pSCIP->bDriveNumber = btDriveNum;
pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
         (LPVOID)pSCIP,
         sizeof(SENDCMDINPARAMS) - 1,
         (LPVOID)pSCOP,
         sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
         pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
WORD wOutData[256];
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

// 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
// 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
// 避免蓝屏的出现。（期待高人能指出原因）
for(int nDrive = 0; nDrive < 8; nDrive++)
{
      WORD dwBaseAddress;
      BYTE btMasterSlave;       // Master Or Slave
      bool bIsIDEExist;
      bool IsDiskExist;

      switch(nDrive / 2)
      {
         case 0: dwBaseAddress = 0x01F0; break;
         case 1: dwBaseAddress = 0x0170; break;
         case 2: dwBaseAddress = 0x01E8; break;
         case 3: dwBaseAddress = 0x0168; break;
      }

      btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

      // 进入Ring0
      ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
            bIsIDEExist, IsDiskExist, wOutData);
}

// 开始读取
for(int nDrive = 0; nDrive < 8; nDrive++)
{
      WORD dwBaseAddress;
      BYTE btMasterSlave;       // Master Or Slave
      bool bIsIDEExist;
      bool bIsDiskExist;
      switch(nDrive / 2)
      {
         case 0: dwBaseAddress = 0x01F0; break;
         case 1: dwBaseAddress = 0x0170; break;
         case 2: dwBaseAddress = 0x01E8; break;
         case 3: dwBaseAddress = 0x0168; break;
      }

      btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

      // 进入Ring0
      bIsIDEExist  = false;
      bIsDiskExist = false;
      ZeroMemory(wOutData, sizeof(wOutData));

      ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
            bIsIDEExist, bIsDiskExist, wOutData);

      if(bIsIDEExist && bIsDiskExist)
      {
         DWORD dwDiskData[256];
         char  szSerialNumber[21];
         char  szModelNumber[41];

         for(int k=0; k < 256; k++)
            dwDiskData[k] = wOutData[k];

         // 取系列号
         ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
         strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

         // 取模型号
         ZeroMemory(szModelNumber, sizeof(szModelNumber));
         strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

         pSerList->Add(szSerialNumber);
         pModeList->Add(szModelNumber);
      }
}
SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
      BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
BYTE  btIDTR1[6];
DWORD dwOldExceptionHook;
const int nHookExceptionNo = 5;

BYTE  btIsIDEExist = 0;
BYTE  btIsDiskExist = 0;
WORD  wOutDataBuf[256];

BYTE  btIsFirst = (BYTE)bIsFirst;

const BYTE btBit00 = 0x01;
// const BYTE btBit02 = 0x04;
const BYTE btBit06 = 0x40;
const BYTE btBit07 = 0x80;
// const BYTE btERR  = btBit00;
const BYTE btBusy = btBit07;
const BYTE btAtaCmd = 0xEC;
const BYTE btAtapiCmd = 0xA1;

__asm
{
      // 必须先执行这条语句
      JMP EnterRing0

      // 定义过程
      // 等待IDE设备直到其不为忙为止
      WaitWhileBusy proc

      MOV  EBX, 100000
      MOV  DX, dwBaseAddress
      ADD  DX, 7

      LoopWhileBusy:

      DEC  EBX
      CMP  EBX, 0
      JZ Timeout
      in AL, DX
      TEST AL, btBusy
      JNZ  LoopWhileBusy
      JMP  DriveReady

      // 超时，直接退出
      Timeout:
      JMP  LeaveRing0
      DriveReady:
      RET
      ENDP // End of WaitWhileBusy Procedure

      // 设置主盘和从盘标志
      SelectDevice proc

      MOV  DX, dwBaseAddress
      ADD  DX, 6
      MOV  AL, btMasterSlave

      out  DX, AL
      RET

      ENDP  // End of SelectDevice Procedure

      // 向IDE设备发送存取指令
      SendCmd proc

      MOV DX, dwBaseAddress
      ADD DX, 7
      MOV AL, BL // BL是主从盘标识，在过程外设置
      out DX, AL
      RET
      ENDP  // End of SendCmd Procedure

      // Ring0代码
      Ring0Proc:
      PUSHAD
      // 查询IDE设备是否存在
      MOV DX, dwBaseAddress
      ADD DX, 7
      in  AL,DX

      // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
      CMP AL,0xFF
      JZ  LeaveRing0
      CMP AL, 0x7F
      JZ  LeaveRing0

      // 设置IDE设备存在标志
      MOV btIsIDEExist, 1

      // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
      CALL WaitWhileBusy
      CALL SelectDevice

      // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
      CMP  btIsFirst, 1
      JZ LeaveRing0

      // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
      CALL WaitWhileBusy

      // AL的值等于cBit06时，不存在驱动器，直接返回
      TEST AL, btBit06
      JZ LeaveRing0

      // 设置驱动器存在标志
      MOV  btIsDiskExist, 1

      // 发送存取端口命令
      // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
      // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
      CALL WaitWhileBusy
      CALL SelectDevice // 设置主从盘标识
      MOV  BL, btAtaCmd    // 发送读取命令
      CALL SendCmd
      CALL WaitWhileBusy

      // 检查是否出错
      MOV  DX, dwBaseAddress
      ADD  DX, 7

      in AL, DX

      TEST AL, btBit00
      JZ RetrieveInfo // 没有错误时则读数据

      // 如果出错，则进一步尝试使用ATAPI设备命令
      CALL WaitWhileBusy
      CALL SelectDevice
      MOV  BL, btAtapiCmd
      CALL SendCmd
      CALL WaitWhileBusy

      // 检查是否还出错
      MOV  DX, dwBaseAddress
      ADD  DX, 7
      in AL, DX
      TEST AL, btBit00
      JZ RetrieveInfo // 没有错误时则读数据
      JMP  LeaveRing0    // 如果还是出错，直接返回

      // 读取数据
      RetrieveInfo:

      LEA  EDI, wOutDataBuf
      MOV  ECX, 256
      MOV  DX, dwBaseAddress
      CLD

      REP  INSW

      // 退出Ring0代码
      LeaveRing0:

      POPAD
      IRETD

      // 激活Ring0代码
      EnterRing0:

      // 修改中断门
      SIDT FWORD PTR btIDTR1
      MOV EAX, DWORD PTR btIDTR1 + 02h
      ADD EAX, nHookExceptionNo * 08h + 04h
      CLI

      // 保存原异常处理例程入口
      MOV ECX, DWORD PTR [EAX]
      MOV CX, WORD PTR [EAX-04h]
      MOV dwOldExceptionHook, ECX

      // 指定新入口
      LEA EBX, Ring0Proc
      MOV WORD PTR [EAX-04h],BX
      SHR EBX, 10h
      MOV WORD PTR[EAX+02h], BX

      // 激活Ring0代码
      INT nHookExceptionNo

      // 复原入口
      MOV ECX,dwOldExceptionHook
      MOV WORD PTR[EAX-04h], CX
      SHR ECX,10h
      MOV WORD PTR[EAX+02h], CX
      STI
}
if(!bIsFirst)
{
      bIsIDEExist  = (bool)btIsIDEExist;
      bIsDiskExist = (bool)btIsDiskExist;
      CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
}
}
//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}

		自动登录	找回密码
密码			注册

C++获取CPU和硬盘系列号的源代码

浏览过的版块