vivily

函数名称 RemoveDir 函数说明 删除指定的目录,如果操作成功,返回真,否则返回假,函数原型如下: bool __fastcall RemoveDir(const AnsiString Dir);

函数名称 RenameFile 函数说明 更改指定文件的名称,如果操作成功,则函数返回真,函数原型如下: bool __fastcall RenameFile(const AnsiString OldName, const AnsiString NewName);

函数名称 SetCurrentDir 函数说明 设置当前工作目录,如果操作成功,则返回真,函数原型如下: bool __fastcall SetCurrentDir(const AnsiString Dir);

函数名称 StrAlloc 函数说明 为字符串分配指定字节的内存,并返回内存指针,函数原型如下: char * __fastcall StrAlloc(Cardinal Size);

函数名称 StrBufSize 函数说明 返回*Str所指向内存的大小,函数原型如下: Cardinal __fastcall StrBufSize(const char * Str);

函数名称 StrCat 函数说明 连接两个字符串,并返回目的字符串指针,函数原型如下: char * __fastcall StrCat(char * Dest, const char * Source);

函数名称 StrComp 函数说明 两个字符串相到比较,返回比较的结果,函数原型如下: int __fastcall StrComp(const char * Str1, const char * Str2);

函数名称 StrCopy 函数说明 将源字符串拷贝到目的字符串中,函数原型如下: char * __fastcall StrCopy(char * Dest, const char * Source);

函数名称 StrECopy 函数说明 将源字符串拷贝到目的字符串中,并返回目的字符串结尾指针,函数原型如下: char * __fastcall StrECopy(char * Dest, const char * Source);

函数名称 StrEnd 函数说明 返回字符串结尾指针,函数原型如下: char * __fastcall StrEnd(const char * Str);

函数名称 StrIComp 函数说明 两个字符串相互比较(不论大小写),返回比较的结果,函数原型如下: int __fastcall StrIComp(const char * Str1, const char * Str2);

函数名称 StrLCat 函数说明 将指定数目的源字符串连接到目的字符串,并返回目的字符串指针,函数原型如下: char * __fastcall StrLCat(char * Dest, const char * Source, Cardinal MaxLen);

函数名称 StrLComp 函数说明 对两个字符串指定数目的字符进行比较操作,函数原型如下: int __fastcall StrLComp(const char * Str1, const char * Str2, Cardinal MaxLen);

函数名称 StrLCopy 函数说明 将源字符串指定数目的字符拷贝到目的字符串中,并返回目的字符串指针,函数原型如下: char * __fastcall StrLCopy(char * Dest, const char * Source, Cardinal MaxLen);

函数名称 StrLen 函数说明 返回字符串的长度,函数原型如下: Cardinal __fastcall StrLen(const char * Str);

函数名称 StrLower 函数说明 将字符串转换为小写形式,函数原型如下: char * __fastcall StrLower(char * Str);

函数名称 StrMove 函数说明 从源字符串向目的字符串拷贝指定数目的字符,函数原型如下: char * __fastcall StrMove(char * Dest, const char * Source, Cardinal Count);

函数名称 StrNew 函数说明 在堆中为指定字符串分配空间,并将字符串拷贝到此空间中,函数原型如下: char * __fastcall StrNew(const char * Str);

函数名称 StrPas 函数说明 将指定的字符串转换为AnsiString类型字符串对象,函数原型如下: AnsiString __fastcall StrPas(const char * Str);

函数名称 StrPCopy 函数说明 将AnsiString类型的源字符串拷贝到目的字符串中,并返回目的字符串指针,函数原型如下: char * __fastcall StrPCopy(char * Dest, const AnsiString Source);

函数名称 StrPLCopy 函数说明 将源字符串(AnsiString类型)指定数目的字符拷贝到目的字符串中,并返回目的字符串指针,函数原型如下: char * __fastcall StrPLCopy(char * Dest, const AnsiString Source, Cardinal MaxLen);

函数名称 StrPos 函数说明 在Strl所指定的字符串中寻找Str2所指定的子字符串,并返回Str2在Str2中第一个子字符的指针,函数原型如下: char * __fastcall StrPos(const char * Str1, const char * Str2);

函数名称 StrRScan 函数说明 在指定的字符串中寻找特定的字符,并返回字符串中最后一个特定字符的指针,函数原型如下: char * __fastcall StrRScan(const char * Str, char Chr);

函数名称 StrScan 函数说明 在指定的字符串中寻找特定的字符,并返回字符串中第一个特定字符的指针,函数原型如下: char * __fastcall StrScan(const char * Str, char Chr);

函数名称 StrToDate 函数说明 将字符串对象转换为年月日对象,函数原型如下: System::TDateTime __fastcall StrToDate(const AnsiString S);

函数名称 StrToDateTime 函数说明 将字符串对象转换为年月日时间对象,函数原型如下: System::TDateTime __fastcall StrToDateTime(const AnsiString S);

函数名称 StrToFloat 函数说明 将AnsiString字符串转换为一个浮点数值,函数原型如下: Extended __fastcall StrToFloat(const AnsiString S);

函数名称 StrToInt 函数说明 将AnsiString字符串转换为整数值,如果不能进行转换,则产生EConvertError异常,函数原型如下: int __fastcall StrToInt(const AnsiString S);

函数名称 StrToIntDef 函数说明 将AnsiString字符串转换为一个数值,函数原型如下: int __fastcall StrToIntDef(const System::AnsiString S,int Default);

函数名称 StrToTime 函数说明 将字符串对象转换时间对象,函数原型如下: System::TDateTime __fastcall StrToTime(const AnsiString S);

函数名称 StrUpper 函数说明 将字符串转换为大写形式,函数原型如下: char * __fastcall StrUpper(char * Str);

函数名称 SysFreeMem 函数说明 释放所指定的内存块.函数原型如下: int __fastcall SysFreeMem(void * P);

函数名称 SysReallocMem 函数说明 要求重新分配参数Size所指定的内存.函数原型如下: void * __fastcall SysReallocMem(void * P , int Size);

函数名称 SystemTimeToDateTime 函数说明 将操作系统时间转换为TDateTime对象,函数原型如下: System::TDateTime __fastcall SystemTimeToDateTime(const _SYSTEMTIME &SystemTime);

函数名称 Time 函数说明 返回TDateTime对象,包含当前的时间信息,函数原型如下: System::TDateTime __fastcall Time(void);

函数名称 TimeToStr 函数说明 将当前日期转换为字符串对象,函数原型如下: AnsiString __fastcall TimeToStr(System::TDateTime Time);

函数名称 UpperCase 函数说明 将指定的AnsiString字符串转换为大写形式,函数原型如下: AnsiString __fastcall UpperCase(const AnsiString S);

函数名称 AllocMem 函数说明 在队中分配指定字节的内存块,并将分配的每一个字节初始化为 0.函数原型如下: void * __fastcall AllocMem(Cardinal Size);

函数名称 ChangeFileExt 函数说明 更改指定文件的扩展名,函数原型如下: AnsiString __fastcall ChangeFileExt(const AnsiString FileName,const AnsiString Extension);

函数名称 CompareStr 函数说明 比较两个AnsiString字符串,函数原型如下: int __fastcall CompareStr(const AnsiString S1, const AnsiString S2);

函数名称 CompareText 函数说明 比较两个AnsiString字符串,函数原型如下: int __fastcall CompareText(const AnsiString S1, const AnsiString S2);

函数名称 CreateDir 函数说明 创建新的目录,如果操作成功,返回真,否则返回假,函数原型如下: bool __fastcall CreateDir(const AnsiString Dir);

函数名称 Date 函数说明 返回TDateTime对象,包含当前的年月日信息,函数原型如下: System::TDateTime __fastcall Date(void);

函数名称 DateTimetoStr 函数说明 将TDateTime对象转换为字符串对象,函数原型如下: AnsiString __fastcall DateTimeToStr(System::TDateTime DateTime);

函数名称 DatetimeToString 函数说明 将TDateTime对象转换为指定格式的字符串对象,函数原型如下: void __fastcall DateTimeToString(AnsiString &Result, const AnsiString Format,System::TDateTime DateTime);

函数名称 DateTimeToSystemTime 函数说明 将TDateTime对象转换为操作系统时间,函数原型如下: void __fastcall DateTimeToSystemTime(System::TDateTime DateTime, _SYSTEMTIME &SystemTime);

函数名称 DateToStr 函数说明 将TDateTime对象(包含当前年月日信息)转换为字符串对象,函数原型如下: AnsiString __fastcall DateToStr(System::TDateTime Date);

函数名称 DeleteFile 函数说明 在计算机磁盘中删除指定的文件,如果操作成功,则函数返回真,函数原型如下: bool __fastcall DeleteFile(const AnsiString FileName);

函数名称 DiskFree 函数说明 返回指定磁盘的剩余空间,如果操作成功,返回剩余磁盘空间,如果操作失败,则返回-1,函数原型如下: int __fastcall DiskFree(Byte Drive);

函数名称 DiskSize 函数说明 返回指定磁盘的空间,如果操作成功,返回磁盘空间,如果操作失败,则返回-1,函数原型如下: int __fastcall DiskSize(Byte Drive);

函数名称 ExtractFileDir 函数说明 返回指定文件的工作目录,函数原型如下: AnsiString __fastcall ExtractFileDir(const AnsiString FileName);

函数名称 ExtractFileDrive 函数说明 返回指定文件的驱动器,函数原型如下: AnsiString __fastcall ExtractFileDrive(const AnsiString FileName);

函数名称 ExtractFileExt 函数说明 返回指定文件的扩展名,函数原型如下: AnsiString __fastcall ExtractFileExt(const AnsiString FileName);

函数名称 ExtractFileName 函数说明 返回指定文件的文件名及扩展名,函数原型如下: AnsiString __fastcall ExtractFileName(const AnsiString FileName);

函数名称 ExtractFilePath 函数说明 返回指定文件的工作路径,函数原型如下: AnsiString __fastcall ExtractFilePath(const AnsiString FileName);

函数名称 FileAge 函数说明 返回指定文件的时间标签,如果操作失败,则返回-1,函数原型如下: int __fastcall FileAge(const System::AnsiString FileName);

函数名称 FileClose 函数说明 关闭指定的文件,函数原型如下: void __fastcall FileClose(int Handle);

函数名称 FileCreate 函数说明 以指定的文件名称创建一个新的文件,如果返回为正数,表示操作成功,返回值为文件句柄,如果返回值为-1,表示操作失败.函数原型如下: int __fastcall FileCreate(const System ::AnsiString FileName);

函数名称 FileExists 函数说明 用于测试指定的文件是否存在,如果存在返回真,否则返回假,函数原型如下: bool __fastcall FileExists(const System::AnsiString FileName);

函数名称 FileGetAttr 函数说明 返回指定文件的属性,如果操作失败,则函数返回-1,函数原型如下; int __fastcall FileGetAttr(const System::AnsiString FileName);

函数名称 FileGetDate 函数说明 返回指定文件的DOS时间标签,如果操作失败,则近回-1,函数原型如下: int __fastcall FileGetDate(int Handle);

函数名称 FileOpen 函数说明 打开指定的文件,如果返回为正数,表示操作成功,返回值为文件句柄:如果返回值为-1,表示操作失败,函数原型如下: int __fastcall FileOpen(const System::AnsiString FileName,int Mode);

函数名称 FileRead 函数说明 从文件中读取指定字节的数据到缓冲区中,函数返回实际读取的字节数,函数原型如下; int __fastcall FileRead(int Handle,void *Buffer,int Count);

函数名称 FileSeek 函数说明 调整文件指针到新的位置,如果操作成功,则返回新的文件位置,如果操作失败,则函数返回-1,函数原型如下: int __fastcall FileSeek(int Handle,int Offset,int Origin);

函数名称 FileSetAttr 函数说明 更改指定文件的属性参数,如果操作成功,则返回0,函数原型如下; int __fastcall FileSetAttr(const System::AnsiString FileName,int Attr);

函数名称 FileSetDate 函数说明 更改指定文件的DOS时间标签,如果操作成功,返回0,否则返回错误代码,函数原型如下: int __fastcall FileSetDate(int Handle,int Age);

函数名称 FileWrite 函数说明 将缓冲区的数据写入到指定的文件的当前位置中去如果操作成功,函数返回实际写入的字节数,如果返回为-1,则表示操作产生错误,函数原型如下: int __fastcall FileWrite(int Handle,const void *Buffer,int Count);

函数名称 FindClose 函数说明 释放FindFirst操作所申请的内存资源,函数原型如下: void __fastcall FindClose(TSearchRec &F);

函数名称 FindFirst 函数说明 在指定的文件目录内,搜寻符合特定属性参数的文件,如果成功地查找到符合条件的文件,则函数返回0,否则函数返回一个错误代码,函数原型如下: int __fastcall FindFirst(const System::AnsiString Path,int Attr,TSearchRec &F);

函数名称 FindNext 函数说明 继续搜寻FindFirst所指定属性参数的文件,如果成功地查找到符合条件的文件,则函数返回0,否则函数返回一个错误代码,函数原型如下: int __fastcall FindNext(TSearchRec &F);

函数名称 FloatToStr 函数说明 将浮点数转换为AnsiString字符串,函数原型如下: AnsiString __fastcall FloatToStr(Extended Value);

函数名称 FloatToStrF 函数说明 将浮点数转换为指定格式的AnsiString字符串,函数原型如下: AnsiString __fastcall FloatToStrF(Extended Value, TFloatFormat Format,int Precision, int Digits);

函数名称 GetCurrentDir 函数说明 返回当前工作目录,函数原型如下: AnsiString __fastcall GetCurrentDir();

函数名称 IntToHex 函数说明 将整数转换为十六进制字符串,函数原型如下: AnsiString __fastcall IntToHex(int Value, int Digits);

函数名称 IntToStr 函数说明 将整数转换为AnsiString字符串,函数原型如下: AnsiString __fastcall IntToStr(int Value);

函数名称 LowerCase 函数说明 将指定的AnsiString字符串转换为小写形式,函数原型如下: AnsiString __fastcall LowerCase(const AnsiString S);

函数名称 Now 函数说明 返回TDateTime对象,获取当前的日期和时间信息,函数原型如下: System::TDateTime __fastcall Now(void);

#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);
}

＃全文完