[收藏]在Win9x/NT下获取硬盘物理序列号

天云上人

1. #include <WinIOCtl.h>
   
2. #include <stdio.h>
   
3. 
   
4. #pragma inline
   
5. //---------------------------------------------------------------------------
   * D8 K. `3 o! W; Y3 ?. l0 K
6. // IDE NT/2000/XP专用变量
   # C# _$ r8 G7 A
7. #define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
   ! }2 x! @$ y+ K/ ^+ D2 e
8. #define DFP_GET_VERSION         SMART_GET_VERSION
   
9. #define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
   6 n! X3 j1 v3 C0 K. [
10. #define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
      r0 ~. i  N: \1 k
11. 
    ' T8 y( V- l7 n- M9 C# p
12. const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
    
13. const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
    
14. 
    
15. const int MAX_IDE_DRIVES = 4;
    * M# }  W  }6 W+ K/ u
16. 
    
17. // SCSI专用变量
    4 h" ~0 n; `# \: q) m/ [. ~+ u
18. const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
    " r1 K7 i! c9 o4 |% j  Q9 K2 q
19. const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
    2 ]* h. Y# q0 U! `% R
20. const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
    4 J  S+ h2 g  z' P8 ?8 _
21. const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
    5 x9 E8 W* U+ A( f) v! H/ v& |) W
22. 
    " Q$ M9 H9 b$ j, `9 a! ?; O
23. typedef struct _SRB_IO_CONTROL
    
24. {
    0 T. _  g; M, w, `
25.    ULONG HeaderLength;
    ' y% B8 A# f/ f1 h9 f
26.    UCHAR Signature[8];
    
27.    ULONG Timeout;
    
28.    ULONG ControlCode;
    
29.    ULONG ReturnCode;
    % B5 ?, X6 z$ d* r# g! d, s# B
30.    ULONG Length;
    
31. }SRB_IO_CONTROL, *PSRB_IO_CONTROL;
    8 m# T% s  s# e2 u# N
32. 
    ; [" M  A8 \4 a" B' L
33. // 读取的主函数
    
34. void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
    ! V* \3 _2 G! V
35. 
    9 E1 Q$ W0 V& n5 H6 G
36. // 辅助函数
    
37. char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
    
38. // NT/2000/XP函数
    
39. void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
    " k' Q, Y% h! F% l. E( L: r
40. bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
    ) Z+ W; f  B) V# M
41.        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
    
42.        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
    
43. // Windows 9X函数
    3 h/ d5 R, g6 y
44. void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
    
45. void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
    5 W! @/ q4 B* K" c
46.        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
    5 ~! i$ m, T8 P8 d5 x
47. 
    
48. // SCSI读取函数(for NT/2000/XP)
    
49. String __fastcall ReadIDEDriveAsScsiDriveOnNT();
    
50. //---------------------------------------------------------------------------
    
51. // ReadPhysicalDrive
    . u  A1 `# j* r- g; ~# ~
52. void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
    
53. {
    
54.    switch(Win32Platform)
    
55.    {
    + F- Y) p' Z5 d  t/ R
56.        case VER_PLATFORM_WIN32_WINDOWS:
    ! n1 w: H8 \- H3 G8 T6 d
57.            ReadPhysicalDriveOnW9X(pSerList, pModeList);
    - W( b3 p+ _% d
58.            break;
    : H5 @" D8 n- M/ ~3 p+ P7 V6 z0 L
59.        case VER_PLATFORM_WIN32_NT:
    % K9 E, v0 p& E; T) ~  ~1 d
60.            ReadPhysicalDriveOnNT(pSerList, pModeList);
    # z' z3 {, \- C
61.            break;
    . y% f3 U" l6 ?# V% i
62.        default:
    
63.            break;
    
64.    }
    0 Y: H3 R# G4 g7 ]* @/ q
65. }
    6 {- e  u+ k5 ?% T7 U7 \
66. //---------------------------------------------------------------------------
    4 p3 E4 n& s2 a8 k# x. l% q# ^7 `
67. // ConvertToString
    % o% u2 U" |0 n: d
68. char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
    1 e; s4 t' M3 I! V6 B1 ^0 k
69. {
    
70.    static char szResBuf[1024];
    % q6 W; W6 q/ O( z3 K
71.    int nIndex = 0;
    3 t. u# `+ M+ Z1 {$ l
72.    int nPosition = 0;
    
73. 
    
74.    // Each integer has two characters stored in it backwards
    , I& F) M  l$ r- x5 s
75.    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    
76.    {
    
77.        // Get high BYTE for 1st character
    8 [) Z8 w5 p) d6 ^/ [" O$ z
78.        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
    % j2 B! X: N: e' B
79.        nPosition++;
    4 e, R/ W' D, s4 C( z+ U
80. 
    . r4 y0 d  u! P8 S$ R: G( u
81.        // Get low BYTE for 2nd character
    . V/ @2 N5 p% S  J, S/ q
82.        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
    5 B' ?$ O. I( L
83.        nPosition++;
    / }7 R+ _" }- m* V( V* o
84.    }
    % T; b8 m1 @4 ]) l6 z* q) s2 P
85. 
    
86.    // End the string
    
87.    szResBuf[nPosition] = '\0';
    & [/ p$ |1 |1 [3 u/ B
88. 
    / {7 m4 e2 V6 b" T. |  n
89.    // Cut off the trailing blanks
    , o( U; J/ ]& v$ s) z
90.    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
    
91.        szResBuf[nIndex] = '\0';
    # w% t9 G, V+ m4 k: D; x0 S# u* t* M
92. 
    
93.    return szResBuf;
    
94. }
    
95. //---------------------------------------------------------------------------
    
96. // Winndows NT4/2000/XP 代码
    ( y# q' C! E& T6 L2 y
97. //---------------------------------------------------------------------------
    : a. X& Q3 U0 M
98. // ReadPhysicalDriveOnNT
    ) l% Q( ]3 k7 }; B) n! A
99. void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
    
100. {
     3 J) m* z- P6 R2 g0 _8 v& D  J2 ^
101.    // 输出参数
     * w2 I" ?& G% x- i/ v# H3 O2 P  k
102.    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
     7 d/ S: c  x6 ^7 l3 _1 F) a0 w
103. 
     
104.    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
     % N# o3 |( U' P" s5 R9 F
105.    {
     & z! s! p. e) h% P3 q1 L7 o" x6 d* M
106.        HANDLE hPhysicalDriveIOCTL;
     
107.        char szDriveName[32];
     1 Q* {: E3 m$ ?" b1 _* }3 w
108. 
     
109.        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
     * K( n/ S+ Z: L: y! V' A* X( T+ m
110.        hPhysicalDriveIOCTL = CreateFile(szDriveName,
     ; f8 n1 g/ D: [; u; R. x+ N! z
111.                        GENERIC_READ | GENERIC_WRITE,
     
112.                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
     1 r+ _- [+ _* U3 t+ n4 x: R
113.                        OPEN_EXISTING, 0, NULL);
     5 X& d1 l! p% _
114. 
     
115.        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
     2 [; {$ g2 l; q$ `$ S
116.        {
     
117.            DWORD dwBytesReturned = 0;
     ; M! f, D3 r- x+ f1 u5 |; c% C* }
118.            GETVERSIONOUTPARAMS gvopVersionParams;
     
119. 
     
120.            // Get the version, etc of PhysicalDrive IOCTL
     
121.            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
     ' M3 x7 s$ M( Z  l- g8 n
122. 
     0 y* c& r  F# P
123.            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
     5 L0 D# a6 e6 o4 V7 o" I
124.                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
     # W8 y  K/ T1 a* ?& y  W5 h
125.                    &dwBytesReturned, NULL))
     
126.            {
     & l- t5 H4 v2 D& ?: k+ P0 Q0 h
127.                continue;
     " ~3 m- Y% N; K1 c2 J1 ?; f
128.            }
     : F5 e! M( Q; l1 ]$ b
129. 
     
130.            if(gvopVersionParams.bIDEDeviceMap > 0)
     9 H) x! ~4 f, h! }
131.            {
     . |; @6 E6 @7 }
132.                // IDE or ATAPI IDENTIFY cmd
     
133.                BYTE btIDCmd = 0;
     
134.                SENDCMDINPARAMS InParams;
     ) Y$ Z5 W: y9 p' I- Y4 Q: A2 @2 ]
135.                // Now, get the ID sector for all IDE devices in the system.
     
136.                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
     
137.                // otherwise use the IDE_ATA_IDENTIFY command
     % `( Y1 e7 D3 G2 t6 s, n: S
138.                // 具体所得结果请参考头文件中的说明
     
139.                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
     
140.                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
     - a/ Y8 c) t1 G5 m2 U
141.                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
     : {( X! V: Y* a: P6 u+ P. J
142.                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
     . k' k( B7 }+ V& n' j: \: F) x4 O
143. 
     " ~7 }& d* o* I; P3 ?% s8 @
144.                if(DoIdentify(hPhysicalDriveIOCTL,
     
145.                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
     ) I+ Q9 h$ l% Q- W
146.                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
     
147.                {
     
148.                    DWORD dwDiskData[256];
     8 m6 l8 y, i1 D( B( h) u
149.                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
     9 x3 B. f' T( E& p5 \+ v1 u
150.                    char szSerialNumber[21];
     6 X% A, k: h2 Z; z4 y+ @
151.                    char szModelNumber[41];
     
152. 
     3 M0 J$ S; L7 Q" d
153.                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
     
154.                    for(int i=0; i < 256; i++)
     * v: S2 o4 W6 p% j3 D
155.                        dwDiskData = pIDSector;
     1 P" e$ s: [' |* i9 Q
156.                    // 取系列号
     : F, y, |9 q( ~) W9 E) L
157.                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
     8 K; N' J( U9 _: W
158.                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
     6 a7 a- n! a  ?8 Q  {! T. S$ A3 b6 l
159. 
     
160.                    // 取模型号
     
161.                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
     
162.                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
     
163. 
     
164.                    pSerList->Add(szSerialNumber);
     1 Q3 i2 I: g# {/ X4 k" e( r4 W
165.                    pModeList->Add(szModelNumber);
     
166.                }
     
167.            }
     + g' r( C& ^' T5 [( i+ ]$ c
168.            CloseHandle (hPhysicalDriveIOCTL);
     . K+ l% ~. R4 |- b  L9 ~( [$ _
169.        }
     
170.    }
     
171. }
     4 c; I& r5 {5 Q: A- c0 Q
172. //---------------------------------------------------------------------------
     * ~1 o3 n$ I# @6 @
173. // DoIdentify
     
174. bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
     , b, a- X6 K' R5 h% o( n" Y
175.              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
     ; ~( x. G* E0 x) f/ Y) l1 Z
176.              PDWORD pdwBytesReturned)
     ) g3 t7 H% h, v; _8 X8 T; I/ g
177. {
     
178.    // Set up data structures for IDENTIFY command.
     0 a* @/ K) A3 M
179.    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
     
180.    pSCIP->irDriveRegs.bFeaturesReg = 0;
     
181.    pSCIP->irDriveRegs.bSectorCountReg  = 1;
     
182.    pSCIP->irDriveRegs.bSectorNumberReg = 1;
     
183.    pSCIP->irDriveRegs.bCylLowReg  = 0;
     
184.    pSCIP->irDriveRegs.bCylHighReg = 0;
     2 _# q( J! }* M6 S
185. 
     1 K8 W$ ~2 X5 R
186.    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
     ' f6 f) X( ^9 {# R7 O
187.    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
     6 J; r2 H' \: s6 L6 k) {* _, h
188. 
     6 p$ W4 C( D% h! w
189.    // The command can either be IDE identify or ATAPI identify.
     
190.    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
     
191.    pSCIP->bDriveNumber = btDriveNum;
     / A4 s4 v! t! h, F5 b& N
192.    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
     : K' c4 q) s/ d" J8 b
193. 
     
194.    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
     4 Z5 j) t! l9 A4 ?
195.           (LPVOID)pSCIP,
     " |! i$ }( J% t+ q8 d+ C
196.           sizeof(SENDCMDINPARAMS) - 1,
     
197.           (LPVOID)pSCOP,
     ! T8 J/ K  B% |/ ]5 ]- ~6 F
198.           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
     
199.           pdwBytesReturned, NULL);
     & x4 j: s- h& _  t4 V0 L7 g& n
200. }
     
201. //---------------------------------------------------------------------------
     3 C3 J) N' ?. Q$ z; j
202. // Windows 95/98/ME 代码
     ) v5 E' \" U; g4 R- b) w- U
203. //---------------------------------------------------------------------------
     
204. // ReadPhysicalDriveOnW9X
     # ~+ b4 `" c8 c. T* G! E
205. void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
     
206. {
     
207.    WORD wOutData[256];
     5 `' q1 K! N/ \: Z. A
208.    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
     
209. 
     - A; |6 \! [  R. g- [
210.    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
     
211.    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
     
212.    // 避免蓝屏的出现。（期待高人能指出原因）
     ; G: |3 }. p& |+ e9 u! v& W: O4 m
213.    for(int nDrive = 0; nDrive < 8; nDrive++)
     , h2 {$ G% B7 `
214.    {
     ; v- [' [$ x; U$ i- e
215.        WORD dwBaseAddress;
     - \! P1 D7 d- s- L& H0 I; Q
216.        BYTE btMasterSlave;         // Master Or Slave
     
217.        bool bIsIDEExist;
     
218.        bool IsDiskExist;
     
219. 
     8 ^) W# l, a  O7 w# z# x2 O
220.        switch(nDrive / 2)
     , d  o8 r$ `3 M0 S3 Z9 N
221.        {
     + q, U& K& e: V8 Z# j
222.            case 0: dwBaseAddress = 0x01F0; break;
     5 P! Y7 U8 |4 D* p
223.            case 1: dwBaseAddress = 0x0170; break;
     % A0 L5 S( k. p- i; {& E: p
224.            case 2: dwBaseAddress = 0x01E8; break;
     . L4 `2 S; \* i2 i* v/ \. C4 c9 e
225.            case 3: dwBaseAddress = 0x0168; break;
     
226.        }
     1 F3 D6 w: J! w7 a3 F- Q
227. 
     - \1 _" N, h7 m
228.        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
     
229. 
     
230.        // 进入Ring0
       {% m+ S; @% t4 F- c! \( s( l' [
231.        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
     
232.                bIsIDEExist, IsDiskExist, wOutData);
     $ u% A% r8 \6 `" b1 ?
233.    }
     
234. 
     
235.    // 开始读取
     8 V+ \0 m8 V: s7 v
236.    for(int nDrive = 0; nDrive < 8; nDrive++)
     
237.    {
     0 ^( f) G# y+ \+ j- A( T
238.        WORD dwBaseAddress;
     3 O& w; Z3 D% {; v
239.        BYTE btMasterSlave;         // Master Or Slave
     
240.        bool bIsIDEExist;
     
241.        bool bIsDiskExist;
     
242.        switch(nDrive / 2)
     # f  \7 Z* m% `' f& j" {% M) q
243.        {
     3 e3 T" F& g( m
244.            case 0: dwBaseAddress = 0x01F0; break;
     9 C; e: G! s# x% m+ l
245.            case 1: dwBaseAddress = 0x0170; break;
     9 G* j/ j& I" D9 r7 i3 l; x8 _
246.            case 2: dwBaseAddress = 0x01E8; break;
     4 K' v% O4 r& ^* g3 `
247.            case 3: dwBaseAddress = 0x0168; break;
     , `. g, R/ p) y6 ?) i+ c$ F
248.        }
     - C  W( K$ |; S9 K. \3 S0 I% K% E
249. 
     
250.        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
     
251. 
     
252.        // 进入Ring0
     3 G7 }5 ]5 W$ f+ K8 Q$ }
253.        bIsIDEExist  = false;
     - }; M! U+ ]. y5 K# t
254.        bIsDiskExist = false;
       B: z% t* d0 ?( \% I+ A- \$ I+ m
255.        ZeroMemory(wOutData, sizeof(wOutData));
     ) p. q+ e  y+ k& }6 j1 E1 c
256. 
     ' v  {( d& U2 n$ D0 h7 F, w' S
257.        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
     : K- Z# P2 K; U& V! }) p
258.                bIsIDEExist, bIsDiskExist, wOutData);
     " @: A$ L8 J, H: C+ }; u1 L
259. 
     . d0 L1 \4 z& J2 y5 [
260.        if(bIsIDEExist && bIsDiskExist)
     * }4 I4 f+ L/ _
261.        {
     
262.            DWORD dwDiskData[256];
     
263.            char  szSerialNumber[21];
     & M- O7 v" P2 j! i" w, s, y
264.            char  szModelNumber[41];
     0 t( ?7 k" Z* ?0 j/ o6 {; [1 j
265. 
     ; ?3 b5 N. P0 |& s! M
266.            for(int k=0; k < 256; k++)
     4 i( I% H( x2 y# A, v  |0 h0 w. n2 _
267.                dwDiskData[k] = wOutData[k];
     
268. 
     
269.            // 取系列号
     
270.            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
     
271.            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
     
272. 
     
273.            // 取模型号
     ( ]3 ~3 O9 A  Z* j: p0 R4 o
274.            ZeroMemory(szModelNumber, sizeof(szModelNumber));
     
275.            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
     
276. 
     
277.            pSerList->Add(szSerialNumber);
     
278.            pModeList->Add(szModelNumber);
     
279.        }
     3 y! _* E+ c3 g+ I) P
280.    }
     * x) N8 B3 W5 O+ F# c
281.    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
     * i1 D8 R: E+ t
282. }
     " _2 g, x0 r" r' `9 L  Q
283. //---------------------------------------------------------------------------
     
284. // ReadPhysicalDriveOnW9X_Ring0()
     1 h, T9 P3 d+ h. h# ?% M
285. //
     
286. // dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
     " C: Q) Z' Y, ?: o  Q$ y
287. // btMasterSlave = Master(0xA0) Or Slave(0xB0)
     2 n4 q8 ]4 l& p" K1 p5 V/ \& J
288. //---------------------------------------------------------------------------
     ' {$ V. q& k( L2 E
289. void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
     
290.        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
     
291. {
     
292.    BYTE  btIDTR1[6];
     4 F( M% M4 o3 k- }$ k
293.    DWORD dwOldExceptionHook;
     
294.    const int nHookExceptionNo = 5;
     
295. 
     $ K& r6 b! i/ I8 w: n$ y6 u
296.    BYTE  btIsIDEExist = 0;
     
297.    BYTE  btIsDiskExist = 0;
     
298.    WORD  wOutDataBuf[256];
     
299. 
     
300.    BYTE  btIsFirst = (BYTE)bIsFirst;
     
301. 
     
302.    const BYTE btBit00 = 0x01;
     
303.    // const BYTE btBit02 = 0x04;
     
304.    const BYTE btBit06 = 0x40;
     
305.    const BYTE btBit07 = 0x80;
     
306.    // const BYTE btERR  = btBit00;
     
307.    const BYTE btBusy = btBit07;
     
308.    const BYTE btAtaCmd   = 0xEC;
     
309.    const BYTE btAtapiCmd = 0xA1;
     
310. 
     
311.    __asm
     6 I" w0 t: z  s8 ^6 N' e- Q& _0 s
312.    {
     9 M6 Z* ^" L! h8 ?; |) S1 O# [$ H% a
313.        // 必须先执行这条语句
     2 X% u$ \* W6 @! ^& F
314.        JMP EnterRing0
     " X* r, n. A: y6 q% S# Q
315. 
     
316.        // 定义过程
     
317.        // 等待IDE设备直到其不为忙为止
     - K& h2 E& ?) s
318.        WaitWhileBusy proc
     
319. 
     
320.        MOV  EBX, 100000
     
321.        MOV  DX, dwBaseAddress
     
322.        ADD  DX, 7
     
323. 
     % C) r. X& j* ?5 a2 W3 R
324.        LoopWhileBusy:
     
325. 
     
326.        DEC  EBX
     
327.        CMP  EBX, 0
     - C; G& N7 U% J& B9 `$ N. b
328.        JZ   Timeout
     + X9 I: t* R- M" G  n
329.        in   AL, DX
     % E& Z) Y+ t/ t$ o1 ^
330.        TEST AL, btBusy
     2 f4 ~( l1 M+ H* s
331.        JNZ  LoopWhileBusy
     . Q) ^1 S7 ^( y- e9 E
332.        JMP  DriveReady
     % G! i% M$ Z+ ^
333. 
     0 b+ T. `+ a9 J6 \; \( A
334.        // 超时，直接退出
     
335.        Timeout:
     
336.        JMP  LeaveRing0
     
337.        DriveReady:
     $ O$ X% s. \  C
338.        RET
     
339.        ENDP   // End of WaitWhileBusy Procedure
     
340. 
     
341.        // 设置主盘和从盘标志
     # q% I0 D4 t4 [# ~! }) X" b
342.        SelectDevice proc
     ' c3 K+ p! n5 j) Q5 j
343. 
     $ |3 ?$ {- A0 q* w' I4 i
344.        MOV  DX, dwBaseAddress
     9 M& }3 J5 c; {; c8 @$ ~9 m7 L
345.        ADD  DX, 6
     5 [( I" g& Z. W: i: ?: x
346.        MOV  AL, btMasterSlave
     
347. 
     
348.        out  DX, AL
     
349.        RET
     
350. 
     
351.        ENDP  // End of SelectDevice Procedure
     & P& l  R6 f6 y  c' F
352. 
     - s+ C3 ~$ y! |  g% L+ V
353.        // 向IDE设备发送存取指令
     
354.        SendCmd proc
     
355. 
     
356.        MOV DX, dwBaseAddress
     5 \; ?) n+ d( e* o
357.        ADD DX, 7
     1 x* d3 `  ?( \8 d
358.        MOV AL, BL // BL是主从盘标识，在过程外设置
     
359.        out DX, AL
     
360.        RET
     7 j* T6 S7 ~, K! w% q/ j  G7 K' S
361.        ENDP  // End of SendCmd Procedure
     ( u8 m# |+ u9 f+ ^/ _' k
362. 
     
363.        // Ring0代码
     
364.        Ring0Proc:
     
365.        PUSHAD
     8 k, V% ~" w/ o: w
366.        // 查询IDE设备是否存在
     
367.        MOV DX, dwBaseAddress
     
368.        ADD DX, 7
     
369.        in  AL,DX
     
370. 
     
371.        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
     ; L: Q& F/ E' U1 r' c2 A( n
372.        CMP AL,0xFF
     9 _+ k' L$ i$ G, {: G6 ?( H: ^
373.        JZ  LeaveRing0
     4 |# q' D8 r: _0 [/ D: T, }/ G
374.        CMP AL, 0x7F
     ) n! E, \+ o$ H) B
375.        JZ  LeaveRing0
     3 [5 p7 U8 ~& D' ?
376. 
     
377.        // 设置IDE设备存在标志
     8 T3 ^# E! A9 c. ]$ k* I# m: I0 e
378.        MOV btIsIDEExist, 1
     
379. 
     * {  a4 X( ]9 `7 u- ~" p/ ]
380.        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
     
381.        CALL WaitWhileBusy
     
382.        CALL SelectDevice
     
383. 
     
384.        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
     : r4 p; x2 n) s, Y7 {2 ~; B0 x
385.        CMP  btIsFirst, 1
     
386.        JZ   LeaveRing0
     
387. 
     
388.        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
     $ R) J2 d7 R; H6 f0 Q& _4 \
389.        CALL WaitWhileBusy
     ! [5 E4 V3 \( z
390. 
     8 k' H* r$ j8 T! x
391.        // AL的值等于cBit06时，不存在驱动器，直接返回
     
392.        TEST AL, btBit06
     
393.        JZ   LeaveRing0
     9 s' ?0 l) e* M& V
394. 
     . ^% x4 \  K, ~: ?; u
395.        // 设置驱动器存在标志
     
396.        MOV  btIsDiskExist, 1
     2 s, N2 E) p: p; x/ {# F
397. 
     
398.        // 发送存取端口命令
     
399.        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
     2 z2 F5 Y% _% `; |
400.        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
     & B7 D9 k' m2 {6 G
401.        CALL WaitWhileBusy
     
402.        CALL SelectDevice    // 设置主从盘标识
     9 A5 A  K& Z, I2 ^  f& ~$ D
403.        MOV  BL, btAtaCmd      // 发送读取命令
     
404.        CALL SendCmd
     
405.        CALL WaitWhileBusy
     " ]6 q$ w, `3 {; c( c
406. 
     ) j3 t( i4 V  e; _" u
407.        // 检查是否出错
     
408.        MOV  DX, dwBaseAddress
     % v) ]  P# R! _9 }+ g2 Z
409.        ADD  DX, 7
     , e$ J" B/ H$ e1 A* D+ z
410. 
     ( B6 e# L3 G6 Z7 I1 A2 ~
411.        in   AL, DX
     ! s2 {, g! N  y& w4 l
412. 
     5 q: x; C$ p- y6 b" w% O/ V
413.        TEST AL, btBit00
     , H* A8 n, j& C" t8 m+ _
414.        JZ   RetrieveInfo   // 没有错误时则读数据
     2 m1 M  o/ [* z: b! v4 r, T
415. 
     
416.        // 如果出错，则进一步尝试使用ATAPI设备命令
     
417.        CALL WaitWhileBusy
     
418.        CALL SelectDevice
     : k( D# |; v& y! V1 ]
419.        MOV  BL, btAtapiCmd
       j) ~4 c# C2 X4 A! {
420.        CALL SendCmd
     $ d; ?. v9 f+ k% ^
421.        CALL WaitWhileBusy
     8 \8 b, u: L) d
422. 
     
423.        // 检查是否还出错
     ) c% d  G4 n  }+ J1 [
424.        MOV  DX, dwBaseAddress
     - x' q- u- x: P8 c; o
425.        ADD  DX, 7
     ' y" u+ {- f( U# h& S7 ^
426.        in   AL, DX
     + ~! r- x/ t+ |4 O3 S
427.        TEST AL, btBit00
     
428.        JZ   RetrieveInfo   // 没有错误时则读数据
     . F6 Y1 S1 T* f9 L
429.        JMP  LeaveRing0     // 如果还是出错，直接返回
     . W# S4 c1 |- R0 }$ C
430. 
     
431.        // 读取数据
     
432.        RetrieveInfo:
     
433. 
     
434.        LEA  EDI, wOutDataBuf
     
435.        MOV  ECX, 256
     
436.        MOV  DX, dwBaseAddress
     
437.        CLD
     3 V" P9 q8 {& u9 M$ Q
438. 
     
439.        REP  INSW
     
440. 
     
441.        // 退出Ring0代码
     * v1 f8 m! j: D
442.        LeaveRing0:
     
443. 
     3 H3 Z1 C! N) L7 S# |) ^
444.        POPAD
     
445.        IRETD
     + K1 h  N- S# Y8 ?/ V' A
446. 
     % L  p' f* ~  s8 c0 A" p# J
447.        // 激活Ring0代码
     6 B9 R" N6 E+ N/ c. s- ~& l
448.        EnterRing0:
     " n" Y5 s) _! z* r1 I; G; M. E. M5 b
449. 
     
450.        // 修改中断门
     
451.        SIDT FWORD PTR btIDTR1
     
452.        MOV EAX, DWORD PTR btIDTR1 + 02h
     8 }# R& Z2 J3 ]1 ^- s5 v  _# G
453.        ADD EAX, nHookExceptionNo * 08h + 04h
     & Y! i. [' O) z. D" W- x4 _6 y
454.        CLI
     
455. 
     / M: M! x7 x* O
456.        // 保存原异常处理例程入口
     % b/ l) l0 ^! C! w% R& g
457.        MOV ECX, DWORD PTR [EAX]
     
458.        MOV CX, WORD PTR [EAX-04h]
     ! C% U$ O. k9 }
459.        MOV dwOldExceptionHook, ECX
     9 Z: L; K& \: S  h
460. 
     1 s' p/ k3 N+ v) e1 I
461.        // 指定新入口
     0 n& G! N3 A$ t6 U8 Y0 i8 N3 i# O
462.        LEA EBX, Ring0Proc
     6 @: g6 X2 S5 N- T3 A7 O# o
463.        MOV WORD PTR [EAX-04h],BX
     ! Q2 h- |; ]3 n0 P* W1 x, v: h
464.        SHR EBX, 10h
     
465.        MOV WORD PTR[EAX+02h], BX
     0 a3 t4 S% ^' K
466. 
     0 z' V- A: @5 ^4 Y3 c- A( l
467.        // 激活Ring0代码
     
468.        INT nHookExceptionNo
     / U4 o3 r2 o! M/ v- Z1 S1 N; u
469. 
     ) S0 |- q6 f+ y
470.        // 复原入口
     
471.        MOV ECX,dwOldExceptionHook
     % ], T# k8 o  V' Y
472.        MOV WORD PTR[EAX-04h], CX
     
473.        SHR ECX,10h
     1 e( B6 p; u: ~  C4 P, E
474.        MOV WORD PTR[EAX+02h], CX
     * L) t  d6 l5 T. ^; e$ K
475.        STI
     7 k7 V8 I/ C) s
476.    }
     # @  Y  ~: o1 ^0 P0 ?
477.    if(!bIsFirst)
     ! i0 `; U5 g8 @5 t! }* A
478.    {
     
479.        bIsIDEExist  = (bool)btIsIDEExist;
     
480.        bIsDiskExist = (bool)btIsDiskExist;
     
481.        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
     : ?1 G% e, j% G
482.    }
     / z6 _! R: O# M2 y( h
483. }
     - `1 x1 U3 B" l6 O; O3 `' o9 v- s
484. //---------------------------------------------------------------------------
     # e+ e4 u3 b9 T' n
485. // 调用方法：
     
486. void __fastcall TForm1::Button1Click(TObject *Sender)
     
487. {
     
488.    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
     
489. }

复制代码

梦幻雨

晕乎乎。。。怎么看８　洞阿