pax_global_header 0000666 0000000 0000000 00000000064 14051331364 0014512 g ustar 00root root 0000000 0000000 52 comment=1c73567733e70351418df4fe4ef9b7272d9792ea
udisks2-qt5-5.0.6/ 0000775 0000000 0000000 00000000000 14051331364 0013615 5 ustar 00root root 0000000 0000000 udisks2-qt5-5.0.6/.clog.toml 0000664 0000000 0000000 00000000163 14051331364 0015514 0 ustar 00root root 0000000 0000000 [clog]
repository = "https://github.com/linuxdeepin/udisks2-qt5"
changelog = "CHANGELOG.md"
from-latest-tag = true
udisks2-qt5-5.0.6/.gitignore 0000664 0000000 0000000 00000000051 14051331364 0015601 0 ustar 00root root 0000000 0000000 # IDE related
*.user
# Misc
.directory
udisks2-qt5-5.0.6/CHANGELOG.md 0000664 0000000 0000000 00000000273 14051331364 0015430 0 ustar 00root root 0000000 0000000
## 0.0.1 (2019-03-26)
#### Features
* add interfaces ([6668fc33](https://github.com/linuxdeepin/udisks2-qt5/commit/6668fc33c0ffe46b87c69e0f6315fcc3b698dac7))
udisks2-qt5-5.0.6/LICENSE 0000664 0000000 0000000 00000016744 14051331364 0014636 0 ustar 00root root 0000000 0000000 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.cpp 0000664 0000000 0000000 00000043026 14051331364 0016744 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000022631 14051331364 0016410 0 ustar 00root root 0000000 0000000 /*
* 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.cpp 0000664 0000000 0000000 00000056165 14051331364 0017526 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000022365 14051331364 0017166 0 ustar 00root root 0000000 0000000 /*
* 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.cpp 0000664 0000000 0000000 00000010663 14051331364 0016605 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000010634 14051331364 0016250 0 ustar 00root root 0000000 0000000 /*
* 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.cpp 0000664 0000000 0000000 00000040041 14051331364 0016751 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000010343 14051331364 0016420 0 ustar 00root root 0000000 0000000 /*
* 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/ 0000775 0000000 0000000 00000000000 14051331364 0015037 5 ustar 00root root 0000000 0000000 udisks2-qt5-5.0.6/debian/changelog 0000664 0000000 0000000 00000000226 14051331364 0016711 0 ustar 00root root 0000000 0000000 udisks2-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/compat 0000664 0000000 0000000 00000000002 14051331364 0016235 0 ustar 00root root 0000000 0000000 9
udisks2-qt5-5.0.6/debian/control 0000664 0000000 0000000 00000001163 14051331364 0016443 0 ustar 00root root 0000000 0000000 Source: 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/copyright 0000664 0000000 0000000 00000001747 14051331364 0017003 0 ustar 00root root 0000000 0000000 Format: 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.install 0000664 0000000 0000000 00000000063 14051331364 0021764 0 ustar 00root root 0000000 0000000 usr/include/*
usr/lib/*/*.so
usr/lib/*/pkgconfig/*
udisks2-qt5-5.0.6/debian/libudisks2-qt5.install 0000664 0000000 0000000 00000000021 14051331364 0021202 0 ustar 00root root 0000000 0000000 usr/lib/*/*.so.*
udisks2-qt5-5.0.6/debian/rules 0000775 0000000 0000000 00000000324 14051331364 0016116 0 ustar 00root root 0000000 0000000 #!/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/ 0000775 0000000 0000000 00000000000 14051331364 0016337 5 ustar 00root root 0000000 0000000 udisks2-qt5-5.0.6/debian/source/format 0000664 0000000 0000000 00000000015 14051331364 0017546 0 ustar 00root root 0000000 0000000 3.0 (native)
udisks2-qt5-5.0.6/dudisksjob.cpp 0000664 0000000 0000000 00000007625 14051331364 0016474 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000005211 14051331364 0016126 0 ustar 00root root 0000000 0000000 /*
* 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.xml 0000664 0000000 0000000 00000002026 14051331364 0023423 0 ustar 00root root 0000000 0000000
udisks2-qt5-5.0.6/org.freedesktop.UDisks2.xml 0000664 0000000 0000000 00000370026 14051331364 0020733 0 ustar 00root root 0000000 0000000
udisks2-qt5-5.0.6/private/ 0000775 0000000 0000000 00000000000 14051331364 0015267 5 ustar 00root root 0000000 0000000 udisks2-qt5-5.0.6/private/dblockdevice_p.h 0000664 0000000 0000000 00000003207 14051331364 0020377 0 ustar 00root root 0000000 0000000 /*
* 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.pri 0000664 0000000 0000000 00000000050 14051331364 0017450 0 ustar 00root root 0000000 0000000 HEADERS += \
$$PWD/dblockdevice_p.h
udisks2-qt5-5.0.6/rpm/ 0000775 0000000 0000000 00000000000 14051331364 0014413 5 ustar 00root root 0000000 0000000 udisks2-qt5-5.0.6/rpm/udisks2-qt5.spec 0000664 0000000 0000000 00000003121 14051331364 0017357 0 ustar 00root root 0000000 0000000 Name: 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.pro 0000664 0000000 0000000 00000002665 14051331364 0015734 0 ustar 00root root 0000000 0000000 TARGET = 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.cpp 0000664 0000000 0000000 00000010552 14051331364 0020275 0 ustar 00root root 0000000 0000000 /*
* 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.h 0000664 0000000 0000000 00000007654 14051331364 0017753 0 ustar 00root root 0000000 0000000 /*
* 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