Differential D21773 Diff 61387 src/util/externalcommandhelper.cpp

Changeset View

Standalone View

View Options

src/util/externalcommandhelper.cpp

1/************************************************************************* 1​/*************************************************************************
2 * Copyright (C) 2017-2018 by Andrius Štikonas <andrius@stikonas.eu> * 2​ * Copyright (C) 2017-2018 by Andrius Štikonas <andrius@stikonas.eu> *
3​ * Copyright (C) 2019 by Shubham <shubham.jangra@kdemail.net> *
3 * * 4​ * *
4 * This program is free software; you can redistribute it and/or * 5​ * This program is free software; you can redistribute it and/or *
5 * modify it under the terms of the GNU General Public License as * 6​ * modify it under the terms of the GNU General Public License as *
6 * published by the Free Software Foundation; either version 3 of * 7​ * published by the Free Software Foundation; either version 3 of *
7 * the License, or (at your option) any later version. * 8​ * the License, or (at your option) any later version. *
8 * * 9​ * *
9 * This program is distributed in the hope that it will be useful, * 10​ * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 11​ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 12​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. * 13​ * GNU General Public License for more details. *
13 * * 14​ * *
14 * You should have received a copy of the GNU General Public License * 15​ * You should have received a copy of the GNU General Public License *
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.* 16​ * along with this program. If not, see <http://www.gnu.org/licenses/>.*
16 *************************************************************************/ 17​ *************************************************************************/
17 18​
18#include "externalcommandhelper.h" 19​#include "externalcommandhelper.h"
19#include "externalcommand_whitelist.h" 20​#include "externalcommand_whitelist.h"
20 21​
21#include <QtDBus> ​
22#include <QCoreApplication> 22​#include <QCoreApplication>
23​#include <QtDBus>
23#include <QDebug> 24​#include <QDebug>
24#include <QFile> 25​#include <QFile>
25#include <QString> 26​#include <QString>
26#include <QTime> 27​#include <QTime>
27#include <QVariant> 28​#include <QVariant>
28 29​
30​#include <KAuth>
29#include <KLocalizedString> 31​#include <KLocalizedString>
30 32​
31/** Initialize ExternalCommandHelper Daemon and prepare DBus interface 33​/** Initialize ExternalCommandHelper Daemon and prepare DBus interface
32 * 34​ *
33 * KAuth helper runs in the background until application exits. 35​ * Helper runs in the background until application exits.
34 * To avoid forever running helper in case of application crash 36​ * To avoid forever running helper in case of application crash
35 * ExternalCommand class opens a DBus service that we monitor for changes. 37​ * ExternalCommand class opens a DBus service that we monitor for changes.
36 * If helper is not busy then it exits when the client services gets 38​ * If helper is not busy then it exits when the client services gets
37 * unregistered. Otherwise, 39​ * unregistered. Otherwise,
38 * we wait for the current job to finish before exiting, so even in case 40​ * we wait for the current job to finish before exiting, so even in case
39 * of main application crash, we do not leave partially moved data. 41​ * of main application crash, we do not leave partially moved data.
40 * 42​ *
41 * This helper also starts another DBus interface where it listens to 43​ * This helper also starts another DBus interface where it listens to
42 * command execution requests from the application that started the helper. 44​ * command execution requests from the application that started the helper.
43 * 45​ *
44*/ 46​*/
45ActionReply ExternalCommandHelper::init(const QVariantMap& args) ​
46{ ​
47 Q_UNUSED(args) ​
48 ​
49 ActionReply reply; ​
50 47​
48​QVariantMap ExternalCommandHelper::init(QVariantMap reply)
49​{
51 if (!QDBusConnection::systemBus().isConnected() || !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) || 50​ if (!QDBusConnection::systemBus().isConnected() || !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) ||
52 !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots)) { 51​ !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots)) {
53 qWarning() << QDBusConnection::systemBus().lastError().message(); 52​ qWarning() << QDBusConnection::systemBus().lastError().message();
54 reply.addData(QStringLiteral("success"), false); 53​ reply[QStringLiteral("success")] = false;
55 54​
56 // Also end the application loop started by KAuth's main() code. Our loop 55​ // Also end the application loop started by KAuth's main() code. Our loop
57 // exits when our client disappears. Without client we have no reason to 56​ // exits when our client disappears. Without client we have no reason to
58 // live. 57​ // live.
59 qApp->quit(); 58​ qApp->quit();
60 59​
61 return reply; 60​ return reply;
62 } 61​ }
63 62​
64 m_loop = std::make_unique<QEventLoop>(); 63​ m_loop = std::make_unique<QEventLoop>();
65 HelperSupport::progressStep(QVariantMap()); 64​ emit reportProgress(QVariantMap());
66 65​
67 // End the loop and return only once the client is done using us. 66​ // QDBus Srvice watcher which keeps an eye on the client (Main GUI app)
68 auto serviceWatcher = 67​ // End the loop and return only once the client has unregistered over the QDBus.
69 new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"), 68​ auto serviceWatcher = new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"),
70 QDBusConnection::systemBus(), 69​ QDBusConnection::systemBus(),
71 QDBusServiceWatcher::WatchForUnregistration, 70​ QDBusServiceWatcher::WatchForUnregistration,
72 this); 71​ this);
72​
73 connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, 73​ connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered,
74 [this]() { 74​ [this]() {
75 m_loop->exit(); 75​ m_loop->exit();
76 }); 76​ });
77 77​
78 m_loop->exec(); 78​ m_loop->exec();
79 reply.addData(QStringLiteral("success"), true); 79​ reply[QStringLiteral("success")] = true;
80 80​
81 // Also end the application loop started by KAuth's main() code. Our loop ​
82 // exits when our client disappears. Without client we have no reason to ​
83 // live. ​
84 qApp->quit(); 81​ qApp->quit();
85 82​
86 return reply; 83​ return reply;
87} 84​}
88 85​
89 86​
90/** Reads the given number of bytes from the sourceDevice into the given buffer. 87​/** Reads the given number of bytes from the sourceDevice into the given buffer.
91 @param sourceDevice device or file to read from 88​ @param sourceDevice device or file to read from
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Line(s)148{
175 t.start(); 172​ t.start();
176 173​
177 QVariantMap report; 174​ QVariantMap report;
178 175​
179 report[QStringLiteral("report")] = xi18nc("@info:progress", "Copying %1 blocks (%2 bytes) from %3 to %4, direction: %5.", blocksToCopy, 176​ report[QStringLiteral("report")] = xi18nc("@info:progress", "Copying %1 blocks (%2 bytes) from %3 to %4, direction: %5.", blocksToCopy,
180 sourceLength, readOffset, writeOffset, copyDirection == 1 ? i18nc("direction: left", "left") 177​ sourceLength, readOffset, writeOffset, copyDirection == 1 ? i18nc("direction: left", "left")
181 : i18nc("direction: right", "right")); 178​ : i18nc("direction: right", "right"));
182 179​
183 HelperSupport::progressStep(report); 180​ emit reportProgress(report);
184 181​
185 bool rval = true; 182​ bool rval = true;
186 183​
187 while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) { 184​ while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) {
188 if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize))) 185​ if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize)))
189 break; 186​ break;
190 187​
191 if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection))) 188​ if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection)))
192 break; 189​ break;
193 190​
194 bytesWritten += buffer.size(); 191​ bytesWritten += buffer.size();
195 192​
196 if (++blocksCopied * 100 / blocksToCopy != percent) { 193​ if (++blocksCopied * 100 / blocksToCopy != percent) {
197 percent = blocksCopied * 100 / blocksToCopy; 194​ percent = blocksCopied * 100 / blocksToCopy;
198 195​
199 if (percent % 5 == 0 && t.elapsed() > 1000) { 196​ if (percent % 5 == 0 && t.elapsed() > 1000) {
200 const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000); 197​ const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000);
201 const qint64 estSecsLeft = (100 - percent) * t.elapsed() / percent / 1000; 198​ const qint64 estSecsLeft = (100 - percent) * t.elapsed() / percent / 1000;
202 report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying %1 MiB/second, estimated time left: %2", mibsPerSec, QTime(0, 0).addSecs(estSecsLeft).toString()); 199​ report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying %1 MiB/second, estimated time left: %2", mibsPerSec, QTime(0, 0).addSecs(estSecsLeft).toString());
203 HelperSupport::progressStep(report); 200​ emit reportProgress(report);
204 } 201​ }
205 HelperSupport::progressStep(percent); 202​ emit progress(percent);
206 } 203​ }
207 } 204​ }
208 205​
209 // copy the remainder 206​ // copy the remainder
210 if (rval && lastBlock > 0) { 207​ if (rval && lastBlock > 0) {
211 Q_ASSERT(lastBlock < blockSize); 208​ Q_ASSERT(lastBlock < blockSize);
212 209​
213 const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte; 210​ const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte;
214 const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte; 211​ const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte;
212​
215 report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset); 213​ report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset);
216 HelperSupport::progressStep(report); 214​
215​ emit reportProgress(report);
216​
217 rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock); 217​ rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock);
218 218​
219 if (rval) { 219​ if (rval) {
220 if (targetDevice.isEmpty()) 220​ if (targetDevice.isEmpty())
221 reply[QStringLiteral("targetByteArray")] = buffer; 221​ reply[QStringLiteral("targetByteArray")] = buffer;
222 else 222​ else
223 rval = writeData(targetDevice, buffer, lastBlockWriteOffset); 223​ rval = writeData(targetDevice, buffer, lastBlockWriteOffset);
224 } 224​ }
225 225​
226 if (rval) { 226​ if (rval) {
227 HelperSupport::progressStep(100); 227​ emit progress(100);
228 bytesWritten += buffer.size(); 228​ bytesWritten += buffer.size();
229 } 229​ }
230 } 230​ }
231 231​
232 report[QStringLiteral("report")] = xi18ncp("@info:progress argument 2 is a string such as 7 bytes (localized accordingly)", "Copying 1 block (%2) finished.", "Copying %1 blocks (%2) finished.", blocksCopied, i18np("1 byte", "%1 bytes", bytesWritten)); 232​ report[QStringLiteral("report")] = xi18ncp("@info:progress argument 2 is a string such as 7 bytes (localized accordingly)", "Copying 1 block (%2) finished.", "Copying %1 blocks (%2) finished.", blocksCopied, i18np("1 byte", "%1 bytes", bytesWritten));
233 HelperSupport::progressStep(report); 233​
234​ emit reportProgress(report);
234 235​
235 reply[QStringLiteral("success")] = rval; 236​ reply[QStringLiteral("success")] = rval;
236 return reply; 237​ return reply;
237} 238​}
238 239​
239bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte) 240​bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte)
240{ 241​{
241 // Do not allow using this helper for writing to arbitrary location 242​ // Do not allow using this helper for writing to arbitrary location
Show All 13 Lines251{
255 if (command.isEmpty()) { 256​ if (command.isEmpty()) {
256 reply[QStringLiteral("success")] = false; 257​ reply[QStringLiteral("success")] = false;
257 return reply; 258​ return reply;
258 } 259​ }
259 260​
260 // Compare with command whitelist 261​ // Compare with command whitelist
261 QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1); 262​ QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1);
262 if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) { 263​ if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) {
263 qInfo() << command <<" command is not one of the whitelisted command"; 264​ qInfo() << command <<"Command is not one of the whitelisted command";
264 m_loop->exit(); 265​ m_loop->exit();
265 reply[QStringLiteral("success")] = false; 266​ reply[QStringLiteral("success")] = false;
266 return reply; 267​ return reply;
267 } 268​ }
268 269​
269// connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput); 270​ // connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput);
270 271​
271 m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } ); 272​ m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } );
272 m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode)); 273​ m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode));
273 m_cmd.start(command, arguments); 274​ m_cmd.start(command, arguments);
274 m_cmd.write(input); 275​ m_cmd.write(input);
275 m_cmd.closeWriteChannel(); 276​ m_cmd.closeWriteChannel();
276 m_cmd.waitForFinished(-1); 277​ m_cmd.waitForFinished(-1);
278​
277 QByteArray output = m_cmd.readAllStandardOutput(); 279​ QByteArray output = m_cmd.readAllStandardOutput();
278 reply[QStringLiteral("output")] = output; 280​ reply[QStringLiteral("output")] = output;
279 reply[QStringLiteral("exitCode")] = m_cmd.exitCode(); 281​ reply[QStringLiteral("exitCode")] = m_cmd.exitCode();
280 282​
281 return reply; 283​ return reply;
282} 284​}
283 285​
284void ExternalCommandHelper::exit() 286​void ExternalCommandHelper::exit()
285{ 287​{
286 m_loop->exit(); 288​ m_loop->exit();
287 289​
288 QDBusConnection::systemBus().unregisterObject(QStringLiteral("/Helper")); 290​ QDBusConnection::systemBus().unregisterObject(QStringLiteral("/Helper"));
289 QDBusConnection::systemBus().unregisterService(QStringLiteral("org.kde.kpmcore.helperinterface")); 291​ QDBusConnection::systemBus().unregisterService(QStringLiteral("org.kde.kpmcore.helperinterface"));
290} 292​}
291 293​
292void ExternalCommandHelper::onReadOutput() 294​/*void ExternalCommandHelper::onReadOutput()
293{ 295​{
294/* const QByteArray s = cmd.readAllStandardOutput(); 296​ const QByteArray s = cmd.readAllStandardOutput();
295 297​
296 if(output.length() > 10*1024*1024) { // prevent memory overflow for badly corrupted file systems 298​ if(output.length() > 10*1024*1024) { // prevent memory overflow for badly corrupted file systems
297 if (report()) 299​ if (report())
298 report()->line() << xi18nc("@info:status", "(Command is printing too much output)"); 300​ report()->line() << xi18nc("@info:status", "(Command is printing too much output)");
299 return; 301​ return;
300 } 302​ }
301 303​
302 output += s; 304​ output += s;
303 305​
304 if (report()) 306​ if (report())
305 *report() << QString::fromLocal8Bit(s);*/ 307​ *report() << QString::fromLocal8Bit(s);
306} 308​}*/
307 309​
308KAUTH_HELPER_MAIN("org.kde.kpmcore.externalcommand", ExternalCommandHelper) 310​KAUTH_HELPER_MAIN("org.kde.kpmcore.externalcommand", ExternalCommandHelper)