Differential D22438 Diff 61986 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) 47​QVariantMap ExternalCommandHelper::init(QVariantMap reply)
46{ 48​{
47 Q_UNUSED(args) ​
48 ​
49 ActionReply reply; ​
50 ​
51 if (!QDBusConnection::systemBus().isConnected() || !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) || 49​ if (!QDBusConnection::systemBus().isConnected() || !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) ||
52 !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots)) { 50​ !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots)) {
53 qWarning() << QDBusConnection::systemBus().lastError().message(); 51​ qWarning() << QDBusConnection::systemBus().lastError().message();
54 reply.addData(QStringLiteral("success"), false); 52​ reply[QStringLiteral("success")] = false;
55 53​
56 // Also end the application loop started by KAuth's main() code. Our loop 54​ // 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 55​ // exits when our client disappears. Without client we have no reason to
58 // live. 56​ // live.
59 qApp->quit(); 57​ qApp->quit();
60 58​
61 return reply; 59​ return reply;
62 } 60​ }
63 61​
64 m_loop = std::make_unique<QEventLoop>(); 62​ m_loop = std::make_unique<QEventLoop>();
65 HelperSupport::progressStep(QVariantMap()); 63​ emit reportProgress(QVariantMap());
66 64​
67 // End the loop and return only once the client is done using us. 65​ // QDBus Srvice watcher which keeps an eye on the client (Main GUI app)
68 auto serviceWatcher = 66​ // End the loop and return only once the client has unregistered over the QDBus.
69 new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"), 67​ auto serviceWatcher = new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"),
70 QDBusConnection::systemBus(), 68​ QDBusConnection::systemBus(),
71 QDBusServiceWatcher::WatchForUnregistration, 69​ QDBusServiceWatcher::WatchForUnregistration,
72 this); 70​ this);
71​
73 connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, 72​ connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered,
74 [this]() { 73​ [this]() {
75 m_loop->exit(); 74​ m_loop->exit();
76 }); 75​ });
77 76​
78 m_loop->exec(); 77​ m_loop->exec();
79 reply.addData(QStringLiteral("success"), true); 78​ reply[QStringLiteral("success")] = true;
80 79​
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(); 80​ qApp->quit();
85 81​
86 return reply; 82​ return reply;
87} 83​}
88 84​
89 85​
90/** Reads the given number of bytes from the sourceDevice into the given buffer. 86​/** Reads the given number of bytes from the sourceDevice into the given buffer.
91 @param sourceDevice device or file to read from 87​ @param sourceDevice device or file to read from
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Line(s)147{
175 t.start(); 171​ t.start();
176 172​
177 QVariantMap report; 173​ QVariantMap report;
178 174​
179 report[QStringLiteral("report")] = xi18nc("@info:progress", "Copying %1 blocks (%2 bytes) from %3 to %4, direction: %5.", blocksToCopy, 175​ 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") 176​ sourceLength, readOffset, writeOffset, copyDirection == 1 ? i18nc("direction: left", "left")
181 : i18nc("direction: right", "right")); 177​ : i18nc("direction: right", "right"));
182 178​
183 HelperSupport::progressStep(report); 179​ emit reportProgress(report);
184 180​
185 bool rval = true; 181​ bool rval = true;
186 182​
187 while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) { 183​ while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) {
188 if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize))) 184​ if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize)))
189 break; 185​ break;
190 186​
191 if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection))) 187​ if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection)))
192 break; 188​ break;
193 189​
194 bytesWritten += buffer.size(); 190​ bytesWritten += buffer.size();
195 191​
196 if (++blocksCopied * 100 / blocksToCopy != percent) { 192​ if (++blocksCopied * 100 / blocksToCopy != percent) {
197 percent = blocksCopied * 100 / blocksToCopy; 193​ percent = blocksCopied * 100 / blocksToCopy;
198 194​
199 if (percent % 5 == 0 && t.elapsed() > 1000) { 195​ if (percent % 5 == 0 && t.elapsed() > 1000) {
200 const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000); 196​ const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000);
201 const qint64 estSecsLeft = (100 - percent) * t.elapsed() / percent / 1000; 197​ 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()); 198​ 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); 199​ emit reportProgress(report);
204 } 200​ }
205 HelperSupport::progressStep(percent); 201​ emit progress(percent);
206 } 202​ }
207 } 203​ }
208 204​
209 // copy the remainder 205​ // copy the remainder
210 if (rval && lastBlock > 0) { 206​ if (rval && lastBlock > 0) {
211 Q_ASSERT(lastBlock < blockSize); 207​ Q_ASSERT(lastBlock < blockSize);
212 208​
213 const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte; 209​ const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte;
214 const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte; 210​ const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte;
211​
215 report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset); 212​ report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset);
216 HelperSupport::progressStep(report); 213​
214​ emit reportProgress(report);
215​
217 rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock); 216​ rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock);
218 217​
219 if (rval) { 218​ if (rval) {
220 if (targetDevice.isEmpty()) 219​ if (targetDevice.isEmpty())
221 reply[QStringLiteral("targetByteArray")] = buffer; 220​ reply[QStringLiteral("targetByteArray")] = buffer;
222 else 221​ else
223 rval = writeData(targetDevice, buffer, lastBlockWriteOffset); 222​ rval = writeData(targetDevice, buffer, lastBlockWriteOffset);
224 } 223​ }
225 224​
226 if (rval) { 225​ if (rval) {
227 HelperSupport::progressStep(100); 226​ emit progress(100);
228 bytesWritten += buffer.size(); 227​ bytesWritten += buffer.size();
229 } 228​ }
230 } 229​ }
231 230​
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)); 231​ 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); 232​
233​ emit reportProgress(report);
234 234​
235 reply[QStringLiteral("success")] = rval; 235​ reply[QStringLiteral("success")] = rval;
236 return reply; 236​ return reply;
237} 237​}
238 238​
239bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte) 239​bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte)
240{ 240​{
241 // Do not allow using this helper for writing to arbitrary location 241​ // Do not allow using this helper for writing to arbitrary location
Show All 13 Lines250{
255 if (command.isEmpty()) { 255​ if (command.isEmpty()) {
256 reply[QStringLiteral("success")] = false; 256​ reply[QStringLiteral("success")] = false;
257 return reply; 257​ return reply;
258 } 258​ }
259 259​
260 // Compare with command whitelist 260​ // Compare with command whitelist
261 QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1); 261​ QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1);
262 if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) { 262​ if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) {
263 qInfo() << command <<" command is not one of the whitelisted command"; 263​ qInfo() << command <<"Command is not one of the whitelisted command";
264 m_loop->exit(); 264​ m_loop->exit();
265 reply[QStringLiteral("success")] = false; 265​ reply[QStringLiteral("success")] = false;
266 return reply; 266​ return reply;
267 } 267​ }
268 268​
269// connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput); 269​// connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput);
270 270​
271 m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } ); 271​ m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } );
272 m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode)); 272​ m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode));
273 m_cmd.start(command, arguments); 273​ m_cmd.start(command, arguments);
274 m_cmd.write(input); 274​ m_cmd.write(input);
275 m_cmd.closeWriteChannel(); 275​ m_cmd.closeWriteChannel();
276 m_cmd.waitForFinished(-1); 276​ m_cmd.waitForFinished(-1);
277​
277 QByteArray output = m_cmd.readAllStandardOutput(); 278​ QByteArray output = m_cmd.readAllStandardOutput();
279​
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)
311​
312​#include "moc_externalcommandhelper.cpp"