Differential D22889 Diff 64349 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 <aryan100jangid@gmail.com> *
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"
20​
21​#include "externalcommand_interface.h"
19#include "externalcommand_whitelist.h" 22​#include "externalcommand_whitelist.h"
20 23​
21#include <QtDBus> ​
22#include <QCoreApplication> 24​#include <QCoreApplication>
25​#include <QtDBus>
23#include <QDebug> 26​#include <QDebug>
27​#include <QElapsedTimer>
24#include <QFile> 28​#include <QFile>
25#include <QString> 29​#include <QString>
26#include <QTime> ​
27#include <QVariant> 30​#include <QVariant>
28 31​
29#include <KLocalizedString> 32​#include <KLocalizedString>
30 33​
31/** Initialize ExternalCommandHelper Daemon and prepare DBus interface 34​/** Initialize ExternalCommandHelper Daemon and prepare DBus interface
32 * 35​ *
33 * KAuth helper runs in the background until application exits. 36​ * Helper runs in the background until application exits.
34 * To avoid forever running helper in case of application crash 37​ * To avoid forever running helper in case of application crash
35 * ExternalCommand class opens a DBus service that we monitor for changes. 38​ * 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 39​ * If helper is not busy then it exits when the client services gets
37 * unregistered. Otherwise, 40​ * unregistered. Otherwise,
38 * we wait for the current job to finish before exiting, so even in case 41​ * 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. 42​ * of main application crash, we do not leave partially moved data.
40 * 43​ *
41 * This helper also starts another DBus interface where it listens to 44​ * This helper also starts another DBus interface where it listens to
42 * command execution requests from the application that started the helper. 45​ * command execution requests from the application that started the helper.
43 * 46​ *
44*/ 47​*/
45ActionReply ExternalCommandHelper::init(const QVariantMap& args) ​
46{ ​
47 Q_UNUSED(args) ​
48 48​
49 ActionReply reply; 49​/** Reads the given number of bytes from the sourceDevice into the given buffer.
50​ @param argc argument count
51​ @param argv argument vector
52​ @return zero on success, non-zero on failure
53​*/
54​int ExternalCommandHelper::helperMain(int argc, char **argv)
55​{
56​ QCoreApplication app(argc, argv);
50 57​
51 if (!QDBusConnection::systemBus().isConnected() || !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) || 58​ if (!QDBusConnection::systemBus().isConnected() ||
52 !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots)) { 59​ !QDBusConnection::systemBus().registerObject(QStringLiteral("/Helper"), this, QDBusConnection::ExportAllSlots) ||
broulikUnsubmitted
Done

One should register objects before registering the service as the service might become visible to the bus in an inconsistent state (i.e. show up before the objects are registered)

broulik: One should register objects before registering the service as the service might become visible…
60​ !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.helperinterface")) ||
cjlcarvalhoUnsubmitted
Not Done

What happens when a service/object is registered and the other one is not?

cjlcarvalho: What happens when a service/object is registered and the other one is not?
61​ !QDBusConnection::systemBus().registerObject(QStringLiteral("/Application"), this, QDBusConnection::ExportAllSlots) ||
62​ !QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.kpmcore.applicationinterface"))) {
63​ qDebug() << "Failed to initialize the Helper";
53 qWarning() << QDBusConnection::systemBus().lastError().message(); 64​ qWarning() << QDBusConnection::systemBus().lastError().message();
54 reply.addData(QStringLiteral("success"), false); ​
55 65​
56 // Also end the application loop started by KAuth's main() code. Our loop 66​ // We have no reason to live when Main GUI app has expired
57 // exits when our client disappears. Without client we have no reason to ​
58 // live. ​
59 qApp->quit(); 67​ qApp->quit();
60 68​
61 return reply; 69​ return app.exec();
62 } 70​ }
63 71​
64 m_loop = std::make_unique<QEventLoop>(); 72​ m_loop = std::make_unique<QEventLoop>();
65 HelperSupport::progressStep(QVariantMap()); ​
66 73​
67 // End the loop and return only once the client is done using us. 74​ // We send zero percent new data on initial start-up
68 auto serviceWatcher = 75​ sendProgress(0);
69 new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"), 76​
77​ // QDBus Service watcher which keeps an eye on the client (Main GUI app)
78​ // End the loop and return only once the client has unregistered over the QDBus.
79​ auto serviceWatcher = new QDBusServiceWatcher(QStringLiteral("org.kde.kpmcore.applicationinterface"),
70 QDBusConnection::systemBus(), 80​ QDBusConnection::systemBus(),
71 QDBusServiceWatcher::WatchForUnregistration, 81​ QDBusServiceWatcher::WatchForUnregistration,
72 this); 82​ this);
83​
73 connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, 84​ connect(serviceWatcher, &QDBusServiceWatcher::serviceUnregistered,
74 [this]() { 85​ [this]() {
75 m_loop->exit(); 86​ m_loop->exit();
76 }); 87​ });
77 88​
78 m_loop->exec(); 89​ m_loop->exec();
79 reply.addData(QStringLiteral("success"), true); ​
80 90​
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(); 91​ qApp->quit();
85 92​
86 return reply; 93​ return app.exec();
87} 94​}
88 95​
89 96​
90/** Reads the given number of bytes from the sourceDevice into the given buffer. 97​/** Reads the given number of bytes from the sourceDevice into the given buffer.
91 @param sourceDevice device or file to read from 98​ @param sourceDevice device or file to read from
92 @param buffer buffer to store the bytes read in 99​ @param buffer buffer to store the bytes read in
93 @param offset offset where to begin reading 100​ @param offset offset where to begin reading
94 @param size the number of bytes to read 101​ @param size the number of bytes to read
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Line(s)135{
141 if (device.write(buffer) != buffer.size()) { 148​ if (device.write(buffer) != buffer.size()) {
142 qCritical() << xi18n("Could not write to device <filename>%1</filename>.", targetDevice); 149​ qCritical() << xi18n("Could not write to device <filename>%1</filename>.", targetDevice);
143 return false; 150​ return false;
144 } 151​ }
145 152​
146 return true; 153​ return true;
147} 154​}
148 155​
156​/** Sends progress to the main application in terms of percentage.
broulikUnsubmitted
Done

This is a lie.

broulik: This is a lie.
157​ @param percent Percent of job completed.
158​*/
159​void ExternalCommandHelper::sendProgress(int percent)
160​{
161​ auto interface = new org::kde::kpmcore::applicationinterface(QStringLiteral("org.kde.kpmcore.applicationinterface"),
broulikUnsubmitted
Done

QDBusInterface constructor blocks introspecting DBus. You probably want to use an interface generated from an XML file to avoid this.

broulik: `QDBusInterface` constructor blocks introspecting DBus. You probably want to use an interface…
162​ QStringLiteral("/Application"), QDBusConnection::systemBus(), this);
163​ interface->setTimeout(10 * 24 * 3600 * 1000); // 10 days
164​
165​ QDBusPendingCall pcall = interface->emitNewData(percent);
166​
167​ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pcall, this);
168​ QEventLoop loop;
169​
170​ auto exitLoop = [&] (QDBusPendingCallWatcher *watcher) {
171​ loop.exit();
172​ if (watcher->isError())
broulikUnsubmitted
Not Done

What's the point of the event loop?

broulik: What's the point of the event loop?
173​ qWarning() << watcher->error();
174​ };
175​
176​ connect(watcher, &QDBusPendingCallWatcher::finished, [this, exitLoop, watcher](){
177​ watcher->deleteLater();
178​ }
179​ );
180​
181​ loop.exec();
182​}
183​
184​/** Sends progress to the main application in terms of string message.
185​ @param message Message to send to the main application.
186​*/
187​void ExternalCommandHelper::sendProgress(QString message)
188​{
189​ auto interface = new org::kde::kpmcore::applicationinterface(QStringLiteral("org.kde.kpmcore.applicationinterface"),
190​ QStringLiteral("/Application"), QDBusConnection::systemBus(), this);
191​ interface->setTimeout(10 * 24 * 3600 * 1000); // 10 days
192​
193​ QDBusPendingCall pcall = interface->emitNewData(message);
194​
195​ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pcall, this);
196​ QEventLoop loop;
197​
198​ auto exitLoop = [&] (QDBusPendingCallWatcher *watcher) {
199​ loop.exit();
200​ if (watcher->isError())
broulikUnsubmitted
Done

You're leaking the watcher, call watcher->deleteLater() in the finished handler

broulik: You're leaking the watcher, call `watcher->deleteLater()` in the `finished` handler
201​ qWarning() << watcher->error();
202​ };
203​
204​ connect(watcher, &QDBusPendingCallWatcher::finished, [this, exitLoop, watcher](){
205​ watcher->deleteLater();
206​ }
207​ );
208​
209​ loop.exec();
210​}
211​
149// If targetDevice is empty then return QByteArray with data that was read from disk. 212​// If targetDevice is empty then return QByteArray with data that was read from disk.
150QVariantMap ExternalCommandHelper::copyblocks(const QString& sourceDevice, const qint64 sourceFirstByte, const qint64 sourceLength, const QString& targetDevice, const qint64 targetFirstByte, const qint64 blockSize) 213​QVariantMap ExternalCommandHelper::copyblocks(const QString& sourceDevice, const qint64 sourceFirstByte, const qint64 sourceLength, const QString& targetDevice, const qint64 targetFirstByte, const qint64 blockSize)
151{ 214​{
152 QVariantMap reply; 215​ QVariantMap reply;
153 reply[QStringLiteral("success")] = true; 216​ reply[QStringLiteral("success")] = true;
154 217​
155 const qint64 blocksToCopy = sourceLength / blockSize; 218​ const qint64 blocksToCopy = sourceLength / blockSize;
156 qint64 readOffset = sourceFirstByte; 219​ qint64 readOffset = sourceFirstByte;
157 qint64 writeOffset = targetFirstByte; 220​ qint64 writeOffset = targetFirstByte;
158 qint32 copyDirection = 1; 221​ qint32 copyDirection = 1;
159 222​
160 if (targetFirstByte > sourceFirstByte) { 223​ if (targetFirstByte > sourceFirstByte) {
161 readOffset = sourceFirstByte + sourceLength - blockSize; 224​ readOffset = sourceFirstByte + sourceLength - blockSize;
162 writeOffset = targetFirstByte + sourceLength - blockSize; 225​ writeOffset = targetFirstByte + sourceLength - blockSize;
163 copyDirection = -1; 226​ copyDirection = -1;
164 } 227​ }
165 228​
166 const qint64 lastBlock = sourceLength % blockSize; 229​ const qint64 lastBlock = sourceLength % blockSize;
167 230​
168 qint64 bytesWritten = 0; 231​ qint64 bytesWritten = 0;
169 qint64 blocksCopied = 0; 232​ qint64 blocksCopied = 0;
170 233​
171 QByteArray buffer; 234​ QByteArray buffer;
172 int percent = 0; 235​ int percent = 0;
173 QTime t; ​
174 236​
237​
238​ QElapsedTimer t;
broulikUnsubmitted
Done

This probably wants to be a QElapsedTimer

broulik: This probably wants to be a `QElapsedTimer`
175 t.start(); 239​ t.start();
176 240​
177 QVariantMap report; 241​ sendProgress(xi18nc("@info:progress", "Copying %1 blocks (%2 bytes) from %3 to %4, direction: %5.", blocksToCopy,
178 242​
179 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") ​
181 : i18nc("direction: right", "right")); ​
182 243​
183 HelperSupport::progressStep(report); 244​ sourceLength, readOffset, writeOffset, copyDirection == 1 ? i18nc("direction: left", "left")
245​ : i18nc("direction: right", "right")));
184 246​
185 bool rval = true; 247​ bool rval = true;
186 248​
187 while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) { 249​ while (blocksCopied < blocksToCopy && !targetDevice.isEmpty()) {
188 if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize))) 250​ if (!(rval = readData(sourceDevice, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize)))
189 break; 251​ break;
190 252​
191 if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection))) 253​ if (!(rval = writeData(targetDevice, buffer, writeOffset + blockSize * blocksCopied * copyDirection)))
192 break; 254​ break;
193 255​
194 bytesWritten += buffer.size(); 256​ bytesWritten += buffer.size();
195 257​
196 if (++blocksCopied * 100 / blocksToCopy != percent) { 258​ if (++blocksCopied * 100 / blocksToCopy != percent) {
197 percent = blocksCopied * 100 / blocksToCopy; 259​ percent = blocksCopied * 100 / blocksToCopy;
198 260​
199 if (percent % 5 == 0 && t.elapsed() > 1000) { 261​ if (percent % 5 == 0 && t.elapsed() > 1000) {
200 const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000); 262​ const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (t.elapsed() / 1000);
201 const qint64 estSecsLeft = (100 - percent) * t.elapsed() / percent / 1000; 263​ 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()); 264​
203 HelperSupport::progressStep(report); 265​ sendProgress(xi18nc("@info:progress", "Copying %1 MiB/second, estimated time left: %2", mibsPerSec, QTime(0, 0).addSecs(estSecsLeft).toString()));
266​
204 } 267​ }
205 HelperSupport::progressStep(percent); 268​ sendProgress(percent);
206 } 269​ }
207 } 270​ }
208 271​
209 // copy the remainder 272​ // copy the remainder
210 if (rval && lastBlock > 0) { 273​ if (rval && lastBlock > 0) {
211 Q_ASSERT(lastBlock < blockSize); 274​ Q_ASSERT(lastBlock < blockSize);
212 275​
213 const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte; 276​ const qint64 lastBlockReadOffset = copyDirection > 0 ? readOffset + blockSize * blocksCopied : sourceFirstByte;
214 const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte; 277​ const qint64 lastBlockWriteOffset = copyDirection > 0 ? writeOffset + blockSize * blocksCopied : targetFirstByte;
215 report[QStringLiteral("report")]= xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset); 278​
216 HelperSupport::progressStep(report); 279​ sendProgress(xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset));
280​
217 rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock); 281​ rval = readData(sourceDevice, buffer, lastBlockReadOffset, lastBlock);
218 282​
219 if (rval) { 283​ if (rval) {
220 if (targetDevice.isEmpty()) 284​ if (targetDevice.isEmpty())
221 reply[QStringLiteral("targetByteArray")] = buffer; 285​ reply[QStringLiteral("targetByteArray")] = buffer;
222 else 286​ else
223 rval = writeData(targetDevice, buffer, lastBlockWriteOffset); 287​ rval = writeData(targetDevice, buffer, lastBlockWriteOffset);
224 } 288​ }
225 289​
stikonasUnsubmitted
Done

Most of this code (except for asyncCall is the same in all cases).

It would make sense to factor it out into a separate function which might e.g. take an argument that is passed to emitNewData.

If you do just this you might still need two function (one for int overload that passed progress percents, one for the other call with QStrings).

It might be possible to unify it more but at leat do that...

stikonas: Most of this code (except for asyncCall is the same in all cases). It would make sense to…
226 if (rval) { 290​ if (rval) {
227 HelperSupport::progressStep(100); 291​ sendProgress(100);
228 bytesWritten += buffer.size(); 292​ bytesWritten += buffer.size();
229 } 293​ }
230 } 294​ }
231 295​
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)); 296​ sendProgress(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); ​
234 297​
235 reply[QStringLiteral("success")] = rval; 298​ reply[QStringLiteral("success")] = rval;
236 return reply; 299​ return reply;
237} 300​}
238 301​
239bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte) 302​bool ExternalCommandHelper::writeData(const QByteArray& buffer, const QString& targetDevice, const qint64 targetFirstByte)
240{ 303​{
241 // Do not allow using this helper for writing to arbitrary location 304​ // Do not allow using this helper for writing to arbitrary location
242 if ( targetDevice.left(5) != QStringLiteral("/dev/") && !targetDevice.contains(QStringLiteral("/etc/fstab"))) 305​ if ( targetDevice.left(5) != QStringLiteral("/dev/") && !targetDevice.contains(QStringLiteral("/etc/fstab")))
243 return false; 306​ return false;
244 307​
245 return writeData(targetDevice, buffer, targetFirstByte); 308​ return writeData(targetDevice, buffer, targetFirstByte);
246} 309​}
247 310​
248 ​
249QVariantMap ExternalCommandHelper::start(const QString& command, const QStringList& arguments, const QByteArray& input, const int processChannelMode) 311​QVariantMap ExternalCommandHelper::start(const QString& command, const QStringList& arguments, const QByteArray& input, const int processChannelMode)
250{ 312​{
251 QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8")); 313​ QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
252 QVariantMap reply; 314​ QVariantMap reply;
253 reply[QStringLiteral("success")] = true; 315​ reply[QStringLiteral("success")] = true;
254 316​
255 if (command.isEmpty()) { 317​ if (command.isEmpty()) {
256 reply[QStringLiteral("success")] = false; 318​ reply[QStringLiteral("success")] = false;
257 return reply; 319​ return reply;
258 } 320​ }
259 321​
260 // Compare with command whitelist 322​ // Compare with command whitelist
261 QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1); 323​ QString basename = command.mid(command.lastIndexOf(QLatin1Char('/')) + 1);
262 if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) { 324​ if (std::find(std::begin(allowedCommands), std::end(allowedCommands), basename) == std::end(allowedCommands)) {
263 qInfo() << command <<" command is not one of the whitelisted command"; 325​ qInfo() << command <<"Command is not one of the whitelisted command";
264 m_loop->exit(); 326​ m_loop->exit();
265 reply[QStringLiteral("success")] = false; 327​ reply[QStringLiteral("success")] = false;
266 return reply; 328​ return reply;
267 } 329​ }
268 330​
269// connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput); 331​// connect(&cmd, &QProcess::readyReadStandardOutput, this, &ExternalCommandHelper::onReadOutput);
270 332​
271 m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } ); 333​ m_cmd.setEnvironment( { QStringLiteral("LVM_SUPPRESS_FD_WARNINGS=1") } );
272 m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode)); 334​ m_cmd.setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(processChannelMode));
273 m_cmd.start(command, arguments); 335​ m_cmd.start(command, arguments);
274 m_cmd.write(input); 336​ m_cmd.write(input);
275 m_cmd.closeWriteChannel(); 337​ m_cmd.closeWriteChannel();
276 m_cmd.waitForFinished(-1); 338​ m_cmd.waitForFinished(-1);
339​
277 QByteArray output = m_cmd.readAllStandardOutput(); 340​ QByteArray output = m_cmd.readAllStandardOutput();
341​
278 reply[QStringLiteral("output")] = output; 342​ reply[QStringLiteral("output")] = output;
279 reply[QStringLiteral("exitCode")] = m_cmd.exitCode(); 343​ reply[QStringLiteral("exitCode")] = m_cmd.exitCode();
280 344​
281 return reply; 345​ return reply;
282} 346​}
283 347​
284void ExternalCommandHelper::exit() 348​void ExternalCommandHelper::exit()
285{ 349​{
286 m_loop->exit(); 350​ m_loop->exit();
287 351​
288 QDBusConnection::systemBus().unregisterObject(QStringLiteral("/Helper")); 352​ QDBusConnection::systemBus().unregisterObject(QStringLiteral("/Helper"));
289 QDBusConnection::systemBus().unregisterService(QStringLiteral("org.kde.kpmcore.helperinterface")); 353​ QDBusConnection::systemBus().unregisterService(QStringLiteral("org.kde.kpmcore.helperinterface"));
290} 354​}
291 355​
292void ExternalCommandHelper::onReadOutput() 356​/*void ExternalCommandHelper::onReadOutput()
293{ 357​{
294/* const QByteArray s = cmd.readAllStandardOutput(); 358​ const QByteArray s = cmd.readAllStandardOutput();
295 359​
296 if(output.length() > 10*1024*1024) { // prevent memory overflow for badly corrupted file systems 360​ if(output.length() > 10*1024*1024) { // prevent memory overflow for badly corrupted file systems
297 if (report()) 361​ if (report())
298 report()->line() << xi18nc("@info:status", "(Command is printing too much output)"); 362​ report()->line() << xi18nc("@info:status", "(Command is printing too much output)");
299 return; 363​ return;
300 } 364​ }
301 365​
302 output += s; 366​ output += s;
303 367​
304 if (report()) 368​ if (report())
305 *report() << QString::fromLocal8Bit(s);*/ 369​ *report() << QString::fromLocal8Bit(s);
306} 370​}*/
307 371​
308KAUTH_HELPER_MAIN("org.kde.kpmcore.externalcommand", ExternalCommandHelper) 372​HELPER_MAIN()