TnbDriveCommander.h

[詳解]

#pragma once
#include <ntddscsi.h>   // SDK
#include <WinIoCtl.h>   // SDK
#include "TnbPointerHandle.h"
#include "TnbHandleHandle.h"
#include "TnbCollection.h"
#include "TnbWriter.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CDriveCommander : public IWriter
{
public:
    
    struct TSenseData
    {
        BYTE KEY;       
        BYTE ASC;       
        BYTE ASCQ;      
        void Clear(void) {
            KEY = ASC = ASCQ = 0;
        }
    };
 
 
    //-----
 
 
    CDriveCommander(void) : m_timeout(2)
    {
        m_sense.Clear();
    }
 
    bool IsOpened(void) const
    {
        return ! m_hhDrive.IsNull();
    }
 
    virtual void Close(void)
    {
        m_hhDrive.Null();
    }
 
    bool OpenDrive(DWORD driveNo)
    {
        Close();
        m_hhDrive = ::CreateFile(CStr::Fmt(_T("\\\\.\\PhysicalDrive%d"), driveNo),
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                NULL,
                                OPEN_EXISTING,
                                0, NULL);
        return ! m_hhDrive.IsNull();
    }
 
    bool OpenLetter(TCHAR driveLetter)
    {
        Close();
        m_hhDrive = ::CreateFile(CStr::Fmt(_T("\\\\.\\%c:"), driveLetter),
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ,
                                NULL,
                                OPEN_EXISTING,
                                0, NULL);
        return ! m_hhDrive.IsNull();
    }
 
    const TSenseData& GetSense(void) const
    {
        return m_sense;
    }
 
    bool Update()
    {
        DWORD d;
        return !! ::DeviceIoControl(m_hhDrive, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, &d, NULL);
    }
 
    bool DismountVolume()
    {
        DWORD d;
        return !! ::DeviceIoControl(m_hhDrive, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &d, NULL);
    }
 
    bool LockVolume(void)
    {
        DWORD d;
        return !! ::DeviceIoControl(m_hhDrive, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &d, NULL);
    }
 
    bool UnlockVolume(void)
    {
        DWORD d;
        return !! ::DeviceIoControl(m_hhDrive, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &d, NULL);
    }
 
    int SendCommand(const ISequenceCollectionT<BYTE>& cdb)
    {
        if ( m_hhDrive.IsNull() ) 
        {
            ::SetLastError(ERROR_ACCESS_DENIED);
            return -1; 
        }
        CCdbInfo tmp(0, SCSI_IOCTL_DATA_UNSPECIFIED); //SCSI_IOCTL_DATA_IN
        tmp.SetCdb(cdb, m_timeout);
        return m_SendCdb(tmp);
    }
 
    int SendCommandWithWritePhase(
            const ISequenceCollectionT<BYTE>& cdb, const ISequenceCollectionT<BYTE>& data)
    {
        if ( m_hhDrive.IsNull() ) 
        {
            ::SetLastError(ERROR_ACCESS_DENIED);
            return -1; 
        }
        size_t l = data.GetSize();
        CCdbInfo tmp(l, static_cast<BYTE>((l > 0) ? SCSI_IOCTL_DATA_OUT : SCSI_IOCTL_DATA_UNSPECIFIED));
        tmp.SetCdb(cdb, m_timeout);
        if ( l > 0 )
        {
            MemCopy(tmp.RefData(), data.ReferBuffer(), l);
        }
        return m_SendCdb(tmp);
    }
 
    int SendCommandWithReadPhase(ICollectionT<BYTE>& _d,
                    const ISequenceCollectionT<BYTE>& cdb, int readSize)
    {
        if ( m_hhDrive.IsNull() ) 
        {
            ::SetLastError(ERROR_ACCESS_DENIED);
            return -1; 
        }
        CCdbInfo tmp(readSize, SCSI_IOCTL_DATA_IN);
        tmp.SetCdb(cdb, m_timeout);
        int r = m_SendCdb(tmp);
        if ( r == 0 )
        {
            _d.CopyElements(readSize, tmp.RefData());
        }
        return r;
    }
 
    int Send_ModeSense(ICollectionT<BYTE>& _d, BYTE pc, bool isWithBd = false)
    {
        BYTE cdb[6] = {0x1A/*ModeSense*/, _BIT(3)/*Block Descriptor 転送なし*/, pc, 0, 4, 0};
        int r = SendCommandWithReadPhase(_d, CArrayAdapterT<BYTE>(cdb), cdb[4]);
        if ( r == 0 && _d.GetSize() >= 4 )
        {
            cdb[1] = static_cast<BYTE>((isWithBd && _d.At(3) == 8) ? 0 : _BIT(3));
            cdb[4] = static_cast<BYTE>(4 + _d.At(3) + _d.At(0));
            r = SendCommandWithReadPhase(_d, CArrayAdapterT<BYTE>(cdb), cdb[4]);
        }
        return r;
    }
 
    int Send_Inquiry(ICollectionT<BYTE>& _d)
    {
        BYTE cdb[6] = {0x12/*Inquiry*/, 0, 0, 0, 8, 0};
        int r = SendCommandWithReadPhase(_d, CArrayAdapterT<BYTE>(cdb), cdb[4]);
        if ( r == 0 )
        {
            cdb[4] = static_cast<BYTE>(5 + _d.At(4));
            r = SendCommandWithReadPhase(_d, CArrayAdapterT<BYTE>(cdb), cdb[4]);
        }
        return r;
    }
 
    int Send_TestUnit(void)
    {
        BYTE cdb[6] = {0/*TestUnit*/, 0, 0, 0, 0, 0};
        return SendCommand(CArrayAdapterT<BYTE>(cdb));
    }
 
    int Send_StartStop(BYTE b = 2)
    {
        BYTE cdb[6] = {0x1B/*StartStop*/, 1, 0, 0, b, 0};
        return SendCommand(CArrayAdapterT<BYTE>(cdb));
    }
 
    int Send_ReadCapacity(DWORD& _blockAddress, DWORD& _blockLength)
    {
        BYTE cdb[10] = {0x25/*ReadCapacity*/, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        CByteVector vb;
        int r = SendCommandWithReadPhase(vb, CArrayAdapterT<BYTE>(cdb), 8);
        if ( r == 0 )
        {
            BYTE* p = reinterpret_cast<BYTE*>(vb.GetBuffer());
            _blockAddress = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
            _blockLength = p[4] << 24 | p[5] << 16 | p[6] << 8 | p[7];
        }
        return r;
    }
 
    int Send_Write10(DWORD ba, const ISequenceCollectionT<BYTE>& d, DWORD div = 512)
    {
        BYTE cdb[10] = {0x2A/*Write10*/, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        cdb[2] = static_cast<BYTE>(ba >> 24);
        cdb[3] = static_cast<BYTE>(ba >> 16);
        cdb[4] = static_cast<BYTE>(ba >> 8);
        cdb[5] = static_cast<BYTE>(ba);
        DWORD l = d.GetSize() / div;
        cdb[7] = static_cast<BYTE>(l >> 8);
        cdb[8] = static_cast<BYTE>(l);
        int r = SendCommandWithWritePhase(CArrayAdapterT<BYTE>(cdb), d);
        return r;
    }
 
    HANDLE GetSafeHandle(void) const
    {
        return m_hhDrive;
    }
 
    bool GetVendorId(CStr& _id, bool withRevision = false) const
    {
        CDriveCommander* p = const_cast<CDriveCommander*>(this);
        CByteVector vb;
        p->Send_TestUnit(); // 空読込み
        if ( p->Send_Inquiry(vb) == 0 && vb.GetSize() >= 36 )
        {
            const char* p = reinterpret_cast<const char*>(vb.ReferBuffer());
            CAscii a1;
            a1.SetFromLeft(&p[8], 8);
            _id = a1;
            a1.SetFromLeft(&p[16], 16);
            _id += a1;
            if ( withRevision )
            {
                a1.SetFromLeft(&p[32], 4);
                _id += a1;
            }
            return true;
        }
        return false;
    }
 
    virtual LPCTSTR GetOpenName(void) const
    {
        m_vendorId.Empty();
        GetVendorId(m_vendorId);
        return m_vendorId;
    }
 
    virtual bool CanRead(void) const
    {
        CDriveCommander* p = const_cast<CDriveCommander*>(this);
        return (p->Send_TestUnit()) == 0;
    }
 
    virtual bool CanWrite(void) const
    {
        CDriveCommander* p = const_cast<CDriveCommander*>(this);
        CByteVector vb;
        if ( CanRead() && p->Send_ModeSense(vb, 0x3F) == 0 && vb.GetSize() >= 4 )
        {
            //TNB::DebugDump(vb.GetSize(), vb.ReferBuffer());
            // vb[1]; //Media ID
            // vb[2]; // 3Byte目の最上位Bitが WriteProtect 状態です（1なら WP）。
            return (vb[2] & _BIT(7)) == 0;
        }
        return false;
    }
 
    virtual LONGLONG GetSize(void) const 
    {
        CWorkMem w(sizeof(DISK_GEOMETRY_EX) + sizeof(DISK_PARTITION_INFO) + sizeof(DISK_DETECTION_INFO));
        w.Fill(0);
        DWORD returnedBytes = 0;
        BOOL r = ::DeviceIoControl(
                GetSafeHandle(), IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, w.Ref(), w.GetSize(), &returnedBytes, NULL);
        DISK_GEOMETRY_EX* pGeometry = reinterpret_cast<DISK_GEOMETRY_EX*>(w.Ref());
        //DISK_PARTITION_INFO* pPartition= DiskGeometryGetPartition(pGeometry);
        //DISK_DETECTION_INFO* pDetection = DiskGeometryGetDetect(pGeometry);
        LONGLONG ll = pGeometry->DiskSize.QuadPart;
        return r ? ll : -1;
    }
 
    bool GetGeometry(DISK_GEOMETRY& _g) const 
    {
        CWorkMem w(sizeof(DISK_GEOMETRY_EX) + sizeof(DISK_PARTITION_INFO) + sizeof(DISK_DETECTION_INFO));
        w.Fill(0);
        DWORD returnedBytes = 0;
        BOOL r = ::DeviceIoControl(
                GetSafeHandle(), IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, w.Ref(), w.GetSize(), &returnedBytes, NULL);
        DISK_GEOMETRY_EX* pGeometry = reinterpret_cast<DISK_GEOMETRY_EX*>(w.Ref());
        _g = pGeometry->Geometry;
        return !! r;
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode seek = TOP) const 
    {
        if ( seek == END )
        {
            llOffset += GetSize();
            seek = TOP;
        }
        LARGE_INTEGER r;
        r.QuadPart = llOffset;
        r.LowPart = ::SetFilePointer(GetSafeHandle(), r.LowPart, &r.HighPart, seek);
        if ( r.LowPart == INVALID_SET_FILE_POINTER )
        {
            if ( ::GetLastError() != NO_ERROR )
            {
                r.QuadPart = -1;
            }
        }
        return r.QuadPart;
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        DWORD dwRead;
        BOOL boRc = ::ReadFile(GetSafeHandle(), _P, ToDword(size), &dwRead, NULL);
        if ( ! boRc )
        {
            throw CReadFailureException(::GetLastError());
        }
        return dwRead;
    }
 
    virtual void Write(size_t size, LPCVOID P)
    {
        if ( size >= ULONG_MAX )
        {
            throw CWriteFailureException(ERROR_BAD_LENGTH);
        }
        DWORD dwWrite;
        bool boRc = !! ::WriteFile(GetSafeHandle(), P, ToDword(size), &dwWrite, NULL);
        DWORD dwError = boRc ? 0 : ::GetLastError();
        if ( ! boRc || size != dwWrite )
        {
            throw CWriteFailureException(dwError);
        }
    }
    
    virtual void SetEnd(void)
    {
        throw CNotSupportException();
    }
 
private:
 
    struct TScsiPassThroughEx
    {
        SCSI_PASS_THROUGH   spt;        
        DWORD               boundary;   
        BYTE                abSense[32];
    };
 
    class CCdbInfo
    {
        CWorkMem    m_work;         
        size_t      m_size;         
    public:
        CCdbInfo(size_t size, BYTE bMode) : m_work(0)
        {
            m_size = sizeof(TScsiPassThroughEx) + size;
            m_work.Resize(m_size);
            TScsiPassThroughEx* P = reinterpret_cast<TScsiPassThroughEx*>(m_work.Ref());
            ::ZeroMemory(P, m_size);
            P->spt.Length               = sizeof(SCSI_PASS_THROUGH);
//          P->spt.SenseInfoLength      = 18;
            P->spt.SenseInfoLength      = 32;
            P->spt.DataIn               = bMode;
            P->spt.DataTransferLength   = static_cast<ULONG>(size);
            P->spt.TimeOutValue         = 2;
            if ( size != 0 )
            {
                P->spt.DataBufferOffset = sizeof(TScsiPassThroughEx);
            }
            P->spt.SenseInfoOffset      = offsetof(TScsiPassThroughEx, abSense);
        }
        void SetCdb(const ISequenceCollectionT<BYTE>& cdb, DWORD timeout)
        {
            TScsiPassThroughEx* P = reinterpret_cast<TScsiPassThroughEx*>(m_work.Ref());
            P->spt.CdbLength = static_cast<BYTE>(cdb.GetSize());
            MemCopy(P->spt.Cdb, cdb.ReferBuffer(), cdb.GetSize());
            P->spt.TimeOutValue = timeout;
        }
        TScsiPassThroughEx* Ref(void)
        {
            return reinterpret_cast<TScsiPassThroughEx*>(m_work.Ref());
        }
        BYTE* RefData(void)
        {
            return m_work.Ref() + sizeof(TScsiPassThroughEx);
        }
        size_t GetLength(void)
        {
            return m_size;
        }
    };
 
    template<typename TYP>
    class CArrayAdapterT : public ISequenceCollectionT<TYP>
    {
        DEFSUPER(ISequenceCollectionT<TYP>);
        const TYP*          m_pcType;           
        size_t              m_size;             
    public:
        template<typename T> CArrayAdapterT(const T& t)
            : _super(), m_pcType(static_cast<const TYP*>(t)), m_size(sizeof(T) / sizeof(TYP)) {}
        virtual size_t GetSize(void) const { return m_size; }
        virtual const TYP* ReferBuffer(void) const { return m_pcType; }
    };
 
    int m_SendCdb(CCdbInfo& cdb)
    {
        DWORD dwResult = 0;
        TScsiPassThroughEx* P = cdb.Ref();
        BOOL r = ::DeviceIoControl(m_hhDrive,
                                IOCTL_SCSI_PASS_THROUGH,
                                P,
                                cdb.GetLength(),
                                P,
                                cdb.GetLength(),
                                &dwResult,
                                NULL);
        m_sense.Clear();
        if ( r && P->spt.ScsiStatus != 0 )
        {
            m_sense.KEY = static_cast<BYTE>(P->abSense[2] & 0x0F);
            if ( P->abSense[7] >= 0x0A )
            {
                m_sense.ASC = P->abSense[12];
                m_sense.ASCQ = P->abSense[13];
            }
            return P->spt.ScsiStatus;
        }
        return r ? 0 : -1;
    }
 
    CHandleHandle   m_hhDrive;      
    TSenseData      m_sense;        
    DWORD           m_timeout;      
    mutable CStr    m_vendorId;     
};
 
 
 
}; // TNB
 
 
 
#if 0
 
// メモ
 http://support.microsoft.com/kb/871134/ja
 http://support.microsoft.com/kb/137247/ja
 
#endif