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

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

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

: ^- Y7 J# d+ ~& s, |3 j
#include "StdAfx.h"
) Y7 x2 m/ J, R+ j
#include ".\puiddisk.h"
! f- S' e" w5 N; h/ z$ O0 p' Z1 k
#define _WIN32_DCOM) b' i$ l: z) h7 s8 v# j+ y
#include <iostream>
5 p6 H N% y/ P% f
using namespace std;
) S/ ~+ L% H# e' d7 ^* K
#include <comdef.h>9 R3 t3 P/ i6 y: K: z
#include <Wbemidl.h>
5 L$ A. h6 x0 @0 v. Q0 I+ C' z
+ J2 ^& O/ Z8 q8 L2 y
# pragma comment(lib, "wbemuuid.lib")
2 O2 H* g$ k+ v) P) T
CpuIDDisk::CpuIDDisk(void)
* \- |' b2 l& Q
{( a: w, ~: g; |& C0 j8 E7 Y4 s
GetInfomation();
5 W6 Z) p! L0 o
}
, e9 A" C I+ |3 d& r
6 q0 u A5 Q/ ]6 M2 a% y
CpuIDDisk::~CpuIDDisk(void)
' }9 S [4 i, s9 M5 T/ K
{
( n+ _1 N9 @% m; J, r
}
! S. p% q: G5 r% \
int CpuIDDisk::GetInfomation(void)/ B8 ]: s2 T& S7 z) |( C9 |
{) z+ _/ b/ m; G4 ]6 q% R
HRESULT hres;5 J# g- u4 k) j/ w: C
//步骤1：不是必须的，COM只须也只能初始化一次
# G) W# S; H! d
hres = CoInitializeEx(0, COINIT_MULTITHREADED );& q0 p) `* q$ M; [, q' k( H
if (FAILED(hres))
7 @% {1 f. D) B, ^3 b% o2 n' h
{
; q2 X0 b& Z: w! X$ W
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
7 ]- S9 z0 H Q
}! ]# O' D* C' l$ P5 I+ ~6 M
//步骤2：不是必须的，COM只须也只能设置一次# N) t; ]3 D7 t
//Set general COM security levels0 ?* R" d L I5 g( V
hres = CoInitializeSecurity(
; |1 G! G! I; A5 t$ G* }( S1 |( @
NULL, 6 Z% @7 p# ?' k4 @2 W
-1, // COM authentication# y1 Y; w6 a7 q2 u5 Z, }. |2 }
NULL, // Authentication services
! a- i0 u4 `. @5 C8 y
NULL, // Reserved- N7 \+ V2 z) \% E2 Y' S
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
4 o( x* c6 j h8 A
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
" z1 O4 c6 z: x6 | L
NULL, // Authentication info
. ]$ y8 V. l/ c9 |3 c W1 d
EOAC_NONE, // Additional capabilities
# k! j$ v& P7 S: b4 G. x# o
NULL // Reserved
% A: u* {8 Q' B
);* H6 X' ~5 g R- b6 j, i
- p, @0 m: s1 A. ~# T% S
if (FAILED(hres))
* r/ @1 I! y6 n' Y
{; W" Y9 }5 h& J9 v0 A5 R9 r7 V, V+ q
CoUninitialize();
% z6 g M" R8 }! v2 U
return 1; // Program has failed.
6 X0 @" n/ b0 a( t1 ]
}7 `% z1 Y' \7 Q/ B& r
0 y" f9 q8 U% A0 V
//以上不是必须的，若已有“::COMInit();”，则要跳过* Z1 }/ N( H0 z9 X
//步骤3： Obtain the initial locator to WMI ; k/ l7 q+ _" x( _ H: u4 u
IWbemLocator *pLoc = NULL;: C, j5 n5 N6 K6 {- _. q
hres = CoCreateInstance(
5 d: x9 ^0 B. F) i3 L
CLSID_WbemLocator, 3 O( j# M) t3 W2 j. y
0, 1 m4 ~6 c3 O7 V' [0 f# Z
CLSCTX_INPROC_SERVER, $ o; C9 ]0 D9 D
IID_IWbemLocator, (LPVOID *) &pLoc);- b" | D. P! C5 d! |! q
: y$ V) l5 s# R/ u( d, F8 u
if (FAILED(hres))
) K) O0 y$ Z6 X9 [7 g+ x8 D7 j
{
. `$ y1 V: |. }9 t5 k
CoUninitialize();
2 O: u) H' \# x& \, r( H v/ ~# q
return 1;//Failed to create IWbemLocator object
$ {2 c3 Y5 a7 M, n2 k) O* x, C
} J; a o( ?: L6 r
; U( R* B& d; i1 D/ D
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method. R0 Q/ M( b$ B. w
IWbemServices *pSvc = NULL;
4 r9 z5 w' c6 r5 \) f: T. \1 Y
hres = pLoc->ConnectServer(
3 M1 i5 T7 ]0 A, h& ~
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
' Z, v! \, s4 U
NULL, // User name. NULL = current user) U& J5 i5 S0 C8 T, W) I; V' P
NULL, // User password. NULL = current& c: Q6 }/ x; C" } u( U w
0, // Locale. NULL indicates current
7 {, H: c1 {* C* I2 i2 `3 c% ~6 B2 I
NULL, // Security flags.
N' D( e/ N7 B) V
0, // Authority (e.g. Kerberos)
/ |6 X0 I* m. l# M, L' o1 ~. H
0, // Context object 7 ]3 t7 z5 }& `( @5 I$ D. I+ E
&pSvc // pointer to IWbemServices proxy( T& d* H Y; r) c* I
);
- d$ X/ }$ _, t% X9 I* D! D6 p
, N0 }; \* x; Y* D" {
if (FAILED(hres))$ l# i' j" m9 t' ~3 W. Q
{$ r0 q3 u6 X8 {4 G* ]$ d# E0 s( v
pLoc->Release(); - U/ m; p9 C* b! a7 X
CoUninitialize();
: _/ F6 d! r! F+ l8 M; {
return 1; // Program has failed./ ?" C/ _5 H* x+ J
}, G) \$ T% w5 q+ Q
// 步骤5： Set security levels on the proxy
/ H0 x E0 q5 r8 M( G! n. c; s T
hres = CoSetProxyBlanket(+ G& j. j% {; ~ U% ? K+ |7 W1 K8 k1 ]
pSvc, // Indicates the proxy to set5 r( \9 \7 l6 t3 g3 P( q
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
U# x' [9 p5 `2 Y7 \
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx* O. Z4 \: ~4 @
NULL, // Server principal name
/ N& `$ q8 j4 ]$ M7 e( W
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
& C& p4 C( V+ K. B$ S% h' m/ V; [
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
! t. a# l5 b- ~5 ^: C* ~4 `
NULL, // client identity
4 y1 D9 T; f% Q+ _7 P2 b8 l. H2 ]
EOAC_NONE // proxy capabilities 4 P' b, o& v h5 X# ]) s
);
) A1 ?+ Q. |% N2 a( l& f5 ]
) i. |% M# V% M5 {
if (FAILED(hres))+ ^8 U* z! h+ E1 I
{" E* }% t$ I4 ]- Z" {
pSvc->Release();8 i$ O, \$ ~) h; I Y6 {6 C6 H
pLoc->Release(); 6 M5 T+ ^: t/ S' W4 A3 n
CoUninitialize();
' k9 o+ m& g% R; t. Z
return 1; , m+ d7 s" R0 _* h0 }$ u, O5 Z- J
}
) n! f: F& R2 [
: M+ A0 o* d; h/ y
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
; d6 H1 f( R0 Q; l% x
IEnumWbemClassObject* pEnumerator = NULL;
6 l% E7 x" Q* [# s2 w6 k
//计算CPUID
}6 a0 h; F& h# H9 c' V! b& s
hres = pSvc->ExecQuery(4 u8 i6 K4 c: H
bstr_t("WQL"),
+ b9 E, u4 x$ H9 [
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
4 j" e" q% l- R. ~: \2 w4 ]
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, ; v4 X% k! B% o" P
NULL,# Q" h" f0 [" _* G N$ g' N( C( i
&pEnumerator);
& Z2 x0 _: k, g2 B! v7 V5 H9 x% U
! i/ w2 `3 K: D: t. O0 \
if (FAILED(hres))
9 O; W a) j; @. ~
{
3 ~- t7 p+ s; ~9 ^5 @' q, \
pSvc->Release();
! v# V, x0 |$ Z4 R+ v7 c: V3 c
pLoc->Release();+ s& d a6 o7 {1 c' c& B1 m& {
CoUninitialize();6 _7 m- m& B. i* V$ e
return 1;$ j) A) J& _9 {4 X2 _
}
. B3 [- J3 p% G; J% _& |& k: L
// 步骤7：Get the data from the query ) ~8 b) e2 |8 w
IWbemClassObject *pclsObj;
' O6 [# d8 r/ z7 y
ULONG uReturn = 0;
( d0 ]5 ?5 t7 S `- J
while (pEnumerator)
, v+ L8 W" l+ E4 o3 R4 M
{9 W1 d! b1 f, b1 f# ^
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
: g- U9 y, E, N
&pclsObj, &uReturn);, s/ B! z4 v% z( a' h% M
) D- M+ B) R( z0 X4 [* I* g
if(0 == uReturn)( Q, J, x8 f) T% Q6 A# z( b3 Q
{
+ U# i2 U( x: {9 w i1 @
break;
; R, C2 V& R8 p1 y
}
! X F" V& ?0 c8 k! E% X- q2 R
VARIANT vtProp;
3 F5 g3 j- m/ H6 e$ c0 b- U
VariantInit(&vtProp);& _. B, i# K! j" ^4 S# Q2 |
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);) `" ^* w2 L9 d' [
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
& b8 u' R6 E `+ n! c9 P) z
}" ~* O Q7 I* m0 g: `+ {! a
3 w: E4 W& i+ k3 \! p" D; F, L- b
//计算硬盘系列号
6 A4 D$ g7 w! A, j7 E
hres = pSvc->ExecQuery(5 L, Y6 y, ?7 y* p
bstr_t("WQL"),
7 i$ p' R9 O8 B
bstr_t("SELECT * FROM Win32_DiskDrive"),
2 Q- o: u4 s$ u
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
6 d. |& J& m" G; J
NULL,: }( l. C2 x: I
&pEnumerator);
+ [0 h0 c9 ]& F2 ^9 p# ~
; D5 V; o* ?' `; I3 F0 v, U
if (FAILED(hres))8 b. c8 W, W/ H2 Z5 ~7 U
{
- ?1 O1 F4 [: A( ~2 W$ }7 J
pSvc->Release();- U# j) S4 N( n- p
pLoc->Release();
% G: [7 X: R" P, C; U" O
CoUninitialize();" s, `* A$ |3 V, b1 g
return 1;
( R2 q a- A$ U4 i8 ^- J& |4 r6 P2 w
}
6 `; [0 }1 W; Q f2 c; G7 Q
while (pEnumerator)2 P( [7 P9 e$ `$ P$ i2 a* T
{
2 s; v$ T& z2 ]( X
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, . w/ F! V$ b# p" j2 L
&pclsObj, &uReturn);
$ F+ n1 \7 r) A* l r, `
8 m; U; F$ T, X1 _0 K
if(0 == uReturn)! W' H1 e- _; j: [! B' X
{
j7 f1 ]6 R4 F+ {5 e
break;
& S& u1 w7 k% Z
}
5 z8 M1 ?7 |- S( a( T; y) d+ `5 q
; ]2 T" l& D' }) J$ d
VARIANT vtProp;, y& |7 g' X% s, q* l( w
VariantInit(&vtProp);
5 W5 U& z3 ?, Y4 x I, O( N
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);) \ n. B* S$ g/ N- c
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);- z; e+ \/ _& T! f% Z6 T* l
}+ w2 s! b0 k5 t; v# N' Y0 n9 M* }
2 Y. ~! o) A2 r
pSvc->Release();
2 [4 u: b; v, h `2 q; Z
pLoc->Release();1 i' c4 N- {3 M2 k
pEnumerator->Release();# ~* Y7 r+ i% O g/ A! Q& P1 P
pclsObj->Release();
' O1 \, T5 N7 m: g& z4 N
CoUninitialize();" Z+ U8 R" B, e2 v' b* G6 Z% U
7 y6 R" K0 y( _1 S1 R7 m
return 0; " Y7 \/ g# B& ^% J! y6 T
}
# H8 Q9 C; B, L3 h* Z8 m

复制代码

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

浏览过的版块