pax_global_header00006660000000000000000000000064140513313640014512gustar00rootroot0000000000000052 comment=1c73567733e70351418df4fe4ef9b7272d9792ea udisks2-qt5-5.0.6/000077500000000000000000000000001405133136400136155ustar00rootroot00000000000000udisks2-qt5-5.0.6/.clog.toml000066400000000000000000000001631405133136400155140ustar00rootroot00000000000000[clog] repository = "https://github.com/linuxdeepin/udisks2-qt5" changelog = "CHANGELOG.md" from-latest-tag = true udisks2-qt5-5.0.6/.gitignore000066400000000000000000000000511405133136400156010ustar00rootroot00000000000000# IDE related *.user # Misc .directory udisks2-qt5-5.0.6/CHANGELOG.md000066400000000000000000000002731405133136400154300ustar00rootroot00000000000000 ## 0.0.1 (2019-03-26) #### Features * add interfaces ([6668fc33](https://github.com/linuxdeepin/udisks2-qt5/commit/6668fc33c0ffe46b87c69e0f6315fcc3b698dac7)) udisks2-qt5-5.0.6/LICENSE000066400000000000000000000167441405133136400146360ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. udisks2-qt5-5.0.6/dblockdevice.cpp000066400000000000000000000430261405133136400167440ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "dblockdevice.h" #include "private/dblockdevice_p.h" #include "udisks2_interface.h" #include "objectmanager_interface.h" DBlockDevicePrivate::DBlockDevicePrivate(DBlockDevice *qq) : q_ptr(qq) { } void DBlockDevice::onInterfacesAdded(const QDBusObjectPath &object_path, const QMap &interfaces_and_properties) { Q_D(DBlockDevice); const QString &path = object_path.path(); if (path != d->dbus->path()) return; if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Filesystem"))) { Q_EMIT hasFileSystemChanged(true); } if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Partition"))) { Q_EMIT hasPartitionChanged(true); } if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Encrypted"))) { Q_EMIT isEncryptedChanged(true); } } void DBlockDevice::onInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces) { Q_D(DBlockDevice); const QString &path = object_path.path(); if (path != d->dbus->path()) return; for (const QString &i : interfaces) { if (i == QStringLiteral(UDISKS2_SERVICE ".Filesystem")) { Q_EMIT hasFileSystemChanged(false); } else if (i == QStringLiteral(UDISKS2_SERVICE ".Partition")) { Q_EMIT hasPartitionChanged(false); } else if (i == QStringLiteral(UDISKS2_SERVICE ".Encrypted")) { Q_EMIT isEncryptedChanged(false); } } } void DBlockDevice::onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties) { if (interface.endsWith(".PartitionTable")) { auto begin = changed_properties.begin(); while (begin != changed_properties.constEnd()) { if (begin.key() == "Type") { Q_EMIT ptTypeChanged(); break; } ++begin; } } else { auto begin = changed_properties.begin(); for (; begin != changed_properties.constEnd(); ++begin) { QString property_name = begin.key(); int pindex = this->metaObject()->indexOfProperty(property_name.toLatin1().constData()); if (pindex < 0) { property_name[0] = property_name.at(0).toLower(); pindex = this->metaObject()->indexOfProperty(property_name.toLatin1().constData()); } if (pindex < 0) continue; const QMetaProperty &mp = this->metaObject()->property(pindex); if (!mp.hasNotifySignal()) continue; mp.notifySignal().invoke(this, QGenericArgument(begin.value().typeName(), begin.value().constData())); } } } DBlockDevice::~DBlockDevice() { } bool DBlockDevice::isValid() const { Q_D(const DBlockDevice); return d->dbus->isValid(); } bool DBlockDevice::watchChanges() const { Q_D(const DBlockDevice); return d->watchChanges; } /*! * \brief Get the block device (patition) DBus path. * * \return the DBus path */ QString DBlockDevice::path() const { Q_D(const DBlockDevice); return d->dbus->path(); } QList > DBlockDevice::configuration() const { Q_D(const DBlockDevice); return d->dbus->configuration(); } QString DBlockDevice::cryptoBackingDevice() const { Q_D(const DBlockDevice); return d->dbus->cryptoBackingDevice().path(); } /*! * \brief Get the device path, like `/dev/sda1` * * \return Device path in QByteArray. */ QByteArray DBlockDevice::device() const { Q_D(const DBlockDevice); return d->dbus->device(); } qulonglong DBlockDevice::deviceNumber() const { Q_D(const DBlockDevice); return d->dbus->deviceNumber(); } /*! * \brief Get the disk device dbus path * * \return a dbus path in QString */ QString DBlockDevice::drive() const { Q_D(const DBlockDevice); return d->dbus->drive().path(); } bool DBlockDevice::hintAuto() const { Q_D(const DBlockDevice); return d->dbus->hintAuto(); } QString DBlockDevice::hintIconName() const { Q_D(const DBlockDevice); return d->dbus->hintIconName(); } bool DBlockDevice::hintIgnore() const { Q_D(const DBlockDevice); return d->dbus->hintIgnore(); } QString DBlockDevice::hintName() const { Q_D(const DBlockDevice); return d->dbus->hintName(); } bool DBlockDevice::hintPartitionable() const { Q_D(const DBlockDevice); return d->dbus->hintPartitionable(); } QString DBlockDevice::hintSymbolicIconName() const { Q_D(const DBlockDevice); return d->dbus->hintSymbolicIconName(); } bool DBlockDevice::hintSystem() const { Q_D(const DBlockDevice); return d->dbus->hintSystem(); } QString DBlockDevice::id() const { Q_D(const DBlockDevice); return d->dbus->id(); } QString DBlockDevice::idLabel() const { Q_D(const DBlockDevice); return d->dbus->idLabel(); } QString DBlockDevice::idType() const { Q_D(const DBlockDevice); return d->dbus->idType(); } DBlockDevice::FSType DBlockDevice::fsType() const { const QString &fs_type = idType(); if (fs_type.isEmpty()) return InvalidFS; if (fs_type == "hfs+") return hfs_plus; bool ok = false; const QMetaEnum me = QMetaEnum::fromType(); int value = me.keyToValue(fs_type.toLatin1().constData(), &ok); if (!ok) { return UnknowFS; } return static_cast(value); } QString DBlockDevice::idUUID() const { Q_D(const DBlockDevice); return d->dbus->idUUID(); } QString DBlockDevice::idUsage() const { Q_D(const DBlockDevice); return d->dbus->idUsage(); } QString DBlockDevice::idVersion() const { Q_D(const DBlockDevice); return d->dbus->idVersion(); } QString DBlockDevice::mDRaid() const { Q_D(const DBlockDevice); return d->dbus->mDRaid().path(); } QString DBlockDevice::mDRaidMember() const { Q_D(const DBlockDevice); return d->dbus->mDRaidMember().path(); } QByteArray DBlockDevice::preferredDevice() const { Q_D(const DBlockDevice); return d->dbus->preferredDevice(); } bool DBlockDevice::readOnly() const { Q_D(const DBlockDevice); return d->dbus->readOnly(); } qulonglong DBlockDevice::size() const { Q_D(const DBlockDevice); return d->dbus->size(); } QByteArrayList DBlockDevice::symlinks() const { Q_D(const DBlockDevice); return d->dbus->symlinks(); } QStringList DBlockDevice::userspaceMountOptions() const { Q_D(const DBlockDevice); return d->dbus->userspaceMountOptions(); } bool DBlockDevice::hasFileSystem() const { Q_D(const DBlockDevice); return hasFileSystem(d->dbus->path()); } bool DBlockDevice::hasPartitionTable() const { Q_D(const DBlockDevice); return hasPartitionTable(d->dbus->path()); } bool DBlockDevice::hasPartition() const { Q_D(const DBlockDevice); return hasPartition(d->dbus->path()); } bool DBlockDevice::isEncrypted() const { Q_D(const DBlockDevice); return isEncrypted(d->dbus->path()); } bool DBlockDevice::isLoopDevice() const { Q_D(const DBlockDevice); return UDisks2::interfaceExists(d->dbus->path(), UDISKS2_SERVICE ".Loop"); } bool DBlockDevice::hasFileSystem(const QString &path) { return UDisks2::interfaceExists(path, UDISKS2_SERVICE ".Filesystem"); } bool DBlockDevice::hasPartitionTable(const QString &path) { return UDisks2::interfaceExists(path, UDISKS2_SERVICE ".PartitionTable"); } bool DBlockDevice::hasPartition(const QString &path) { return UDisks2::interfaceExists(path, UDISKS2_SERVICE ".Partition"); } bool DBlockDevice::isEncrypted(const QString &path) { return UDisks2::interfaceExists(path, UDISKS2_SERVICE ".Encrypted"); } QByteArrayList DBlockDevice::mountPoints() const { if (!hasFileSystem()) return QByteArrayList(); Q_D(const DBlockDevice); OrgFreedesktopUDisks2FilesystemInterface fsif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); return fsif.mountPoints(); } DBlockDevice::PTType DBlockDevice::ptType() const { Q_D(const DBlockDevice); if (!UDisks2::interfaceExists(d->dbus->path(), UDISKS2_SERVICE ".PartitionTable")) { return InvalidPT; } OrgFreedesktopUDisks2PartitionTableInterface ptif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); const QString &type = ptif.type(); if (type.isEmpty()) { return InvalidPT; } if (type == "dos") { return MBR; } if (type == "gpt") { return GPT; } return UnknowPT; } QList > DBlockDevice::childConfiguration() const { Q_D(const DBlockDevice); if (!isEncrypted()) { return QList>(); } OrgFreedesktopUDisks2EncryptedInterface eif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); return eif.childConfiguration(); } QDBusError DBlockDevice::lastError() const { Q_D(const DBlockDevice); return d->err; } void DBlockDevice::setWatchChanges(bool watchChanges) { Q_D(DBlockDevice); if (d->watchChanges == watchChanges) return; d->watchChanges = watchChanges; OrgFreedesktopDBusObjectManagerInterface *object_manager = UDisks2::objectManager(); auto sb = QDBusConnection::systemBus(); if (watchChanges) { connect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded, this, &DBlockDevice::onInterfacesAdded); connect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved, this, &DBlockDevice::onInterfacesRemoved); sb.connect(UDISKS2_SERVICE, d->dbus->path(), "org.freedesktop.DBus.Properties", "PropertiesChanged", this, SLOT(onPropertiesChanged(const QString &, const QVariantMap &))); } else { disconnect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded, this, &DBlockDevice::onInterfacesAdded); disconnect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved, this, &DBlockDevice::onInterfacesRemoved); sb.disconnect(UDISKS2_SERVICE, d->dbus->path(), "org.freedesktop.DBus.Properties", "PropertiesChanged", this, SLOT(onPropertiesChanged(const QString &, const QVariantMap &))); } } void DBlockDevice::addConfigurationItem(const QPair &item, const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->AddConfigurationItem(item, options); r.waitForFinished(); d->err = r.error(); } void DBlockDevice::format(const QString &type, const QVariantMap &options) { Q_D(DBlockDevice); d->dbus->setTimeout(INT_MAX); auto r = d->dbus->Format(type, options); r.waitForFinished(); d->err = r.error(); d->dbus->setTimeout(-1); } void DBlockDevice::format(const DBlockDevice::FSType &type, const QVariantMap &options) { if (type < ext2) return; format(QString::fromLatin1(QMetaEnum::fromType().valueToKey(type)), options); } QList > DBlockDevice::getSecretConfiguration(const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->GetSecretConfiguration(options); r.waitForFinished(); d->err = r.error(); return r.value(); } QDBusUnixFileDescriptor DBlockDevice::openDevice(const QString &mode, const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->OpenDevice(mode, options); r.waitForFinished(); d->err = r.error(); return r.value(); } QDBusUnixFileDescriptor DBlockDevice::openForBackup(const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->OpenForBackup(options); r.waitForFinished(); d->err = r.error(); return r.value(); } QDBusUnixFileDescriptor DBlockDevice::openForBenchmark(const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->OpenForBenchmark(options); r.waitForFinished(); d->err = r.error(); return r.value(); } QDBusUnixFileDescriptor DBlockDevice::openForRestore(const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->OpenForRestore(options); r.waitForFinished(); d->err = r.error(); return r.value(); } void DBlockDevice::removeConfigurationItem(const QPair &item, const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->RemoveConfigurationItem(item, options); r.waitForFinished(); d->err = r.error(); } void DBlockDevice::rescan(const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->Rescan(options); r.waitForFinished(); d->err = r.error(); } void DBlockDevice::updateConfigurationItem(const QPair &old_item, const QPair &new_item, const QVariantMap &options) { Q_D(DBlockDevice); auto r = d->dbus->UpdateConfigurationItem(old_item, new_item, options); r.waitForFinished(); d->err = r.error(); } /*! * \brief Mount the block device. * * \param options please refer to \l {http://storaged.org/doc/udisks2-api/latest/gdbus-org.freedesktop.UDisks2.Filesystem.html#gdbus-method-org-freedesktop-UDisks2-Filesystem.Mount} {UDisks2.Filesystem Mount()} * * \return the mount point path. * * \sa unmount() */ QString DBlockDevice::mount(const QVariantMap &options) { if (!hasFileSystem()) { return QString(); } Q_D(DBlockDevice); OrgFreedesktopUDisks2FilesystemInterface fsif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); auto r = fsif.Mount(options); r.waitForFinished(); d->err = r.error(); return r.value(); } void DBlockDevice::unmount(const QVariantMap &options) { if (!hasFileSystem()) { return; } Q_D(DBlockDevice); OrgFreedesktopUDisks2FilesystemInterface fsif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); auto r = fsif.Unmount(options); r.waitForFinished(); d->err = r.error(); } /*! * \brief Check if we can set the filesystem label. * * \return */ bool DBlockDevice::canSetLabel() const { if (!hasFileSystem()) { return false; } // blumia: Since gvfs can't correctly mount a label-renamed patition // we simply disable rename support if we don't unmount the // patition. Will be add back when we switch to udisks2. if (/*fsType() == ntfs && */!mountPoints().isEmpty()) { return false; } return true; } /*! * \brief Sets the filesystem label. * * \param options Options (currently unused except for standard options). */ void DBlockDevice::setLabel(const QString &label, const QVariantMap &options) { if (!hasFileSystem()) { return; } Q_D(DBlockDevice); OrgFreedesktopUDisks2FilesystemInterface fsif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); auto r = fsif.SetLabel(label, options); r.waitForFinished(); d->err = r.error(); } void DBlockDevice::changePassphrase(const QString &passphrase, const QString &new_passphrase, const QVariantMap &options) { if (!isEncrypted()) { return; } Q_D(DBlockDevice); OrgFreedesktopUDisks2EncryptedInterface eif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); auto r = eif.ChangePassphrase(passphrase, new_passphrase, options); r.waitForFinished(); d->err = r.error(); } void DBlockDevice::lock(const QVariantMap &options) { if (!isEncrypted()) { return; } Q_D(DBlockDevice); OrgFreedesktopUDisks2EncryptedInterface eif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); QDBusPendingReply r = eif.Lock(options); r.waitForFinished(); d->err = r.error(); } QString DBlockDevice::unlock(const QString &passphrase, const QVariantMap &options) { if (!isEncrypted()) { return QString(); } Q_D(DBlockDevice); OrgFreedesktopUDisks2EncryptedInterface eif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); auto r = eif.Unlock(passphrase, options); r.waitForFinished(); d->err = r.error(); return r.value().path(); } QString DBlockDevice::cleartextDevice() { if (!isEncrypted()) { return QString(); } Q_D(const DBlockDevice); OrgFreedesktopUDisks2EncryptedInterface eif(UDISKS2_SERVICE, d->dbus->path(), QDBusConnection::systemBus()); return eif.cleartextDevice().path(); } DBlockDevice::DBlockDevice(const QString &path, QObject *parent) : DBlockDevice(*new DBlockDevicePrivate(this), path, parent) { } DBlockDevice::DBlockDevice(DBlockDevicePrivate &dd, const QString &path, QObject *parent) : QObject(parent) , d_ptr(&dd) { dd.dbus = new OrgFreedesktopUDisks2BlockInterface(UDISKS2_SERVICE, path, QDBusConnection::systemBus(), this); connect(this, &DBlockDevice::idTypeChanged, this, &DBlockDevice::fsTypeChanged); } udisks2-qt5-5.0.6/dblockdevice.h000066400000000000000000000226311405133136400164100ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DBLOCKDEVICE_H #define DBLOCKDEVICE_H #include #include #include #include class QDBusObjectPath; class DBlockDevicePrivate; class DBlockDevice : public QObject { Q_OBJECT Q_DECLARE_PRIVATE(DBlockDevice) Q_PROPERTY(QString path READ path CONSTANT FINAL) Q_PROPERTY(bool watchChanges READ watchChanges WRITE setWatchChanges) Q_PROPERTY(bool hasFileSystem READ hasFileSystem NOTIFY hasFileSystemChanged) Q_PROPERTY(bool hasPartition READ hasPartition NOTIFY hasPartitionChanged) Q_PROPERTY(bool isEncrypted READ isEncrypted NOTIFY isEncryptedChanged) Q_PROPERTY(bool isLoopDevice READ isLoopDevice) Q_PROPERTY(QList> configuration READ configuration NOTIFY configurationChanged) Q_PROPERTY(QString cryptoBackingDevice READ cryptoBackingDevice NOTIFY cryptoBackingDeviceChanged) Q_PROPERTY(QByteArray device READ device) Q_PROPERTY(qulonglong deviceNumber READ deviceNumber) Q_PROPERTY(QString drive READ drive) Q_PROPERTY(bool hintAuto READ hintAuto NOTIFY hintAutoChanged) Q_PROPERTY(QString hintIconName READ hintIconName NOTIFY hintIconNameChanged) Q_PROPERTY(bool hintIgnore READ hintIgnore NOTIFY hintIgnoreChanged) Q_PROPERTY(QString hintName READ hintName NOTIFY hintNameChanged) Q_PROPERTY(bool hintPartitionable READ hintPartitionable NOTIFY hintPartitionableChanged) Q_PROPERTY(QString hintSymbolicIconName READ hintSymbolicIconName NOTIFY hintSymbolicIconNameChanged) Q_PROPERTY(bool hintSystem READ hintSystem) Q_PROPERTY(QString id READ id) Q_PROPERTY(QString idLabel READ idLabel NOTIFY idLabelChanged) Q_PROPERTY(QString idType READ idType NOTIFY idTypeChanged) Q_PROPERTY(FSType fsType READ fsType NOTIFY fsTypeChanged) Q_PROPERTY(QString idUUID READ idUUID NOTIFY idUUIDChanged) Q_PROPERTY(QString idUsage READ idUsage NOTIFY idUsageChanged) Q_PROPERTY(QString idVersion READ idVersion NOTIFY idVersionChanged) Q_PROPERTY(QString mDRaid READ mDRaid NOTIFY mDRaidChanged) Q_PROPERTY(QString mDRaidMember READ mDRaidMember NOTIFY mDRaidMemberChanged) Q_PROPERTY(QByteArray preferredDevice READ preferredDevice NOTIFY preferredDeviceChanged) Q_PROPERTY(bool readOnly READ readOnly NOTIFY readOnlyChanged) Q_PROPERTY(qulonglong size READ size NOTIFY sizeChanged) Q_PROPERTY(QByteArrayList symlinks READ symlinks NOTIFY symlinksChanged) Q_PROPERTY(QStringList userspaceMountOptions READ userspaceMountOptions NOTIFY userspaceMountOptionsChanged) // of FileSystem Q_PROPERTY(QByteArrayList mountPoints READ mountPoints NOTIFY mountPointsChanged) // of ParitionTable Q_PROPERTY(PTType ptType READ ptType NOTIFY ptTypeChanged) // of Encrypted Q_PROPERTY(QList> childConfiguration READ childConfiguration NOTIFY childConfigurationChanged) Q_PROPERTY(QString cleartextDevice READ cleartextDevice NOTIFY cleartextDeviceChanged) public: // partition table type enum PTType { InvalidPT, MBR, GPT, UnknowPT }; Q_ENUM(PTType) enum FSType { InvalidFS, UnknowFS, ext2, ext3, ext4, fat12, fat16, fat32, btrfs, f2fs, hfs_plus, minix, nilfs2, ntfs, reiser4, vfat, iso9660, jfs, xfs, swap, LVM2_member, crypto_LUKS }; Q_ENUM(FSType) ~DBlockDevice(); bool isValid() const; bool watchChanges() const; QString path() const; QList> configuration() const; QString cryptoBackingDevice() const; QByteArray device() const; qulonglong deviceNumber() const; QString drive() const; bool hintAuto() const; QString hintIconName() const; bool hintIgnore() const; QString hintName() const; bool hintPartitionable() const; QString hintSymbolicIconName() const; bool hintSystem() const; QString id() const; QString idLabel() const; QString idType() const; FSType fsType() const; QString idUUID() const; QString idUsage() const; QString idVersion() const; QString mDRaid() const; QString mDRaidMember() const; QByteArray preferredDevice() const; bool readOnly() const; qulonglong size() const; QByteArrayList symlinks() const; QStringList userspaceMountOptions() const; bool hasFileSystem() const; bool hasPartitionTable() const; bool hasPartition() const; bool isEncrypted() const; bool isLoopDevice() const; static bool hasFileSystem(const QString &path); static bool hasPartitionTable(const QString &path); static bool hasPartition(const QString &path); static bool isEncrypted(const QString &path); QByteArrayList mountPoints() const; PTType ptType() const; QList> childConfiguration() const; QDBusError lastError() const; public Q_SLOTS: void setWatchChanges(bool watchChanges); void addConfigurationItem(const QPair &item, const QVariantMap &options); void format(const QString &type, const QVariantMap &options); void format(const FSType &type, const QVariantMap &options); QList> getSecretConfiguration(const QVariantMap &options); QDBusUnixFileDescriptor openDevice(const QString &mode, const QVariantMap &options); QDBusUnixFileDescriptor openForBackup(const QVariantMap &options); QDBusUnixFileDescriptor openForBenchmark(const QVariantMap &options); QDBusUnixFileDescriptor openForRestore(const QVariantMap &options); void removeConfigurationItem(const QPair &item, const QVariantMap &options); void rescan(const QVariantMap &options); void updateConfigurationItem(const QPair &old_item, const QPair &new_item, const QVariantMap &options); // of Filesystem QString mount(const QVariantMap &options); void unmount(const QVariantMap &options); bool canSetLabel() const; void setLabel(const QString &label, const QVariantMap &options); // of Encrypted void changePassphrase(const QString &passphrase, const QString &new_passphrase, const QVariantMap &options); void lock(const QVariantMap &options); QString unlock(const QString &passphrase, const QVariantMap &options); QString cleartextDevice(); Q_SIGNALS: void hasFileSystemChanged(bool hasFileSystem); void hasPartitionChanged(bool hasPartition); void isEncryptedChanged(bool isEncrypted); void configurationChanged(QList> configuration); void cryptoBackingDeviceChanged(QString cryptoBackingDevice); void hintAutoChanged(bool hintAuto); void hintIconNameChanged(QString hintIconName); void hintIgnoreChanged(bool hintIgnore); void hintNameChanged(QString hintName); void hintPartitionableChanged(bool hintPartitionable); void hintSymbolicIconNameChanged(QString hintSymbolicIconName); void idLabelChanged(QString idLabel); void idTypeChanged(QString idType); void fsTypeChanged(); void idUUIDChanged(QString idUUID); void idUsageChanged(QString idUsage); void idVersionChanged(QString idVersion); void mDRaidChanged(QString mDRaid); void mDRaidMemberChanged(QString mDRaidMember); void preferredDeviceChanged(QByteArray preferredDevice); void readOnlyChanged(bool readOnly); void sizeChanged(qulonglong size); void symlinksChanged(QByteArrayList symlinks); void userspaceMountOptionsChanged(QStringList userspaceMountOptions); void ptTypeChanged(); void mountPointsChanged(const QByteArrayList &mountPoints); void childConfigurationChanged(QList> childConfiguration); void cleartextDeviceChanged(const QString &cleartextDevice); protected: explicit DBlockDevice(const QString &path, QObject *parent = nullptr); explicit DBlockDevice(DBlockDevicePrivate &dd, const QString &path, QObject *parent = nullptr); QScopedPointer d_ptr; private Q_SLOTS: void onInterfacesAdded(const QDBusObjectPath &object_path, const QMap &interfaces_and_properties); void onInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); void onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties); // Q_PRIVATE_SLOT(d_ptr, void _q_onPropertiesChanged(const QString &, const QVariantMap &)) friend class DDiskManager; }; #endif // DBLOCKDEVICE_H udisks2-qt5-5.0.6/dblockpartition.cpp000066400000000000000000000561651405133136400175260ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "dblockpartition.h" #include "private/dblockdevice_p.h" #include "udisks2_interface.h" class DBlockPartitionPrivate : public DBlockDevicePrivate { public: DBlockPartitionPrivate(DBlockPartition *qq); OrgFreedesktopUDisks2PartitionInterface *dbus; }; DBlockPartitionPrivate::DBlockPartitionPrivate(DBlockPartition *qq) : DBlockDevicePrivate(qq) { } qulonglong DBlockPartition::flags() const { Q_D(const DBlockPartition); return d->dbus->flags(); } bool DBlockPartition::isContained() const { Q_D(const DBlockPartition); return d->dbus->isContained(); } bool DBlockPartition::isContainer() const { Q_D(const DBlockPartition); return d->dbus->isContainer(); } QString DBlockPartition::name() const { Q_D(const DBlockPartition); return d->dbus->name(); } uint DBlockPartition::number() const { Q_D(const DBlockPartition); return d->dbus->number(); } qulonglong DBlockPartition::offset() const { Q_D(const DBlockPartition); return d->dbus->offset(); } qulonglong DBlockPartition::size() const { Q_D(const DBlockPartition); return d->dbus->size(); } QString DBlockPartition::table() const { Q_D(const DBlockPartition); return d->dbus->table().path(); } QString DBlockPartition::type() const { Q_D(const DBlockPartition); return d->dbus->type(); } DBlockPartition::Type DBlockPartition::eType() const { const QString &type = this->type(); if (type.isEmpty()) return Empty; bool ok = false; int value = type.toInt(&ok, 16); if (!ok) { return Unknow; } return static_cast(value); } QString DBlockPartition::UUID() const { Q_D(const DBlockPartition); return d->dbus->uUID(); } DBlockPartition::GUIDType DBlockPartition::guidType() const { static QByteArrayList list; if (list.isEmpty()) { // None list << "00000000-0000-0000-0000-000000000000" << "024DEE41-33E7-11D3-9D69-0008C781F39F" << "C12A7328-F81F-11D2-BA4B-00A0C93EC93B" << "21686148-6449-6E6F-744E-656564454649" << "D3BFE2DE-3DAF-11DF-BA40-E3A556D89593" << "F4019732-066E-4E12-8273-346C5641494F" << "BFBFAFE7-A34F-448A-9A5B-6213EB736C22" // Windows << "E3C9E316-0B5C-4DB8-817D-F92DF00215AE" << "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7" << "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3" << "AF9B60A0-1431-4F62-BC68-3311714A69AD" << "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC" << "37AFFC90-EF7D-4e96-91C3-2D7AE055B174" << "E75CAF8F-F680-4CEE-AFA3-B001E56EFC2D" // HP-UX << "75894C1E-3AEB-11D3-B7C1-7B03A0000000" << "E2A1E728-32E3-11D6-A682-7B03A0000000" // Linux << "0FC63DAF-8483-4772-8E79-3D69D8477DE4" << "A19D880F-05FC-4D3B-A006-743F0F84911E" << "44479540-F297-41B2-9AF7-D131D5F0458A" << "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709" << "69DAD710-2CE4-4E3C-B16C-21A1D49ABED3" << "B921B045-1DF0-41C3-AF44-4C6F280D3FAE" << "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F" << "E6D6D379-F507-44C2-A23C-238F2A3DF928" << "933AC7E1-2EB4-4F13-B844-0E14E2AEF915" << "3B8F8425-20E0-4F3B-907F-1A25A76F98E8" << "7FFEC5C9-2D00-49B7-8941-3EA10A5586B7" << "CA7D7CCB-63ED-4C53-861C-1742536059CC" << "8DA63339-0007-60C0-C436-083AC8230908" // FreeBSD << "83BD6B9D-7F41-11DC-BE0B-001560B84F0F" << "516E7CB4-6ECF-11D6-8FF8-00022D09712B" << "516E7CB5-6ECF-11D6-8FF8-00022D09712B" << "516E7CB6-6ECF-11D6-8FF8-00022D09712B" << "516E7CB8-6ECF-11D6-8FF8-00022D09712B" << "516E7CBA-6ECF-11D6-8FF8-00022D09712B" // macOS Darwin << "48465300-0000-11AA-AA11-00306543ECAC" << "55465300-0000-11AA-AA11-00306543ECAC" << "6A898CC3-1DD2-11B2-99A6-080020736631" << "52414944-0000-11AA-AA11-00306543ECAC" << "52414944-5F4F-11AA-AA11-00306543ECAC" << "426F6F74-0000-11AA-AA11-00306543ECAC" << "4C616265-6C00-11AA-AA11-00306543ECAC" << "5265636F-7665-11AA-AA11-00306543ECAC" << "53746F72-6167-11AA-AA11-00306543ECAC" << "B6FA30DA-92D2-4A9A-96F1-871EC6486200" << "2E313465-19B9-463F-8126-8A7993773801" << "FA709C7E-65B1-4593-BFD5-E71D61DE9B02" << "BBBA6DF5-F46F-4A89-8F59-8765B2727503" // Solaris illumos << "6A82CB45-1DD2-11B2-99A6-080020736631" << "6A85CF4D-1DD2-11B2-99A6-080020736631" << "6A87C46F-1DD2-11B2-99A6-080020736631" << "6A8B642B-1DD2-11B2-99A6-080020736631" // << "6A898CC3-1DD2-11B2-99A6-080020736631" << "6A8EF2E9-1DD2-11B2-99A6-080020736631" << "6A90BA39-1DD2-11B2-99A6-080020736631" << "6A9283A5-1DD2-11B2-99A6-080020736631" // reserved partition << "6A945A3B-1DD2-11B2-99A6-080020736631" << "6A9630D1-1DD2-11B2-99A6-080020736631" << "6A980767-1DD2-11B2-99A6-080020736631" << "6A96237F-1DD2-11B2-99A6-080020736631" << "6A8D2AC7-1DD2-11B2-99A6-080020736631" // NetBSD << "49F48D32-B10E-11DC-B99B-0019D1879648" << "49F48D5A-B10E-11DC-B99B-0019D1879648" << "49F48D82-B10E-11DC-B99B-0019D1879648" << "49F48DAA-B10E-11DC-B99B-0019D1879648" << "2DB519C4-B10F-11DC-B99B-0019D1879648" << "2DB519EC-B10F-11DC-B99B-0019D1879648" // ChromeOS << "FE3A2A5D-4F32-41A7-B725-ACCC3285A309" << "3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC" << "2E0A753D-9E48-43B0-8337-B15192CB1B5E" // HaiKu << "42465331-3BA3-10F1-802A-4861696B7521" // MidnightBSD << "85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7" << "85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7" << "85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7" << "0394EF8B-237E-11E1-B4B3-E89A8F7FC3A7" << "85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7" << "85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7" // Ceph << "45B0969E-9B03-4F30-B4C6-B4B80CEFF106" << "45B0969E-9B03-4F30-B4C6-5EC00CEFF106" << "4FBD7E29-9D25-41B8-AFD0-062C0CEFF05D" << "4FBD7E29-9D25-41B8-AFD0-5EC00CEFF05D" << "89C57F98-2FE5-4DC0-89C1-F3AD0CEFF2BE" << "89C57F98-2FE5-4DC0-89C1-5EC00CEFF2BE" // OpenBSD << "824CC7A0-36A8-11E3-890A-952519AD3F61" // QNX << "CEF5A9AD-73BC-4601-89F3-CDEEEEE321A1" // Plan 9 << "C91818F9-8025-47AF-89D2-F030D7000C2C" // VMware ESX << "9D275380-40AD-11DB-BF97-000C2911D1B8" << "AA31E02A-400F-11DB-9590-000C2911D1B8" << "9198EFFC-31C0-11DB-8F78-000C2911D1B8" // Android-IA << "2568845D-2332-4675-BC39-8FA5A4748D15" << "114EAFFE-1552-4022-B26E-9B053604CF84" << "49A4D17F-93A3-45C1-A0DE-F50B2EBE2599" << "4177C722-9E92-4AAB-8644-43502BFD5506" << "EF32A33B-A409-486C-9141-9FFB711F6266" << "20AC26BE-20B7-11E3-84C5-6CFDB94711E9" << "38F428E6-D326-425D-9140-6E0EA133647C" << "A893EF21-E428-470A-9E55-0668FD91A2D9" << "DC76DDA9-5AC1-491C-AF42-A82591580C0D" << "EBC597D0-2053-4B15-8B64-E0AAC75F4DB1" << "8F68CC74-C5E5-48DA-BE91-A0C8C15E9C80" << "767941D0-2085-11E3-AD3B-6CFDB94711E9" << "AC6D7924-EB71-4DF8-B48D-E267B27148FF" // Open Network Install Environment (ONIE) << "7412F7D5-A156-4B13-81DC-867174929325" << "D4E6E2CD-4469-46F3-B5CB-1BFF57AFC149" // PowerPC << "9E1A2D38-C612-4316-AA26-8B49521E5A8B" // freedesktop.org OSes (Linux, etc.) << "BC13C2FF-59E6-4262-A352-B275FD6F7172" // Atari IOS << "734E5AFE-F61A-11E6-BC64-92361F002671"; } const QString &guid = this->type(); if (guid.isEmpty()) return InvalidUUID; int index = list.indexOf(guid.toLatin1()); if (index < 0) return UnknowUUID; return static_cast((index + GUIDTypeBegin)); } QString DBlockPartition::typeDescription(DBlockPartition::Type type) { switch (type) { case Empty: return "Empty"; case FAT12Type: return "FAT12"; case XENIX_root: return "XENIX root"; case XENIX_usr: return "XENIX usr"; case FAT16_Less_32M: return "FAT16 <32M"; case Extended: return "Extended"; case FAT16Type: return "FAT16"; case HPFS_NTFS: return "HPFS/NTFS"; case AIX: return "AIX"; case AIX_bootable: return "AIX bootable"; case OS2_Boot_Manager: return "OS2 Boot Manager"; case Win95_FAT32: return "Win95 FAT32"; case Win95_FAT32_LBA: return "Win95 FAT32 (LBA)"; case Win95_FAT16_LBA: return "Win95 FAT16 (LBA)"; case Win95_Extended_LBA: return "Win95 Ext'd (LBA)"; case OPUS: return "OPUS"; case Hidden_FAT12: return "Hidden FAT12"; case Compaq_diagnostics: return "Compaq diagnostics"; case Hidden_FAT16_Less_32M: return "Hidden FAT16 <32M"; case Hidden_FAT16: return "Hidden FAT16"; case Hidden_HPFS_or_NTFS: return "Hidden HPFS/NTFS"; case AST_SmartSleep: return "AST SmartSleep"; case Hidden_Win95_FAT32: return "Hidden Win95 FAT32"; case Hidden_Win95_FAT32_LBA: return "Hidden Win95 FAT32 (LBA)"; case Hidden_Win95_FAT16_LBA: return "Hidden Win95 FAT16"; case NEC_DOS: return "NEC DOS"; case Plan9: return "Plan 9"; case PartitionMagic_recovery: return "PartitionMagic recovery"; case Venix_80286: return "Venix 80286"; case PPC_PReP_Boot: return "PPC PReP Boot"; case SFS: return "SFS"; case QNX4_dot_x: return "QNX4.x"; case QNX4_dot_x_2nd_part: return "QNX4.x.2nd part"; case QNX4_dot_x_3rd_part: return "QNX4.x 3rd part"; case OnTrack_DM: return "OnTrack DM"; case OnTrack_DM6_Aux1: return "OnTrack DM6 Aux1"; case CP_M: return "CP/M"; case OnTrack_DM6_Aux3: return "OnTrack DM6 Aux3"; case OnTrackDM6: return "OnTrackDM6"; case EZ_Drive: return "EZ-Drive"; case Golden_Bow: return "Golden Bow"; case Priam_Edisk: return "Priam Edisk"; case SpeedStor: return "SpeedStor"; case GNU_HURD_or_SysV: return "GNU HURD or SysV"; case Novell_Netware_286: return "Novell Netware 286"; case Novell_Netware_386: return "Novell Netware 386"; case DiskSecure_Multi_Boot: return "DiskSecure Multi-Boot"; case PC_IX: return "PC/IX"; case Old_Minix: return "Old Minix"; case Minix_old_Linux: return "Minix / old Linux"; case Linux_swap: return "Linux swap"; case Linux: return "Linux"; case OS2_hidden_C_drive: return "OS/2 hidden C: drive"; case Linux_extended: return "Linux extended"; case NTFS_volume_set_1: return "NTFS volume set"; case NTFS_volume_set_2: return "NTFS volume set"; case Linux_LVM: return "Linux LVM"; case Amoeba: return "Amoeba"; case Amoeba_BBT: return "Amoeba BBT"; case BSD_OS: return "BSD/OS"; case IBM_Thinkpad_hibernation: return "IBM Thinkpad hibernation"; case FreeBSD: return "FreeBSD"; case OpenBSD: return "OpenBSD"; case NeXTSTEP: return "NeXTSTEP"; case NetBSD: return "NetBSD"; case BSDI_fs: return "BSDI fs"; case BSDI_swap: return "BSDI swap"; case Boot_Wizard_hidden: return "Boot Wizard hidden"; case DRDOS_sec_FAT12: return "DRDOS/sec (FAT-12)"; case DRDOS_sec_FAT16_Less_32M: return "DRDOS/sec (FAT-16 < 32M)"; case DRDOS_sec_FAT16: return "DRDOS/sec (FAT-16)"; case Syrinx: return "Syrinx"; case Non_FS_data: return "Non-FS data"; case CP_M_CTOS_dot_dot_dot: return "CP/M / CTOS / ..."; case Dell_Utility: return "Dell Utility"; case BootIt: return "BootIt"; case DOS_access: return "DOS access"; case DOS_R_O: return "DOS R/O"; case SpeedStor_1: return "SpeedStor"; case BeOS_fs: return "BeOS fs"; case EFI_GPT: return "EFI GPT"; case EFI_FAT12_16_32: return "EFI (FAT-12/16/32)"; case Linux_PA_RISC_boot: return "Linux/PA-RISC boot"; case SpeedStor_2: return "SpeedStor"; case SeppdStor_3: return "SpeedStor"; case DOS_secondary: return "DOS secondary"; case Linux_raid_autodetect: return "Linux raid autodetect"; case LANstep: return "LANstep"; case BBT: return "BBT"; default: break; } return QString(); } QString DBlockPartition::guidTypeDescription(GUIDType type) { switch ((int)type) { case Unused_None: return "Unused entry"; case MBR_PS_None: return "MBR partition scheme"; case EFI_SP_None: return "EFI System partition"; case BIOS_BP_None: return "BIOS boot partition"; case iFFS_None: return "Intel Fast Flash (iFFS) partition (for Intel Rapid Start technology)"; case Sony_BP_None: return "Sony boot partition"; case Lenove_BP_None: return "Lenovo boot partition"; // Windows case MSR_Win: return "Microsoft Reserved Partition (MSR)"; case BasicData_Win: return "Basic data partition of Windows"; case LDM_Win: return "Logical Disk Manager (LDM) metadata partition of Windows"; case LDM_DP_Win: return "Logical Disk Manager data partition of Windows"; case WRE_Win: return "Windows Recovery Environment"; case IBM_GPFS_Win: return "IBM General Parallel File System (GPFS) partition of Windows"; case SSP_Win: return "Storage Spaces partition of Windows"; // HP-UX case DP_HPUX: return "Data partition of HP-UX"; case SP_HPUX: return "Service Partition of HP-UX"; // Linux case LFD_Linux: return "Linux filesystem data"; case RAID_P_Linux: return "RAID partition of Linux"; case RP_x86_Linux: return "Root partition (x86) of Linux"; case RP_x86_64_Linux: return "Root partition (x86-64) of Linux"; case RP_32bit_ARM_Linux: return "Root partition (32-bit ARM) of Linux"; case RP_64bit_ARM_Linux: return "Root partition (64-bit ARM/AArch64) of Linux"; case SP_Linux: return "Swap partition of Linux"; case LVM_P_Linux: return "Logical Volume Manager (LVM) partition of Linux"; case Home_P_Linux: return "/home partition of Linux"; case Srv_P_Linux: return "/srv (server data) partition of Linux"; case Plain_DC_P_Linux: return "Plain dm-crypt partition of Linux"; case LUKS_P_Linux: return "LUKS partition of Linux"; case Reserved_Linux: return "Reserved of Linux"; // FreeBSD case BP_FreeBSD: return "Boot partition of FreeBSD"; case DP_FreeBSD: return "Data partition of FreeBSD"; case SP_FreeBSD: return "Swap partition of FreeBSD"; case UFS_P_FreeBSD: return "Unix File System (UFS) partition of FreeBSD"; case VVM_P_FreeBSD: return "Vinum volume manager partition of FreeBSD"; case ZFS_P_FreeBSD: return "ZFS partition of FreeBSD"; // macOS Darwin case HFS_PLUS_P_Mac: return "Hierarchical File System Plus (HFS+) partition of macOS"; case UFS_Mac: return "Apple UFS"; case ZFS_Mac: return "ZFS of macOS(Or /usr partition of Solaris illumos)"; case RAID_P_Mac: return "Apple RAID partition"; case RAID_P_Offline_Mac: return "Apple RAID partition, offline"; case BP_Mac: return "Apple Boot partition (Recovery HD)"; case Label_Mac: return "Apple Label"; case TV_RP_Mac: return "Apple TV Recovery partition"; case CS_P_Mac: return "Apple Core Storage (i.e. Lion FileVault) partition"; case SoftRAID_Status_Mac: return "SoftRAID_Status of macOS"; case SoftRAID_Scratch_Mac: return "SoftRAID_Scratch of macOS"; case SoftRAID_Volume_Mac: return "SoftRAID_Volume of macOS"; case SoftRAID_Cache_Mac: return "SoftRAID_Cache of macOS"; // Solaris illumos case BP_Solaris: return "Boot partition of Solaris illumos"; case RP_Solaris: return "Root partition of Solaris illumos"; case SP_Solaris: return "Swap partition of Solaris illumos"; case Backup_P_Solaris: return "Backup partition of Solaris illumos"; case Var_P_Solaris: return "/var partition of Solaris illumos"; case Home_P_Solaris: return "/home partition of Solaris illumos"; case AS_Solaris: return "Alternate sector os Solaris illumos"; case Reserved_Solaris: return "Reserved partition os Solaris illumos"; // NetBSD case SP_NetBSD: return "Swap partition of NetBSD"; case FFS_P_NetBSD: return "FFS partition of NetBSD"; case LFS_P_NetBSD: return "LFS partition of NetBSD"; case RAID_P_NetBSD: return "RAID partition of NetBSD"; case CP_NetBSD: return "Concatenated partition of NetBSD"; case EP_NetBSD: return "Encrypted partition of NetBSD"; // ChromeOS case Kernel_ChromeOS: return "ChromeOS kernel"; case Rootfs_ChromeOS: return "ChromeOS rootfs"; case FU_ChromeOS: return "ChromeOS future use"; // Haiku case BFS_Haiku: return "Haiku BFS"; // MidnightBSD case BP_MidnightBSD: return "Boot partition of MidnightBSD"; case DP_MidnightBSD: return "Data partition of MidnightBSD"; case SP_MidnightBSD: return "Swap partition of MidnightBSD"; case UFS_P_MidnightBSD: return "Unix File System (UFS) partition of MidnightBSD"; case VVM_P_MidnightBSD: return "Vinum volume manager partition of MidnightBSD"; case ZFS_P_MidnightBSD: return "ZFS partition of MidnightBSD"; // Ceph case Journal_Ceph: return "Ceph Journal"; case DC_EJ_Ceph: return "Ceph dm-crypt Encrypted Journal"; case OSD_Ceph: return "Ceph OSD"; case DC_OSD_Ceph: return "Ceph dm-crypt OSD"; case DIC_Ceph: return "Ceph disk in creation"; case DC_DIC_Ceph: return "Ceph dm-crypt disk in creation"; // OpenBSD case DP_OpenBSD: return "Data partition of OpenBSD"; // QNX case PAFS_QNX: return "Power-safe (QNX6) file system of QNX"; // Plan9 case Partition_Plan9: return "Plan 9 partition of Plan9"; // VMware ESX case Vmkcore_VMware: return "vmkcore (coredump partition)"; case VMFS_VMware: return "VMFS filesystem partition"; case Reserved_VMware: return "VMware Reserved"; // Android-IA case Bootloader_Android: return "Android Bootloader"; case Bottloader2_Android: return "Android Bootloader2"; case Boot_Android: return "Android Boot"; case Recovery_Android: return "Android Recovery"; case Misc_Android: return "Android Misc"; case Metadata_Android: return "Android Metadata"; case System_Android: return "Android System"; case Cache_Android: return "Android Cache"; case Data_Android: return "Android Data"; case Persistent_Android: return "Android Persistent"; case Factory_Android: return "Android Factory"; case Fastboot_Android: return "Android Fastboot"; case OEM_Android: return "Android OEM"; // Open Network Install Environment (ONIE) case Boot_ONIE: return "Open Network Install Environment Boot"; case Config_ONIE: return "Open Network Install Environment Config"; // PowerPC case Boot_PowerPC: return "PowerPC PReP boot"; // freedesktop.org OSes (Linux, etc.) case SBLC_OSes: return "Shared boot loader configuration of freedesktop.org OSes (Linux, etc.)"; // Atari TOS case BD_P_Atari: return "Basic data partition (GEM, BGM, F32) of Atari TOS"; case UnknowUUID: return "Unknow GUID"; } return "Invalid GUID type"; } void DBlockPartition::deletePartition(const QVariantMap &options) { Q_D(DBlockPartition); d->dbus->Delete(options); } void DBlockPartition::resize(qulonglong size, const QVariantMap &options) { Q_D(DBlockPartition); d->dbus->Resize(size, options); } void DBlockPartition::setFlags(qulonglong flags, const QVariantMap &options) { Q_D(DBlockPartition); d->dbus->SetFlags(flags, options); } void DBlockPartition::setName(const QString &name, const QVariantMap &options) { Q_D(DBlockPartition); d->dbus->SetName(name, options); } void DBlockPartition::setType(const QString &type, const QVariantMap &options) { Q_D(DBlockPartition); d->dbus->SetType(type, options); } void DBlockPartition::setType(DBlockPartition::Type type, const QVariantMap &options) { if (type == Unknow) return; QString type_string = QString::asprintf("0x%.2s", QByteArray::number(type, 16).constData()); type_string.replace(" ", "0"); setType(type_string, options); } /*! * \class DBlockPartition * \inmodule dde-file-manager-lib * * \brief DBlockPartition class comment goes here * * \sa DDiskManager::createBlockPartition */ DBlockPartition::DBlockPartition(const QString &path, QObject *parent) : DBlockDevice(*new DBlockPartitionPrivate(this), path, parent) { d_func()->dbus = new OrgFreedesktopUDisks2PartitionInterface(UDISKS2_SERVICE, path, QDBusConnection::systemBus(), this); connect(this, &DBlockPartition::typeChanged, this, &DBlockPartition::eTypeChanged); connect(this, &DBlockPartition::UUIDChanged, this, &DBlockPartition::guidTypeChanged); } udisks2-qt5-5.0.6/dblockpartition.h000066400000000000000000000223651405133136400171660ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DBLOCKPARTITION_H #define DBLOCKPARTITION_H #include class DBlockPartitionPrivate; class DBlockPartition : public DBlockDevice { Q_OBJECT Q_DECLARE_PRIVATE(DBlockPartition) Q_PROPERTY(qulonglong flags READ flags NOTIFY flagsChanged) Q_PROPERTY(bool isContained READ isContained NOTIFY isContainedChanged) Q_PROPERTY(bool isContainer READ isContainer NOTIFY isContainerChanged) Q_PROPERTY(QString name READ name NOTIFY nameChanged) Q_PROPERTY(uint number READ number NOTIFY numberChanged) Q_PROPERTY(qulonglong offset READ offset NOTIFY offsetChanged) Q_PROPERTY(qulonglong size READ size NOTIFY sizeChanged) Q_PROPERTY(QString table READ table) Q_PROPERTY(QString type READ type NOTIFY typeChanged) // MBR Partition Type Q_PROPERTY(Type eType READ eType NOTIFY eTypeChanged) // GPT Partition Type Q_PROPERTY(GUIDType guidType READ guidType NOTIFY guidTypeChanged) Q_PROPERTY(QString UUID READ UUID NOTIFY UUIDChanged) public: enum Type { Empty = 0x0, FAT12Type = 0x1, XENIX_root = 0x2, XENIX_usr = 0x3, FAT16_Less_32M = 0x4, Extended = 0x5, FAT16Type = 0x6, HPFS_NTFS = 0x7, AIX = 0x8, AIX_bootable = 0x9, OS2_Boot_Manager = 0xa, Win95_FAT32 = 0xb, Win95_FAT32_LBA = 0xc, Win95_FAT16_LBA = 0xe, Win95_Extended_LBA = 0xf, OPUS = 0x10, Hidden_FAT12 = 0x11, Compaq_diagnostics = 0x12, Hidden_FAT16_Less_32M = 0x14, Hidden_FAT16 = 0x16, Hidden_HPFS_or_NTFS = 0x17, AST_SmartSleep = 0x18, Hidden_Win95_FAT32 = 0x1b, Hidden_Win95_FAT32_LBA = 0x1c, Hidden_Win95_FAT16_LBA = 0x1e, NEC_DOS = 0x24, Plan9 = 0x39, PartitionMagic_recovery = 0x3c, Venix_80286 = 0x40, PPC_PReP_Boot = 0x41, SFS = 0x42, QNX4_dot_x = 0x4d, QNX4_dot_x_2nd_part = 0x4e, QNX4_dot_x_3rd_part = 0x4f, OnTrack_DM = 0x50, OnTrack_DM6_Aux1 = 0x51, CP_M = 0x52, OnTrack_DM6_Aux3 = 0x53, OnTrackDM6 = 0x54, EZ_Drive = 0x55, Golden_Bow = 0x56, Priam_Edisk = 0x5c, SpeedStor = 0x61, GNU_HURD_or_SysV = 0x63, Novell_Netware_286 = 0x64, Novell_Netware_386 = 0x65, DiskSecure_Multi_Boot = 0x70, PC_IX = 0x75, Old_Minix = 0x80, Minix_old_Linux = 0x81, Linux_swap = 0x82, Linux = 0x83, OS2_hidden_C_drive = 0x84, Linux_extended = 0x85, NTFS_volume_set_1 = 0x86, NTFS_volume_set_2 = 0x87, Linux_LVM = 0x8e, Amoeba = 0x93, Amoeba_BBT = 0x94, BSD_OS = 0x9f, IBM_Thinkpad_hibernation = 0xa0, FreeBSD = 0xa5, OpenBSD = 0xa6, NeXTSTEP = 0xa7, NetBSD = 0xa8, BSDI_fs = 0xa9, BSDI_swap = 0xb7, Boot_Wizard_hidden = 0xb8, DRDOS_sec_FAT12 = 0xbb, DRDOS_sec_FAT16_Less_32M = 0xc1, DRDOS_sec_FAT16 = 0xc4, DRDOS_sec_extend = 0xc5, Syrinx = 0xc6, Non_FS_data = 0xc7, Multiuser_DOS_extend = 0xd5, CP_M_CTOS_dot_dot_dot = 0xda, Dell_Utility = 0xdb, BootIt = 0xde, DOS_access = 0xdf, DOS_R_O = 0xe1, SpeedStor_1 = 0xe3, BeOS_fs = 0xe4, EFI_GPT = 0xeb, EFI_FAT12_16_32 = 0xee, Linux_PA_RISC_boot = 0xef, SpeedStor_2 = 0xf0, SeppdStor_3 = 0xf4, DOS_secondary = 0xf2, Linux_raid_autodetect = 0xfd, LANstep = 0xfe, BBT = 0xff, Unknow }; Q_ENUM(Type) enum GUIDType { InvalidUUID = 0, GUIDTypeBegin = 1, // None Unused_None = GUIDTypeBegin, MBR_PS_None = 2, EFI_SP_None = 3, BIOS_BP_None = 4, iFFS_None = 5, Sony_BP_None = 6, Lenove_BP_None = 7, // Windows MSR_Win = 8, BasicData_Win = 9, LDM_Win = 10, LDM_DP_Win = 11, WRE_Win = 12, IBM_GPFS_Win = 13, SSP_Win = 14, // HP-UX DP_HPUX = 15, SP_HPUX = 16, // Linux LFD_Linux = 17, RAID_P_Linux = 18, RP_x86_Linux = 19, RP_x86_64_Linux = 20, RP_32bit_ARM_Linux = 21, RP_64bit_ARM_Linux = 22, SP_Linux = 23, LVM_P_Linux = 24, Home_P_Linux = 25, Srv_P_Linux = 26, Plain_DC_P_Linux = 27, LUKS_P_Linux = 28, Reserved_Linux = 29, // FreeBSD BP_FreeBSD = 30, DP_FreeBSD = 31, SP_FreeBSD = 32, UFS_P_FreeBSD = 33, VVM_P_FreeBSD = 34, ZFS_P_FreeBSD = 35, // macOS Darwin HFS_PLUS_P_Mac = 36, UFS_Mac = 37, ZFS_Mac = 38, RAID_P_Mac = 39, RAID_P_Offline_Mac = 40, BP_Mac = 41, Label_Mac = 42, TV_RP_Mac = 43, CS_P_Mac = 44, SoftRAID_Status_Mac = 45, SoftRAID_Scratch_Mac = 46, SoftRAID_Volume_Mac = 47, SoftRAID_Cache_Mac = 48, // Solaris illumos BP_Solaris = 49, RP_Solaris = 50, SP_Solaris = 51, Backup_P_Solaris = 52, Usr_P_Solaris = ZFS_Mac, Var_P_Solaris = 53, Home_P_Solaris = 54, AS_Solaris = 55, Reserved_Solaris = 56, // NetBSD SP_NetBSD = 57, FFS_P_NetBSD = 58, LFS_P_NetBSD = 59, RAID_P_NetBSD = 60, CP_NetBSD = 61, EP_NetBSD = 62, // ChromeOS Kernel_ChromeOS = 63, Rootfs_ChromeOS = 64, FU_ChromeOS = 65, // Haiku BFS_Haiku = 66, // MidnightBSD BP_MidnightBSD = 67, DP_MidnightBSD = 68, SP_MidnightBSD = 69, UFS_P_MidnightBSD = 70, VVM_P_MidnightBSD = 71, ZFS_P_MidnightBSD = 72, // Ceph Journal_Ceph = 73, DC_EJ_Ceph = 74, OSD_Ceph = 75, DC_OSD_Ceph = 76, DIC_Ceph = 77, DC_DIC_Ceph = 78, // OpenBSD DP_OpenBSD = 79, // QNX PAFS_QNX = 80, // Plan9 Partition_Plan9 = 81, // VMware ESX Vmkcore_VMware = 82, VMFS_VMware = 83, Reserved_VMware = 84, // Android-IA Bootloader_Android = 85, Bottloader2_Android = 86, Boot_Android = 87, Recovery_Android = 88, Misc_Android = 89, Metadata_Android = 90, System_Android = 91, Cache_Android = 92, Data_Android = 93, Persistent_Android = 94, Factory_Android = 95, Fastboot_Android = 96, OEM_Android = 97, // Open Network Install Environment (ONIE) Boot_ONIE = 98, Config_ONIE = 99, // PowerPC Boot_PowerPC = 100, // freedesktop.org OSes (Linux, etc.) SBLC_OSes = 101, // Atari TOS BD_P_Atari = 102, GUIDTypeEnd, UnknowUUID }; Q_ENUM(GUIDType) qulonglong flags() const; bool isContained() const; bool isContainer() const; QString name() const; uint number() const; qulonglong offset() const; qulonglong size() const; QString table() const; QString type() const; Type eType() const; GUIDType guidType() const; QString UUID() const; static QString typeDescription(Type type); static QString guidTypeDescription(GUIDType type); public Q_SLOTS: // METHODS void deletePartition(const QVariantMap &options); void resize(qulonglong size, const QVariantMap &options); void setFlags(qulonglong flags, const QVariantMap &options); void setName(const QString &name, const QVariantMap &options); void setType(const QString &type, const QVariantMap &options); void setType(Type type, const QVariantMap &options); Q_SIGNALS: void flagsChanged(qulonglong flags); void isContainedChanged(bool isContained); void isContainerChanged(bool isContainer); void nameChanged(const QString &name); void numberChanged(uint number); void offsetChanged(qulonglong offset); void sizeChanged(qulonglong size); void typeChanged(const QString &type); void eTypeChanged(); void UUIDChanged(const QString &UUID); void guidTypeChanged(); private: explicit DBlockPartition(const QString &path, QObject *parent = nullptr); friend class DDiskManager; }; #endif // DBLOCKPARTITION_H udisks2-qt5-5.0.6/ddiskdevice.cpp000066400000000000000000000106631405133136400166050ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "ddiskdevice.h" #include "udisks2_interface.h" class DDiskDevicePrivate { public: OrgFreedesktopUDisks2DriveInterface *dbus = nullptr; QDBusError err; }; DDiskDevice::DDiskDevice(const QString &path, QObject *parent) : QObject(parent) , d_ptr(new DDiskDevicePrivate()) { d_ptr->dbus = new OrgFreedesktopUDisks2DriveInterface(UDISKS2_SERVICE, path, QDBusConnection::systemBus(), this); } DDiskDevice::~DDiskDevice() { } QString DDiskDevice::path() const { Q_D(const DDiskDevice); return d->dbus->path(); } bool DDiskDevice::canPowerOff() const { return d_ptr->dbus->canPowerOff(); } QVariantMap DDiskDevice::configuration() const { return d_ptr->dbus->configuration(); } QString DDiskDevice::connectionBus() const { return d_ptr->dbus->connectionBus(); } bool DDiskDevice::ejectable() const { return d_ptr->dbus->ejectable(); } QString DDiskDevice::id() const { return d_ptr->dbus->id(); } QString DDiskDevice::media() const { return d_ptr->dbus->media(); } bool DDiskDevice::mediaAvailable() const { return d_ptr->dbus->mediaAvailable(); } bool DDiskDevice::mediaChangeDetected() const { return d_ptr->dbus->mediaChangeDetected(); } QStringList DDiskDevice::mediaCompatibility() const { return d_ptr->dbus->mediaCompatibility(); } bool DDiskDevice::mediaRemovable() const { return d_ptr->dbus->mediaRemovable(); } QString DDiskDevice::model() const { return d_ptr->dbus->model(); } bool DDiskDevice::optical() const { return d_ptr->dbus->optical(); } bool DDiskDevice::opticalBlank() const { return d_ptr->dbus->opticalBlank(); } uint DDiskDevice::opticalNumAudioTracks() const { return d_ptr->dbus->opticalNumAudioTracks(); } uint DDiskDevice::opticalNumDataTracks() const { return d_ptr->dbus->opticalNumDataTracks(); } uint DDiskDevice::opticalNumSessions() const { return d_ptr->dbus->opticalNumSessions(); } uint DDiskDevice::opticalNumTracks() const { return d_ptr->dbus->opticalNumTracks(); } bool DDiskDevice::removable() const { return d_ptr->dbus->removable(); } QString DDiskDevice::revision() const { return d_ptr->dbus->revision(); } int DDiskDevice::rotationRate() const { return d_ptr->dbus->rotationRate(); } QString DDiskDevice::seat() const { return d_ptr->dbus->seat(); } QString DDiskDevice::serial() const { return d_ptr->dbus->serial(); } QString DDiskDevice::siblingId() const { return d_ptr->dbus->siblingId(); } qulonglong DDiskDevice::size() const { return d_ptr->dbus->size(); } QString DDiskDevice::sortKey() const { return d_ptr->dbus->sortKey(); } qulonglong DDiskDevice::timeDetected() const { return d_ptr->dbus->timeDetected(); } qulonglong DDiskDevice::timeMediaDetected() const { return d_ptr->dbus->timeMediaDetected(); } QString DDiskDevice::vendor() const { return d_ptr->dbus->vendor(); } QString DDiskDevice::WWN() const { return d_ptr->dbus->wWN(); } QDBusError DDiskDevice::lastError() const { Q_D(const DDiskDevice); return d->err; } void DDiskDevice::eject(const QVariantMap &options) { Q_D(DDiskDevice); auto r = d_ptr->dbus->Eject(options); r.waitForFinished(); d->err = r.error(); } void DDiskDevice::powerOff(const QVariantMap &options) { Q_D(DDiskDevice); auto r = d_ptr->dbus->PowerOff(options); r.waitForFinished(); d->err = r.error(); } void DDiskDevice::setConfiguration(const QVariantMap &value, const QVariantMap &options) { Q_D(DDiskDevice); auto r = d_ptr->dbus->SetConfiguration(value, options); r.waitForFinished(); d->err = r.error(); } udisks2-qt5-5.0.6/ddiskdevice.h000066400000000000000000000106341405133136400162500ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DDISKDEVICE_H #define DDISKDEVICE_H #include #include #include class DDiskDevicePrivate; class DDiskDevice : public QObject { Q_OBJECT Q_DECLARE_PRIVATE(DDiskDevice) Q_PROPERTY(QString path READ path CONSTANT FINAL) Q_PROPERTY(bool canPowerOff READ canPowerOff CONSTANT FINAL) Q_PROPERTY(QVariantMap configuration READ configuration CONSTANT FINAL) Q_PROPERTY(QString connectionBus READ connectionBus CONSTANT FINAL) Q_PROPERTY(bool ejectable READ ejectable CONSTANT FINAL) Q_PROPERTY(QString id READ id CONSTANT FINAL) Q_PROPERTY(QString media READ media CONSTANT FINAL) Q_PROPERTY(bool mediaAvailable READ mediaAvailable CONSTANT FINAL) Q_PROPERTY(bool mediaChangeDetected READ mediaChangeDetected CONSTANT FINAL) Q_PROPERTY(QStringList mediaCompatibility READ mediaCompatibility CONSTANT FINAL) Q_PROPERTY(bool mediaRemovable READ mediaRemovable CONSTANT FINAL) Q_PROPERTY(QString model READ model CONSTANT FINAL) Q_PROPERTY(bool optical READ optical CONSTANT FINAL) Q_PROPERTY(bool opticalBlank READ opticalBlank CONSTANT FINAL) Q_PROPERTY(uint opticalNumAudioTracks READ opticalNumAudioTracks CONSTANT FINAL) Q_PROPERTY(uint opticalNumDataTracks READ opticalNumDataTracks CONSTANT FINAL) Q_PROPERTY(uint opticalNumSessions READ opticalNumSessions CONSTANT FINAL) Q_PROPERTY(uint opticalNumTracks READ opticalNumTracks CONSTANT FINAL) Q_PROPERTY(bool removable READ removable CONSTANT FINAL) Q_PROPERTY(QString revision READ revision CONSTANT FINAL) Q_PROPERTY(int rotationRate READ rotationRate CONSTANT FINAL) Q_PROPERTY(QString seat READ seat CONSTANT FINAL) Q_PROPERTY(QString serial READ serial CONSTANT FINAL) Q_PROPERTY(QString siblingId READ siblingId CONSTANT FINAL) Q_PROPERTY(qulonglong size READ size CONSTANT FINAL) Q_PROPERTY(QString sortKey READ sortKey CONSTANT FINAL) Q_PROPERTY(qulonglong timeDetected READ timeDetected CONSTANT FINAL) Q_PROPERTY(qulonglong timeMediaDetected READ timeMediaDetected CONSTANT FINAL) Q_PROPERTY(QString vendor READ vendor CONSTANT FINAL) Q_PROPERTY(QString WWN READ WWN CONSTANT FINAL) public: ~DDiskDevice(); QString path() const; bool canPowerOff() const; QVariantMap configuration() const; QString connectionBus() const; bool ejectable() const; QString id() const; QString media() const; bool mediaAvailable() const; bool mediaChangeDetected() const; QStringList mediaCompatibility() const; bool mediaRemovable() const; QString model() const; bool optical() const; bool opticalBlank() const; uint opticalNumAudioTracks() const; uint opticalNumDataTracks() const; uint opticalNumSessions() const; uint opticalNumTracks() const; bool removable() const; QString revision() const; int rotationRate() const; QString seat() const; QString serial() const; QString siblingId() const; qulonglong size() const; QString sortKey() const; qulonglong timeDetected() const; qulonglong timeMediaDetected() const; QString vendor() const; QString WWN() const; QDBusError lastError() const; public Q_SLOTS: // METHODS void eject(const QVariantMap &options); void powerOff(const QVariantMap &options); void setConfiguration(const QVariantMap &value, const QVariantMap &options); private: explicit DDiskDevice(const QString &path, QObject *parent = nullptr); QScopedPointer d_ptr; friend class DDiskManager; }; #endif // DDISKDEVICE_H udisks2-qt5-5.0.6/ddiskmanager.cpp000066400000000000000000000400411405133136400167510ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "ddiskmanager.h" #include "udisks2_dbus_common.h" #include "udisks2_interface.h" #include "objectmanager_interface.h" #include "dblockdevice.h" #include "dblockpartition.h" #include "ddiskdevice.h" #include "dudisksjob.h" #include #include #include #include #include #include const QString ManagerPath = "/org/freedesktop/UDisks2/Manager"; static int udisks2VersionCompare(const QString &version) { const QStringList &version_list = UDisks2::version().split("."); const QStringList &v_v_list = version.split("."); for (int i = 0; i < version_list.count(); ++i) { if (v_v_list.count() <= i) return -1; int number_v = version_list[i].toInt(); int number_v_v = v_v_list[i].toInt(); if (number_v == number_v_v) continue; return number_v_v > number_v ? 1 : -1; } return v_v_list.count() > version_list.count() ? 1 : 0; } // 2.1.7版本的UDisks2在U盘插入时没有drive device added的信号 // 当收到block device added信号后，通过diskDeviceAddSignalFlag // 判断此块设备对应的磁盘设备信号是否已发送，未发送时补发信号 // 风险：如果 diskDeviceAddSignalFlag 的值删除的不及时 // 会导致设备再插入时不会再有信号发出 static bool fixUDisks2DiskAddSignal() { static bool fix = udisks2VersionCompare("2.1.7.1") > 0; return fix; } class DDiskManagerPrivate { public: DDiskManagerPrivate(DDiskManager *qq); void updateBlockDeviceMountPointsMap(); bool watchChanges = false; QMap blockDeviceMountPointsMap; QSet diskDeviceAddSignalFlag; DDiskManager *q_ptr; }; DDiskManagerPrivate::DDiskManagerPrivate(DDiskManager *qq) : q_ptr(qq) { } void DDiskManagerPrivate::updateBlockDeviceMountPointsMap() { blockDeviceMountPointsMap.clear(); auto om = UDisks2::objectManager(); const QMap> &objects = om->GetManagedObjects().value(); auto begin = objects.constBegin(); while (begin != objects.constEnd()) { const QString path = begin.key().path(); const QMap object = begin.value(); ++begin; if (!path.startsWith(QStringLiteral("/org/freedesktop/UDisks2/block_devices/"))) { continue; } const QVariantMap &filesystem = object.value(QStringLiteral(UDISKS2_SERVICE ".Filesystem")); if (filesystem.isEmpty()) { continue; } blockDeviceMountPointsMap[path] = qdbus_cast(filesystem.value("MountPoints")); } } void DDiskManager::onInterfacesAdded(const QDBusObjectPath &object_path, const QMap &interfaces_and_properties) { const QString &path = object_path.path(); const QString &path_drive = QStringLiteral("/org/freedesktop/UDisks2/drives/"); const QString &path_device = QStringLiteral("/org/freedesktop/UDisks2/block_devices/"); const QString &path_job = QStringLiteral("/org/freedesktop/UDisks2/jobs/"); Q_D(DDiskManager); if (path.startsWith(path_drive)) { if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Drive"))) { if (fixUDisks2DiskAddSignal()) { if (!d->diskDeviceAddSignalFlag.contains(path)) { d->diskDeviceAddSignalFlag.insert(path); // 防止flag未清除导致再也收不到此设备的信号 QTimer::singleShot(1000, this, [d, path] { d->diskDeviceAddSignalFlag.remove(path); }); Q_EMIT diskDeviceAdded(path); } } else { Q_EMIT diskDeviceAdded(path); } } } else if (path.startsWith(path_device)) { if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Block"))) { if (fixUDisks2DiskAddSignal()) { QScopedPointer bd(createBlockDevice(path)); const QString &drive = bd->drive(); if (!d->diskDeviceAddSignalFlag.contains(drive)) { d->diskDeviceAddSignalFlag.insert(drive); // 防止flag未清除导致再也收不到此设备的信号 QTimer::singleShot(1000, this, [d, drive] { d->diskDeviceAddSignalFlag.remove(drive); }); Q_EMIT diskDeviceAdded(drive); } } Q_EMIT blockDeviceAdded(path); } if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Filesystem"))) { Q_D(DDiskManager); d->blockDeviceMountPointsMap.remove(object_path.path()); Q_EMIT fileSystemAdded(path); } } else if (path.startsWith(path_job)) { if (interfaces_and_properties.contains(QStringLiteral(UDISKS2_SERVICE ".Job"))) { Q_EMIT jobAdded(path); } } } void DDiskManager::onInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces) { const QString &path = object_path.path(); Q_D(DDiskManager); for (const QString &i : interfaces) { if (i == QStringLiteral(UDISKS2_SERVICE ".Drive")) { d->diskDeviceAddSignalFlag.remove(path); Q_EMIT diskDeviceRemoved(path); } else if (i == QStringLiteral(UDISKS2_SERVICE ".Filesystem")) { d->blockDeviceMountPointsMap.remove(object_path.path()); Q_EMIT fileSystemRemoved(path); } else if (i == QStringLiteral(UDISKS2_SERVICE ".Block")) { Q_EMIT blockDeviceRemoved(path); } } } void DDiskManager::onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties, const QDBusMessage &message) { Q_D(DDiskManager); const QString &path = message.path(); if (changed_properties.contains("Optical")) { Q_EMIT opticalChanged(path); } if (interface != UDISKS2_SERVICE ".Filesystem") { return; } if (!changed_properties.contains("MountPoints")) { return; } const QByteArrayList old_mount_points = d->blockDeviceMountPointsMap.value(path); const QByteArrayList &new_mount_points = qdbus_cast(changed_properties.value("MountPoints")); d->blockDeviceMountPointsMap[path] = new_mount_points; Q_EMIT mountPointsChanged(path, old_mount_points, new_mount_points); if (old_mount_points.isEmpty()) { if (!new_mount_points.isEmpty()) { Q_EMIT mountAdded(path, new_mount_points.first()); } } else if (new_mount_points.isEmpty()) { Q_EMIT mountRemoved(path, old_mount_points.first()); } } /*! * \class DDiskManager * \inmodule dde-file-manager-lib * * \brief DDiskManager provide severial ways to manage devices and partitions. * * \sa DBlockPartition, DBlockDevice, UDiskDeviceInfo */ DDiskManager::DDiskManager(QObject *parent) : QObject(parent) , d_ptr(new DDiskManagerPrivate(this)) { } DDiskManager::~DDiskManager() { } static QStringList getDBusNodeNameList(const QString &service, const QString &path, const QDBusConnection &connection) { QDBusInterface ud2(service, path, "org.freedesktop.DBus.Introspectable", connection); QDBusReply reply = ud2.call("Introspect"); QXmlStreamReader xml_parser(reply.value()); QStringList nodeList; while (!xml_parser.atEnd()) { xml_parser.readNext(); if (xml_parser.tokenType() == QXmlStreamReader::StartElement && xml_parser.name().toString() == "node") { const QString &name = xml_parser.attributes().value("name").toString(); if (!name.isEmpty()) { nodeList << path + "/" + name; } } } return nodeList; } QStringList DDiskManager::blockDevices() const { return getDBusNodeNameList(UDISKS2_SERVICE, "/org/freedesktop/UDisks2/block_devices", QDBusConnection::systemBus()); } QStringList DDiskManager::diskDevices() const { return getDBusNodeNameList(UDISKS2_SERVICE, "/org/freedesktop/UDisks2/drives", QDBusConnection::systemBus()); } QStringList DDiskManager::blockDevices(QVariantMap options) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); auto reply = udisksmgr.GetBlockDevices(options); reply.waitForFinished(); QList resultList = reply.value(); QStringList dbusPaths; for (const QDBusObjectPath &singleResult : resultList) { dbusPaths << singleResult.path(); } return dbusPaths; } bool DDiskManager::watchChanges() const { Q_D(const DDiskManager); return d->watchChanges; } QString DDiskManager::objectPrintable(const QObject *object) { QString string; QDebug debug(&string); const QMetaObject *mo = object->metaObject(); debug << object; int property_count = mo->propertyCount(); int base_property_count = QObject::staticMetaObject.propertyCount(); debug << "\n"; for (int i = base_property_count; i < property_count; ++i) { const QMetaProperty &mp = mo->property(i); debug.nospace() << mp.name() << ": " << mp.read(object); debug << "\n"; } return string; } DBlockDevice *DDiskManager::createBlockDevice(const QString &path, QObject *parent) { return new DBlockDevice(path, parent); } DBlockDevice *DDiskManager::createBlockDeviceByDevicePath(const QByteArray &path, QObject *parent) const { for (const QString &block : blockDevices()) { DBlockDevice *device = new DBlockDevice(block, parent); if (device->device() == path) { return device; } device->deleteLater(); } return nullptr; } DBlockPartition *DDiskManager::createBlockPartition(const QString &path, QObject *parent) { return new DBlockPartition(path, parent); } DBlockPartition *DDiskManager::createBlockPartitionByMountPoint(const QByteArray &path, QObject *parent) const { for (const QString &block : blockDevices()) { DBlockPartition *device = new DBlockPartition(block, parent); if (device->mountPoints().contains(path)) { return device; } device->deleteLater(); } return nullptr; } DBlockPartition *DDiskManager::createBlockPartition(const QStorageInfo &info, QObject *parent) const { return createBlockPartitionByMountPoint(info.rootPath().toLocal8Bit() + '\0', parent); } DDiskDevice *DDiskManager::createDiskDevice(const QString &path, QObject *parent) { return new DDiskDevice(path, parent); } DUDisksJob *DDiskManager::createJob(const QString &path, QObject *parent) { return new DUDisksJob(path, parent); } QStringList DDiskManager::supportedFilesystems() { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); return udisksmgr.supportedFilesystems(); } QStringList DDiskManager::supportedEncryptionTypes() { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); return udisksmgr.supportedEncryptionTypes(); } QStringList DDiskManager::resolveDevice(QVariantMap devspec, QVariantMap options) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); QStringList ret; auto devices = udisksmgr.ResolveDevice(devspec, options); devices.waitForFinished(); if (!devices.isError()) { for (auto &d : devices.value()) { ret.push_back(d.path()); } } return ret; } QStringList DDiskManager::resolveDeviceNode(QString devnode, QVariantMap options) { return resolveDevice({{"path", QVariant(devnode)}}, options); } bool DDiskManager::canCheck(const QString &type, QString *requiredUtil) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); auto r = udisksmgr.CanCheck(type); r.waitForFinished(); if (r.isError()) { return false; } if (requiredUtil) { *requiredUtil = r.value().second; } return r.value().first; } bool DDiskManager::canFormat(const QString &type, QString *requiredUtil) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); auto r = udisksmgr.CanFormat(type); r.waitForFinished(); if (r.isError()) { return false; } if (requiredUtil) { *requiredUtil = r.value().second; } return r.value().first; } bool DDiskManager::canRepair(const QString &type, QString *requiredUtil) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); auto r = udisksmgr.CanRepair(type); r.waitForFinished(); if (r.isError()) { return false; } if (requiredUtil) { *requiredUtil = r.value().second; } return r.value().first; } bool DDiskManager::canResize(const QString &type, QString *requiredUtil) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); auto r = udisksmgr.CanRepair(type); r.waitForFinished(); if (r.isError()) { return false; } if (requiredUtil) { *requiredUtil = r.value().second; } return r.value().first; } QString DDiskManager::loopSetup(int fd, QVariantMap options) { OrgFreedesktopUDisks2ManagerInterface udisksmgr(UDISKS2_SERVICE, ManagerPath, QDBusConnection::systemBus()); QDBusUnixFileDescriptor dbusfd; dbusfd.setFileDescriptor(fd); auto r = udisksmgr.LoopSetup(dbusfd, options); r.waitForFinished(); return r.value().path(); } QDBusError DDiskManager::lastError() { return QDBusConnection::systemBus().lastError(); } void DDiskManager::setWatchChanges(bool watchChanges) { Q_D(DDiskManager); if (d->watchChanges == watchChanges) return; OrgFreedesktopDBusObjectManagerInterface *object_manager = UDisks2::objectManager(); auto sc = QDBusConnection::systemBus(); if (watchChanges) { connect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded, this, &DDiskManager::onInterfacesAdded); connect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved, this, &DDiskManager::onInterfacesRemoved); d->updateBlockDeviceMountPointsMap(); sc.connect(UDISKS2_SERVICE, QString(), "org.freedesktop.DBus.Properties", "PropertiesChanged", this, SLOT(onPropertiesChanged(const QString &, const QVariantMap &, const QDBusMessage&))); } else { disconnect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded, this, &DDiskManager::onInterfacesAdded); disconnect(object_manager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved, this, &DDiskManager::onInterfacesRemoved); d->blockDeviceMountPointsMap.clear(); sc.disconnect(UDISKS2_SERVICE, QString(), "org.freedesktop.DBus.Properties", "PropertiesChanged", this, SLOT(onPropertiesChanged(const QString &, const QVariantMap &, const QDBusMessage&))); } } udisks2-qt5-5.0.6/ddiskmanager.h000066400000000000000000000103431405133136400164200ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DDISKMANAGER_H #define DDISKMANAGER_H #include #include #include QT_BEGIN_NAMESPACE class QDBusObjectPath; class QStorageInfo; QT_END_NAMESPACE class DBlockDevice; class DBlockPartition; class DDiskDevice; class DUDisksJob; class DDiskManagerPrivate; class DDiskManager : public QObject { Q_OBJECT Q_DECLARE_PRIVATE(DDiskManager) Q_PROPERTY(bool watchChanges READ watchChanges WRITE setWatchChanges) public: explicit DDiskManager(QObject *parent = nullptr); ~DDiskManager(); Q_DECL_DEPRECATED_X("Use the static variant instead") QStringList blockDevices() const; QStringList diskDevices() const; static QStringList blockDevices(QVariantMap options); bool watchChanges() const; static QString objectPrintable(const QObject *object); static DBlockDevice *createBlockDevice(const QString &path, QObject *parent = nullptr); // device 路径以 '\0' 结尾 DBlockDevice *createBlockDeviceByDevicePath(const QByteArray &path, QObject *parent = nullptr) const; static DBlockPartition *createBlockPartition(const QString &path, QObject *parent = nullptr); // 挂载点以 '\0' 结尾 DBlockPartition *createBlockPartitionByMountPoint(const QByteArray &path, QObject *parent = nullptr) const; DBlockPartition *createBlockPartition(const QStorageInfo &info, QObject *parent = nullptr) const; static DDiskDevice *createDiskDevice(const QString &path, QObject *parent = nullptr); static DUDisksJob *createJob(const QString &path, QObject *parent = nullptr); static QStringList supportedFilesystems(); static QStringList supportedEncryptionTypes(); static QStringList resolveDevice(QVariantMap devspec, QVariantMap options); static QStringList resolveDeviceNode(QString devnode, QVariantMap options); static bool canCheck(const QString &type, QString *requiredUtil = nullptr); static bool canFormat(const QString &type, QString *requiredUtil = nullptr); static bool canRepair(const QString &type, QString *requiredUtil = nullptr); static bool canResize(const QString &type, QString *requiredUtil = nullptr); static QString loopSetup(int fd, QVariantMap options); static QDBusError lastError(); public Q_SLOTS: void setWatchChanges(bool watchChanges); Q_SIGNALS: void blockDeviceAdded(const QString &path); void blockDeviceRemoved(const QString &path); void diskDeviceAdded(const QString &path); void diskDeviceRemoved(const QString &path); void fileSystemAdded(const QString &blockDevicePath); void fileSystemRemoved(const QString &blockDevicePath); void mountAdded(const QString &blockDevicePath, const QByteArray &mountPoint); void mountRemoved(const QString &blockDevicePath, const QByteArray &mountPoint); void mountPointsChanged(const QString &blockDevicePath, const QByteArrayList &oldMountPoints, const QByteArrayList &newMountPoints); void jobAdded(const QString &jobPath); void opticalChanged(const QString &path); private: QScopedPointer d_ptr; private Q_SLOTS: void onInterfacesAdded(const QDBusObjectPath &, const QMap &); void onInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); void onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties, const QDBusMessage &message); }; #endif // DDISKMANAGER_H udisks2-qt5-5.0.6/debian/000077500000000000000000000000001405133136400150375ustar00rootroot00000000000000udisks2-qt5-5.0.6/debian/changelog000066400000000000000000000002261405133136400167110ustar00rootroot00000000000000udisks2-qt5 (0.0.1) unstable; urgency=medium * Initial release. -- Deepin Package Builder Tue, 26 Feb 2019 11:46:47 +0800 udisks2-qt5-5.0.6/debian/compat000066400000000000000000000000021405133136400162350ustar00rootroot000000000000009 udisks2-qt5-5.0.6/debian/control000066400000000000000000000011631405133136400164430ustar00rootroot00000000000000Source: udisks2-qt5 Section: admin Priority: optional Maintainer: Deepin Package Builder Build-Depends: debhelper (>= 9), qtbase5-dev, pkg-config Standards-Version: 3.9.8 Homepage: http://github.com/linuxdeepin/udisks2-qt5 Package: libudisks2-qt5 Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends} Description: UDisks2 library with Qt5 UDisks2 DBus interfaces binding of Qt5. Package: libudisks2-qt5-dev Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, libudisks2-qt5( =${binary:Version}) Description: libudisks2-qt5 developer package UDisks2 DBus interfaces binding of Qt5. udisks2-qt5-5.0.6/debian/copyright000066400000000000000000000017471405133136400170030ustar00rootroot00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: deepin-anything Source: http://github.com/linuxdeepin/deepin-anything Files: * Copyright: 2018 Deepin.Inc License: LGPL-3+ This package is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. . This package 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 Lesser General Public License for more details. . You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . On Debian systems, the complete text of the GNU General Public License version 3 can be found in "/usr/share/common-licenses/LGPL-3". udisks2-qt5-5.0.6/debian/libudisks2-qt5-dev.install000066400000000000000000000000631405133136400217640ustar00rootroot00000000000000usr/include/* usr/lib/*/*.so usr/lib/*/pkgconfig/* udisks2-qt5-5.0.6/debian/libudisks2-qt5.install000066400000000000000000000000211405133136400212020ustar00rootroot00000000000000usr/lib/*/*.so.* udisks2-qt5-5.0.6/debian/rules000077500000000000000000000003241405133136400161160ustar00rootroot00000000000000#!/usr/bin/make -f export QT_SELECT=5 %: dh $@ override_dh_installinit: true override_dh_auto_configure: dh_auto_configure -- VERSION=$(DEB_VERSION_UPSTREAM) LIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) udisks2-qt5-5.0.6/debian/source/000077500000000000000000000000001405133136400163375ustar00rootroot00000000000000udisks2-qt5-5.0.6/debian/source/format000066400000000000000000000000151405133136400175460ustar00rootroot000000000000003.0 (native) udisks2-qt5-5.0.6/dudisksjob.cpp000066400000000000000000000076251405133136400164740ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "dudisksjob.h" #include "udisks2_interface.h" #include class DUDisksJobPrivate { DUDisksJobPrivate(DUDisksJob *) { } DUDisksJob *q_ptr; OrgFreedesktopUDisks2JobInterface *dbusif; Q_DECLARE_PUBLIC(DUDisksJob) }; DUDisksJob::~DUDisksJob() { } QString DUDisksJob::path() const { Q_D(const DUDisksJob); return d->dbusif->path(); } QStringList DUDisksJob::objects() const { Q_D(const DUDisksJob); QStringList ret; for (auto &o : d->dbusif->objects()) { ret.push_back(o.path()); } return ret; } bool DUDisksJob::cancelable() const { Q_D(const DUDisksJob); return d->dbusif->cancelable(); } bool DUDisksJob::progressValid() const { Q_D(const DUDisksJob); return d->dbusif->progressValid(); } double DUDisksJob::progress() const { Q_D(const DUDisksJob); return d->dbusif->progress(); } QString DUDisksJob::operation() const { Q_D(const DUDisksJob); return d->dbusif->operation(); } quint32 DUDisksJob::startedByUid() const { Q_D(const DUDisksJob); return d->dbusif->startedByUID(); } quint64 DUDisksJob::bytes() const { Q_D(const DUDisksJob); return d->dbusif->bytes(); } quint64 DUDisksJob::expectedEndTime() const { Q_D(const DUDisksJob); return d->dbusif->expectedEndTime(); } quint64 DUDisksJob::rate() const { Q_D(const DUDisksJob); return d->dbusif->rate(); } quint64 DUDisksJob::startTime() const { Q_D(const DUDisksJob); return d->dbusif->startTime(); } void DUDisksJob::cancel(const QVariantMap &options) { Q_D(DUDisksJob); d->dbusif->Cancel(options).waitForFinished(); } DUDisksJob::DUDisksJob(QString path, QObject *parent) : QObject(parent) , d_ptr(new DUDisksJobPrivate(this)) { Q_D(DUDisksJob); d->dbusif = new OrgFreedesktopUDisks2JobInterface(UDISKS2_SERVICE, path, QDBusConnection::systemBus()); QDBusConnection::systemBus().connect(UDISKS2_SERVICE, d->dbusif->path(), "org.freedesktop.DBus.Properties", "PropertiesChanged", this, SLOT(onPropertiesChanged(const QString &, const QVariantMap &))); connect(d->dbusif, &OrgFreedesktopUDisks2JobInterface::Completed, this, &DUDisksJob::completed); } void DUDisksJob::onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties) { Q_UNUSED(interface) auto begin = changed_properties.begin(); for (; begin != changed_properties.constEnd(); ++begin) { QString property_name = begin.key(); int pindex = this->metaObject()->indexOfProperty(property_name.toLatin1().constData()); if (pindex < 0) { property_name[0] = property_name.at(0).toLower(); pindex = this->metaObject()->indexOfProperty(property_name.toLatin1().constData()); } if (pindex < 0) continue; const QMetaProperty &mp = this->metaObject()->property(pindex); if (!mp.hasNotifySignal()) continue; mp.notifySignal().invoke(this, QGenericArgument(begin.value().typeName(), begin.value().constData())); } } udisks2-qt5-5.0.6/dudisksjob.h000066400000000000000000000052111405133136400161260ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DUDISKSJOB_H #define DUDISKSJOB_H #include class DUDisksJobPrivate; class DUDisksJob : public QObject { Q_OBJECT Q_DECLARE_PRIVATE(DUDisksJob) Q_PROPERTY(QString path READ path CONSTANT FINAL) Q_PROPERTY(QStringList objects READ objects CONSTANT FINAL) Q_PROPERTY(bool cancelable READ cancelable CONSTANT FINAL) Q_PROPERTY(bool progressValid READ progressValid CONSTANT FINAL) Q_PROPERTY(double progress READ progress NOTIFY progressChanged FINAL) Q_PROPERTY(QString operation READ operation CONSTANT FINAL) Q_PROPERTY(quint32 startedByUid READ startedByUid CONSTANT FINAL) Q_PROPERTY(quint64 bytes READ bytes CONSTANT FINAL) Q_PROPERTY(quint64 expectedEndTime READ expectedEndTime NOTIFY expectedEndTimeChanged FINAL) Q_PROPERTY(quint64 rate READ rate NOTIFY rateChanged FINAL) Q_PROPERTY(quint64 startTime READ startTime CONSTANT FINAL) public: ~DUDisksJob(); QString path() const; QStringList objects() const; bool cancelable() const; bool progressValid() const; double progress() const; QString operation() const; quint32 startedByUid() const; quint64 bytes() const; quint64 expectedEndTime() const; quint64 rate() const; quint64 startTime() const; public Q_SLOTS: void cancel(const QVariantMap &options); Q_SIGNALS: void completed(bool success, QString message); void progressChanged(double progress); void rateChanged(quint64 rate); void expectedEndTimeChanged(quint64 expectedEndTime); private: QScopedPointer d_ptr; explicit DUDisksJob(QString path, QObject *parent = nullptr); private Q_SLOTS: void onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties); friend class DDiskManager; }; #endif udisks2-qt5-5.0.6/org.freedesktop.UDisks2.ObjectManager.xml000066400000000000000000000020261405133136400234230ustar00rootroot00000000000000 udisks2-qt5-5.0.6/org.freedesktop.UDisks2.xml000066400000000000000000003700261405133136400207330ustar00rootroot00000000000000 udisks2-qt5-5.0.6/private/000077500000000000000000000000001405133136400152675ustar00rootroot00000000000000udisks2-qt5-5.0.6/private/dblockdevice_p.h000066400000000000000000000032071405133136400203770ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef DBLOCKDEVICE_P_H #define DBLOCKDEVICE_P_H #include "dblockdevice.h" QT_BEGIN_NAMESPACE class QDBusObjectPath; QT_END_NAMESPACE class OrgFreedesktopUDisks2BlockInterface; class DBlockDevicePrivate { public: explicit DBlockDevicePrivate(DBlockDevice *qq); OrgFreedesktopUDisks2BlockInterface *dbus; bool watchChanges = false; DBlockDevice *q_ptr; QDBusError err; void _q_onInterfacesAdded(const QDBusObjectPath &object_path, const QMap &interfaces_and_properties); void _q_onInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); void _q_onPropertiesChanged(const QString &interface, const QVariantMap &changed_properties); Q_DECLARE_PUBLIC(DBlockDevice) }; #endif // DBLOCKDEVICE_P_H udisks2-qt5-5.0.6/private/private.pri000066400000000000000000000000501405133136400174500ustar00rootroot00000000000000HEADERS += \ $$PWD/dblockdevice_p.h udisks2-qt5-5.0.6/rpm/000077500000000000000000000000001405133136400144135ustar00rootroot00000000000000udisks2-qt5-5.0.6/rpm/udisks2-qt5.spec000066400000000000000000000031211405133136400173570ustar00rootroot00000000000000Name: udisks2-qt5 Version: 5.0.0 Release: 3%{?dist} Summary: Qt5 binding for udisks2 License: GPLv3+ URL: https://github.com/linuxdeepin/udisks2-qt5 Source0: %{name}_%{version}.tar.gz BuildRequires: gcc-c++ BuildRequires: pkgconfig(Qt5Core) %description This package provides a Qt5 binding for udisks2. %package devel Summary: Development package for %{name} Requires: %{name}%{?_isa} = %{version}-%{release} Requires: qt5-qtbase-devel%{?isa} %description devel Header files and libraries for %{name}. %prep %setup -q sed -i 's|/lib|/%{_lib}|' udisks2.pro %build # help find (and prefer) qt5 utilities, e.g. qmake, lrelease export PATH=%{_qt5_bindir}:$PATH %qmake_qt5 PREFIX=%{_prefix} %make_build %install %make_install INSTALL_ROOT=%{buildroot} %files %doc CHANGELOG.md %{_libdir}/lib%{name}.so.0* %files devel %{_includedir}/%{name} %{_libdir}/lib%{name}.so %{_libdir}/pkgconfig/%{name}.pc %changelog * Wed Jul 29 2020 Fedora Release Engineering - 5.0.0-3 - Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild * Fri Jan 31 2020 Fedora Release Engineering - 5.0.0-2 - Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild * Mon Aug 05 2019 Robin Lee - 5.0.0-1 - Release 5.0.0 * Sat Jul 27 2019 Fedora Release Engineering - 0.0.1-2 - Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild * Thu Apr 4 2019 Robin Lee - 0.0.1-1 - Initial packaging udisks2-qt5-5.0.6/udisks2.pro000066400000000000000000000026651405133136400157340ustar00rootroot00000000000000TARGET = udisks2-qt5 QT += core dbus QT -= gui TEMPLATE = lib isEmpty(VERSION): VERSION = 0.0.1 SOURCES += \ $$PWD/ddiskdevice.cpp \ $$PWD/ddiskmanager.cpp \ $$PWD/udisks2_dbus_common.cpp \ $$PWD/dblockdevice.cpp \ $$PWD/dblockpartition.cpp \ $$PWD/dudisksjob.cpp udisk2.files = $$PWD/org.freedesktop.UDisks2.xml udisk2.header_flags = -i $$PWD/udisks2_dbus_common.h -N DBUS_INTERFACES += udisk2 $$PWD/org.freedesktop.UDisks2.ObjectManager.xml HEADERS += \ $$PWD/ddiskdevice.h \ $$PWD/udisks2_dbus_common.h \ $$PWD/ddiskmanager.h \ $$PWD/dblockdevice.h \ $$PWD/dblockpartition.h \ $$PWD/dudisksjob.h include($$PWD/private/private.pri) INCLUDEPATH += $$PWD OTHER_FILES += $$PWD/*.xml isEmpty(PREFIX): PREFIX = /usr isEmpty(LIB_INSTALL_DIR) { target.path = $$PREFIX/lib } else { target.path = $$LIB_INSTALL_DIR } isEmpty(INCLUDE_INSTALL_DIR) { includes.path = $$PREFIX/include/$$TARGET } else { includes.path = $$INCLUDE_INSTALL_DIR } includes.files += $$PWD/*.h includes_private.path = $$includes.path/private includes_private.files += $$PWD/private/*.h INSTALLS += includes includes_private target CONFIG += create_pc create_prl no_install_prl QMAKE_PKGCONFIG_LIBDIR = $$target.path QMAKE_PKGCONFIG_VERSION = $$VERSION QMAKE_PKGCONFIG_DESTDIR = pkgconfig QMAKE_PKGCONFIG_NAME = $$TARGET QMAKE_PKGCONFIG_DESCRIPTION = UDisks2 Library with Qt5 QMAKE_PKGCONFIG_INCDIR = $$includes.path udisks2-qt5-5.0.6/udisks2_dbus_common.cpp000066400000000000000000000105521405133136400202750ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "udisks2_dbus_common.h" #include "objectmanager_interface.h" #include "udisks2_interface.h" #include #include #include #include #include namespace UDisks2 { Q_GLOBAL_STATIC_WITH_ARGS(OrgFreedesktopDBusObjectManagerInterface, omGlobal, (UDISKS2_SERVICE, "/org/freedesktop/UDisks2", QDBusConnection::systemBus())) Q_GLOBAL_STATIC_WITH_ARGS(OrgFreedesktopUDisks2ManagerInterface, umGlobal, (UDISKS2_SERVICE, "/org/freedesktop/UDisks2/Manager", QDBusConnection::systemBus())) bool interfaceExists(const QString &path, const QString &interface) { QDBusInterface ud2(UDISKS2_SERVICE, path, "org.freedesktop.DBus.Introspectable", QDBusConnection::systemBus()); QDBusReply reply = ud2.call("Introspect"); QXmlStreamReader xml_parser(reply.value()); while (!xml_parser.atEnd()) { xml_parser.readNext(); if (xml_parser.tokenType() == QXmlStreamReader::StartElement && xml_parser.name().toString() == "interface") { const QString &name = xml_parser.attributes().value("name").toString(); if (name == interface) { return true; } } } return false; } OrgFreedesktopDBusObjectManagerInterface *objectManager() { if (!omGlobal.exists()) { qDBusRegisterMetaType>(); qDBusRegisterMetaType>>(); qDBusRegisterMetaType(); qDBusRegisterMetaType>(); qDBusRegisterMetaType>>(); QMetaType::registerDebugStreamOperator>>(); } return omGlobal; } QString version() { return umGlobal->version(); } QStringList supportedFilesystems() { return umGlobal->supportedFilesystems(); } } QDBusArgument &operator<<(QDBusArgument &argument, const UDisks2::SmartAttribute &mystruct) { argument.beginStructure(); argument << mystruct.id << mystruct.name << mystruct.flags << mystruct.value << mystruct.worst << mystruct.threshold << mystruct.pretty << mystruct.pretty_unit << mystruct.expansion; argument.endStructure(); return argument; } const QDBusArgument &operator>>(const QDBusArgument &argument, UDisks2::SmartAttribute &mystruct) { argument.beginStructure(); argument >> mystruct.id >> mystruct.name >> mystruct.flags >> mystruct.value >> mystruct.worst >> mystruct.threshold >> mystruct.pretty >> mystruct.pretty_unit >> mystruct.expansion; argument.endStructure(); return argument; } QDBusArgument &operator<<(QDBusArgument &argument, const UDisks2::ActiveDeviceInfo &mystruct) { argument.beginStructure(); argument << mystruct.block << mystruct.slot << mystruct.state << mystruct.num_read_errors << mystruct.expansion; argument.endStructure(); return argument; } const QDBusArgument &operator>>(const QDBusArgument &argument, UDisks2::ActiveDeviceInfo &mystruct) { argument.beginStructure(); argument >> mystruct.block >> mystruct.slot >> mystruct.state >> mystruct.num_read_errors >> mystruct.expansion; argument.endStructure(); return argument; } udisks2-qt5-5.0.6/udisks2_dbus_common.h000066400000000000000000000076541405133136400177530ustar00rootroot00000000000000/* * Copyright (C) 2020 UOS Technology Co., Ltd. * * Author: zccrs * * Maintainer: xushitong * max-lv * zhangsheng * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef UDISK2_DBUS_COMMON_H #define UDISK2_DBUS_COMMON_H #include #include #include QT_BEGIN_NAMESPACE class QDBusArgument; QT_END_NAMESPACE class OrgFreedesktopDBusObjectManagerInterface; #define UDISKS2_SERVICE "org.freedesktop.UDisks2" namespace UDisks2 { /// by: http://storaged.org/doc/udisks2-api/2.7.2/gdbus-org.freedesktop.UDisks2.Drive.Ata.html#gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartGetAttributes struct SmartAttribute { uchar id; // Attribute Identifier QString name; // The identifier as a string. quint16 flags; // 16-bit attribute flags (bit 0 is prefail/oldage, bit 1 is online/offline). qint32 value; // The current value or -1 if unknown. qint32 worst; // The worst value of -1 if unknown. qint32 threshold; // The threshold or -1 if unknown. qint64 pretty; // An interpretation of the value - must be ignored if pretty_unit is 0. qint32 pretty_unit; // The unit of the pretty value - the following units are known: 0 (unknown), 1 (dimensionless), 2 (milliseconds), 3 (sectors), 4 (millikelvin). QVariantMap expansion; // Currently unused. Intended for future expansion. }; /// by: http://storaged.org/doc/udisks2-api/2.7.2/gdbus-org.freedesktop.UDisks2.MDRaid.html#gdbus-property-org-freedesktop-UDisks2-MDRaid.ActiveDevices struct ActiveDeviceInfo { QDBusObjectPath block; // The object path for the underlying block device (guaranteed to implement the org.freedesktop.UDisks2.Block interface) qint32 slot; // -1 if the device is not currently part of the array (ie. spare or faulty), otherwise the slot number the device currently fills (between 0 and "NumDevices") QStringList state; // The state of the device - known elements include faulty, in_sync, write_mostly, blocked and spare quint64 num_read_errors; // An ongoing count of read errors that have been detected on this device but have not caused the device to be evicted from the array QVariantMap expansion; // Currently unused. Intended for future expansion. }; /// by: http://storaged.org/doc/udisks2-api/2.7.2/udisks-std-options.html // default options // Many method calls take a parameter of type 'a{sv}' that is normally called options. The following table lists well-known options: // "auth.no_user_interaction" bool // If set to TRUE, then no user interaction will happen when checking if the method call is authorized. bool interfaceExists(const QString &path, const QString &interface); OrgFreedesktopDBusObjectManagerInterface *objectManager(); QStringList supportedFilesystems(); QString version(); } Q_DECLARE_METATYPE(UDisks2::SmartAttribute) QDBusArgument &operator<<(QDBusArgument &argument, const UDisks2::SmartAttribute &mystruct); const QDBusArgument &operator>>(const QDBusArgument &argument, UDisks2::SmartAttribute &mystruct); Q_DECLARE_METATYPE(UDisks2::ActiveDeviceInfo) QDBusArgument &operator<<(QDBusArgument &argument, const UDisks2::ActiveDeviceInfo &mystruct); const QDBusArgument &operator>>(const QDBusArgument &argument, UDisks2::ActiveDeviceInfo &mystruct); #endif // UDISK2_DBUS_COMMON_H