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

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

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

' {; L% M. Z1 L1 o0 C
#include "StdAfx.h"( v* b' Q5 |# k2 Z
#include ".\puiddisk.h"9 b; x8 x& W B
#define _WIN32_DCOM
' u& @+ j+ h; V* W" a
#include <iostream>
" d( L: K- ^* ] [0 A/ d
using namespace std;
6 e) X- \# p u+ U |, n
#include <comdef.h>( \$ _3 _! V3 x
#include <Wbemidl.h>8 t" a' A' _0 Z6 X: w) w; l
1 _% o9 Y8 l/ M" }) D t/ l, ]( y
# pragma comment(lib, "wbemuuid.lib")4 `# |8 M5 h# B$ @% B0 R0 Q
CpuIDDisk::CpuIDDisk(void)8 Y; Q" h; R `3 f5 |4 D" d
{
- w' I, o. Z, e/ d
GetInfomation();
4 V# F! g- e6 R# H& n0 z E& \
}
. N0 p! g* S2 m5 T( B: A# }/ j
7 e. a' W2 ?( t, o7 E- G3 J
CpuIDDisk::~CpuIDDisk(void)
2 t" b, ~/ P% i' ]" H
{
- S N* R6 C4 q! [4 y
}) ^2 _; i( S/ g& y( n# p( ~
int CpuIDDisk::GetInfomation(void)
) F1 X/ j/ x5 G3 J; }* Y" u8 I
{
1 q7 B6 ?: V* K" ~1 \
HRESULT hres;" R$ G$ m7 j, e- P5 o) i, @/ G8 P
//步骤1：不是必须的，COM只须也只能初始化一次
, y0 R E( z/ v! u& S
hres = CoInitializeEx(0, COINIT_MULTITHREADED );+ U7 @( f7 }) j6 {
if (FAILED(hres))3 B7 t$ G" \4 E+ r+ v! j# p
{' ]5 ~: F5 U" A4 @8 ~2 B
return 1; //初始化COM异常：注意，COM只须也只能初始化一次% U5 g$ ^4 n2 }3 h: l8 q
}
+ N6 R- }, D0 r( G
//步骤2：不是必须的，COM只须也只能设置一次
' q h- \8 c7 @* t/ \
//Set general COM security levels7 }- B$ l5 p' G7 N; V
hres = CoInitializeSecurity(9 h/ r% [3 W) e r& O# L1 ?
NULL, 8 Y0 x5 K6 T" [
-1, // COM authentication& R& E. z; N7 |! b$ V; }9 n
NULL, // Authentication services# P2 h' n% U+ k
NULL, // Reserved8 W- \* ^9 }% _8 v9 b8 K6 w& q
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication , n- Y, U% {* ]. E" |) A0 s* I
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation ) ?* T7 |' j4 c; L3 Q, m" A
NULL, // Authentication info, ]& X- I/ `8 Z0 I+ r" F1 N
EOAC_NONE, // Additional capabilities + ^ N# a' g( ~( L
NULL // Reserved+ F: I3 B4 r/ b, w- z/ D8 \# k1 E% @
);
; S7 H8 e$ j' I; Y
( W6 r% |% ]/ H4 v. D
if (FAILED(hres))
# R2 h" ~0 N% w4 W/ n+ l. O: V
{
3 i% \3 T; S+ u4 l% f/ d$ v3 ^' l
CoUninitialize();8 N* J! M5 V: T/ O* L& _2 i2 p
return 1; // Program has failed.
1 z$ x6 e2 b4 }6 Q- H
}/ T3 X( V( b7 c8 k
5 C* n1 L1 a3 a( S" y' c8 d
//以上不是必须的，若已有“::COMInit();”，则要跳过 X' H) E2 V+ n/ |4 q
//步骤3： Obtain the initial locator to WMI " I9 j* y/ a( t3 E- u; R
IWbemLocator *pLoc = NULL;
' u% @( w# f! ^# E8 a
hres = CoCreateInstance(
$ y: K% X9 s7 V5 F B
CLSID_WbemLocator,
. N* U" y; N: h' B5 B& q" {
0, ; }" N8 t: T+ V+ `4 O: h
CLSCTX_INPROC_SERVER, 0 |6 s" @4 ?$ a+ w
IID_IWbemLocator, (LPVOID *) &pLoc);$ |' x% |: l% b* |* ?. H
4 U/ C9 X4 S; l. Q2 S
if (FAILED(hres))
' K$ z w; E1 @5 u3 [# B
{' Q* I$ p' T. q0 Y0 a8 e
CoUninitialize();
4 M; X1 x4 u/ F9 e9 U( ^5 F/ _& I
return 1;//Failed to create IWbemLocator object
- \7 D0 q( {* U: t
}2 J' _' o7 T. `, g& U% s1 p
/ B+ Z- y+ V+ D$ c5 E8 }
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method3 {1 p/ N3 p: H* Z8 ]. J5 g
IWbemServices *pSvc = NULL;8 ~* R. r0 G' |1 k) ~* q
hres = pLoc->ConnectServer(
5 m" w, Q* p2 f H7 c) s& I% B
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace; B: ~0 `$ w. K/ W. c- e' ~
NULL, // User name. NULL = current user
# x P) y# e6 V8 k+ D ?! C
NULL, // User password. NULL = current
/ N- W% L6 S6 G
0, // Locale. NULL indicates current) }" r8 g6 W( u" o, L7 m6 V, h+ O
NULL, // Security flags.
& Z/ F- \7 l% I6 z0 e
0, // Authority (e.g. Kerberos)$ Q9 I5 [, n. L1 A' ]+ g/ P
0, // Context object 3 h4 ?4 S: f9 _+ C2 d
&pSvc // pointer to IWbemServices proxy
* ?( T5 u Y/ N) u0 y( _0 I6 H
);0 h5 P5 \( u5 z# T
" U2 g5 q- m2 H1 a
if (FAILED(hres))
- L, I' c; G2 g: p6 s* Y( D
{
6 T5 F; I$ ^1 c3 q' A- f' s. q
pLoc->Release();
7 z/ ?$ H# n* P# _( |. }% V
CoUninitialize();! P7 a6 M+ u9 I q* f0 R
return 1; // Program has failed.- Z" K# l) i# {+ n) k% Z% Z \6 M
}) n0 n# U2 _) J6 i
// 步骤5： Set security levels on the proxy
3 Y5 m& W5 {$ A
hres = CoSetProxyBlanket(
7 ?. M# q, S. T& }5 {& E# e3 m
pSvc, // Indicates the proxy to set9 y' d/ j1 j# L. N0 r" S' I
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx1 q& v+ L8 ]$ N6 X1 w i6 Q
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
" B* d5 X. w* y6 n4 o* ^
NULL, // Server principal name , `9 @5 N; P9 U" }- r6 b3 z
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx " d4 K) I% T8 K1 C! O; O/ t+ Q+ M" J
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
) x5 I8 a1 L8 C1 n H {6 J
NULL, // client identity
4 E4 H. A5 T1 t/ F5 w
EOAC_NONE // proxy capabilities
' ?/ Q) }. B+ G5 U) U/ H: a/ Q
);
& q. L, ^$ q8 B3 j. @4 {
" m5 @& }5 `( e9 f1 L( V
if (FAILED(hres))% e! f V8 v$ \1 f' L7 c
{) ~0 n3 R' P! H/ H. }% H8 ~; V% v; T9 Q
pSvc->Release();+ N: S- Z- A4 d! ?9 v
pLoc->Release(); $ w% S9 H6 a( P0 Q4 w* D. ?; g
CoUninitialize();
, S4 H3 |* l$ m3 E9 S
return 1; . |+ t, p+ i* J7 K8 _: B
}
, o* L' M; D3 C" o1 H: C0 o- {' B
5 A& F* t9 m9 _# U' f$ I
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----7 ]' j* r: {, g8 \$ U# _
IEnumWbemClassObject* pEnumerator = NULL;
# L+ u7 `6 \6 F, n. S
//计算CPUID& W2 J5 w0 g1 B
hres = pSvc->ExecQuery($ |( p% ?6 R; F! j
bstr_t("WQL"),
: L9 m1 j. j2 A8 s' G
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem8 K) }# Q- r/ m0 s4 b; R
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
* j" q |, w; b7 e8 Y
NULL,/ p5 x# P% p: H8 K! _& Y
&pEnumerator);1 J: l( ~5 v: \" ^, o
0 I5 h+ i( }9 p9 }$ k8 n% ^
if (FAILED(hres))4 ~0 H3 r6 L: p" |9 S
{
1 h! Z5 Q) r1 L4 R/ z
pSvc->Release();9 d/ Q2 F4 E0 x# J; C
pLoc->Release();5 q! E5 c1 U/ B& m" ~! f& a/ j* D& U. S
CoUninitialize();
+ A, l2 V3 r* o4 G
return 1;
- ?( }4 c% V- ?, g* f, c
}2 S5 C8 `0 l- A' I$ I
// 步骤7：Get the data from the query
1 k/ _& D1 M7 L! V2 _$ U
IWbemClassObject *pclsObj;# ]$ J' h7 \- d, A9 M+ M5 A
ULONG uReturn = 0;( M) X' p# o: H1 x4 m
while (pEnumerator)( J* i6 ?5 G( { X8 O
{
, x3 e1 Y j/ }" E2 O
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, 1 q( J: S- e& H* \ o5 t% O
&pclsObj, &uReturn);
/ I J1 t4 K" g: w
* ?" n9 }# ?1 v8 E
if(0 == uReturn)
- b" }$ r3 l, R4 L
{* F9 z8 w9 c {" P# n$ c
break; B8 M- r' N3 h% D# z: k7 v u
}
4 i5 s! Q/ y" r7 X/ p7 e
VARIANT vtProp;
/ v. _$ c$ L) y
VariantInit(&vtProp);
- X$ L" s% j! u/ }& m8 k
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
, p1 P7 h" F3 w/ \' d
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
( x' i3 k' J7 ~5 Q, u0 q* ]4 R
}
8 A! L' {% k0 ?6 r
: f9 t/ H8 G3 Z& ]/ ~3 l, Y. t) b2 K
//计算硬盘系列号
9 y& r8 v5 N+ P
hres = pSvc->ExecQuery(
( Y$ n, v' a" w% s- F
bstr_t("WQL"),
7 q+ P Q8 Y: j3 b& q1 n7 ^) e2 S
bstr_t("SELECT * FROM Win32_DiskDrive"), p* G* X P. i5 i! p8 `4 Q
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, - I3 \9 V9 c6 h X
NULL,% ]. g0 e) a, u( J
&pEnumerator);* n5 R- \" v, z
4 b; ~* D- h, G4 g- ?
if (FAILED(hres))! i- ?6 N4 }% d4 }
{, w8 e3 W. l+ O* b
pSvc->Release();
$ V7 g2 p7 \: X) A" q
pLoc->Release();6 T0 `7 l% b* B i( \1 ~& P4 _
CoUninitialize();
- ^/ I7 S# O& I+ @- k/ p7 e/ U
return 1; 9 Z1 _ l- f! r) ]" c7 q6 _
}
Z- \' U7 i/ d% s! s
while (pEnumerator)
. W- S- B( n9 N
{: u/ b. p" r& n( w
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, / A( K, H4 D3 u9 `1 f0 X U5 i) z, z
&pclsObj, &uReturn);8 p$ p9 [- |/ o& p {1 G( `- s4 D
/ H/ ^2 L5 y, I/ n2 H4 D
if(0 == uReturn)
. `4 e, V& f2 S; m
{4 H1 C+ C/ J1 a
break;4 D; Y: N! m% c$ N" D# I4 G
}
p3 E6 ~5 Z5 Z- z+ E; J
( f( i$ m6 D1 b* i6 k1 H
VARIANT vtProp;
) y/ O* T8 ]5 ~; _% t6 v/ E0 U
VariantInit(&vtProp);
0 `) B/ y1 Q w9 P; R9 W# e! d" e
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);& R# S. M' b8 I- v) p6 N
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
; `! i0 \! l$ B& ~# H& n9 }: L
}
. \% [& S3 F. G! F! z
8 m# N5 C8 J0 M4 l
pSvc->Release();
* P3 l* {+ R* z; [9 ?' M
pLoc->Release();
8 e+ i4 s% Z3 U* j4 Z- v8 w+ }
pEnumerator->Release();. r5 ]% o, {$ I; u
pclsObj->Release();: f! A6 M# V; }% v
CoUninitialize();
5 \2 m. ]- m" Z- p- b
* {; l! e4 `& j% S9 }" Y* \
return 0; , ^, j6 h: v& X
}
" c4 [' {0 D. W6 \* o3 d

复制代码

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

浏览过的版块