tdestoragedevice.h

/* This file is part of the TDE libraries
   Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
             (C) 2013 Golubev Alexander <fatzer2@gmail.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
 
#ifndef _TDESTORAGEDEVICE_H
#define _TDESTORAGEDEVICE_H
 
#include "tdegenericdevice.h"
#include "tqvariant.h"
 
struct crypt_device;
 
// Keep readDiskDeviceSubtypeFromString() in tdehardwaredevices.cpp in sync with this enum
namespace TDEDiskDeviceType {
#if __cplusplus >= 201103L
enum TDEDiskDeviceType : unsigned long long {
#else
enum TDEDiskDeviceType {
#endif
    Null          = 0x0000000000000000ULL,
    MediaDevice   = 0x0000000000000001ULL,
    Floppy        = 0x0000000000000002ULL,
    CDROM         = 0x0000000000000004ULL,
    CDR           = 0x0000000000000008ULL,
    CDRW          = 0x0000000000000010ULL,
    CDMO          = 0x0000000000000020ULL,
    CDMRRW        = 0x0000000000000040ULL,
    CDMRRWW       = 0x0000000000000080ULL,
    DVDROM        = 0x0000000000000100ULL,
    DVDRAM        = 0x0000000000000200ULL,
    DVDR          = 0x0000000000000400ULL,
    DVDRW         = 0x0000000000000800ULL,
    DVDRDL        = 0x0000000000001000ULL,
    DVDRWDL       = 0x0000000000002000ULL,
    DVDPLUSR      = 0x0000000000004000ULL,
    DVDPLUSRW     = 0x0000000000008000ULL,
    DVDPLUSRDL    = 0x0000000000010000ULL,
    DVDPLUSRWDL   = 0x0000000000020000ULL,
    BDROM         = 0x0000000000040000ULL,
    BDR           = 0x0000000000080000ULL,
    BDRW          = 0x0000000000100000ULL,
    HDDVDROM      = 0x0000000000200000ULL,
    HDDVDR        = 0x0000000000400000ULL,
    HDDVDRW       = 0x0000000000800000ULL,
    Zip           = 0x0000000001000000ULL,
    Jaz           = 0x0000000002000000ULL,
    Camera        = 0x0000000004000000ULL,
    LUKS          = 0x0000000008000000ULL,
    OtherCrypted  = 0x0000000010000000ULL,
    CDAudio       = 0x0000000020000000ULL,
    CDVideo       = 0x0000000040000000ULL,
    DVDVideo      = 0x0000000080000000ULL,
    BDVideo       = 0x0000000100000000ULL,
    Flash         = 0x0000000200000000ULL,
    USB           = 0x0000000400000000ULL,
    Tape          = 0x0000000800000000ULL,
    HDD           = 0x0000001000000000ULL,
    Optical       = 0x0000002000000000ULL,
    RAM           = 0x0000004000000000ULL,
    Loop          = 0x0000008000000000ULL,
    CompactFlash  = 0x0000010000000000ULL,
    MemoryStick   = 0x0000020000000000ULL,
    SmartMedia    = 0x0000040000000000ULL,
    SDMMC         = 0x0000080000000000ULL,
    UnlockedCrypt = 0x0000100000000000ULL,
    Other         = 0x8000000000000000ULL
};
 
inline TDEDiskDeviceType operator|(TDEDiskDeviceType a, TDEDiskDeviceType b)
{
    return static_cast<TDEDiskDeviceType>(static_cast<unsigned long long>(a) | static_cast<unsigned long long>(b));
}
 
inline TDEDiskDeviceType operator&(TDEDiskDeviceType a, TDEDiskDeviceType b)
{
    return static_cast<TDEDiskDeviceType>(static_cast<unsigned long long>(a) & static_cast<unsigned long long>(b));
}
 
inline TDEDiskDeviceType operator~(TDEDiskDeviceType a)
{
    return static_cast<TDEDiskDeviceType>(~static_cast<unsigned long long>(a));
}
};
 
namespace TDEDiskDeviceStatus {
enum TDEDiskDeviceStatus {
    Null               = 0x00000000,
    Mountable          = 0x00000001,
    Removable          = 0x00000002,
    Inserted           = 0x00000004,
    Blank              = 0x00000008,
    UsedByDevice       = 0x00000010,
    UsesDevice         = 0x00000020,
    ContainsFilesystem = 0x00000040,
    Hotpluggable       = 0x00000080,
    Hidden             = 0x00000100,
    Other              = 0x80000000
};
 
inline TDEDiskDeviceStatus operator|(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b)
{
    return static_cast<TDEDiskDeviceStatus>(static_cast<int>(a) | static_cast<int>(b));
}
 
inline TDEDiskDeviceStatus operator&(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b)
{
    return static_cast<TDEDiskDeviceStatus>(static_cast<int>(a) & static_cast<int>(b));
}
 
inline TDEDiskDeviceStatus operator~(TDEDiskDeviceStatus a)
{
    return static_cast<TDEDiskDeviceStatus>(~static_cast<int>(a));
}
};
 
namespace TDELUKSKeySlotStatus {
enum TDELUKSKeySlotStatus {
    Invalid  = 0x00000000,
    Inactive = 0x00000001,
    Active   = 0x00000002,
    Last     = 0x00000004,
    Other    = 0x80000000
};
 
inline TDELUKSKeySlotStatus operator|(TDELUKSKeySlotStatus a, TDELUKSKeySlotStatus b)
{
    return static_cast<TDELUKSKeySlotStatus>(static_cast<int>(a) | static_cast<int>(b));
}
 
inline TDELUKSKeySlotStatus operator&(TDELUKSKeySlotStatus a, TDELUKSKeySlotStatus b)
{
    return static_cast<TDELUKSKeySlotStatus>(static_cast<int>(a) & static_cast<int>(b));
}
 
inline TDELUKSKeySlotStatus operator~(TDELUKSKeySlotStatus a)
{
    return static_cast<TDELUKSKeySlotStatus>(~static_cast<int>(a));
}
};
 
typedef TQValueList<TDELUKSKeySlotStatus::TDELUKSKeySlotStatus> TDELUKSKeySlotStatusList;
 
namespace TDELUKSResult {
enum TDELUKSResult {
    Invalid          = 0x00000000,
    Success          = 0x00000001,
    LUKSNotSupported = 0x00000002,
    LUKSNotFound     = 0x00000003,
    InvalidKeyslot   = 0x00000004,
    KeyslotOpFailed  = 0x00000005,
    Other            = 0x80000000
};
};
 
typedef TQMap<TQString, TQString> TDEStorageMountOptions;
 
class TDECORE_EXPORT TDEStorageDevice : public TDEGenericDevice
{
    public:
        TDEStorageDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
 
        ~TDEStorageDevice();
 
        TQString diskLabel();
 
        TQString diskUUID();
 
        TQString mappedName();
 
        TDEDiskDeviceType::TDEDiskDeviceType diskType();
 
        TDEDiskDeviceStatus::TDEDiskDeviceStatus diskStatus();
 
        bool mediaInserted();
 
        TQString fileSystemName();
 
        TQString fileSystemUsage();
 
        TQStringList holdingDevices();
 
        TQStringList slaveDevices();
 
        TQStringVariantMap mountDevice(TQString mediaName = TQString::null,
            TDEStorageMountOptions mountOptions = TDEStorageMountOptions());
 
        TQStringVariantMap unmountDevice();
 
        TQStringVariantMap unlockDevice(const TQString &passphrase);
 
        TQStringVariantMap lockDevice();
 
        TQString mountPath();
 
        unsigned long long deviceSize();
 
        TQString deviceFriendlySize();
 
        TQPixmap icon(TDEIcon::StdSizes size);
 
        TQString friendlyName();
 
        TQString detailedFriendlyName();
 
        TQString friendlyDeviceType();
 
        bool isDiskOfType(TDEDiskDeviceType::TDEDiskDeviceType tf);
 
        bool checkDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus sf);
 
        bool lockDriveMedia(bool lock);
 
        bool ejectDriveMedia();
 
        TQStringVariantMap ejectDrive();
 
        void cryptSetOperationsUnlockPassword(TQByteArray password);
 
        void cryptClearOperationsUnlockPassword();
 
        bool cryptOperationsUnlockPasswordSet();
 
        TDELUKSResult::TDELUKSResult cryptCheckKey(unsigned int keyslot);
 
        TDELUKSResult::TDELUKSResult cryptAddKey(unsigned int keyslot, TQByteArray password);
 
        TDELUKSResult::TDELUKSResult cryptDelKey(unsigned int keyslot);
 
        unsigned int cryptKeySlotCount();
 
        TDELUKSKeySlotStatusList cryptKeySlotStatus();
 
        TQString cryptKeySlotFriendlyName(TDELUKSKeySlotStatus::TDELUKSKeySlotStatus status);
 
    protected:
        void internalSetDeviceNode(TQString dn);
 
        void internalSetDiskLabel(TQString dn);
 
        void internalSetDiskUUID(TQString id);
 
        void internalSetDiskType(TDEDiskDeviceType::TDEDiskDeviceType tf);
 
        void internalSetDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus st);
 
        void internalSetMediaInserted(bool inserted);
 
        void internalSetFileSystemName(TQString fn);
 
        void internalSetFileSystemUsage(TQString fu);
 
        void internalSetHoldingDevices(TQStringList hd);
 
        void internalSetSlaveDevices(TQStringList sd);
 
        void internalInitializeLUKSIfNeeded();
 
        void internalGetLUKSKeySlotStatus();
 
        void internalUpdateMappedName();
 
        void internalUpdateMountPath();
 
    private:
        TQString m_mappedName;  // Alternative name for a mapped device
        TDEDiskDeviceType::TDEDiskDeviceType m_diskType;
        TDEDiskDeviceStatus::TDEDiskDeviceStatus m_diskStatus;
        TQString m_diskName;
        TQString m_diskUUID;
        TQString m_fileSystemName;
        TQString m_fileSystemUsage;
        bool m_mediaInserted;
        TQString m_mountPath;
        TQStringList m_holdingDevices;
        TQStringList m_slaveDevices;
        struct crypt_device* m_cryptDevice;
        TQByteArray m_cryptDevicePassword;
        TQString m_cryptDeviceType;
        unsigned int m_cryptKeySlotCount;
        TDELUKSKeySlotStatusList m_cryptKeyslotStatus;
 
    friend class TDEHardwareDevices;
};
 
#endif // _TDESTORAGEDEVICE_H