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

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

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

2 n3 h7 A' v1 q7 ]! ]
#include "StdAfx.h"" g/ e( f; n/ L/ M7 _
#include ".\puiddisk.h"
4 a( l0 Z3 e* [8 I
#define _WIN32_DCOM
1 K* \) _+ c4 H" d4 P% ?% ^
#include <iostream>9 B$ M( {" \1 p: N
using namespace std;6 Z& m6 F7 v, N/ V3 l- Y& P+ H
#include <comdef.h>
8 Q$ v6 M; q# [/ c8 O* \# a, k2 W
#include <Wbemidl.h>1 @5 |4 Z4 `0 F! d5 T
! n0 z y# ~8 [* }
# pragma comment(lib, "wbemuuid.lib")) ~" s2 o) I, B% E! e# _) }
CpuIDDisk::CpuIDDisk(void)7 _2 e( x( R% k" W" l" `0 Z
{/ Y+ |- g- ~ {6 h& Q2 p( ?
GetInfomation();
& x \" }( F9 u) Y5 Y5 \
}7 S* A6 P1 M# p h, j
1 T3 t. C( N# s2 ^, L# T8 Q# Z
CpuIDDisk::~CpuIDDisk(void)
. [, b' D% P! u. v6 o
{5 j) c) g4 U, A, {/ S# ?
}! a9 U5 | |* A8 Z
int CpuIDDisk::GetInfomation(void)
( F0 O* v' X0 M' ], z7 F
{! y {! h2 l& j6 i% _
HRESULT hres;. `1 K3 O; c/ B+ Y
//步骤1：不是必须的，COM只须也只能初始化一次- Q/ {2 `9 m; {* [8 z7 j/ }: ^9 G
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
7 G/ A6 R5 l8 X. b% o
if (FAILED(hres))
, a0 f0 f6 j9 o) V2 N: V
{: H) c! H; i: p2 |1 B3 d
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
0 v- ?! P. g* S4 ]# I) A4 [
}
# b. d" X; {$ I
//步骤2：不是必须的，COM只须也只能设置一次
r, f; [+ e! y" k' `
//Set general COM security levels7 e2 n* ?- x7 N% O9 s9 k9 W- V
hres = CoInitializeSecurity(
$ t0 ?8 H, M, _" L- l7 h8 o
NULL, 2 i- P& T) y' O! K& K9 Z3 m
-1, // COM authentication
" I: e- E: q3 O. \! O6 a9 J
NULL, // Authentication services
! d6 q' X: I, @2 u
NULL, // Reserved0 V) P1 w+ ]3 I6 g5 t2 `6 M
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication ' ?' A" {% j2 T( K* x- s C1 S
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
^) R. q" L8 r' h# S* N
NULL, // Authentication info6 p" ^* k. t- }) M( ~0 X
EOAC_NONE, // Additional capabilities
7 k+ n4 o' ^0 s+ H& d& ^) n" U
NULL // Reserved3 o; o7 L' W* O% A R) n' y
);8 c3 Z( I1 c7 M5 I; _3 z
0 ]1 M; }' B+ _- a
if (FAILED(hres))
% B1 [# ~! J# b+ n( R
{- d% G/ Q# i. U+ ?) D) Y
CoUninitialize();
/ s- R! p' s: H6 }' m
return 1; // Program has failed." Y4 b: x1 V# Z5 \, B6 d- n; ?
}+ R3 `( |* u3 q
" Y# A5 R4 z5 i/ t+ c2 T
//以上不是必须的，若已有“::COMInit();”，则要跳过
2 z& y0 N' ?! ?! j2 Y3 C
//步骤3： Obtain the initial locator to WMI # ?9 S; b( N* j9 [7 O9 R; f' }
IWbemLocator *pLoc = NULL;
' c7 [4 s4 Q6 l; c" M
hres = CoCreateInstance(
1 M7 M4 X& h n5 N( h
CLSID_WbemLocator, 5 M0 L: l- C# \2 v& B
0,
4 ]+ ?4 V ^. I6 U% A2 `& I
CLSCTX_INPROC_SERVER,
4 C( F* j4 b( u0 L' N9 i6 m
IID_IWbemLocator, (LPVOID *) &pLoc);5 k: g9 W& E* F3 O7 P. [
( ]+ J; Y* Y6 q! L4 u+ c
if (FAILED(hres))
3 _/ A" c! l$ l) p& @: k
{- z P% R/ r- H4 S
CoUninitialize();0 P& A5 |; r8 |+ }( F& }6 D
return 1;//Failed to create IWbemLocator object0 \- g( r$ j2 `9 |# D
}8 B9 w: y9 ^7 s$ S
" a0 Z) N. ?, ?2 A
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method) S- i8 ^/ n6 _- t9 q' ~. X% a
IWbemServices *pSvc = NULL;! u5 P: l: @7 b# _' z0 ~% `: x x
hres = pLoc->ConnectServer(
4 ~; a0 Z9 p9 ~0 k1 q+ O
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
0 v; v I I$ z# p) h" X
NULL, // User name. NULL = current user
3 e V( F; h9 D: c9 J+ x
NULL, // User password. NULL = current
# s8 o: ?+ ]7 V( @' l# y
0, // Locale. NULL indicates current
; l' p; L n7 F) D6 R
NULL, // Security flags.
3 H, N4 k/ c1 ?4 `& Z$ t5 D
0, // Authority (e.g. Kerberos)
$ `4 r3 T' @8 j
0, // Context object 6 O, y( C- n- B
&pSvc // pointer to IWbemServices proxy& u6 u" L. B' z- k, E# p: \% s
); C) f1 k, ~5 J4 f- A
! w0 O4 @% G9 [+ h) g9 r5 ^
if (FAILED(hres))
* { C: B. j( E! O, Y6 ?1 l
{
: b; @- Q5 l6 l( D& @" A
pLoc->Release();
0 {' m8 ~/ r/ \( T
CoUninitialize();
1 F2 }$ \0 \8 @ G% F: X6 c
return 1; // Program has failed.4 z- i& A' m! [' W% Y
}, y# P$ n0 w4 O5 g- K3 D+ z
// 步骤5： Set security levels on the proxy% E- h9 F6 _; l+ U% Q: v9 h
hres = CoSetProxyBlanket($ g& n' Z( P$ J5 J
pSvc, // Indicates the proxy to set
8 F9 R8 ~9 h: _$ R6 R9 \3 c
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
3 F1 D! X1 }" n$ C2 @# P. N
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
, K4 w5 H5 m* n9 E% U& t
NULL, // Server principal name 4 J" s" ?1 E% w6 a& B8 F
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
# |* e" r; n- R: |
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx. Z$ m! V) Q% e2 {+ e
NULL, // client identity
- E# J; d8 n# n( |( o, |" Q. u! f2 n% q
EOAC_NONE // proxy capabilities / l7 R- `# K3 H0 p
);4 ~8 C) f) r) _$ s
; d0 x+ _" U6 e6 \ E3 B. r9 J4 Z
if (FAILED(hres))& \' ^2 G/ F% N7 o. K |$ T
{
. V# r8 o( ^& ~0 c, C1 n
pSvc->Release(); z6 M# P7 b2 b }. x) d
pLoc->Release();
' m6 [- ?- L9 v- s8 Z9 h
CoUninitialize();* V8 k& S- t& Q' \) R* ~. y
return 1; 9 n B9 K/ w0 K/ @" K) R0 [, u8 G
}4 ?! c0 I- L! P, D
8 k/ g3 t6 ?! q5 x+ z9 N. `0 v) ^
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
& k8 M& T3 Y* K9 O2 C
IEnumWbemClassObject* pEnumerator = NULL;7 |4 w4 \# ]+ Q$ V; h/ S
//计算CPUID2 U& D7 F3 q% x$ b }" x5 Y- o) Z' e' R
hres = pSvc->ExecQuery(
5 |6 g% ]1 Q( G H9 x6 q
bstr_t("WQL"), ' M) _) b" e8 `9 ~, j" h. m7 p
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
( N- J9 @" V) k9 ?
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, ) K4 e# y( _3 I
NULL,
& [( H# {# W& w5 c, u2 p
&pEnumerator);
+ l& W) U; @% |) U
% ^# d. z" u, O5 m8 t6 e# o
if (FAILED(hres)). n% U' Z4 T; V: n/ o& B, ^! H0 o
{/ Y* |3 n2 ?+ W4 a8 p
pSvc->Release();+ {) d. \; I( z
pLoc->Release();, @7 F6 g8 |% ~0 f4 } S
CoUninitialize();
) O( S6 U! |5 w9 a/ ?
return 1;
! O" D- O- l6 @- `6 f, [
}
* g! u/ ?: B0 B2 Q" ]! {2 ~
// 步骤7：Get the data from the query ) f7 K, b' [5 T$ x J) \
IWbemClassObject *pclsObj;- N3 M4 b/ P0 f% M9 D% Q$ p
ULONG uReturn = 0;& b8 m: U/ ]2 b9 {+ D% Q; `3 S/ N
while (pEnumerator)6 r' ^8 w. x! [( ~8 S1 l3 _# z
{9 }+ e8 l; G' V E5 f+ a
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
* N0 ?2 Y# v3 D) ?/ o% G) \- K
&pclsObj, &uReturn);
6 H3 K" m+ T5 A' j8 U
+ _1 J3 ]: d( m f
if(0 == uReturn)
, r2 x8 W; H# {- m( n
{
$ O2 G& O' q. g) w, t* ]
break;
2 X% X6 e7 Z- ?- @* |' _
}
: x$ m& V; S4 D7 c- E! P! H- h
VARIANT vtProp;+ |' ?7 W4 o' s2 V
VariantInit(&vtProp);% b1 X/ T" n W6 L# y
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);4 V" r4 n6 |" X9 o
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量* U: H8 g6 \- R8 K
}
& p2 m( f% u) A M1 b' m
# L- X0 d P4 `$ y6 i1 M8 k
//计算硬盘系列号9 K1 h5 d8 }5 t8 P; Q& Y/ f
hres = pSvc->ExecQuery(
W, y6 p' \7 ]- ~* E! x
bstr_t("WQL"), ! Z) K4 T7 g8 Z7 Z1 J
bstr_t("SELECT * FROM Win32_DiskDrive"),
% J% g0 E7 X' N
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, ( v6 i: k6 ?8 x* x. P7 _3 i5 r% C
NULL,
# o' S9 s8 M2 B# q( X8 f1 C# t% g
&pEnumerator);
7 `5 U+ w5 d1 q; j. Z9 g
1 ]9 b4 n, U/ u6 ^' A* l4 H! i! O
if (FAILED(hres))2 G5 \; ~! l# h* ]
{- Z4 X$ V2 N r7 }
pSvc->Release();
1 E5 @! r! p0 f! E. \4 X
pLoc->Release();
0 ~8 N: J" k: U
CoUninitialize();8 c1 K/ R# D$ B! i5 A5 S3 G
return 1; ( f, N1 b3 G) W% [/ C1 k/ [* d
}
3 `$ t$ b! m* S; M1 s
while (pEnumerator)
6 D0 O& F4 f9 P6 K& v6 ]+ e
{. }6 e7 s! K$ R T' r6 g
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
) u- a) T7 I7 c& ?, U( p, t
&pclsObj, &uReturn);
1 ~* X$ Z& J' N+ V5 ]" t0 P+ f
! r4 v' S) J& l$ b" K5 d* [2 h! f; n
if(0 == uReturn)7 J3 j1 h" h. T9 g6 i
{( l& Y& p1 o3 N( l
break;1 g6 ]+ C2 L* ^6 M
}
) k: G/ i0 l3 x9 L$ E! G1 k
" `) O% w) i6 |# V2 B
VARIANT vtProp;9 b G x( i: u4 z
VariantInit(&vtProp);
2 {6 x! Z6 q4 b* ^" ~$ K; P
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
* p; j- C. ^$ K1 B1 v0 D, |
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
- H2 e. m8 y; U# {. ^
}
5 F1 c3 ]/ f4 ]/ k- W& ^1 T
( S+ K+ }+ y. n, w( ~& C# e0 Z
pSvc->Release();
, N/ _; p$ ]+ Q* [9 t
pLoc->Release();6 E0 b' i: S' q$ x; q7 x* z
pEnumerator->Release();% \6 V$ t8 k; H
pclsObj->Release();- s! I) X$ F4 \, q9 E
CoUninitialize();
0 q; q' D) M2 e* K: E* ]) [# j
' E$ y1 [& H7 G& A' ?0 ~
return 0; 4 ?3 l9 N. n: B- N! q
}: ]6 r8 O9 t4 H o! W

复制代码

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

浏览过的版块