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

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

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

! n$ e5 e% Q3 ~" b) H c
#include "StdAfx.h"
+ ~$ `! _- l/ v2 x+ |
#include ".\puiddisk.h": `% Z7 [, H% g; s0 w: q
#define _WIN32_DCOM
; \! t% e" Z& H8 @1 G8 c& |
#include <iostream>
1 w* {" x: F5 v. j! D+ `; ?
using namespace std;
1 ?/ G: K) V7 }: @
#include <comdef.h>* O1 }$ D* J+ |1 A3 g
#include <Wbemidl.h>
( x- l: d: ^5 M% s2 T; P
7 J. t% L2 \+ J- P2 h& C7 w
# pragma comment(lib, "wbemuuid.lib")- e% F) l3 ^0 R$ E( D1 }4 Q
CpuIDDisk::CpuIDDisk(void), r( G1 n& W$ \+ d
{1 r9 s/ g7 W8 f' b7 T
GetInfomation();
+ r! g& m, v1 q4 d/ ?
}
]$ l) J. \: d" y. V2 x( a
8 z3 t! ]1 s+ G) L1 O, c' G
CpuIDDisk::~CpuIDDisk(void)1 R( T7 O c. p* h; P+ ~
{, O; X) d" d) f5 S7 X; h( D& T
}
5 U! [6 F ~# A% h+ U
int CpuIDDisk::GetInfomation(void)
+ [1 m1 F$ H3 ?0 Q; O' v- s
{: L( O7 B' G) {- x" z
HRESULT hres;4 E6 i) g0 {, ^
//步骤1：不是必须的，COM只须也只能初始化一次, d/ V$ @9 Y- ]- a- P$ E# i
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
% V* M- t; c& x" T5 t1 |
if (FAILED(hres))
. w. a& y, i% ^8 J
{
t6 T |" K+ K O8 f w4 }8 k
return 1; //初始化COM异常：注意，COM只须也只能初始化一次7 H- [) b B/ E/ O; M
}
5 l4 S/ A+ N/ V1 p: p+ O
//步骤2：不是必须的，COM只须也只能设置一次. k7 q& _1 ^8 _9 h/ Z
//Set general COM security levels
: H" u+ D1 f; O3 s# n: P: l
hres = CoInitializeSecurity(' q9 P- v7 W) N3 C* ]
NULL,
- E' x ]' m/ b, K% Q X: W: O
-1, // COM authentication
/ K% f% {/ ~8 @
NULL, // Authentication services
1 O2 I% ?7 P. a1 p! b! G( R, _- n5 U: _
NULL, // Reserved
* T5 [3 `) h: `+ d
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
+ S5 u! E; T0 y- e" T- }/ y7 R
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation 6 V9 r2 n4 Q8 n4 S8 p/ A
NULL, // Authentication info6 r% I+ P! r3 p5 n
EOAC_NONE, // Additional capabilities 1 @% L8 g8 P2 j6 ^3 b. {
NULL // Reserved! ?- {: `) F3 u7 S
);
9 b1 ^+ u: h* s) X |$ B3 P
! W* _# A7 [/ y# Z/ t# _: k0 Q f
if (FAILED(hres))
1 g; @6 ^# ]7 b. ]6 p. b
{* z5 Z5 S0 X" N
CoUninitialize();" k8 w; S& q. w" ]9 h+ ~" b
return 1; // Program has failed.
( w' e* G& }; R; C1 M
}$ j& D h. h' ]9 u
* K: R$ N1 ?( u; k
//以上不是必须的，若已有“::COMInit();”，则要跳过
" Z* y1 l5 m1 y% c# V0 m
//步骤3： Obtain the initial locator to WMI $ A1 P& @6 ^* T/ i. U B; T, ]
IWbemLocator *pLoc = NULL;
0 \ d+ D/ `& I8 {" W; t- R# ~
hres = CoCreateInstance($ ?9 U4 N d W" ~, D6 z& j
CLSID_WbemLocator, 9 S$ @( k, `' u% X
0,
& O7 W3 L8 J+ q1 M" ~
CLSCTX_INPROC_SERVER,
6 [* Y5 G1 c' g1 B8 j6 N
IID_IWbemLocator, (LPVOID *) &pLoc);
; M o+ A+ L/ F# |& L
" N* k) h8 j) h: F5 i+ a( ~/ f
if (FAILED(hres))8 ~& Q4 o4 W4 d
{
6 M( z/ E( p5 z3 T
CoUninitialize();
* r& ~2 D" v' V1 l0 @. c$ T. V
return 1;//Failed to create IWbemLocator object: M$ J; i. Y7 c9 P
}
1 ?: `( k7 m. ?
; V1 m/ ]* z# C+ Z
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method8 N q6 r3 s0 Q/ q/ K
IWbemServices *pSvc = NULL;
" F4 z! l: h; p& j4 w$ u$ o
hres = pLoc->ConnectServer(
. @, |: w: i% L6 i: Z3 A4 E
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace4 m& v1 m* L2 W& I" s' m! Z2 H
NULL, // User name. NULL = current user
NULL, // User password. NULL = current
! f; R& U; l% k# T& f
0, // Locale. NULL indicates current
+ |: b6 J6 C# `; }6 k4 F* L
NULL, // Security flags.
) U& Y: x! }, R# v/ @# C0 t) S
0, // Authority (e.g. Kerberos)) M' C+ b E: `: {7 T: o
0, // Context object - b( u" w0 K. C4 D3 Z
&pSvc // pointer to IWbemServices proxy8 J' b' v+ c% ~, U8 X0 u* z
); h2 I) d( e5 ~6 u3 A8 a
: k6 z) d8 H, G( b
if (FAILED(hres))
) x+ m5 g1 L* Y) g+ D s2 B
{ c; I& ~& s- r
pLoc->Release();
2 G& D! k @- d. m( ]% ?& V" d& c
CoUninitialize();# q9 o; h; P; ^, ]' l, z6 G3 f
return 1; // Program has failed.' S; j9 j1 w1 X$ Z- J
}3 [+ a- g4 y# ?7 |8 `+ ~
// 步骤5： Set security levels on the proxy2 s6 I9 o# A% o
hres = CoSetProxyBlanket(
6 y }2 }: u$ M1 P
pSvc, // Indicates the proxy to set
) p1 |: z% v; j& q3 m* H# k5 p
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
4 I4 t* V, g1 T0 T- Y& m
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx, H& H" ]$ v' I7 M
NULL, // Server principal name
3 I$ H( @; |6 x# ^1 M+ x3 d) M
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx ) N5 R- |. \" c/ ^- b Y6 L# f
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
* T7 [& T( {6 z& R5 H
NULL, // client identity8 p* W8 ^) W r2 ^) E
EOAC_NONE // proxy capabilities 6 B: q. k g; i2 e1 V) d: ?7 S
);: c& E9 ]1 o- \; I( F
0 C! C( K. ]5 U6 s# I
if (FAILED(hres))$ Z, r8 b' y# ]( _6 u; o
{3 H2 _0 e, Q# B' F
pSvc->Release(); X8 V+ y( h* A
pLoc->Release();
# N" H* g7 ~+ F7 _% V5 B5 A+ }1 h
CoUninitialize();/ ?" }6 |# T6 n. Y, x
return 1;
0 J# \( B; W! T5 f" u; o" D
}
2 S$ ^8 ~1 h3 I) }8 i, L) V7 t
+ s9 k- S- @- u; J% D
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
. C4 H( C& K2 m5 p; d; x9 r
IEnumWbemClassObject* pEnumerator = NULL;3 X. y- t& `7 }* t+ H$ F4 i
//计算CPUID
U$ h, B5 m- w, {
hres = pSvc->ExecQuery(
0 u9 i, E3 O; |" R- l+ k2 D
bstr_t("WQL"), 2 {) q6 g6 n% \2 t5 G
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem6 o' l6 a; x3 G M0 H# _
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
7 j" g$ o( g9 K9 w$ n
NULL,
) r$ P7 a& Q. K3 w3 {
&pEnumerator);; l! n4 U, }; p m; ^7 T. K
3 v6 M- w6 N2 y0 [7 Z, v+ y N
if (FAILED(hres))5 o, T4 ]$ _1 V' |2 \) q% T Z" f
{
' S( g4 e+ V7 F" h
pSvc->Release();
0 r" Q; h% `; A. |' R& Q3 l$ Y8 f
pLoc->Release();
6 ]1 b* Y! e4 y7 y- Q0 w& C8 {
CoUninitialize();# Z$ b2 n8 l" G9 W1 Z
return 1;) h; t4 }( n- h
}
, H9 F/ j0 n8 Z2 p1 n6 U3 L
// 步骤7：Get the data from the query 6 V3 ]3 D* m7 D) `8 X
IWbemClassObject *pclsObj;
' F9 R. ?& G8 f" A& [. d5 {
ULONG uReturn = 0;+ L* Z' d& m1 ]
while (pEnumerator)( _+ u3 m6 D* w2 F6 {* s4 a4 y
{5 l3 Q, {9 [6 f( G7 i% D
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
! O- j; h& \1 }
&pclsObj, &uReturn);
5 k# ?$ W3 e7 R1 f3 @
& I6 S8 P$ A9 C# l' X7 o8 O0 e. E
if(0 == uReturn)
3 o( W* J' W$ ^$ }3 j/ A
{
" m4 }7 I8 e d5 b& Y( U. [0 x
break;
) Q% Z2 j; H3 p" r% d% B( ^
}
& V7 y9 |3 ~( @% v4 ^
VARIANT vtProp;
1 u; v4 S, K2 F! W3 a
VariantInit(&vtProp);
6 j7 Z3 R0 i5 g) z$ w& d9 B' L
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
- ~' K8 _6 A3 i
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量1 s- i z& x7 K" h/ P! o
}, b$ p8 ^; ?# R/ d5 d1 `
4 H+ B5 o9 C a% w( [
//计算硬盘系列号
) n3 \- ~$ O% @" M4 n5 ~! X/ C
hres = pSvc->ExecQuery(' k4 N- b+ I6 l% S1 r
bstr_t("WQL"), $ n; P5 L9 G) P. y# g6 G# o
bstr_t("SELECT * FROM Win32_DiskDrive"),$ G; m+ h* ^5 i& G; d% u5 F
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
4 ?; d1 s+ A3 c! l
NULL,
2 F8 v L3 P- H( z3 i
&pEnumerator);9 @& j0 u! u/ q( _) O( L0 h
: ]4 ^$ }( T, U. X/ @# P/ d) M8 q
if (FAILED(hres))
' E, Q2 c3 r6 O0 z" F! [; K
{6 s; @( ^ j2 @1 C: |- A ~
pSvc->Release();
' \9 `8 ], O$ r& F* A1 ]. W6 r0 J
pLoc->Release();% z' R$ c5 Z' J5 Q! u
CoUninitialize();
) B% H0 q; ^8 [; Q- }/ C
return 1; / Y& U# d7 Z* u3 A5 D7 Z `3 m- c
}
) ~ m9 v6 [- H: L7 h7 G# @! g8 J
while (pEnumerator)4 l1 H, K. @- y) S8 ]
{5 N% X( s% B3 u/ ]* M7 g
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
; e# |3 R q4 v, O" b3 V
&pclsObj, &uReturn);
/ ^' T# g5 {) B- I
( M1 \6 t) b0 z& ]
if(0 == uReturn)' D) Q! }4 ^! j" ?# k5 o( x
{
0 W- l2 {' {3 }- X. ?$ o
break;$ B8 J# J! q6 [( K6 K5 A! Y
}
( J' I& y: B' n& L- T; I
9 b) h2 r7 J/ Y; I
VARIANT vtProp;$ U# r U% p5 F6 O* h7 K
VariantInit(&vtProp);
) s7 w y; M2 o( n' ]: B. g
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);! d5 ?( j, y' U4 C9 v$ N
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);1 q# }- I; J( V6 D# Y8 t- E
}" R2 @: M- U7 M: B
k5 v# T6 p1 R" t( g. k) V
pSvc->Release();$ E) s! ^3 T" d0 N
pLoc->Release();5 o' @/ w1 l; E- P: j2 B3 s. n
pEnumerator->Release();
7 q0 j. D* j, R% U7 Q2 h
pclsObj->Release();
4 A1 O) C# D" j
CoUninitialize();
- p( }/ t4 M9 c0 z* s- Z w
- f m' V+ Z7 v( |$ P) L- J
return 0;
+ y8 f T0 B5 g+ D6 h+ i0 R
}
, T% F* P/ f9 B5 w4 x

复制代码

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

浏览过的版块