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

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

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

4 k" R+ F% y8 H& X L
#include "StdAfx.h"
0 W& h% o0 o7 ~! \% K% W
#include ".\puiddisk.h"
, E( z; B0 X' J3 w
#define _WIN32_DCOM
' ~* b4 ]9 L8 {3 I
#include <iostream>9 d# A1 {2 o6 c
using namespace std;
5 z, G' e, ~: E% L
#include <comdef.h>
* t6 |' T1 H2 @# G
#include <Wbemidl.h>
: w& A, r1 _# m/ R/ @! T5 u
7 u4 ?# T/ K& ~ r. {7 G
# pragma comment(lib, "wbemuuid.lib")7 U0 u D& v) |4 e
CpuIDDisk::CpuIDDisk(void)% L5 W" P- Q n# x$ g2 ]- A" D& n1 c9 m
{
: p/ n, Q. B; e7 D( J
GetInfomation();4 F& C5 `0 q! x* \# R
}+ g9 y! V2 h8 r6 W% ~# h9 x
4 [, e+ J) K& {
CpuIDDisk::~CpuIDDisk(void)# `- ^, M, G9 x$ ~& l4 Z. ~
{+ }3 n# u- G0 {- j q/ W" n b) j
}' P7 `! b; \9 a6 d7 T3 e. ^+ A
int CpuIDDisk::GetInfomation(void)3 ~( W0 A8 [! `8 w! q! [% ~
{
% O8 z1 U$ q& @ r6 a2 P- A5 L
HRESULT hres;
6 u% U4 R& ~9 t2 i% x# Z
//步骤1：不是必须的，COM只须也只能初始化一次7 F) u( x# s7 U* G
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
9 i5 l7 w4 N5 x7 Y+ c/ Q; `
if (FAILED(hres))
0 v( \# }6 I5 ?
{5 x/ z8 w/ |% a6 [0 v! P, Y. |
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
% Y4 g; A# W7 {8 R. H* E4 t
}% x1 u% N( x& X
//步骤2：不是必须的，COM只须也只能设置一次! h& y* V- S% f3 m4 h; M
//Set general COM security levels
: d: d; u( v) \/ w) o. f' v+ ~8 L
hres = CoInitializeSecurity( i3 e/ I- T' W( S' D/ |( F0 n7 f
NULL,
! Q' ^5 ^( X& H5 {
-1, // COM authentication6 e- Q; Q* w w2 q! B# {( y
NULL, // Authentication services; R# r* J9 p& ~! Q
NULL, // Reserved
4 j$ N& i% y8 _
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication ; Q2 r$ R0 x0 D
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation 2 ]) Y# i3 B* T: ?$ H. B
NULL, // Authentication info$ u; Q/ E& y9 W" _0 w+ j8 H' w
EOAC_NONE, // Additional capabilities
0 d$ ^! V- S) y2 T1 |% r
NULL // Reserved
. O C9 X. b) v9 P$ U2 H
);
/ N5 ]( ~4 ?! y9 o3 t
3 w1 H3 I7 g4 l
if (FAILED(hres))
3 X; n! Z$ M* v( J. X/ ~
{& w: r, U3 D/ \: E- w' ]- T
CoUninitialize();
0 U1 Q& z% \! d
return 1; // Program has failed.1 I8 |$ X6 q) |
}9 Z* u5 K1 P! r3 ] v: G: |
. A" W M. e5 L( b T7 m
//以上不是必须的，若已有“::COMInit();”，则要跳过" y" F9 n& C( V- ~! o9 H6 J
//步骤3： Obtain the initial locator to WMI 7 \9 t2 f6 [9 X4 F; w- F5 U
IWbemLocator *pLoc = NULL;7 `" q% ^* |' E# M1 e; }
hres = CoCreateInstance(6 N7 ~; _4 t, C5 _% O
CLSID_WbemLocator,
5 _, P1 u9 w" h X; S
0,
4 a, j. j6 o" n* L
CLSCTX_INPROC_SERVER,
t# X {1 e9 E! v8 p
IID_IWbemLocator, (LPVOID *) &pLoc); G9 F+ e7 Y1 f r1 C- Q
, h/ g% z1 O9 F
if (FAILED(hres))* `, t$ S$ M) q4 Q* T* @
{" D# a6 C3 X3 V( X+ a
CoUninitialize();
2 J4 X& |4 W: K- s% g
return 1;//Failed to create IWbemLocator object7 w' v8 n" c- ?2 C5 u' S) r+ ^
}: W. `$ j) l$ N# ~
) A3 s' A, ^' i1 @4 |( T$ X/ ]0 `
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
7 b% S' ?/ y4 Z; c5 k4 }
IWbemServices *pSvc = NULL;) b$ A' G2 y9 Z) @
hres = pLoc->ConnectServer(
3 ~8 t K6 e" T/ K! w7 o9 k$ z
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace2 K1 X" ]4 l1 L/ q# h# a6 X1 T
NULL, // User name. NULL = current user% I& o# P/ }+ K' X
NULL, // User password. NULL = current4 i- ]5 u; m/ s$ z S
0, // Locale. NULL indicates current7 P2 M+ \" X0 }1 V- o6 ~
NULL, // Security flags.# n0 ^( h6 c" I8 ^ P
0, // Authority (e.g. Kerberos)& ~$ s/ N! l N! I+ B% v
0, // Context object 7 ?1 T- t+ [+ \
&pSvc // pointer to IWbemServices proxy
) M+ g" h/ \4 I0 q
);& v% p' S# P' G. }' p' O
) E* ^9 U/ n1 u6 n
if (FAILED(hres)) |2 t9 x' l9 L* J P
{: m# H8 p4 H) p' P
pLoc->Release();
% v" y' {% R+ I. {% I
CoUninitialize();( `3 g2 ?6 o5 j1 ]) F) Q! a
return 1; // Program has failed." k2 }* P' \3 Y- {6 T- I H) x8 E2 l
}6 c3 g! T5 H$ {1 F0 t
// 步骤5： Set security levels on the proxy6 V9 i! |1 O: Q' R+ r
hres = CoSetProxyBlanket(% ]. m8 X8 A4 x0 Z5 c* i' G
pSvc, // Indicates the proxy to set
! N, ^: O* @9 p3 E, r/ x: w: L
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx/ u. G- Z- R( i$ n, p% i
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
7 M/ m" i9 z8 }% |) Z) }
NULL, // Server principal name
/ P. z. A$ I8 v
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
. i* P- b. k; w! L0 E
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx& N3 d; p/ {. r Q J( J
NULL, // client identity
6 x, @2 F* k) Y8 ?; k$ B- l
EOAC_NONE // proxy capabilities
$ b& e" R8 V' q3 R0 C
);
: ?4 l" J; [% `. v' U
/ X6 k4 [( K9 y
if (FAILED(hres)), Y# _9 S5 P: H( E
{
, j. z- B" e% |# J% Y' t
pSvc->Release();( }, ^" i' H1 i( v7 `- x
pLoc->Release();
# @! F2 Q* t, G+ [% u; R6 E
CoUninitialize();
2 I1 V2 h/ x7 o: [' @. t
return 1; 1 B! p& v- g7 x
}( _3 N0 h* a, y+ P+ O: j) e1 ~( C
4 p6 A- m- Y7 L; w! D! u1 n
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----6 y1 |& \. d' m z9 C
IEnumWbemClassObject* pEnumerator = NULL;" B0 ~ |# q4 z* q
//计算CPUID) r- p9 p( w8 r
hres = pSvc->ExecQuery(
& a9 C- \; |9 D m! z' s" b1 d
bstr_t("WQL"),
w/ s' B6 D6 O" w) C \, K8 |
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem5 W, B3 `' S, l# {1 o4 Z
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
}( |6 y1 Z0 ]9 e- X$ U
NULL,
& C6 u, F4 Y. f6 Y
&pEnumerator);3 f. r) }0 H( G" S# r
) u" |) c8 @0 C2 s: U
if (FAILED(hres))) s5 g9 T f) b6 H: H' l8 G1 t7 [
{
' A$ Z; w8 F. Q- `* D6 o) B
pSvc->Release();0 u$ j3 p% n) a2 M& o3 a0 f
pLoc->Release();. t# m* `, A1 y4 u. o( J
CoUninitialize();: z8 `0 R$ d6 o- D) C; ^ E) j
return 1;; q8 i; M4 ?3 u$ J1 J: p
}
$ x5 X8 C9 |8 g8 x
// 步骤7：Get the data from the query
: Q1 h/ a, `* `6 d5 d; Y- a9 H
IWbemClassObject *pclsObj;
) }; \& e/ p" s- y' U% X, s
ULONG uReturn = 0;4 k8 A8 w( b1 E0 a# ~$ n
while (pEnumerator)+ O! X- u4 t' D7 j+ Y# ^& ]
{1 |7 c( f3 A6 g1 p# @1 k6 X( K
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
; z% t3 v! ^) m6 ~, V f+ y
&pclsObj, &uReturn);8 k" u% y: S( {$ p X/ g& W) i
% H- I5 Q6 I1 }1 q( J- C9 K
if(0 == uReturn)5 l# G6 a3 f& h8 C* m# s
{ _& c# X. N4 x4 b8 ?2 G
break;
+ \- d) H4 ~( N: B
}# a# E' Y# _3 S+ O3 l
VARIANT vtProp;
; `& w0 N1 @3 v
VariantInit(&vtProp);1 } R: ^" s' U7 {2 h
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);- Q) V( C; L/ K2 `2 B" d
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
( N# p) ~ E& Z5 K! P4 z2 Y
}
8 g R+ i! }0 H! h! _
# X8 e( L/ E" f( B
//计算硬盘系列号& G& @: `& ~# s/ v8 L
hres = pSvc->ExecQuery(" w5 w7 O) H) u; e
bstr_t("WQL"),
: w& W1 f1 n7 s7 M1 {
bstr_t("SELECT * FROM Win32_DiskDrive"),5 }. ^1 B2 S4 n
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 6 ~/ t% E6 _5 U6 x6 i8 A8 s8 w
NULL,: p( S: |1 E) l" f! i1 M5 ^
&pEnumerator);3 z% M3 T3 u. ?! S+ N4 x9 S6 c+ p
" \* v ~& @" [6 ]3 J3 w
if (FAILED(hres))
4 c7 R# X* H3 L
{
! k) M6 a+ ^& I" y) }: f
pSvc->Release();
1 h0 r6 X" k% B
pLoc->Release();
4 j# ^6 S. J0 A0 L5 K& s
CoUninitialize();- Q6 L( f: f8 b5 r3 L) V2 `0 Z4 g
return 1;
% q2 t$ t7 J" s( \5 ?+ U; ^
}
* ?$ a. {7 t" b+ ^% o
while (pEnumerator)
) p( z, B5 X) V+ h- F. T
{
, i m! ]( _; p" I( i% O. M0 d
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, 2 \ D% ?. ]9 H& b' F
&pclsObj, &uReturn);
+ `# Y. i9 M0 m# A& i7 w
7 C7 W- g' I0 s p1 {; n8 M
if(0 == uReturn)
' v6 ^/ a& P# K$ j
{
, K$ z( j, o5 G3 D$ t, ?( k3 d
break;6 J6 y* B# M2 O; n
}' a( U, m- X4 T; t
: G" ]- P$ [4 p/ q3 G
VARIANT vtProp;
3 F1 t+ f* a" w
VariantInit(&vtProp);2 u$ u5 g8 d. L1 n2 t- R, c, g
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);; f8 t" \. D! _+ y8 D) Z) n* y
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
6 f7 p8 J+ {5 w$ G6 o# M0 ~7 C
}9 b" l& ~$ |( @1 ~- U1 b
) b' l5 n$ r- ]5 K# g
pSvc->Release();
2 g _4 n% a' ~4 D5 p @6 x
pLoc->Release();4 l* T5 K! _. W6 g5 Q* y* j1 k
pEnumerator->Release();/ g9 f, _5 K8 f) k
pclsObj->Release();7 u- t" Y \5 o
CoUninitialize();8 M8 V9 |" q+ \5 ^8 n) S
' v5 `3 g1 ]" x' E
return 0;
* I: T' N- O9 y# t4 C+ L
}7 t. D* e: Y, P0 [

复制代码

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

浏览过的版块