diff --git a/src/core/fstab.cpp b/src/core/fstab.cpp index 2a5fb69..dd1e4a4 100644 --- a/src/core/fstab.cpp +++ b/src/core/fstab.cpp @@ -1,211 +1,206 @@ /************************************************************************* * Copyright (C) 2009, 2010 by Volker Lanz * * Copyright (C) 2016 by Teo Mrnjavac * * Copyright (C) 2017 by Andrius Štikonas * * * * 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 (at your option) 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 "core/fstab.h" #include "util/externalcommand.h" #include #include #include #include #include #include #include static void parseFsSpec(const QString& m_fsSpec, FstabEntryType& m_entryType, QString& m_deviceNode); static QString findBlkIdDevice(const QString& token, const QString& value); FstabEntry::FstabEntry(const QString& fsSpec, const QString& mountPoint, const QString& type, const QString& options, int dumpFreq, int passNumber, const QString& comment) : m_fsSpec(fsSpec) , m_mountPoint(mountPoint) , m_type(type) , m_dumpFreq(dumpFreq) , m_passNumber(passNumber) , m_comment(comment) { m_options = options.split(QLatin1Char(',')); parseFsSpec(m_fsSpec, m_entryType, m_deviceNode); } /** @param s the new value for the fs_spec field of fstab entry */ void FstabEntry::setFsSpec(const QString& s) { m_fsSpec = s; parseFsSpec(m_fsSpec, m_entryType, m_deviceNode); } FstabEntryList readFstabEntries( const QString& fstabPath ) { FstabEntryList fstabEntries; QFile fstabFile( fstabPath ); if ( fstabFile.open( QIODevice::ReadOnly | QIODevice::Text ) ) { const QStringList fstabLines = QString::fromLocal8Bit(fstabFile.readAll()).split( QLatin1Char('\n') ); for ( const QString& rawLine : fstabLines ) { QString line = rawLine.trimmed(); if ( line.startsWith( QLatin1Char('#') ) || line.isEmpty()) { fstabEntries.append( { {}, {}, {}, {}, {}, {}, line } ); continue; } QString comment = line.section( QLatin1Char('#'), 1 ); QStringList splitLine = line.section( QLatin1Char('#'), 0, 0 ).split( QRegularExpression(QStringLiteral("[\\s]+")), QString::SkipEmptyParts ); // We now split the standard components of /etc/fstab entry: // (0) path, or UUID, or LABEL, etc, // (1) mount point, // (2) file system type, // (3) options, // (4) dump frequency (optional, defaults to 0), no comment is allowed if omitted, // (5) pass number (optional, defaults to 0), no comment is allowed if omitted, // (#) comment (optional). switch (splitLine.length()) { case 4: fstabEntries.append( {splitLine.at(0), splitLine.at(1), splitLine.at(2), splitLine.at(3) } ); break; case 5: fstabEntries.append( {splitLine.at(0), splitLine.at(1), splitLine.at(2), splitLine.at(3), splitLine.at(4).toInt() } ); break; case 6: fstabEntries.append( {splitLine.at(0), splitLine.at(1), splitLine.at(2), splitLine.at(3), splitLine.at(4).toInt(), splitLine.at(5).toInt(), comment.isEmpty() ? QString() : QLatin1Char('#') + comment } ); break; default: fstabEntries.append( { {}, {}, {}, {}, {}, {}, QLatin1Char('#') + line } ); } } fstabFile.close(); if (fstabEntries.last().entryType() == comment && fstabEntries.last().comment().isEmpty()) fstabEntries.removeLast(); } return fstabEntries; } QStringList possibleMountPoints(const QString& deviceNode, const QString& fstabPath) { QStringList mountPoints; QString canonicalPath = QFileInfo(deviceNode).canonicalFilePath(); const FstabEntryList fstabEntryList = readFstabEntries( fstabPath ); for (const FstabEntry &entry : fstabEntryList) if (QFileInfo(entry.deviceNode()).canonicalFilePath() == canonicalPath) mountPoints.append(entry.mountPoint()); return mountPoints; } static QString findBlkIdDevice(const QString& token, const QString& value) { - blkid_cache cache; QString rval; - if (blkid_get_cache(&cache, nullptr) == 0) { - if (char* c = blkid_evaluate_tag(token.toLocal8Bit().constData(), value.toLocal8Bit().constData(), &cache)) { - rval = QString::fromLocal8Bit(c); - free(c); - } - - blkid_put_cache(cache); + if (char* c = blkid_evaluate_tag(token.toLocal8Bit().constData(), value.toLocal8Bit().constData(), nullptr)) { + rval = QString::fromLocal8Bit(c); + free(c); } return rval; } static void parseFsSpec(const QString& m_fsSpec, FstabEntryType& m_entryType, QString& m_deviceNode) { m_entryType = FstabEntryType::comment; if (m_fsSpec.startsWith(QStringLiteral("UUID="))) { m_entryType = FstabEntryType::uuid; m_deviceNode = findBlkIdDevice(QStringLiteral("UUID"), QString(m_fsSpec).remove(QStringLiteral("UUID="))); } else if (m_fsSpec.startsWith(QStringLiteral("LABEL="))) { m_entryType = FstabEntryType::label; m_deviceNode = findBlkIdDevice(QStringLiteral("LABEL"), QString(m_fsSpec).remove(QStringLiteral("LABEL="))); } else if (m_fsSpec.startsWith(QStringLiteral("PARTUUID="))) { m_entryType = FstabEntryType::uuid; m_deviceNode = findBlkIdDevice(QStringLiteral("PARTUUID"), QString(m_fsSpec).remove(QStringLiteral("PARTUUID="))); } else if (m_fsSpec.startsWith(QStringLiteral("PARTLABEL="))) { m_entryType = FstabEntryType::label; m_deviceNode = findBlkIdDevice(QStringLiteral("PARTLABEL"), QString(m_fsSpec).remove(QStringLiteral("PARTLABEL="))); } else if (m_fsSpec.startsWith(QStringLiteral("/"))) { m_entryType = FstabEntryType::deviceNode; m_deviceNode = m_fsSpec; } } static void writeEntry(QFile& output, const FstabEntry& entry) { QTextStream s(&output); if (entry.entryType() == FstabEntryType::comment) { s << entry.comment() << "\n"; return; } QString options; if (entry.options().size() > 0) { options = entry.options().join(QLatin1Char(',')); if (options.isEmpty()) options = QStringLiteral("defaults"); } else options = QStringLiteral("defaults"); s << entry.fsSpec() << "\t" << (entry.mountPoint().isEmpty() ? QStringLiteral("none") : entry.mountPoint()) << "\t" << entry.type() << "\t" << options << "\t" << entry.dumpFreq() << "\t" << entry.passNumber() << "\t" << entry.comment() << "\n"; } bool writeMountpoints(const FstabEntryList fstabEntries, const QString& filename) { QTemporaryFile out; out.setAutoRemove(false); if (!out.open()) { qWarning() << "could not open output file " << out.fileName(); return false; } else { for (const auto &e : fstabEntries) writeEntry(out, e); out.close(); const QString bakFilename = QStringLiteral("%1.bak").arg(filename); ExternalCommand mvCmd(QStringLiteral("mv"), { filename, bakFilename } ); if ( !(mvCmd.run(-1) && mvCmd.exitCode() == 0) ) { qWarning() << "could not backup " << filename << " to " << bakFilename; return false; } ExternalCommand mvCmd2(QStringLiteral("mv"), { out.fileName(), filename } ); if ( !(mvCmd2.run(-1) && mvCmd2.exitCode() == 0) ) { qWarning() << "could not move " << out.fileName() << " to " << filename; return false; } } return true; } diff --git a/src/core/smartparser.cpp b/src/core/smartparser.cpp index ebd62da..4dcf046 100644 --- a/src/core/smartparser.cpp +++ b/src/core/smartparser.cpp @@ -1,158 +1,157 @@ /************************************************************************* * Copyright (C) 2018 by Caio Carvalho * * * * 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 (at your option) 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 "core/smartparser.h" #include "core/smartattributeparseddata.h" #include "core/smartdiskinformation.h" #include "util/externalcommand.h" #include #include #include #include #include #include /** Creates a new SmartParser object @param device_path device path that indicates the device that SMART must analyse */ SmartParser::SmartParser(const QString &device_path) : m_DevicePath(device_path), m_DiskInformation(nullptr) { - } /** Initialize SmartParser data, retrieve the information from SMART JSON and initialize the disk information data */ bool SmartParser::init() { loadSmartOutput(); if (m_SmartOutput.isEmpty()) return false; QJsonObject smartJson = m_SmartOutput.object(); QString model_name = QStringLiteral("model_name"); QString firmware = QStringLiteral("firmware_version"); QString serial_number = QStringLiteral("serial_number"); QString device = QStringLiteral("device"); QString smart_status = QStringLiteral("smart_status"); QString passed = QStringLiteral("passed"); QString self_test = QStringLiteral("self_test"); QString status = QStringLiteral("status"); QString value = QStringLiteral("value"); QString user_capacity = QStringLiteral("user_capacity"); if (!smartJson.contains(device)) { qDebug() << "smart disk open failed for " << devicePath() << ": " << strerror(errno); return false; } if (!smartJson.contains(smart_status)) { qDebug() << "getting smart status failed for " << devicePath() << ": " << strerror(errno); return false; } if (!smartJson.contains(model_name) || !smartJson.contains(firmware) || !smartJson.contains(serial_number)) { qDebug() << "getting disk identification data failed for " << devicePath() << ": " << strerror( errno); return false; } m_DiskInformation = new SmartDiskInformation(); QJsonObject smartStatus = smartJson[smart_status].toObject(); m_DiskInformation->setSmartStatus(smartStatus[passed].toBool()); m_DiskInformation->setModel(smartJson[model_name].toString()); m_DiskInformation->setFirmware(smartJson[firmware].toString()); m_DiskInformation->setSerial(smartJson[serial_number].toString()); m_DiskInformation->setSize(smartJson[user_capacity].toVariant().toULongLong()); QJsonObject selfTest = smartJson[self_test].toObject(); QJsonObject selfTestStatus = selfTest[status].toObject(); m_DiskInformation->setSelfTestExecutionStatus((SmartDiskInformation::SmartSelfTestExecutionStatus) selfTestStatus[value].toInt()); loadAttributes(); m_DiskInformation->updateBadSectors(); m_DiskInformation->updateOverall(); if (!m_DiskInformation->updateTemperature()) qDebug() << "getting temp failed for " << devicePath() << ": " << strerror(errno); if (!m_DiskInformation->updatePowerOn()) qDebug() << "getting powered on time failed for " << devicePath() << ": " << strerror(errno); if (!m_DiskInformation->updatePowerCycle()) qDebug() << "getting power cycles failed for " << devicePath() << ": " << strerror(errno); return true; } /** Run smartctl command and recover its output */ void SmartParser::loadSmartOutput() { if (m_SmartOutput.isEmpty()) { ExternalCommand smartctl(QStringLiteral("smartctl"), { QStringLiteral("--all"), QStringLiteral("--json"), devicePath() }); if (smartctl.run() && smartctl.exitCode() == 0) { QByteArray output = smartctl.rawOutput(); m_SmartOutput = QJsonDocument::fromJson(output); } else qDebug() << "smartctl initialization failed for " << devicePath() << ": " << strerror(errno); } } /** Load SMART disk attributes from JSON data */ void SmartParser::loadAttributes() { loadSmartOutput(); if (m_SmartOutput.isEmpty()) return; QJsonObject smartJson = m_SmartOutput.object(); QString ata_smart_attributes = QStringLiteral("ata_smart_attributes"); QString table = QStringLiteral("table"); QJsonObject ataSmartAttributes = smartJson[ata_smart_attributes].toObject(); QJsonArray attributeArray = ataSmartAttributes[table].toArray(); if (!m_DiskInformation) { qDebug() << "error loading smart attributes for " << devicePath() << ": " << strerror(errno); return; } for (const QJsonValue &value : qAsConst(attributeArray)) { SmartAttributeParsedData parsedObject(m_DiskInformation, value.toObject()); m_DiskInformation->addAttribute(parsedObject); } }