andrius
/
kpmcore
1
0
Fork 0
Code Pull Requests Releases Activity

Revert merge of branch luks-decorator.

This commit is contained in:
Andrius Štikonas 2015-09-16 14:18:13 +01:00
parent c95f663172
commit efd3179d95
14 changed files with 90 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -73,7 +73,7 @@ add_definitions(
)
find_package(PkgConfig REQUIRED)
pkg_check_modules(BLKID REQUIRED blkid>=2.23)
pkg_check_modules(BLKID REQUIRED blkid)
pkg_check_modules(LIBATASMART REQUIRED libatasmart)
include_directories(${Qt5Core_INCLUDE_DIRS} ${UUID_INCLUDE_DIRS} ${BLKID_INCLUDE_DIRS} lib/ src/)

9
src/core/partition.cpp
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2008 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -293,7 +292,7 @@ bool Partition::mount(Report& report)
bool success = false;
if (fileSystem().canMount(deviceNode()))
success = fileSystem().mount(deviceNode(), mountPoint());
success = fileSystem().mount(deviceNode());
else {
ExternalCommand mountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("-v") << deviceNode() << mountPoint());
if (mountCmd.run() && mountCmd.exitCode() == 0)
@ -322,11 +321,7 @@ bool Partition::unmount(Report& report)
setMountPoint(QString());
} else {
ExternalCommand umountCmd(report,
QStringLiteral("umount"),
{ QStringLiteral("-v"),
QStringLiteral("-A"),
deviceNode() });
ExternalCommand umountCmd(report, QStringLiteral("umount"), QStringList() << QStringLiteral("-v") << deviceNode());
if (!umountCmd.run() || umountCmd.exitCode() != 0)
success = false;
}

60
src/fs/filesystem.cpp
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2012 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -22,10 +21,8 @@
#include "util/capacity.h"
#include <blkid/blkid.h>
#include <KLocalizedString>
#include <QDebug>
const std::array< QColor, FileSystem::__lastType > FileSystem::defaultColorCode =
{
@ -106,60 +103,6 @@ static QString readBlkIdValue(const QString& deviceNode, const QString& tag)
return rval;
}
FileSystem::Type FileSystem::detectFileSystem(const QString& partitionPath)
{
FileSystem::Type rval = FileSystem::Unknown;
blkid_cache cache;
if (blkid_get_cache(&cache, nullptr) == 0) {
blkid_dev dev;
if ((dev = blkid_get_dev(cache,
partitionPath.toLocal8Bit().constData(),
BLKID_DEV_NORMAL)) != nullptr) {
QString s = QString::fromUtf8(blkid_get_tag_value(cache,
"TYPE",
partitionPath.toLocal8Bit().constData()));
if (s == QStringLiteral("ext2")) rval = FileSystem::Ext2;
else if (s == QStringLiteral("ext3")) rval = FileSystem::Ext3;
else if (s.startsWith(QStringLiteral("ext4"))) rval = FileSystem::Ext4;
else if (s == QStringLiteral("swap")) rval = FileSystem::LinuxSwap;
else if (s == QStringLiteral("ntfs")) rval = FileSystem::Ntfs;
else if (s == QStringLiteral("reiserfs")) rval = FileSystem::ReiserFS;
else if (s == QStringLiteral("reiser4")) rval = FileSystem::Reiser4;
else if (s == QStringLiteral("xfs")) rval = FileSystem::Xfs;
else if (s == QStringLiteral("jfs")) rval = FileSystem::Jfs;
else if (s == QStringLiteral("hfs")) rval = FileSystem::Hfs;
else if (s == QStringLiteral("hfsplus")) rval = FileSystem::HfsPlus;
else if (s == QStringLiteral("ufs")) rval = FileSystem::Ufs;
else if (s == QStringLiteral("vfat")) {
// libblkid uses SEC_TYPE to distinguish between FAT16 and FAT32
QString st = QString::fromUtf8(blkid_get_tag_value(cache,
"SEC_TYPE",
partitionPath.toLocal8Bit().constData()));
if (st == QStringLiteral("msdos"))
rval = FileSystem::Fat16;
else
rval = FileSystem::Fat32;
} else if (s == QStringLiteral("btrfs")) rval = FileSystem::Btrfs;
else if (s == QStringLiteral("ocfs2")) rval = FileSystem::Ocfs2;
else if (s == QStringLiteral("zfs_member")) rval = FileSystem::Zfs;
else if (s == QStringLiteral("hpfs")) rval = FileSystem::Hpfs;
else if (s == QStringLiteral("crypto_LUKS")) rval = FileSystem::Luks;
else if (s == QStringLiteral("exfat")) rval = FileSystem::Exfat;
else if (s == QStringLiteral("nilfs2")) rval = FileSystem::Nilfs2;
else if (s == QStringLiteral("LVM2_member")) rval = FileSystem::Lvm2_PV;
else
qWarning() << "blkid: unknown file system type " << s << " on " << partitionPath;
}
blkid_put_cache(cache);
}
return rval;
}
/** Reads the label for this FileSystem
@param deviceNode the device node for the Partition the FileSystem is on
@return the FileSystem label or an empty string in case of error
@ -441,9 +384,8 @@ void FileSystem::move(qint64 newStartSector)
@param mountPoint the mount point to mount the FileSystem on
@return true on success
*/
bool FileSystem::mount(const QString &deviceNode, const QString &mountPoint)
bool FileSystem::mount(const QString& mountPoint)
{
Q_UNUSED(deviceNode);
Q_UNUSED(mountPoint);
return false;

6
src/fs/filesystem.h
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2012 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -171,7 +170,6 @@ public:
static QString nameForType(FileSystem::Type t);
static QList<FileSystem::Type> types();
static FileSystem::Type typeForName(const QString& s);
static FileSystem::Type detectFileSystem(const QString& partitionPath);
virtual bool canMount(const QString&) const {
return false; /**< @return true if this FileSystem can be mounted */
@ -183,8 +181,8 @@ public:
virtual QString mountTitle() const;
virtual QString unmountTitle() const;
virtual bool mount(const QString& deviceNode, const QString& mountPoint);
virtual bool unmount(const QString& deviceNode);
virtual bool mount(const QString& mountPoint);
virtual bool unmount(const QString& mountPoint);
qint64 firstSector() const {
return m_FirstSector; /**< @return the FileSystem's first sector */

4
src/fs/linuxswap.cpp
View File

@ -130,10 +130,8 @@ QString linuxswap::unmountTitle() const
return i18nc("@title:menu", "Deactivate swap");
}
bool linuxswap::mount(const QString& deviceNode, const QString& mountPoint)
bool linuxswap::mount(const QString& deviceNode)
{
Q_UNUSED(mountPoint);
ExternalCommand cmd(QStringLiteral("swapon"), QStringList() << deviceNode);
return cmd.run(-1) && cmd.exitCode() == 0;
}

8
src/fs/linuxswap.h
View File

@ -55,11 +55,11 @@ public:
return true;
}
virtual bool mount(const QString& deviceNode, const QString& mountPoint) override;
virtual bool unmount(const QString& deviceNode) override;
virtual bool mount(const QString& deviceNode);
virtual bool unmount(const QString& deviceNode);
virtual QString mountTitle() const override;
virtual QString unmountTitle() const override;
virtual QString mountTitle() const;
virtual QString unmountTitle() const;
virtual CommandSupportType supportCreate() const {
return m_Create;

252
src/fs/luks.cpp
View File

@ -1,7 +1,6 @@
/*************************************************************************
* Copyright (C) 2012 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2013 by Andrius Štikonas <andrius@stikonas.eu> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -19,14 +18,11 @@
#include "fs/luks.h"
#include "fs/filesystemfactory.h"
#include "gui/decryptluksdialog.h"
#include "util/capacity.h"
#include "util/externalcommand.h"
#include <QDebug>
#include <QDialog>
#include <QPointer>
#include <QString>
@ -49,22 +45,11 @@ FileSystem::CommandSupportType luks::m_SetLabel = FileSystem::cmdSupportNone;
FileSystem::CommandSupportType luks::m_UpdateUUID = FileSystem::cmdSupportNone;
FileSystem::CommandSupportType luks::m_GetUUID = FileSystem::cmdSupportNone;
luks::luks(qint64 firstsector,
qint64 lastsector,
qint64 sectorsused,
const QString& label)
: FileSystem(firstsector, lastsector, sectorsused, label, FileSystem::Luks)
, m_innerFs(nullptr)
, m_isCryptOpen(false)
, m_isMounted(false)
luks::luks(qint64 firstsector, qint64 lastsector, qint64 sectorsused, const QString& label) :
FileSystem(firstsector, lastsector, sectorsused, label, FileSystem::Luks)
{
}
luks::~luks()
{
delete m_innerFs;
}
void luks::init()
{
m_UpdateUUID = findExternal(QStringLiteral("cryptsetup")) ? cmdSupportFileSystem : cmdSupportNone;
@ -103,236 +88,39 @@ qint64 luks::minCapacity() const
QString luks::mountTitle() const
{
return i18nc("@title:menu", "Mount");
return i18nc("@title:menu", "Decrypt");
}
QString luks::unmountTitle() const
{
return i18nc("@title:menu", "Unmount");
}
QString luks::cryptOpenTitle() const
{
return i18nc("@title:menu", "Decrypt");
}
QString luks::cryptCloseTitle() const
{
return i18nc("@title:menu", "Deactivate");
}
bool luks::canMount(const QString& deviceNode) const
bool luks::mount(const QString& deviceNode)
{
return m_isCryptOpen &&
!m_isMounted &&
m_innerFs &&
m_innerFs->canMount(deviceNode);
}
bool luks::canUnmount(const QString& deviceNode) const
{
return m_isCryptOpen &&
m_isMounted &&
m_innerFs &&
m_innerFs->canUnmount(deviceNode);
}
bool luks::isMounted() const
{
return m_isCryptOpen && m_isMounted;
}
bool luks::canCryptOpen(const QString&) const
{
return !m_isCryptOpen && !m_isMounted;
}
bool luks::canCryptClose(const QString&) const
{
return m_isCryptOpen && !m_isMounted;
}
bool luks::isCryptOpen() const
{
return m_isCryptOpen;
}
bool luks::cryptOpen(const QString& deviceNode)
{
if (m_isCryptOpen)
{
if (!mapperName(deviceNode).isEmpty())
{
qWarning() << "LUKS device" << deviceNode
<< "already decrypted."
<< "Cannot decrypt again.";
return false;
}
else
{
qWarning() << "LUKS device" << deviceNode
<< "reportedly decrypted but mapper node not found."
<< "Marking device as NOT decrypted and trying to "
"decrypt again anyway.";
m_isCryptOpen = false;
}
}
QPointer<DecryptLuksDialog> dlg = new DecryptLuksDialog(0, deviceNode); //TODO: parent widget instead of 0
if (dlg->exec() != QDialog::Accepted)
if (dlg->exec() == QDialog::Accepted)
{
std::vector<QString> commands;
commands.push_back(QStringLiteral("echo"));
commands.push_back(QStringLiteral("cryptsetup"));
std::vector<QStringList> args;
args.push_back(QStringList() << dlg->luksPassphrase().text());
args.push_back(QStringList() << QStringLiteral("luksOpen") << deviceNode << dlg->luksName().text());
ExternalCommand cmd(commands, args);
delete dlg;
return false;
return cmd.run(-1) && cmd.exitCode() == 0;
}
std::vector<QString> commands;
commands.push_back(QStringLiteral("echo"));
commands.push_back(QStringLiteral("cryptsetup"));
std::vector<QStringList> args;
args.push_back(QStringList() << dlg->luksPassphrase().text());
args.push_back(QStringList() << QStringLiteral("luksOpen") << deviceNode << dlg->luksName().text());
delete dlg;
ExternalCommand cmd(commands, args);
if (!(cmd.run(-1) && cmd.exitCode() == 0))
return false;
if (m_innerFs)
{
delete m_innerFs;
m_innerFs = nullptr;
}
QString mapperNode = mapperName(deviceNode);
if (mapperNode.isEmpty())
return false;
FileSystem::Type innerFsType = detectFileSystem(mapperNode);
m_innerFs = FileSystemFactory::cloneWithNewType(innerFsType,
*this);
m_isCryptOpen = (m_innerFs != nullptr);
if (m_isCryptOpen)
return true;
return false;
}
bool luks::cryptClose(const QString& deviceNode)
{
if (!m_isCryptOpen)
{
qWarning() << "Cannot close LUKS device" << deviceNode
<< "because it's not open.";
return false;
}
if (m_isMounted)
{
qWarning() << "Cannot close LUKS device" << deviceNode
<< "because the filesystem is mounted.";
return false;
}
ExternalCommand cmd(QStringLiteral("cryptsetup"), QStringList() << QStringLiteral("luksClose") << mapperName(deviceNode));
if (!(cmd.run(-1) && cmd.exitCode() == 0))
return false;
delete m_innerFs;
m_innerFs = nullptr;
m_isCryptOpen = (m_innerFs != nullptr);
if (!m_isCryptOpen)
return true;
return false;
}
bool luks::mount(const QString& deviceNode, const QString& mountPoint)
{
if (!m_isCryptOpen)
{
qWarning() << "Cannot mount device" << deviceNode
<< "before decrypting it first.";
return false;
}
if (m_isMounted)
{
qWarning() << "Cannot mount device" << deviceNode
<< "because it's already mounted.";
return false;
}
Q_ASSERT(m_innerFs);
QString mapperNode = mapperName(deviceNode);
if (mapperNode.isEmpty())
return false;
if (m_innerFs->canMount(mapperNode))
{
if (m_innerFs->mount(mapperNode, mountPoint))
{
m_isMounted = true;
return true;
}
}
else {
ExternalCommand mountCmd(
QStringLiteral("mount"),
{ QStringLiteral("-v"), mapperNode, mountPoint });
if (mountCmd.run() && mountCmd.exitCode() == 0)
{
m_isMounted = true;
return true;
}
}
return false;
}
bool luks::unmount(const QString& deviceNode)
{
if (!m_isCryptOpen)
{
qWarning() << "Cannot unmount device" << deviceNode
<< "before decrypting it first.";
return false;
}
if (!m_isMounted)
{
qWarning() << "Cannot unmount device" << deviceNode
<< "because it's not mounted.";
return false;
}
Q_ASSERT(m_innerFs);
QString mapperNode = mapperName(deviceNode);
if (mapperNode.isEmpty())
return false;
if (m_innerFs->canUnmount(mapperNode))
{
if (m_innerFs->unmount(mapperNode))
{
m_isMounted = false;
return true;
}
}
else {
ExternalCommand unmountCmd(
QStringLiteral("mount"),
{ QStringLiteral("-v"), QStringLiteral("-A"), mapperNode });
if (unmountCmd.run() && unmountCmd.exitCode() == 0)
{
m_isMounted = false;
return true;
}
}
return false;
ExternalCommand cmd(QStringLiteral("cryptsetup"), QStringList() << QStringLiteral("luksClose") << mapperName(deviceNode));
return cmd.run(-1) && cmd.exitCode() == 0;
}
QString luks::readUUID(const QString& deviceNode) const
@ -352,6 +140,16 @@ bool luks::updateUUID(Report& report, const QString& deviceNode) const
return cmd.run(-1) && cmd.exitCode() == 0;
}
bool luks::canMount(const QString&) const
{
return true;
}
bool luks::canUnmount(const QString&) const
{
return true;
}
QString luks::mapperName(const QString& deviceNode)
{
ExternalCommand cmd(QStringLiteral("find"), QStringList() << QStringLiteral("/dev/mapper/") << QStringLiteral("-exec") << QStringLiteral("cryptsetup") << QStringLiteral("status") << QStringLiteral("{}") << QStringLiteral(";"));

30
src/fs/luks.h
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2012 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -24,8 +23,7 @@
#include "../fs/filesystem.h"
#include <QtGlobal>
#include <QPointer>
#include <qglobal.h>
class Report;
@ -40,7 +38,6 @@ class LIBKPMCORE_EXPORT luks : public FileSystem
{
public:
luks(qint64 firstsector, qint64 lastsector, qint64 sectorsused, const QString& label);
virtual ~luks();
public:
static void init();
@ -88,24 +85,13 @@ public:
virtual QString readUUID(const QString& deviceNode) const;
virtual bool updateUUID(Report& report, const QString& deviceNode) const;
virtual QString mountTitle() const override;
virtual QString unmountTitle() const override;
QString cryptOpenTitle() const;
QString cryptCloseTitle() const;
virtual bool canMount(const QString&) const;
virtual bool canUnmount(const QString&) const;
bool isMounted() const;
bool canCryptOpen(const QString& deviceNode) const;
bool canCryptClose(const QString& deviceNode) const;
bool isCryptOpen() const;
bool cryptOpen(const QString& deviceNode);
bool cryptClose(const QString& deviceNode);
virtual bool mount(const QString& deviceNode, const QString& mountPoint) override;
virtual bool unmount(const QString& deviceNode) override;
virtual bool mount(const QString& deviceNode);
virtual bool unmount(const QString& deviceNode);
virtual QString mountTitle() const;
virtual QString unmountTitle() const;
static QString mapperName(const QString& deviceNode);
@ -128,12 +114,6 @@ public:
static CommandSupportType m_SetLabel;
static CommandSupportType m_UpdateUUID;
static CommandSupportType m_GetUUID;
private:
FileSystem* m_innerFs;
bool m_isCryptOpen;
bool m_isMounted;
};
}

2
src/plugins/libparted/CMakeLists.txt
View File

@ -29,7 +29,7 @@ file (GLOB pmlibpartedbackendplugin_SRCS *.cpp)
add_library(pmlibpartedbackendplugin SHARED ${pmlibpartedbackendplugin_SRCS})
target_link_libraries(pmlibpartedbackendplugin kpmcore ${LIBPARTED_LIBS} KF5::KIOCore KF5::I18n)
target_link_libraries(pmlibpartedbackendplugin kpmcore ${LIBPARTED_LIBS} ${BLKID_LIBRARIES} KF5::KIOCore KF5::I18n)
install(TARGETS pmlibpartedbackendplugin DESTINATION ${PLUGIN_INSTALL_DIR})
kcoreaddons_desktop_to_json(pmlibpartedbackendplugin pmlibpartedbackendplugin.desktop)

54
src/plugins/libparted/libpartedbackend.cpp
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2008-2012 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
@ -49,6 +48,7 @@
#include <parted/parted.h>
#include <unistd.h>
#include <blkid/blkid.h>
K_PLUGIN_FACTORY_WITH_JSON(LibPartedBackendFactory, "pmlibpartedbackendplugin.json", registerPlugin<LibPartedBackend>();)
@ -345,10 +345,8 @@ void LibPartedBackend::scanDevicePartitions(PedDevice*, Device& d, PedDisk* pedD
QString mountPoint;
bool mounted;
if (fs->type() == FileSystem::Luks) {
mounted = dynamic_cast<FS::luks*>(fs)->isMounted();
mountPoint = mountPoints.findByDevice(FS::luks::mapperName(node)) ?
mountPoints.findByDevice(FS::luks::mapperName(node))->mountPoint() :
QString();
mountPoint = FS::luks::mapperName(node);
mounted = (mountPoint != QString()) ? true : false;
} else {
mountPoint = mountPoints.findByDevice(node) ? mountPoints.findByDevice(node)->mountPoint() : QString();
mounted = ped_partition_is_busy(pedPartition);
@ -480,12 +478,50 @@ FileSystem::Type LibPartedBackend::detectFileSystem(PedPartition* pedPartition)
{
FileSystem::Type rval = FileSystem::Unknown;
char* pedPath = ped_partition_get_path(pedPartition);
blkid_cache cache;
char* pedPath = nullptr;
if (pedPath)
rval = FileSystem::detectFileSystem(QString::fromUtf8(pedPath));
if (blkid_get_cache(&cache, nullptr) == 0 && (pedPath = ped_partition_get_path(pedPartition))) {
blkid_dev dev;
free(pedPath);
if ((dev = blkid_get_dev(cache, pedPath, BLKID_DEV_NORMAL)) != nullptr) {
QString s = QString::fromUtf8(blkid_get_tag_value(cache, "TYPE", pedPath));
if (s == QStringLiteral("ext2")) rval = FileSystem::Ext2;
else if (s == QStringLiteral("ext3")) rval = FileSystem::Ext3;
else if (s.startsWith(QStringLiteral("ext4"))) rval = FileSystem::Ext4;
else if (s == QStringLiteral("swap")) rval = FileSystem::LinuxSwap;
else if (s == QStringLiteral("ntfs")) rval = FileSystem::Ntfs;
else if (s == QStringLiteral("reiserfs")) rval = FileSystem::ReiserFS;
else if (s == QStringLiteral("reiser4")) rval = FileSystem::Reiser4;
else if (s == QStringLiteral("xfs")) rval = FileSystem::Xfs;
else if (s == QStringLiteral("jfs")) rval = FileSystem::Jfs;
else if (s == QStringLiteral("hfs")) rval = FileSystem::Hfs;
else if (s == QStringLiteral("hfsplus")) rval = FileSystem::HfsPlus;
else if (s == QStringLiteral("ufs")) rval = FileSystem::Ufs;
else if (s == QStringLiteral("vfat") && pedPartition->fs_type != nullptr) {
// libblkid does not distinguish between fat16 and fat32, so we're still using libparted
// for those
if (strcmp(pedPartition->fs_type->name, "fat16") == 0)
rval = FileSystem::Fat16;
else if (strcmp(pedPartition->fs_type->name, "fat32") == 0)
rval = FileSystem::Fat32;
} else if (s == QStringLiteral("btrfs")) rval = FileSystem::Btrfs;
else if (s == QStringLiteral("ocfs2")) rval = FileSystem::Ocfs2;
else if (s == QStringLiteral("zfs_member")) rval = FileSystem::Zfs;
else if (s == QStringLiteral("hpfs")) rval = FileSystem::Hpfs;
else if (s == QStringLiteral("crypto_LUKS")) rval = FileSystem::Luks;
else if (s == QStringLiteral("exfat")) rval = FileSystem::Exfat;
else if (s == QStringLiteral("nilfs2")) rval = FileSystem::Nilfs2;
else if (s == QStringLiteral("LVM2_member")) rval = FileSystem::Lvm2_PV;
else
qWarning() << "blkid: unknown file system type " << s << " on " << pedPath;
}
blkid_put_cache(cache);
free(pedPath);
}
return rval;
}

1
src/plugins/libparted/libpartedbackend.h
View File

@ -1,6 +1,5 @@
/*************************************************************************
* Copyright (C) 2008, 2010 by Volker Lanz <vl@fidra.de> *
* Copyright (C) 2015 by Teo Mrnjavac <teo@kde.org> *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *

3
src/util/CMakeLists.txt
View File

@ -1,5 +1,3 @@
set_source_files_properties( util/ismounted.c PROPERTIES LANGUAGE CXX )
set(UTIL_SRC
util/capacity.cpp
util/externalcommand.cpp
@ -7,7 +5,6 @@ set(UTIL_SRC
util/helpers.cpp
util/htmlreport.cpp
util/report.cpp
util/ismounted.c
)
set(UTIL_LIB_HDRS

6
src/util/helpers.cpp
View File

@ -17,7 +17,6 @@
#include "util/helpers.h"
#include "../util/globallog.h"
#include "../util/ismounted.h"
#include "../ops/operation.h"
@ -67,8 +66,3 @@ void showColumnsContextMenu(const QPoint& p, QTreeWidget& tree)
tree.resizeColumnToContents(action->data().toInt());
}
}
bool isMounted(const QString& deviceNode)
{
return is_mounted(deviceNode.toLatin1().constData());
}

7
src/util/helpers.h
View File

@ -19,10 +19,11 @@
#define HELPERS__H
#include "../fs/filesystem.h"
#include "../util/libpartitionmanagerexport.h"
#include "../fs/filesystem.h"
class KAboutData;
class QString;
class QPoint;
class QTreeWidget;
@ -35,6 +36,4 @@ LIBKPMCORE_EXPORT void showColumnsContextMenu(const QPoint& p, QTreeWidget& tree
LIBKPMCORE_EXPORT bool checkAccessibleDevices();
LIBKPMCORE_EXPORT bool isMounted(const QString& deviceNode);
#endif