存储设备的一种访问方法

本文是根据Lynn McGuire的著名程序 DiskID32程序基础修改而来的 ,部分关键代码,仅供参考.

主要用到了ATA/APAPI的IDENTIFY DEVICE指令,

ATA/APAPI是T13起草和发布的IDE/EIDE/UDMA硬盘及其它可移动存储设备与主机接口的标准,

该接口标准规定了ATA/ATAPI设备的输入输出寄存器和指令集.

用到的常量和结构如下

#include <winioctl.h>

 

//  IOCTL控制码
#define  IOCTL_STORAGE_QUERY_PROPERTY   CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)

 

#define   DFP_SEND_DRIVE_COMMAND   CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define   DFP_RECEIVE_DRIVE_DATA   CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define   IDE_ATA_IDENTIFY    0xEC    //   ATA的ID指令(IDENTIFY DEVICE)
#define   FILE_DEVICE_SCSI         0x0000001b
#define   IOCTL_SCSI_MINIPORT_IDENTIFY  ((FILE_DEVICE_SCSI << 16) + 0x0501)
#define   IOCTL_SCSI_MINIPORT 0x0004D008   //   see NTDDSCSI.H for definition

 

IDENTIFY DEVICE专门用于固定硬盘，而IDENTIFY PACKET DEVICE用于可移动存储设备如CDROM、CF、MO、ZIP、TAPE等。因为驱动程序的原因，不管是IDENTIFY DEVICE也好，IDENTIFY PACKET DEVICE也好，获取可移动存储设备的详细信息，一般是做不到的。而且除了IDE硬盘，对SCSI、USB等接口的硬盘也不起作用。除非厂商提供的驱动支持这样的功能。另外ATA/ATAPI有很多指令，如READ SECTORS, WRITE SECTORS, SECURITY, SLEEP, STANDBY等，对这些指令操作的过程中也要很慎重.

 最新的SDK已经声明了很多以前需要手工声明的结构类型,如

IDEREGS  DRIVERSTATUS SENDCMDINPARAMS SENDCMDOUTPARAMS

 

结构声明:

 

//  查询存储设备属性的类型
typedef  enum  _STORAGE_QUERY_TYPE {
    PropertyStandardQuery  =   0 ,           //  读取描述
        PropertyExistsQuery,                 //  测试是否支持
        PropertyMaskQuery,                   //  读取指定的描述
        PropertyQueryMaxDefined                 //  验证数据
} STORAGE_QUERY_TYPE,  * PSTORAGE_QUERY_TYPE;

//  查询存储设备还是适配器属性
typedef  enum  _STORAGE_PROPERTY_ID {
    StorageDeviceProperty  =   0 ,             //  查询设备属性
        StorageAdapterProperty                 //  查询适配器属性
} STORAGE_PROPERTY_ID,  * PSTORAGE_PROPERTY_ID;

//  查询属性输入的数据结构
typedef  struct  _STORAGE_PROPERTY_QUERY {
    STORAGE_PROPERTY_ID PropertyId;         //  设备/适配器
    STORAGE_QUERY_TYPE QueryType;         //  查询类型 
    UCHAR AdditionalParameters[ 1 ];         //  额外的数据(仅定义了象征性的1个字节)
} STORAGE_PROPERTY_QUERY,  * PSTORAGE_PROPERTY_QUERY;


typedef  struct  _STORAGE_DEVICE_DESCRIPTOR {
    ULONG Version;         //  版本
    ULONG Size;             //  结构大小
    UCHAR DeviceType;     //  设备类型
    UCHAR DeviceTypeModifier;     //  SCSI-2额外的设备类型
    BOOLEAN RemovableMedia;         //  是否可移动
    BOOLEAN CommandQueueing;     //  是否支持命令队列
    ULONG VendorIdOffset;         //  厂家设定值的偏移
    ULONG ProductIdOffset;         //  产品ID的偏移
    ULONG ProductRevisionOffset;     //  产品版本的偏移
    ULONG SerialNumberOffset;         //  序列号的偏移
    STORAGE_BUS_TYPE BusType;         //  总线类型
    ULONG RawPropertiesLength;         //  额外的属性数据长度
    UCHAR RawDeviceProperties[ 1 ];     //  额外的属性数据(仅定义了象征性的1个字节)
} STORAGE_DEVICE_DESCRIPTOR,  * PSTORAGE_DEVICE_DESCRIPTOR;

 

typedef  struct  _IDINFO
{
    USHORT  wGenConfig;                     //  WORD 0: 基本信息字
    USHORT  wNumCyls;                     //  WORD 1: 柱面数
    USHORT  wReserved2;                     //  WORD 2: 保留
    USHORT  wNumHeads;                     //  WORD 3: 磁头数
    USHORT  wReserved4;                     //  WORD 4: 保留
    USHORT  wReserved5;                     //  WORD 5: 保留
    USHORT  wNumSectorsPerTrack;         //  WORD 6: 每磁道扇区数
    USHORT  wVendorUnique[ 3 ];             //  WORD 7-9: 厂家设定值
    CHAR    sSerialNumber[ 20 ];             //  WORD 10-19:序列号
    USHORT  wBufferType;                 //  WORD 20: 缓冲类型
    USHORT  wBufferSize;                 //  WORD 21: 缓冲大小
    USHORT  wECCSize;                     //  WORD 22: ECC校验大小
    CHAR    sFirmwareRev[ 8 ];             //  WORD 23-26: 固件版本
    CHAR    sModelNumber[ 40 ];             //  WORD 27-46: 内部型号
    USHORT  wMoreVendorUnique;             //  WORD 47: 厂家设定值
    USHORT  wReserved48;                 //  WORD 48: 保留
     struct  {
        USHORT  reserved1: 8 ;
        USHORT  DMA: 1 ;                     //  1=支持DMA
        USHORT  LBA: 1 ;                     //  1=支持LBA
        USHORT  DisIORDY: 1 ;                 //  1=可不使用IORDY
        USHORT  IORDY: 1 ;                 //  1=支持IORDY
        USHORT  SoftReset: 1 ;             //  1=需要ATA软启动
        USHORT  Overlap: 1 ;                 //  1=支持重叠操作
        USHORT  Queue: 1 ;                 //  1=支持命令队列
        USHORT  InlDMA: 1 ;                 //  1=支持交叉存取DMA
    } wCapabilities;                     //  WORD 49: 一般能力
    USHORT  wReserved1;                     //  WORD 50: 保留
    USHORT  wPIOTiming;                     //  WORD 51: PIO时序
    USHORT  wDMATiming;                     //  WORD 52: DMA时序
     struct  {
        USHORT  CHSNumber: 1 ;             //  1=WORD 54-58有效
        USHORT  CycleNumber: 1 ;             //  1=WORD 64-70有效
        USHORT  UnltraDMA: 1 ;             //  1=WORD 88有效
        USHORT  reserved: 13 ;
    } wFieldValidity;                     //  WORD 53: 后续字段有效性标志
    USHORT  wNumCurCyls;                 //  WORD 54: CHS可寻址的柱面数
    USHORT  wNumCurHeads;                 //  WORD 55: CHS可寻址的磁头数
    USHORT  wNumCurSectorsPerTrack;         //  WORD 56: CHS可寻址每磁道扇区数
    USHORT  wCurSectorsLow;                 //  WORD 57: CHS可寻址的扇区数低位字
    USHORT  wCurSectorsHigh;             //  WORD 58: CHS可寻址的扇区数高位字
     struct  {
        USHORT  CurNumber: 8 ;             //  当前一次性可读写扇区数
        USHORT  Multi: 1 ;                 //  1=已选择多扇区读写
        USHORT  reserved1: 7 ;
    } wMultSectorStuff;                     //  WORD 59: 多扇区读写设定
    ULONG  dwTotalSectors;                 //  WORD 60-61: LBA可寻址的扇区数
    USHORT  wSingleWordDMA;                 //  WORD 62: 单字节DMA支持能力
     struct  {
        USHORT  Mode0: 1 ;                 //  1=支持模式0 (4.17Mb/s)
        USHORT  Mode1: 1 ;                 //  1=支持模式1 (13.3Mb/s)
        USHORT  Mode2: 1 ;                 //  1=支持模式2 (16.7Mb/s)
        USHORT  Reserved1: 5 ;
        USHORT  Mode0Sel: 1 ;                 //  1=已选择模式0
        USHORT  Mode1Sel: 1 ;                 //  1=已选择模式1
        USHORT  Mode2Sel: 1 ;                 //  1=已选择模式2
        USHORT  Reserved2: 5 ;
    } wMultiWordDMA;                     //  WORD 63: 多字节DMA支持能力
     struct  {
        USHORT  AdvPOIModes: 8 ;             //  支持高级POI模式数
        USHORT  reserved: 8 ;
    } wPIOCapacity;                         //  WORD 64: 高级PIO支持能力
    USHORT  wMinMultiWordDMACycle;         //  WORD 65: 多字节DMA传输周期的最小值
    USHORT  wRecMultiWordDMACycle;         //  WORD 66: 多字节DMA传输周期的建议值
    USHORT  wMinPIONoFlowCycle;             //  WORD 67: 无流控制时PIO传输周期的最小值
    USHORT  wMinPOIFlowCycle;             //  WORD 68: 有流控制时PIO传输周期的最小值
    USHORT  wReserved69[ 11 ];             //  WORD 69-79: 保留
     struct  {
        USHORT  Reserved1: 1 ;
        USHORT  ATA1: 1 ;                     //  1=支持ATA-1
        USHORT  ATA2: 1 ;                     //  1=支持ATA-2
        USHORT  ATA3: 1 ;                     //  1=支持ATA-3
        USHORT  ATA4: 1 ;                     //  1=支持ATA/ATAPI-4
        USHORT  ATA5: 1 ;                     //  1=支持ATA/ATAPI-5
        USHORT  ATA6: 1 ;                     //  1=支持ATA/ATAPI-6
        USHORT  ATA7: 1 ;                     //  1=支持ATA/ATAPI-7
        USHORT  ATA8: 1 ;                     //  1=支持ATA/ATAPI-8
        USHORT  ATA9: 1 ;                     //  1=支持ATA/ATAPI-9
        USHORT  ATA10: 1 ;                 //  1=支持ATA/ATAPI-10
        USHORT  ATA11: 1 ;                 //  1=支持ATA/ATAPI-11
        USHORT  ATA12: 1 ;                 //  1=支持ATA/ATAPI-12
        USHORT  ATA13: 1 ;                 //  1=支持ATA/ATAPI-13
        USHORT  ATA14: 1 ;                 //  1=支持ATA/ATAPI-14
        USHORT  Reserved2: 1 ;
    } wMajorVersion;                     //  WORD 80: 主版本
    USHORT  wMinorVersion;                 //  WORD 81: 副版本
    USHORT  wReserved82[ 6 ];                 //  WORD 82-87: 保留
     struct  {
        USHORT  Mode0: 1 ;                 //  1=支持模式0 (16.7Mb/s)
        USHORT  Mode1: 1 ;                 //  1=支持模式1 (25Mb/s)
        USHORT  Mode2: 1 ;                 //  1=支持模式2 (33Mb/s)
        USHORT  Mode3: 1 ;                 //  1=支持模式3 (44Mb/s)
        USHORT  Mode4: 1 ;                 //  1=支持模式4 (66Mb/s)
        USHORT  Mode5: 1 ;                 //  1=支持模式5 (100Mb/s)
        USHORT  Mode6: 1 ;                 //  1=支持模式6 (133Mb/s)
        USHORT  Mode7: 1 ;                 //  1=支持模式7 (166Mb/s) ???
        USHORT  Mode0Sel: 1 ;                 //  1=已选择模式0
        USHORT  Mode1Sel: 1 ;                 //  1=已选择模式1
        USHORT  Mode2Sel: 1 ;                 //  1=已选择模式2
        USHORT  Mode3Sel: 1 ;                 //  1=已选择模式3
        USHORT  Mode4Sel: 1 ;                 //  1=已选择模式4
        USHORT  Mode5Sel: 1 ;                 //  1=已选择模式5
        USHORT  Mode6Sel: 1 ;                 //  1=已选择模式6
        USHORT  Mode7Sel: 1 ;                 //  1=已选择模式7
    } wUltraDMA;                         //  WORD 88:  Ultra DMA支持能力
    USHORT    wReserved89[ 167 ];             //  WORD 89-255
} IDINFO,  * PIDINFO;

头文件声明的几个重要函数

 

     void  AdjustString( char *  str,  int  len);
    BOOL IdentifyDevice(HANDLE hDevice, PIDINFO pIdInfo);
    BOOL GetPhysicalDriveInfoInNT( int  nDrive, PIDINFO pIdInfo);
     void  GetBoisUUID();
    CString MakeActualString(LPCTSTR pszMsg);
    BOOL GetDriveProperty(HANDLE hDevice, PSTORAGE_DEVICE_DESCRIPTOR pDevDesc);
    BOOL GetDriveGeometry(HANDLE hDevice, PDISK_GEOMETRY pGeometry);
    HANDLE OpenDevice(LPCTSTR pszDevicePath);
     int  GetDevicePath(LPGUID lpGuid, LPTSTR *  pszDevicePath);

 

cpp

 

#pragma  comment(lib,"Setupapi.lib")
#define  BUFSIZE1 1024

#define  INTERFACE_DETAIL_SIZE    (1024)
#define  MEDIA_INFO_SIZE        (sizeof(GET_MEDIA_TYPES) + sizeof(DEVICE_MEDIA_INFO) * 15)

#define  MAX_DEVICE        16

const  GUID DiskClassGuid  =   { 0x53f56307L ,  0xb6bf ,  0x11d0 , { 0x94 ,  0xf2 ,  0x00 ,  0xa0 ,  0xc9 ,  0x1e ,  0xfb ,  0x8b }};

 

void  CCGuardTestDlg::OnStart() 
{
    HANDLE hDevice;
    PDISK_GEOMETRY pGeometry;
    PSTORAGE_DEVICE_DESCRIPTOR pDevDesc;
     int  i,j;
     int  nDevice;
     char *  szDevicePath[MAX_DEVICE];
    pGeometry  =   new  DISK_GEOMETRY;
    CString strTmp  =   "" ;
     for (i = 0 ;i < MAX_DEVICE;i ++ ) szDevicePath[i] = new   char [ 256 ];
    pDevDesc  =  (PSTORAGE_DEVICE_DESCRIPTOR) new  BYTE[ sizeof (STORAGE_DEVICE_DESCRIPTOR)  +   512   -   1 ];
    
    pDevDesc -> Size  =   sizeof (STORAGE_DEVICE_DESCRIPTOR)  +   512   -   1 ;
    
    LPGUID lpGuid  =  (LPGUID) & DiskClassGuid;
     for (i = 0 ; i < sizeof (lpGuid) / sizeof (LPGUID); i ++ )
    {
        nDevice     =  GetDevicePath(lpGuid, szDevicePath);

         for (j = 0 ; j < nDevice; j ++ )
        {
            hDevice  =  OpenDevice( szDevicePath[j] );
             if (hDevice  !=  INVALID_HANDLE_VALUE)
            {
                GetDriveGeometry(hDevice, pGeometry);
                GetDriveProperty(hDevice, pDevDesc);
                 char *  p;
                
                p =  ( char * )pDevDesc;
                
                strTmp  =  (pDevDesc -> ProductRevisionOffset  ?   & p[pDevDesc -> ProductRevisionOffset] :  "" ); //  firmware version
                strTmp  =  MakeActualString(strTmp);
                
                strTmp  =  (pDevDesc -> SerialNumberOffset  ?   & p[pDevDesc -> SerialNumberOffset] :  "" );
                strTmp  =  MakeActualString(strTmp);

                strTmp  =  (pDevDesc -> ProductIdOffset  ?   & p[pDevDesc -> ProductIdOffset] :  "" );
                strTmp  =  MakeActualString(strTmp);
                ULONGLONG DiskSize  =  pGeometry -> Cylinders.QuadPart  *  (ULONGLONG)pGeometry -> TracksPerCylinder  *
                    (ULONGLONG)pGeometry -> SectorsPerTrack  *  (ULONGLONG)pGeometry -> BytesPerSector;
                strTmp.Format( " Disk size = %I64d Bytes (%I64d MB) " , DiskSize, DiskSize  /  ( 1024   *   1024 ));
                
                CloseHandle(hDevice);
            }
        }
    }    
    delete pGeometry;
     for (i = 0 ;i < MAX_DEVICE;i ++ ) delete []szDevicePath[i];
}

 

 

void  CCGuardTestDlg::OnGetPhyinfo() 
{
    CString strInfo;
    IDINFO IdInfo;

     for ( int  i = 0 ; i < 4 ; i ++ ) // 一般不会挂十来块硬盘吧
    {
         if (GetPhysicalDriveInfoInNT(i,  & IdInfo))
        {
            strInfo  +=   " "   +  MakeIdeInfo(i,  0 ,  & IdInfo);
        }
    }
    
}

 

 

int  CCGuardTestDlg::GetDevicePath(LPGUID lpGuid, LPTSTR  * pszDevicePath)
{
    HDEVINFO hDevInfoSet;
    SP_DEVICE_INTERFACE_DATA ifdata;
    PSP_DEVICE_INTERFACE_DETAIL_DATA pDetail;
     int  nCount;
    BOOL bResult;
    
    hDevInfoSet  =  ::SetupDiGetClassDevs(lpGuid,     
            NULL,                                    
            NULL,                                    
            DIGCF_PRESENT  |  DIGCF_DEVICEINTERFACE);
     if  ( INVALID_HANDLE_VALUE  ==  hDevInfoSet )
    {
         return   0 ;
    }
    pDetail  =  (PSP_DEVICE_INTERFACE_DETAIL_DATA)::GlobalAlloc(LMEM_ZEROINIT, INTERFACE_DETAIL_SIZE);
    pDetail -> cbSize  =   sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);
    
    
    nCount  =   0 ;
    bResult  =  TRUE;
    
     while  (bResult)
    {
                ifdata.cbSize = sizeof (ifdata);
    
         //  枚举符合该GUID的设备接口
        bResult  =  ::SetupDiEnumDeviceInterfaces(
                hDevInfoSet,             //  设备信息集句柄
                NULL,                     //  不需额外的设备描述
                lpGuid,                     //  GUID
                (ULONG)nCount,             //  设备信息集里的设备序号
                 & ifdata);                 //  设备接口信息

         if (bResult)
        {
             //  取得该设备接口的细节(设备路径)
            bResult  =  SetupDiGetInterfaceDeviceDetail(
                    hDevInfoSet,             //  设备信息集句柄
                     & ifdata,                 //  设备接口信息
                    pDetail,                 //  设备接口细节(设备路径)
                    INTERFACE_DETAIL_SIZE,     //  输出缓冲区大小
                    NULL,                     //  不需计算输出缓冲区大小(直接用设定值)
                    NULL);                     //  不需额外的设备描述

             if (bResult)
            {
                 //  复制设备路径到输出缓冲区
                ::strcpy(pszDevicePath[nCount], pDetail -> DevicePath);

                 //  调整计数值
                nCount ++ ;
            }
        }
    }
    
     //  释放设备接口数据空间
    ::GlobalFree(pDetail);

     //  关闭设备信息集句柄
    ::SetupDiDestroyDeviceInfoList(hDevInfoSet);

     return  nCount;
}

HANDLE CCGuardTestDlg::OpenDevice(LPCTSTR pszDevicePath)
{
    HANDLE hDevice;
    
     //  打开设备
    hDevice =  ::CreateFile(pszDevicePath,             //  设备路径
        GENERIC_READ  |  GENERIC_WRITE,             //  读写方式
        FILE_SHARE_READ  |  FILE_SHARE_WRITE,         //  共享方式
        NULL,                                     //  默认的安全描述符
        OPEN_EXISTING,                             //  创建方式
         0 ,                                         //  不需设置文件属性
        NULL);                                     //  不需参照模板文件
    
     return  hDevice;
}

BOOL CCGuardTestDlg::GetDriveGeometry(HANDLE hDevice, PDISK_GEOMETRY pGeometry)
{
    PGET_MEDIA_TYPES pMediaTypes;     //  内部用的输出缓冲区
    DWORD dwOutBytes;                 //  输出数据长度
    BOOL bResult;                     //  DeviceIoControl的返回结果

     //  申请内部用的输出缓冲区
    pMediaTypes  =  (PGET_MEDIA_TYPES)::GlobalAlloc(LMEM_ZEROINIT, MEDIA_INFO_SIZE);

        bResult  =  ::DeviceIoControl(hDevice,             //  设备句柄
            IOCTL_STORAGE_GET_MEDIA_TYPES_EX,         //  取介质类型参数
            NULL,  0 ,                                 //  不需要输入数据
            pMediaTypes, MEDIA_INFO_SIZE,             //  输出数据缓冲区
             & dwOutBytes,                             //  输出数据长度
            (LPOVERLAPPED)NULL);                     //  用同步I/O    

     if (bResult)
    {
         //  注意到结构DEVICE_MEDIA_INFO是在结构DISK_GEOMETRY的基础上扩充的
         //  为简化程序，用memcpy代替如下多条赋值语句：
         //  pGeometry->MediaType = (MEDIA_TYPE)pMediaTypes->MediaInfo[0].DeviceSpecific.DiskInfo.MediaType;
         //  pGeometry->Cylinders = pMediaTypes->MediaInfo[0].DeviceSpecific.DiskInfo.Cylinders;
         //  pGeometry->TracksPerCylinder = pMediaTypes->MediaInfo[0].DeviceSpecific.DiskInfo.TracksPerCylinder;
         //  ... ...
        ::memcpy(pGeometry, pMediaTypes -> MediaInfo,  sizeof (DISK_GEOMETRY));
    }

    ::GlobalFree(pMediaTypes);

     return  bResult;
}

BOOL CCGuardTestDlg::GetDriveProperty(HANDLE hDevice, PSTORAGE_DEVICE_DESCRIPTOR pDevDesc)
{
    STORAGE_PROPERTY_QUERY    Query;     //  查询输入参数
    DWORD dwOutBytes;                 //  IOCTL输出数据长度
    BOOL bResult;                     //  IOCTL返回值
    
     //  指定查询方式
    Query.PropertyId  =  StorageDeviceProperty;
    Query.QueryType  =  PropertyStandardQuery;
    
     //  用IOCTL_STORAGE_QUERY_PROPERTY取设备属性信息
    bResult  =  ::DeviceIoControl(hDevice,             //  设备句柄
        IOCTL_STORAGE_QUERY_PROPERTY,             //  取设备属性信息
         & Query,  sizeof (STORAGE_PROPERTY_QUERY),     //  输入数据缓冲区
        pDevDesc, pDevDesc -> Size,                 //  输出数据缓冲区
         & dwOutBytes,                             //  输出数据长度
        (LPOVERLAPPED)NULL);                     //  用同步I/O    
    
     return  bResult;
}

CString CCGuardTestDlg::MakeActualString(LPCTSTR pszMsg)
{
         int  i;
     int  len;
    BOOL fNeedTranslation;
    CString strMsg;

    len  =  ::strlen(pszMsg);
    
    fNeedTranslation  =  TRUE;

    i = 0 ;
     while (i < len  &&  fNeedTranslation)
    {
         if ( ! (pszMsg[i] >= ' 0 '   &&  pszMsg[i] <= ' 9 '   ||  
            pszMsg[i] >= ' A '   &&  pszMsg[i] <= ' F '   ||
            pszMsg[i] >= ' a '   &&  pszMsg[i] <= ' f ' ))
        {
            fNeedTranslation  =  FALSE;
        }

        i ++ ;
    }

     if (fNeedTranslation)
    {
        WORD word;

         for (i = 0 ; i < len; i += 4 )
        {
            ::sscanf( & pszMsg[i],  " %04x " ,  & word);

            strMsg  +=  ( char )(word % 256 );
            strMsg  +=  ( char )(word / 256 );
        }
    }
     else
    {
        strMsg  =  pszMsg;
    }

    strMsg.TrimLeft();
    strMsg.TrimRight();

     return  strMsg;
}


BOOL CCGuardTestDlg::GetPhysicalDriveInfoInNT( int  nDrive, PIDINFO pIdInfo)
{
    HANDLE hDevice;             //  设备句柄
    BOOL bResult;             //  返回结果
     char  szFileName[ 20 ];     //  文件名

    ::sprintf(szFileName, " //./PhysicalDrive%d " , nDrive);
//     nDevice    = GetDevicePath(lpGuid, szDevicePath);
    hDevice  =  OpenDevice(szFileName);

     if (hDevice  ==  INVALID_HANDLE_VALUE)
    {
         return  FALSE;
    }

     //  IDENTIFY DEVICE
    bResult  =  IdentifyDevice(hDevice, pIdInfo);

     if (bResult)
    {
         //  调整字符串
        AdjustString(pIdInfo -> sSerialNumber,  20 );
        AdjustString(pIdInfo -> sModelNumber,  40 );
        AdjustString(pIdInfo -> sFirmwareRev,  8 );
    }

    ::CloseHandle (hDevice);

     return  bResult;
}

BOOL CCGuardTestDlg::IdentifyDevice(HANDLE hDevice, PIDINFO pIdInfo)
{
    PSENDCMDINPARAMS pSCIP;         //  输入数据结构指针
    PSENDCMDOUTPARAMS pSCOP;     //  输出数据结构指针
    DWORD dwOutBytes;             //  IOCTL输出数据长度
    BOOL bResult;                 //  IOCTL返回值

     //  申请输入/输出数据结构空间
    pSCIP  =  (PSENDCMDINPARAMS)::GlobalAlloc(LMEM_ZEROINIT,  sizeof (SENDCMDINPARAMS) - 1 );
    pSCOP  =  (PSENDCMDOUTPARAMS)::GlobalAlloc(LMEM_ZEROINIT,  sizeof (SENDCMDOUTPARAMS) + sizeof (IDINFO) - 1 );

    pSCIP -> irDriveRegs.bCommandReg  =  IDE_ATA_IDENTIFY;  //  really important!

    
     //  指定输入/输出数据缓冲区大小
    pSCIP -> cBufferSize  =   0 ;
    pSCOP -> cBufferSize  =   sizeof (IDINFO);

     //  IDENTIFY DEVICE
    bResult  =  ::DeviceIoControl(hDevice,                         //  设备句柄
        DFP_RECEIVE_DRIVE_DATA,                                     //  指定IOCTL
        pSCIP,  sizeof (SENDCMDINPARAMS)  -   1 ,                         //  输入数据缓冲区
        pSCOP,  sizeof (SENDCMDOUTPARAMS)  +   sizeof (IDINFO)  -   1 ,     //  输出数据缓冲区
         & dwOutBytes,                                             //  输出数据长度
        (LPOVERLAPPED)NULL);                                     //  用同步I/O

     //  复制设备参数结构
    ::memcpy(pIdInfo, pSCOP -> bBuffer,  sizeof (IDINFO));

     //  释放输入/输出数据空间
    ::GlobalFree(pSCOP);
    ::GlobalFree(pSCIP);

     return  bResult;
}

 

void CCGuardTestDlg::AdjustString(char *str, int len)
{
  char ch;
 int i;

 // 两两颠倒
 for(i=0;i<len;i+=2)
 {
  ch = str[i];
  str[i] = str[i+1];
  str[i+1] = ch;
 }

 // 若是右对齐的，调整为左对齐 (去掉左边的空格)
 i=0;
 while(i<len && str[i]==' ') i++;

 ::memmove(str, &str[i], len-i);

 // 去掉右边的空格
 i = len - 1;
 while(i>=0 && str[i]==' ')
 {
  str[i] = '/0';
  i--;
 }
}