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

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

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

' H: Y1 Z3 y9 l# ?9 _; o
#include "StdAfx.h"4 J0 v9 r/ P7 B! {
#include ".\puiddisk.h"
- X5 P. J n) }% J" I
#define _WIN32_DCOM M/ U' k. n/ n& y" u" `+ A
#include <iostream>$ P* [" V' F! P* T% z1 J
using namespace std;
' Q) y v& A% l# d
#include <comdef.h>1 [9 U8 u- G% N. @
#include <Wbemidl.h>$ W0 t+ R/ L7 F8 K# Z$ h, g
8 K7 }' w# r8 X5 ^/ W9 f/ \4 E* X% M
# pragma comment(lib, "wbemuuid.lib")
6 W% w9 D7 n0 Z; Q$ m1 g
CpuIDDisk::CpuIDDisk(void)( n& A! q9 _; Q# O7 |
{
7 R2 w( n2 r0 j# r
GetInfomation();: ] N8 p8 t6 r' n i$ N/ m
}- l, i8 _/ S: V5 l
# C" S5 w' I! ^5 J) @; a
CpuIDDisk::~CpuIDDisk(void)' F3 M+ c; F0 v$ z* Y
{
& c, |" f8 a. F. C1 g) M
}' `0 o* |, z) K# ]) X5 ~9 d
int CpuIDDisk::GetInfomation(void)
: Q" w6 h, \5 R/ L. I
{( A2 Z, Y- {5 F8 N1 F; [8 ^/ G
HRESULT hres;
/ \- b! E* L% u7 Y$ |7 J
//步骤1：不是必须的，COM只须也只能初始化一次, V5 O" v, }+ l* D1 s- M
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
( C, ` H g: P# d3 M0 g
if (FAILED(hres))
- \* r, x8 ^, Y
{ i' c3 d" h$ b$ W0 ?% T2 S- J1 _
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
+ c6 v' `: I0 D8 j" r0 b; T+ G: Z
}
% ?9 X: |9 k) @" @/ b7 a. q% I
//步骤2：不是必须的，COM只须也只能设置一次$ {* d0 _9 B. i" o/ w" j1 Z
//Set general COM security levels. P8 ] u! n4 L/ s# g; u
hres = CoInitializeSecurity(& ]4 s! `+ h- U) [) q
NULL,
0 `2 v1 v; m4 s; {4 H$ |4 ?
-1, // COM authentication1 ~' Y& q0 O" u3 ^' \$ b7 y
NULL, // Authentication services8 i5 E7 v. S; @; W: F: E1 v5 j
NULL, // Reserved7 u7 L; R2 ^6 O$ E! _- K) r; F
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication 1 @: F, r! ?7 |0 j( u: M5 w
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
2 Z) ~8 k! j, T
NULL, // Authentication info
' P8 l& U0 F0 r; [" ]
EOAC_NONE, // Additional capabilities # ?6 U; X) J# T& F
NULL // Reserved5 V/ _5 z2 O/ f- `8 P
);& U+ R4 x" t+ |2 a& x
4 g2 U% d! }# q B6 p* b
if (FAILED(hres))) l# s7 I& Q$ ]7 d q7 d7 D
{
. y( W4 q7 e2 C' k* i9 P# P. J- L
CoUninitialize();4 j" X' ?* \) z; n. y/ m6 r
return 1; // Program has failed.8 k1 x4 i+ }9 F5 W* R1 V/ v
}
4 ^# G% `7 ^+ ]) x8 Q% o+ }
: d; i: m8 d& p4 Y$ f1 P6 R& _
//以上不是必须的，若已有“::COMInit();”，则要跳过
; ^. a0 _0 z6 z( u' h/ h8 y
//步骤3： Obtain the initial locator to WMI
# c6 ^1 K5 l% ^; f% N3 C1 U+ l
IWbemLocator *pLoc = NULL;6 }- T: Z0 Z D
hres = CoCreateInstance(# o* R5 {$ h3 |6 V
CLSID_WbemLocator,
2 Y8 b$ U$ k1 S2 g4 ?7 m
0, ( i7 ?/ A% `5 o/ z
CLSCTX_INPROC_SERVER, # O% O% _4 v# b7 F! l2 a
IID_IWbemLocator, (LPVOID *) &pLoc);
6 P3 u4 A) J9 Q
^- `) Y. T \ B2 l
if (FAILED(hres))
( x' H/ o" s& ?0 Y' w* c
{
( J! F8 j' Q/ b* K! d
CoUninitialize();* e6 k; T+ H7 w
return 1;//Failed to create IWbemLocator object! S$ l6 x8 \+ R+ j
}9 W% N5 x' c7 z E O6 t/ a
6 R/ e( p, e$ f% d% A9 t2 U) W
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method$ z# M, E# \( e/ S! L
IWbemServices *pSvc = NULL;0 }1 ]4 q! x! x- o5 p5 x5 o# f+ e
hres = pLoc->ConnectServer(- @' f( P, j, Q+ L
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace1 P- |8 q2 l h# e# @) P2 Y
NULL, // User name. NULL = current user
$ ~0 z" \4 B6 ?* V% n f& |2 {
NULL, // User password. NULL = current6 l' I8 a) S1 M' b. g/ U9 U" Q. ~
0, // Locale. NULL indicates current
2 w$ y/ z9 y* [! e: t; a: A
NULL, // Security flags., `* \6 v* r2 F4 M" Z7 M- e5 h
0, // Authority (e.g. Kerberos)) [/ M, e. j9 X5 o
0, // Context object , O# t7 V) h1 g
&pSvc // pointer to IWbemServices proxy
/ L+ ^+ p6 {- x) w& s6 U; n
);( g# m5 \/ }! n# I( y3 y
: n- a! @7 `( ~% [$ D( q
if (FAILED(hres))
) E8 k5 y/ i5 o5 {3 d
{# |" v, H: C5 P/ D7 n* a# r
pLoc->Release(); 0 I* W7 { @. m" I$ T! T, t% c# N
CoUninitialize();, ^* D; x" E/ \, S! j X
return 1; // Program has failed.4 B# Y, m$ [5 v
}; v( V7 w9 \+ [/ R
// 步骤5： Set security levels on the proxy
0 M0 _- L0 H+ u9 y
hres = CoSetProxyBlanket(
2 B3 J. S1 E+ Z5 @7 J' Y% z- i6 u
pSvc, // Indicates the proxy to set9 R0 s/ K- B, j4 d% P- c+ p' T
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
: ]3 s5 w5 b8 f7 r
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
0 W' m" y$ P$ }" @2 S
NULL, // Server principal name 8 a7 E% v" O7 f: B% M0 A' ?# H
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
) e8 n/ s4 S" G
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx/ O5 Y4 B- s" j9 L- G
NULL, // client identity" u! G) J! x, z( b! V& E
EOAC_NONE // proxy capabilities
6 ^" R) Q; j: d% h; t, m! F0 ~
);! F$ A. f9 S m
% j) g" k5 s( _! d2 j3 j' h& H+ {
if (FAILED(hres)) b& c: ^1 G) s. p- F. o! e& r" l
{" k }+ q; }3 X9 i T# X# ^3 v+ N8 |
pSvc->Release();
* J2 V9 q: y/ B/ s9 d3 C1 d
pLoc->Release();
# z i. c1 }/ j* M6 C% r1 q: [
CoUninitialize();
, L- U" H4 r# d+ @: d4 o
return 1; - N6 l o6 [$ U" e. |7 K
}
5 g2 x) G Y2 J) X! F
$ x; ^1 ]9 X+ } R8 ~- P" p. E
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
6 f) x/ C o/ y4 i, e1 ~% Y
IEnumWbemClassObject* pEnumerator = NULL;/ [- B0 j/ h4 v* d" l% e4 y
//计算CPUID! w7 `9 u2 ~* c/ L- R
hres = pSvc->ExecQuery(" F: w3 Q2 n# I, f- n3 `! z! D
bstr_t("WQL"),
2 {8 |( P( d" b
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem5 g) ?8 |1 ~% M) F; {1 E
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, : E( C. U' D0 r
NULL, |( w9 D2 b. Y$ [+ F: T' z
&pEnumerator);
) T! w( R1 c+ u7 r* R0 [) h
1 j5 a$ U V) o0 }$ d) T. j
if (FAILED(hres))+ O) c8 h' s0 t' r2 @ A3 l
{3 a$ A4 A; N u- ^* \( o' B% ? N+ C" d" k
pSvc->Release();
% [1 b, N6 F7 w' _3 u" f. F. L
pLoc->Release();
1 B- u1 V; `) \# p& b% U
CoUninitialize();& l. |7 G" a2 o+ a- }8 x
return 1;
- j* J- ^2 Q% E' l% B# m
}
: t' K3 t ^% E1 _- F+ N! B* ]
// 步骤7：Get the data from the query 3 ~" F9 n+ ~( G+ \% r: l, v5 w
IWbemClassObject *pclsObj;
* B' x$ n$ e4 O0 l2 \' U7 j
ULONG uReturn = 0;
$ s: D9 F; g' h' a+ s" Z5 F
while (pEnumerator)( k7 l+ C9 u: n! h
{1 m3 O. u* P) W' `5 v
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, ; l4 v4 r! W, h5 s6 w
&pclsObj, &uReturn);
% u7 e$ a* h) ~3 t9 o
& P8 N8 x( j- F% l
if(0 == uReturn)
+ c, F. ~. V5 ^: n9 i6 m
{ x% i2 ]+ B2 p% S4 ]
break;
3 K N0 [9 R% Z- `# ~/ x" u/ \
}0 ?9 `& D+ Q, _# E3 }# ]; w' D
VARIANT vtProp;
3 Y- k3 s4 w, b
VariantInit(&vtProp);2 V3 N! L+ v- I( x2 p
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
: D7 N8 k9 [5 H5 P: |
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量! w$ C: u1 K1 p5 E# G p7 p
}
4 U5 |6 g$ t( {/ s
! i q7 e* Z8 b8 {( [( A
//计算硬盘系列号
1 k4 C8 s( a J5 R, r, t
hres = pSvc->ExecQuery(
. \% b! x+ ~* _ F: s. m0 [5 f- f
bstr_t("WQL"), $ `6 s- [1 K! o# P, s% a
bstr_t("SELECT * FROM Win32_DiskDrive"),, Y( Z4 Q) g) j' T( f1 w- q7 ]
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
8 z4 k- S: a0 d4 v4 c6 |7 l9 x1 L
NULL,
0 k5 C$ V( g8 h* r, m3 O0 p
&pEnumerator);
# w; p6 c; P% K" t& s+ {7 T
, ^9 C+ }' O: _( U2 v2 Z+ n
if (FAILED(hres))
9 [9 h B4 @' r! M- @( O" h
{5 Q A$ e" m) o' p
pSvc->Release();
0 I0 O3 A8 I5 ^2 j! o
pLoc->Release();6 g. _: ?9 Y7 H3 w
CoUninitialize();) n! N& t2 |& p5 i k; K3 ?
return 1; 9 n1 b7 g. k* I+ [* S3 v7 {
} U; G, D" M5 u; U N
while (pEnumerator)- E2 Y+ ~ V4 W
{3 s0 O: W2 s# H- q2 f( D; _$ p
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
8 q6 o, ~7 L5 R* a3 s' K7 }
&pclsObj, &uReturn);
2 _# V; z& [8 z( A i7 |
( t8 ^0 T- \0 @
if(0 == uReturn)+ l0 p/ `4 X% Z- r# q
{
; @; R' m- E' C) O5 F$ _, E* J
break;. u5 T9 C/ `# o* ?
}
1 [7 B/ O4 ?& C* H
2 t. F* K0 k7 Y- C
VARIANT vtProp;" J+ q% I" F2 t$ i9 w6 M7 J/ c
VariantInit(&vtProp);8 n6 j) E# ]3 i6 a8 A+ Q
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
$ h! `# I4 Q- E9 b3 [- R
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
- r, S* B7 i/ k; P: u# @! m2 u4 k
}" Y7 j, D1 l {0 @4 E! U
+ s' i4 m# s9 a- [- F/ c" Q# g* [
pSvc->Release();: d0 L: Z( k! D- _8 C' g& e) o+ S
pLoc->Release();
4 _5 g+ ~+ L1 T6 X% \ |- J
pEnumerator->Release();6 A2 N! F1 y% c* h
pclsObj->Release();
1 T- P+ t& _2 w- z/ j
CoUninitialize();" K+ \. {0 t. X2 K' @4 Q4 E: p
% [8 ?, ^3 g, Z
return 0;
' {, |7 M9 Y4 b; m2 Z* ]
}4 t* O& N D( G) r& G$ I

复制代码

天云上人 · 发表于 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和硬盘系列号的源代码

浏览过的版块