TnbDriveInformation.h

[詳解]

#pragma once
#include "TnbDriveCommander.h"
#include "TnbDump.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CDriveInformation
{
public:
 
    CDriveInformation(void) : m_cLetter(0)
    {
    }
 
    void Detatch(void)
    {
        m_cLetter = 0;
    }
 
    bool Atatch(TCHAR cLetter)
    {
        Detatch();
        if ( ExistDrive(cLetter) )
        {
            m_cLetter = cLetter;
            return true;
        }
        return false;
    }
 
    bool IsValid(void) const
    {
        return m_cLetter != 0;
    }
 
    DWORD GetType(void) const
    {
        TCHAR a[] = { m_cLetter, ':', '\\', 0 };
        return ::GetDriveType(a);
    }
 
    bool GetPhysicalDriveNumber(CVectorT<int>& _pdn) const
    {
        TCHAR a[] = { m_cLetter, ':', '\\', 0 };
        return GetPhysicalDriveNumber(_pdn, a);
    }
 
    bool IsRemoval(void) const
    {
        switch ( GetType() )
        {
        case DRIVE_REMOVABLE:   // このディスクは、ドライブから取り出せます。 
        case DRIVE_CDROM:   // このドライブは、CD-ROM ドライブです。 
            return true;
        }
        return false;
    }
 
    bool GetVendorId(CStr& _id, bool withRevision = false) const
    {
        CDriveCommander scsi;   
        if ( scsi.OpenLetter(m_cLetter) )
        {
            return scsi.GetVendorId(_id, withRevision);
        }
        return false;
    }
 
    CDriveCommander CreateCommander(void)
    {
        CDriveCommander scsi;   
        scsi.OpenLetter(m_cLetter);
        return scsi;
    }
 
    bool IsReady(void) const
    {
        if ( GetType() == DRIVE_FIXED )
        {
            return true;
        }
        CDriveCommander scsi;   
        if ( scsi.OpenLetter(m_cLetter) )
        {
            scsi.Send_TestUnit();
            return scsi.Send_TestUnit() == 0;
        }
        return false;
    }
    
    bool CanWrite(void) const
    {
        if ( GetType() == DRIVE_FIXED )
        {
            return true;
        }
        CDriveCommander scsi;   
        if ( scsi.OpenLetter(m_cLetter) )
        {
            return scsi.CanWrite(); //ライトプロテクト
        }
        return false;   // 書き込めない
    }
 
    DWORD FormatDlg(HWND hWnd, bool hasCheckDlg = false) const
    {
        DWORD r = 0xFFFFFFFEL;
        if ( IsValid() )
        {
            HMODULE hInst = ::LoadLibraryA("shell32.dll");
            if ( hInst != NULL )
            {
                DWORD (WINAPI *pShFormatDrive)(HWND hWnd, UINT drive, UINT fmdID, UINT options);
                TNB::ForceSet(pShFormatDrive, ::GetProcAddress(hInst, "SHFormatDrive"));
                if ( pShFormatDrive != NULL )
                {
                    UINT nowMode = ::SetErrorMode(0);
                    if ( hasCheckDlg )
                    {
                        ::SetErrorMode(nowMode | SEM_FAILCRITICALERRORS);
                    }
                    else
                    {
                        ::SetErrorMode(nowMode & ~SEM_FAILCRITICALERRORS);
                    }
                    int d = (m_cLetter | 0x20) - 'a';
                    r = (pShFormatDrive)(hWnd, d, 0xFFFF, 0x0);
                    ::SetErrorMode(nowMode);
                }
                ::FreeLibrary(hInst);
            }
        }
        return r;
    }
 
    static bool ExistDrive(TCHAR cLetter)
    {
        int r = (cLetter | 0x20) - 'a';
        if ( r >= 0 && r <= 25 )
        {
            DWORD d = ::GetLogicalDrives();
            return (d & _BIT(r)) != 0;
        }
        return false;
    }
 
    static CVectorT<TCHAR> EnumDrive(void)
    {
        CVectorT<TCHAR> r;
        DWORD d = ::GetLogicalDrives();
        loop ( i, 26 )
        {
            if ( (d & _BIT(i)) != 0 )
            {
                r.Add(static_cast<TCHAR>(_T('A') + i));
            }
        }
        return r;
    }
 
    static bool GetPhysicalDriveNumber(CVectorT<int>& _pdn, LPCTSTR lpszPath)
    {
        _pdn.RemoveAll();
        CStr s1;
        if ( ! ::GetVolumePathName(lpszPath, s1.GetBuffer(1024), 1024) )
        {
            return false;
        }
        s1.ReleaseBuffer();
        CStr vol;
        if ( ! ::GetVolumeNameForVolumeMountPoint(s1, vol.GetBuffer(1024), 1024) )
        {
            return false;
        }
        vol.ReleaseBuffer();
        vol.TrimRight('\\');
        HANDLE h = ::CreateFile(vol, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        VOLUME_DISK_EXTENTS buf;
        DWORD returnedSize = 0;
        BOOL r = ::DeviceIoControl(
                h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, &buf, sizeof(buf), &returnedSize, NULL);
        DWORD le = _GetLastError("DeviceIoControl");
        if ( r && buf.NumberOfDiskExtents == 1 )
        {
            _pdn.Add(buf.Extents[0].DiskNumber);
            ::CloseHandle(h);
            return true;
        }
        if ( le != ERROR_MORE_DATA ) 
        {
            ::CloseHandle(h);
            return false;
        }
        size_t bs = sizeof(buf.NumberOfDiskExtents) + sizeof(buf.Extents) * buf.NumberOfDiskExtents;
        CWorkMem w(bs);
        VOLUME_DISK_EXTENTS* p = reinterpret_cast<VOLUME_DISK_EXTENTS *>(w.Ref());
        r = ::DeviceIoControl(
                h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, p, bs, &returnedSize, NULL);
        le = _GetLastError("DeviceIoControl");
        if ( r )
        {
            loop ( i, p->NumberOfDiskExtents )
            {
                _pdn.Add(p->Extents[i].DiskNumber);
            }
        }
        ::CloseHandle(h);
        return !! r;
    }
 
private:
    TCHAR       m_cLetter;  
};
 
 
 
}; // TNB