No OneTemporary
Actions

Size

106 KB

Subscribers

None

View Options

	diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
	index 769db1f0e..fe391c003 100644
	--- a/src/crypto/decryptverifytask.cpp
	+++ b/src/crypto/decryptverifytask.cpp
	@@ -1,1567 +1,1612 @@
	/* -- mode: c++; c-basic-offset:4 --
	decryptverifytask.cpp

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2008 Klarälvdalens Datakonsult AB

	Kleopatra 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 2 of the License, or
	(at your option) any later version.

	Kleopatra 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, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#include <config-kleopatra.h>

	#include "decryptverifytask.h"

	#include <QGpgME/Protocol>
	#include <QGpgME/VerifyOpaqueJob>
	#include <QGpgME/VerifyDetachedJob>
	#include <QGpgME/DecryptJob>
	#include <QGpgME/DecryptVerifyJob>

	#include <Libkleo/Dn>
	#include <Libkleo/Exception>
	#include <Libkleo/Stl_Util>
	#include <Libkleo/KeyCache>
	#include <Libkleo/Predicates>
	#include <Libkleo/Formatting>
	#include <Libkleo/Classify>

	#include <utils/detail_p.h>
	#include <utils/input.h>
	#include <utils/output.h>
	#include <utils/kleo_assert.h>
	#include <utils/auditlog.h>
	#include <utils/gnupg-helper.h>

	#include <kmime/kmime_header_parsing.h>

	#include <gpgme++/error.h>
	#include <gpgme++/key.h>
	#include <gpgme++/verificationresult.h>
	#include <gpgme++/decryptionresult.h>
	+#include <gpgme++/gpgmepp_version.h>
	+#include <gpgme++/context.h>

	#include <gpg-error.h>

	#include "kleopatra_debug.h"
	#include <KLocalizedString>
	#include <QLocale>

	#include <QByteArray>
	#include <QDateTime>
	#include <QStringList>
	#include <QTextDocument> // Qt::escape
	#include <QRegularExpression>

	#include <algorithm>
	#include <sstream>

	+#if GPGMEPP_VERSION > 0x10B01 // > 1.11.1
	+# define GPGME_HAS_LEGACY_NOMDC
	+#endif
	+
	using namespace Kleo::Crypto;
	using namespace Kleo;
	using namespace GpgME;
	using namespace KMime::Types;

	namespace
	{

	static Error make_error(const gpg_err_code_t code)
	{
	return Error(gpg_error(code));
	}

	static AuditLog auditLogFromSender(QObject *sender)
	{
	return AuditLog::fromJob(qobject_cast<const QGpgME::Job *>(sender));
	}

	static bool addrspec_equal(const AddrSpec &lhs, const AddrSpec &rhs, Qt::CaseSensitivity cs)
	{
	return lhs.localPart.compare(rhs.localPart, cs) == 0 && lhs.domain.compare(rhs.domain, Qt::CaseInsensitive) == 0;
	}

	static bool mailbox_equal(const Mailbox &lhs, const Mailbox &rhs, Qt::CaseSensitivity cs)
	{
	return addrspec_equal(lhs.addrSpec(), rhs.addrSpec(), cs);
	}

	static std::string stripAngleBrackets(const std::string &str)
	{
	if (str.empty()) {
	return str;
	}
	if (str[0] == '<' && str[str.size() - 1] == '>') {
	return str.substr(1, str.size() - 2);
	}
	return str;
	}

	static std::string email(const UserID &uid)
	{

	if (uid.parent().protocol() == OpenPGP) {
	if (const char *const email = uid.email()) {
	return stripAngleBrackets(email);
	} else {
	return std::string();
	}
	}

	Q_ASSERT(uid.parent().protocol() == CMS);

	if (const char *const id = uid.id())
	if (*id == '<') {
	return stripAngleBrackets(id);
	} else {
	return DN(id)[QStringLiteral("EMAIL")].trimmed().toUtf8().constData();
	}
	else {
	return std::string();
	}
	}

	static Mailbox mailbox(const UserID &uid)
	{
	const std::string e = email(uid);
	Mailbox mbox;
	if (!e.empty()) {
	mbox.setAddress(e.c_str());
	}
	return mbox;
	}

	static std::vector<Mailbox> extractMailboxes(const Key &key)
	{
	std::vector<Mailbox> res;
	Q_FOREACH (const UserID &id, key.userIDs()) {
	const Mailbox mbox = mailbox(id);
	if (!mbox.addrSpec().isEmpty()) {
	res.push_back(mbox);
	}
	}
	return res;
	}

	static std::vector<Mailbox> extractMailboxes(const std::vector<Key> &signers)
	{
	std::vector<Mailbox> res;
	for (const Key &i : signers) {
	const std::vector<Mailbox> bxs = extractMailboxes(i);
	res.insert(res.end(), bxs.begin(), bxs.end());
	}
	return res;
	}

	static bool keyContainsMailbox(const Key &key, const Mailbox &mbox)
	{
	const std::vector<Mailbox> mbxs = extractMailboxes(key);
	return std::find_if(mbxs.cbegin(), mbxs.cend(),
	[mbox](const Mailbox &m) {
	return mailbox_equal(mbox, m, Qt::CaseInsensitive);
	}) != mbxs.cend();
	}

	static bool keysContainMailbox(const std::vector<Key> &keys, const Mailbox &mbox)
	{
	return std::find_if(keys.cbegin(), keys.cend(),
	[mbox](const Key &key) {
	return keyContainsMailbox(key, mbox);
	}) != keys.cend();
	}

	static bool relevantInDecryptVerifyContext(const VerificationResult &r)
	{
	// for D/V operations, we ignore verification results which are not errors and contain
	// no signatures (which means that the data was just not signed)

	return (r.error() && r.error().code() != GPG_ERR_DECRYPT_FAILED) \|\| r.numSignatures() > 0;
	}

	static QString signatureSummaryToString(int summary)
	{
	if (summary & Signature::None) {
	return i18n("Error: Signature not verified");
	} else if (summary & Signature::Valid \|\| summary & Signature::Green) {
	return i18n("Good signature");
	} else if (summary & Signature::KeyRevoked) {
	return i18n("Signing certificate was revoked");
	} else if (summary & Signature::KeyExpired) {
	return i18n("Signing certificate is expired");
	} else if (summary & Signature::KeyMissing) {
	return i18n("Certificate is not available");
	} else if (summary & Signature::SigExpired) {
	return i18n("Signature expired");
	} else if (summary & Signature::CrlMissing) {
	return i18n("CRL missing");
	} else if (summary & Signature::CrlTooOld) {
	return i18n("CRL too old");
	} else if (summary & Signature::BadPolicy) {
	return i18n("Bad policy");
	} else if (summary & Signature::SysError) {
	return i18n("System error"); //### retrieve system error details?
	} else if (summary & Signature::Red) {
	return i18n("Bad signature");
	}return QString();
	}

	static QString formatValidSignatureWithTrustLevel(const UserID &id)
	{
	if (id.isNull()) {
	return QString();
	}
	switch (id.validity()) {
	case UserID::Marginal:
	return i18n("The signature is valid but the trust in the certificate's validity is only marginal.");
	case UserID::Full:
	return i18n("The signature is valid and the certificate's validity is fully trusted.");
	case UserID::Ultimate:
	return i18n("The signature is valid and the certificate's validity is ultimately trusted.");
	case UserID::Never:
	return i18n("The signature is valid but the certificate's validity is <em>not trusted</em>.");
	case UserID::Unknown:
	return i18n("The signature is valid but the certificate's validity is unknown.");
	case UserID::Undefined:
	default:
	return i18n("The signature is valid but the certificate's validity is undefined.");
	}
	}

	static QString renderFingerprint(const char *fpr)
	{
	if (!fpr) {
	return QString();
	}
	return QString::fromLatin1(fpr).toUpper().replace(QRegularExpression("(....)"), "\\1 ").trimmed();
	}

	static QString renderKeyLink(const QString &fpr, const QString &text)
	{
	return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(fpr, text);
	}

	static QString renderKey(const Key &key)
	{
	if (key.isNull()) {
	return i18n("Unknown certificate");
	}

	if (key.primaryFingerprint() && strlen(key.primaryFingerprint()) > 16 && key.numUserIDs()) {
	const QString text = QStringLiteral("%1 (%2)").arg(Formatting::prettyNameAndEMail(key).toHtmlEscaped()).arg(
	renderFingerprint(QString::fromLocal8Bit(key.primaryFingerprint()).right(16).toLatin1().constData()));
	return renderKeyLink(QLatin1String(key.primaryFingerprint()), text);
	}

	return renderKeyLink(QLatin1String(key.primaryFingerprint()), renderFingerprint(key.primaryFingerprint()));
	}

	static QString renderKeyEMailOnlyNameAsFallback(const Key &key)
	{
	if (key.isNull()) {
	return i18n("Unknown certificate");
	}
	const QString email = Formatting::prettyEMail(key);
	const QString user = !email.isEmpty() ? email : Formatting::prettyName(key);
	return renderKeyLink(QLatin1String(key.primaryFingerprint()), user);
	}

	static QString formatDate(const QDateTime &dt)
	{
	return QLocale().toString(dt);
	}
	static QString formatSigningInformation(const Signature &sig)
	{
	if (sig.isNull()) {
	return QString();
	}
	const QDateTime dt = sig.creationTime() != 0 ? QDateTime::fromTime_t(sig.creationTime()) : QDateTime();
	QString text;
	Key key = sig.key();
	if (dt.isValid()) {
	text = i18nc("1 is a date", "Signature created on %1", formatDate(dt)) + QStringLiteral("<br>");
	}
	if (key.isNull()) {
	return text += i18n("With unavailable certificate:") + QStringLiteral("<br>ID: 0x%1").arg(QString::fromLatin1(sig.fingerprint()).toUpper());
	}
	text += i18n("With certificate:") + QStringLiteral("<br>") + renderKey(key);

	if (Kleo::gpgComplianceP("de-vs")) {
	text +=
	(QStringLiteral("<br/>")
	+ (IS_DE_VS(sig)
	? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply. The string states that a signature is compliant with that.",
	"The signature is VS-NfD-compliant.")
	: i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply. The string states that a signature is not compliant with that.",
	"The signature <b>is not</b> VS-NfD-compliant.")));
	}

	return text;
	}

	static QString strikeOut(const QString &str, bool strike)
	{
	return QString(strike ? QStringLiteral("<s>%1</s>") : QStringLiteral("%1")).arg(str.toHtmlEscaped());
	}

	static QString formatInputOutputLabel(const QString &input, const QString &output, bool inputDeleted, bool outputDeleted)
	{
	if (output.isEmpty()) {
	return strikeOut(input, inputDeleted);
	}
	return i18nc("Input file --> Output file (rarr is arrow", "%1 → %2",
	strikeOut(input, inputDeleted),
	strikeOut(output, outputDeleted));
	}

	static bool IsErrorOrCanceled(const GpgME::Error &err)
	{
	return err \|\| err.isCanceled();
	}

	static bool IsErrorOrCanceled(const Result &res)
	{
	return IsErrorOrCanceled(res.error());
	}

	static bool IsBad(const Signature &sig)
	{
	return sig.summary() & Signature::Red;
	}

	static bool IsGoodOrValid(const Signature &sig)
	{
	return (sig.summary() & Signature::Valid) \|\| (sig.summary() & Signature::Green);
	}

	static UserID findUserIDByMailbox(const Key &key, const Mailbox &mbox)
	{
	Q_FOREACH (const UserID &id, key.userIDs())
	if (mailbox_equal(mailbox(id), mbox, Qt::CaseInsensitive)) {
	return id;
	}
	return UserID();
	}

	static void updateKeys(const VerificationResult &result) {
	// This little hack works around the problem that GnuPG / GpgME does not
	// provide Key information in a verification result. The Key object is
	// a dummy just holding the KeyID. This hack ensures that all available
	// keys are fetched from the backend and are populated
	for (const auto &sig: result.signatures()) {
	// Update key information
	sig.key(true, true);
	}
	}

	}

	class DecryptVerifyResult::SenderInfo
	{
	public:
	explicit SenderInfo(const Mailbox &infSender, const std::vector<Key> &signers_) : informativeSender(infSender), signers(signers_) {}
	const Mailbox informativeSender;
	const std::vector<Key> signers;
	bool hasInformativeSender() const
	{
	return !informativeSender.addrSpec().isEmpty();
	}
	bool conflicts() const
	{
	return hasInformativeSender() && hasKeys() && !keysContainMailbox(signers, informativeSender);
	}
	bool hasKeys() const
	{
	return std::any_of(signers.cbegin(), signers.cend(), [](const Key &key) { return !key.isNull(); });
	}
	std::vector<Mailbox> signerMailboxes() const
	{
	return extractMailboxes(signers);
	}
	};

	namespace
	{

	static Task::Result::VisualCode codeForVerificationResult(const VerificationResult &res)
	{
	if (res.isNull()) {
	return Task::Result::NeutralSuccess;
	}

	const std::vector<Signature> sigs = res.signatures();
	if (sigs.empty()) {
	return Task::Result::Warning;
	}

	if (std::find_if(sigs.begin(), sigs.end(), IsBad) != sigs.end()) {
	return Task::Result::Danger;
	}

	if ((size_t)std::count_if(sigs.begin(), sigs.end(), IsGoodOrValid) == sigs.size()) {
	return Task::Result::AllGood;
	}

	return Task::Result::Warning;
	}

	static QString formatVerificationResultOverview(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info)
	{
	if (res.isNull()) {
	return QString();
	}

	const Error err = res.error();

	if (err.isCanceled()) {
	return i18n("<b>Verification canceled.</b>");
	} else if (err) {
	return i18n("<b>Verification failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
	}

	const std::vector<Signature> sigs = res.signatures();

	if (sigs.empty()) {
	return i18n("<b>No signatures found.</b>");
	}

	const uint bad = std::count_if(sigs.cbegin(), sigs.cend(), IsBad);
	if (bad > 0) {
	return i18np("<b>Invalid signature.</b>", "<b>%1 invalid signatures.</b>", bad);
	}
	const uint warn = std::count_if(sigs.cbegin(), sigs.cend(), [](const Signature &sig) { return !IsGoodOrValid(sig); });
	if (warn == sigs.size()) {
	return i18np("<b>The data could not be verified.</b>", "<b>%1 signatures could not be verified.</b>", warn);
	}

	//Good signature:
	QString text;
	if (sigs.size() == 1) {
	text = i18n("<b>Valid signature by %1</b>", renderKeyEMailOnlyNameAsFallback(sigs[0].key()));
	if (info.conflicts())
	text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the %1 used for signing.",
	renderKeyLink(QLatin1String(sigs[0].key().primaryFingerprint()), i18n("certificate")));
	} else {
	text = i18np("<b>Valid signature.</b>", "<b>%1 valid signatures.</b>", sigs.size());
	if (info.conflicts()) {
	text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the certificates used for signing.");
	}
	}

	return text;
	}

	static QString formatDecryptionResultOverview(const DecryptionResult &result, const QString &errorString = QString())
	{
	const Error err = result.error();

	if (err.isCanceled()) {
	return i18n("<b>Decryption canceled.</b>");
	- } else if (!errorString.isEmpty()) {
	+ }
	+#ifdef GPGME_HAS_LEGACY_NOMDC
	+ else if (result.isLegacyCipherNoMDC()) {
	+ return i18n("<b>Decryption failed: %1.</b>", i18n("No integrity protection (MDC)."));
	+ }
	+#endif
	+ else if (!errorString.isEmpty()) {
	return i18n("<b>Decryption failed: %1.</b>", errorString.toHtmlEscaped());
	} else if (err) {
	return i18n("<b>Decryption failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
	}
	return i18n("<b>Decryption succeeded.</b>");
	}

	static QString formatSignature(const Signature &sig, const DecryptVerifyResult::SenderInfo &info)
	{
	if (sig.isNull()) {
	return QString();
	}

	const QString text = formatSigningInformation(sig) + QLatin1String("<br/>");
	const Key key = sig.key();

	// Green
	if (sig.summary() & Signature::Valid) {
	const UserID id = findUserIDByMailbox(key, info.informativeSender);
	return text + formatValidSignatureWithTrustLevel(!id.isNull() ? id : key.userID(0));
	}

	// Red
	if ((sig.summary() & Signature::Red)) {
	const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
	if (sig.summary() & Signature::SysError) {
	return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
	}
	return ret;
	}

	// Key missing
	if ((sig.summary() & Signature::KeyMissing)) {
	return text + i18n("You can search the certificate on a keyserver or import it from a file.");
	}

	// Yellow
	if ((sig.validity() & Signature::Validity::Undefined) \|\|
	(sig.validity() & Signature::Validity::Unknown) \|\|
	(sig.summary() == Signature::Summary::None)) {
	return text + (key.protocol() == OpenPGP ? i18n("The used key is not certified by you or any trusted person.") :
	i18n("The used certificate is not certified by a trustworthy Certificate Authority or the Certificate Authority is unknown."));
	}

	// Catch all fall through
	const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
	if (sig.summary() & Signature::SysError) {
	return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
	}
	return ret;
	}

	static QStringList format(const std::vector<Mailbox> &mbxs)
	{
	QStringList res;
	std::transform(mbxs.cbegin(), mbxs.cend(), std::back_inserter(res),
	[](const Mailbox &mbox) {
	return mbox.prettyAddress();
	});
	return res;
	}

	static QString formatVerificationResultDetails(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info, const QString &errorString)
	{
	if ((res.error().code() == GPG_ERR_EIO \|\| res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	return i18n("Input error: %1", errorString);
	}

	const std::vector<Signature> sigs = res.signatures();
	QString details;
	for (const Signature &sig : sigs) {
	details += formatSignature(sig, info) + QLatin1Char('\n');
	}
	details = details.trimmed();
	details.replace(QLatin1Char('\n'), QStringLiteral("<br/><br/>"));
	if (info.conflicts()) {
	details += i18n("<p>The sender's address %1 is not stored in the certificate. Stored: %2</p>", info.informativeSender.prettyAddress(), format(info.signerMailboxes()).join(i18nc("separator for a list of e-mail addresses", ", ")));
	}
	return details;
	}

	static QString formatDecryptionResultDetails(const DecryptionResult &res, const std::vector<Key> &recipients, const QString &errorString, bool isSigned)
	{
	QString details;

	if ((res.error().code() == GPG_ERR_EIO \|\| res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	return i18n("Input error: %1", errorString);
	}

	if (Kleo::gpgComplianceP("de-vs")) {
	details += ((IS_DE_VS(res)
	? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply. The string states that the decryption is compliant with that.",
	"The decryption is VS-NfD-compliant.")
	: i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply. The string states that the decryption is compliant with that.",
	"The decryption <b>is not</b> VS-NfD-compliant."))
	+ QStringLiteral("<br/>"));
	}

	if (res.isNull() \|\| !res.error() \|\| res.error().isCanceled()) {
	if (!isSigned) {
	return details + i18n("<b>Note:</b> You cannot be sure who encrypted this message as it is not signed.");
	}
	return details;
	}

	if (recipients.empty() && res.numRecipients() > 0) {
	return details + QLatin1String("<i>") + i18np("One unknown recipient.", "%1 unknown recipients.", res.numRecipients()) + QLatin1String("</i>");
	}

	+#ifdef GPGME_HAS_LEGACY_NOMDC
	+ if (res.isLegacyCipherNoMDC()) {
	+ details += i18nc("Integrity protection (Efail attack possibility) was missing because an old cipher was used.",
	+ "<b>Hint:</b> If this file was encrypted before the year 2003 it is "
	+ "likely that the file is legitimate. This is because back "
	+ "then integrity protection was not widely used.") + QStringLiteral("<br/><br/>") +
	+ i18nc("The user is offered to force decrypt a non integrity protected message. With the strong advice to re-encrypt it.",
	+ "If you are confident that the file was not manipulated you should re-encrypt it after you have forced the decryption.") +
	+ QStringLiteral("<br/><br/>");
	+ }
	+#endif
	+
	if (!recipients.empty()) {
	details += i18np("Recipient:", "Recipients:", res.numRecipients());
	if (res.numRecipients() == 1) {
	- return details + renderKey(recipients.front());
	+ return details + QLatin1Char(' ') + renderKey(recipients.front());
	}

	details += QLatin1String("<ul>");
	for (const Key &key : recipients) {
	details += QLatin1String("<li>") + renderKey(key) + QLatin1String("</li>");
	}
	if (recipients.size() < res.numRecipients())
	details += QLatin1String("<li><i>") + i18np("One unknown recipient", "%1 unknown recipients",
	res.numRecipients() - recipients.size()) + QLatin1String("</i></li>");

	details += QLatin1String("</ul>");
	}

	return details;
	}

	static QString formatDecryptVerifyResultOverview(const DecryptionResult &dr, const VerificationResult &vr, const DecryptVerifyResult::SenderInfo &info)
	{
	if (IsErrorOrCanceled(dr) \|\| !relevantInDecryptVerifyContext(vr)) {
	return formatDecryptionResultOverview(dr);
	}
	return formatVerificationResultOverview(vr, info);
	}

	static QString formatDecryptVerifyResultDetails(const DecryptionResult &dr,
	const VerificationResult &vr,
	const std::vector<Key> &recipients,
	const DecryptVerifyResult::SenderInfo &info,
	const QString &errorString)
	{
	const QString drDetails = formatDecryptionResultDetails(dr, recipients, errorString, relevantInDecryptVerifyContext(vr));
	if (IsErrorOrCanceled(dr) \|\| !relevantInDecryptVerifyContext(vr)) {
	return drDetails;
	}
	return drDetails + (drDetails.isEmpty() ? QString() : QStringLiteral("<br/>")) + formatVerificationResultDetails(vr, info, errorString);
	}

	} // anon namespace

	class DecryptVerifyResult::Private
	{
	DecryptVerifyResult *const q;
	public:
	Private(DecryptVerifyOperation type,
	const VerificationResult &vr,
	const DecryptionResult &dr,
	const QByteArray &stuff,
	int errCode,
	const QString &errString,
	const QString &input,
	const QString &output,
	const AuditLog &auditLog,
	Task *parentTask,
	const Mailbox &informativeSender,
	DecryptVerifyResult *qq) :
	q(qq),
	m_type(type),
	m_verificationResult(vr),
	m_decryptionResult(dr),
	m_stuff(stuff),
	m_error(errCode),
	m_errorString(errString),
	m_inputLabel(input),
	m_outputLabel(output),
	m_auditLog(auditLog),
	m_parentTask(QPointer<Task>(parentTask)),
	m_informativeSender(informativeSender)
	{
	}

	QString label() const
	{
	return formatInputOutputLabel(m_inputLabel, m_outputLabel, false, q->hasError());
	}

	DecryptVerifyResult::SenderInfo makeSenderInfo() const;

	bool isDecryptOnly() const
	{
	return m_type == Decrypt;
	}
	bool isVerifyOnly() const
	{
	return m_type == Verify;
	}
	bool isDecryptVerify() const
	{
	return m_type == DecryptVerify;
	}
	DecryptVerifyOperation m_type;
	VerificationResult m_verificationResult;
	DecryptionResult m_decryptionResult;
	QByteArray m_stuff;
	int m_error;
	QString m_errorString;
	QString m_inputLabel;
	QString m_outputLabel;
	const AuditLog m_auditLog;
	QPointer <Task> m_parentTask;
	const Mailbox m_informativeSender;
	};

	DecryptVerifyResult::SenderInfo DecryptVerifyResult::Private::makeSenderInfo() const
	{
	return SenderInfo(m_informativeSender, KeyCache::instance()->findSigners(m_verificationResult));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const DecryptionResult &dr, const QByteArray &plaintext, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Decrypt,
	VerificationResult(),
	dr,
	plaintext,
	0,
	QString(),
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const GpgME::Error &err, const QString &what, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Decrypt,
	VerificationResult(),
	DecryptionResult(err),
	QByteArray(),
	err.code(),
	what,
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
	{
	int err = dr.error() ? dr.error().code() : vr.error().code();
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	DecryptVerify,
	vr,
	dr,
	plaintext,
	err,
	QString(),
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	DecryptVerify,
	VerificationResult(),
	DecryptionResult(err),
	QByteArray(),
	err.code(),
	details,
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Verify,
	vr,
	DecryptionResult(),
	plaintext,
	0,
	QString(),
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}
	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Verify,
	VerificationResult(err),
	DecryptionResult(),
	QByteArray(),
	err.code(),
	details,
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const VerificationResult &vr, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Verify,
	vr,
	DecryptionResult(),
	QByteArray(),
	0,
	QString(),
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}
	std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
	Verify,
	VerificationResult(err),
	DecryptionResult(),
	QByteArray(),
	err.code(),
	details,
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

	DecryptVerifyResult::DecryptVerifyResult(DecryptVerifyOperation type,
	const VerificationResult &vr,
	const DecryptionResult &dr,
	const QByteArray &stuff,
	int errCode,
	const QString &errString,
	const QString &inputLabel,
	const QString &outputLabel,
	const AuditLog &auditLog,
	Task *parentTask,
	const Mailbox &informativeSender)
	: Task::Result(), d(new Private(type, vr, dr, stuff, errCode, errString, inputLabel, outputLabel, auditLog, parentTask, informativeSender, this))
	{
	}

	QString DecryptVerifyResult::overview() const
	{
	QString ov;
	if (d->isDecryptOnly()) {
	ov += formatDecryptionResultOverview(d->m_decryptionResult);
	} else if (d->isVerifyOnly()) {
	ov += formatVerificationResultOverview(d->m_verificationResult, d->makeSenderInfo());
	} else {
	ov += formatDecryptVerifyResultOverview(d->m_decryptionResult, d->m_verificationResult, d->makeSenderInfo());
	}
	if (ov.size() + d->label().size() > 120) {
	// Avoid ugly breaks
	ov = QStringLiteral("<br>") + ov;
	}
	return i18nc("label: result example: foo.sig: Verification failed. ", "%1: %2", d->label(), ov);
	}

	QString DecryptVerifyResult::details() const
	{
	if (d->isDecryptOnly()) {
	return formatDecryptionResultDetails(d->m_decryptionResult, KeyCache::instance()->findRecipients(d->m_decryptionResult), errorString(), false);
	}
	if (d->isVerifyOnly()) {
	return formatVerificationResultDetails(d->m_verificationResult, d->makeSenderInfo(), errorString());
	}
	return formatDecryptVerifyResultDetails(d->m_decryptionResult,
	d->m_verificationResult, KeyCache::instance()->findRecipients(
	d->m_decryptionResult), d->makeSenderInfo(), errorString());
	}

	bool DecryptVerifyResult::hasError() const
	{
	return d->m_error != 0;
	}

	int DecryptVerifyResult::errorCode() const
	{
	return d->m_error;
	}

	QString DecryptVerifyResult::errorString() const
	{
	return d->m_errorString;
	}

	AuditLog DecryptVerifyResult::auditLog() const
	{
	return d->m_auditLog;
	}

	QPointer<Task> DecryptVerifyResult::parentTask() const
	{
	return d->m_parentTask;
	}

	Task::Result::VisualCode DecryptVerifyResult::code() const
	{
	if ((d->m_type == DecryptVerify \|\| d->m_type == Verify) && relevantInDecryptVerifyContext(verificationResult())) {
	return codeForVerificationResult(verificationResult());
	}
	return hasError() ? NeutralError : NeutralSuccess;
	}

	GpgME::VerificationResult DecryptVerifyResult::verificationResult() const
	{
	return d->m_verificationResult;
	}

	GpgME::DecryptionResult DecryptVerifyResult::decryptionResult() const
	{
	return d->m_decryptionResult;
	}

	class AbstractDecryptVerifyTask::Private
	{
	public:
	Mailbox informativeSender;
	};

	AbstractDecryptVerifyTask::AbstractDecryptVerifyTask(QObject *parent) : Task(parent), d(new Private) {}

	AbstractDecryptVerifyTask::~AbstractDecryptVerifyTask() {}

	Mailbox AbstractDecryptVerifyTask::informativeSender() const
	{
	return d->informativeSender;
	}

	void AbstractDecryptVerifyTask::setInformativeSender(const Mailbox &sender)
	{
	d->informativeSender = sender;
	}

	class DecryptVerifyTask::Private
	{
	DecryptVerifyTask *const q;
	public:
	- explicit Private(DecryptVerifyTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}
	+ explicit Private(DecryptVerifyTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol), m_ignoreMDCError(false) {}

	void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray &);

	void registerJob(QGpgME::DecryptVerifyJob *job)
	{
	q->connect(job, SIGNAL(result(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)),
	q, SLOT(slotResult(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)));
	q->connect(job, SIGNAL(progress(QString,int,int)),
	q, SLOT(setProgress(QString,int,int)));
	}

	void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);

	std::shared_ptr<Input> m_input;
	std::shared_ptr<Output> m_output;
	const QGpgME::Protocol *m_backend;
	Protocol m_protocol;
	+ bool m_ignoreMDCError;
	};

	void DecryptVerifyTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
	{
	q->emitResult(result);
	Q_EMIT q->decryptVerifyResult(result);
	}

	void DecryptVerifyTask::Private::slotResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plainText)
	{
	updateKeys(vr);
	{
	std::stringstream ss;
	ss << dr << '\n' << vr;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLog auditLog = auditLogFromSender(q->sender());
	if (dr.error().code() \|\| vr.error().code()) {
	m_output->cancel();
	} else {
	try {
	kleo_assert(!dr.isNull() \|\| !vr.isNull());
	m_output->finalize();
	} catch (const GpgME::Exception &e) {
	emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	return;
	}
	}
	const int drErr = dr.error().code();
	const QString errorString = m_output->errorString();
	if ((drErr == GPG_ERR_EIO \|\| drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	emitResult(q->fromDecryptResult(dr.error(), errorString, auditLog));
	return;
	}

	emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, auditLog));
	}

	DecryptVerifyTask::DecryptVerifyTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
	{
	}

	DecryptVerifyTask::~DecryptVerifyTask()
	{
	}

	void DecryptVerifyTask::setInput(const std::shared_ptr<Input> &input)
	{
	d->m_input = input;
	kleo_assert(d->m_input && d->m_input->ioDevice());
	}

	void DecryptVerifyTask::setOutput(const std::shared_ptr<Output> &output)
	{
	d->m_output = output;
	kleo_assert(d->m_output && d->m_output->ioDevice());
	}

	void DecryptVerifyTask::setProtocol(Protocol prot)
	{
	kleo_assert(prot != UnknownProtocol);
	d->m_protocol = prot;
	d->m_backend = prot == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(d->m_backend);
	}

	void DecryptVerifyTask::autodetectProtocolFromInput()
	{
	if (!d->m_input) {
	return;
	}
	const Protocol p = findProtocol(d->m_input->classification());
	if (p == UnknownProtocol) {
	throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature/ciphertext - maybe it is neither ciphertext nor a signature?"), Exception::MessageOnly);
	}
	setProtocol(p);
	}

	QString DecryptVerifyTask::label() const
	{
	return i18n("Decrypting: %1...", d->m_input->label());
	}

	unsigned long long DecryptVerifyTask::inputSize() const
	{
	return d->m_input ? d->m_input->size() : 0;
	}

	QString DecryptVerifyTask::inputLabel() const
	{
	return d->m_input ? d->m_input->label() : QString();
	}

	QString DecryptVerifyTask::outputLabel() const
	{
	return d->m_output ? d->m_output->label() : QString();
	}

	Protocol DecryptVerifyTask::protocol() const
	{
	return d->m_protocol;
	}

	void DecryptVerifyTask::cancel()
	{

	}

	static void ensureIOOpen(QIODevice input, QIODevice output)
	{
	if (input && !input->isOpen()) {
	input->open(QIODevice::ReadOnly);
	}
	if (output && !output->isOpen()) {
	output->open(QIODevice::WriteOnly);
	}
	}

	+void DecryptVerifyTask::setIgnoreMDCError(bool value)
	+{
	+ d->m_ignoreMDCError = value;
	+}
	+
	void DecryptVerifyTask::doStart()
	{
	kleo_assert(d->m_backend);
	try {
	QGpgME::DecryptVerifyJob *const job = d->m_backend->decryptVerifyJob();
	+
	+#ifdef GPGME_HAS_LEGACY_NOMDC
	+ if (d->m_ignoreMDCError) {
	+ qCDebug(KLEOPATRA_LOG) << "Modifying job to ignore MDC errors.";
	+ auto ctx = QGpgME::Job::context(job);
	+ if (!ctx) {
	+ qCWarning(KLEOPATRA_LOG) << "Failed to get context for job";
	+ } else {
	+ const auto err = ctx->setFlag("ignore-mdc-error", "1");
	+ if (err) {
	+ qCWarning(KLEOPATRA_LOG) << "Failed to set ignore mdc errors" << err.asString();
	+ }
	+ }
	+ }
	+#endif
	kleo_assert(job);
	d->registerJob(job);
	ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
	job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
	} catch (const GpgME::Exception &e) {
	d->emitResult(fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
	} catch (const std::exception &e) {
	d->emitResult(fromDecryptVerifyResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
	} catch (...) {
	d->emitResult(fromDecryptVerifyResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
	}

	}

	class DecryptTask::Private
	{
	DecryptTask *const q;
	public:
	explicit Private(DecryptTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}

	void slotResult(const DecryptionResult &, const QByteArray &);

	void registerJob(QGpgME::DecryptJob *job)
	{
	q->connect(job, SIGNAL(result(GpgME::DecryptionResult,QByteArray)),
	q, SLOT(slotResult(GpgME::DecryptionResult,QByteArray)));
	q->connect(job, SIGNAL(progress(QString,int,int)),
	q, SLOT(setProgress(QString,int,int)));
	}

	void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);

	std::shared_ptr<Input> m_input;
	std::shared_ptr<Output> m_output;
	const QGpgME::Protocol *m_backend;
	Protocol m_protocol;
	};

	void DecryptTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
	{
	q->emitResult(result);
	Q_EMIT q->decryptVerifyResult(result);
	}

	void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
	{
	{
	std::stringstream ss;
	ss << result;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLog auditLog = auditLogFromSender(q->sender());
	if (result.error().code()) {
	m_output->cancel();
	} else {
	try {
	kleo_assert(!result.isNull());
	m_output->finalize();
	} catch (const GpgME::Exception &e) {
	emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	return;
	}
	}

	const int drErr = result.error().code();
	const QString errorString = m_output->errorString();
	if ((drErr == GPG_ERR_EIO \|\| drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	emitResult(q->fromDecryptResult(result.error(), errorString, auditLog));
	return;
	}

	emitResult(q->fromDecryptResult(result, plainText, auditLog));
	}

	DecryptTask::DecryptTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
	{
	}

	DecryptTask::~DecryptTask()
	{
	}

	void DecryptTask::setInput(const std::shared_ptr<Input> &input)
	{
	d->m_input = input;
	kleo_assert(d->m_input && d->m_input->ioDevice());
	}

	void DecryptTask::setOutput(const std::shared_ptr<Output> &output)
	{
	d->m_output = output;
	kleo_assert(d->m_output && d->m_output->ioDevice());
	}

	void DecryptTask::setProtocol(Protocol prot)
	{
	kleo_assert(prot != UnknownProtocol);
	d->m_protocol = prot;
	d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(d->m_backend);
	}

	void DecryptTask::autodetectProtocolFromInput()
	{
	if (!d->m_input) {
	return;
	}
	const Protocol p = findProtocol(d->m_input->classification());
	if (p == UnknownProtocol) {
	throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this was S/MIME- or OpenPGP-encrypted - maybe it is not ciphertext at all?"), Exception::MessageOnly);
	}
	setProtocol(p);
	}

	QString DecryptTask::label() const
	{
	return i18n("Decrypting: %1...", d->m_input->label());
	}

	unsigned long long DecryptTask::inputSize() const
	{
	return d->m_input ? d->m_input->size() : 0;
	}

	QString DecryptTask::inputLabel() const
	{
	return d->m_input ? d->m_input->label() : QString();
	}

	QString DecryptTask::outputLabel() const
	{
	return d->m_output ? d->m_output->label() : QString();
	}

	Protocol DecryptTask::protocol() const
	{
	kleo_assert(!"not implemented");
	return UnknownProtocol; // ### TODO
	}

	void DecryptTask::cancel()
	{

	}

	void DecryptTask::doStart()
	{
	kleo_assert(d->m_backend);

	try {
	QGpgME::DecryptJob *const job = d->m_backend->decryptJob();
	kleo_assert(job);
	d->registerJob(job);
	ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
	job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
	} catch (const GpgME::Exception &e) {
	d->emitResult(fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
	} catch (const std::exception &e) {
	d->emitResult(fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
	} catch (...) {
	d->emitResult(fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
	}
	}

	class VerifyOpaqueTask::Private
	{
	VerifyOpaqueTask *const q;
	public:
	explicit Private(VerifyOpaqueTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}

	void slotResult(const VerificationResult &, const QByteArray &);

	void registerJob(QGpgME::VerifyOpaqueJob *job)
	{
	q->connect(job, SIGNAL(result(GpgME::VerificationResult,QByteArray)),
	q, SLOT(slotResult(GpgME::VerificationResult,QByteArray)));
	q->connect(job, SIGNAL(progress(QString,int,int)),
	q, SLOT(setProgress(QString,int,int)));
	}

	void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);

	std::shared_ptr<Input> m_input;
	std::shared_ptr<Output> m_output;
	const QGpgME::Protocol *m_backend;
	Protocol m_protocol;
	};

	void VerifyOpaqueTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
	{
	q->emitResult(result);
	Q_EMIT q->decryptVerifyResult(result);
	}

	void VerifyOpaqueTask::Private::slotResult(const VerificationResult &result, const QByteArray &plainText)
	{
	updateKeys(result);
	{
	std::stringstream ss;
	ss << result;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLog auditLog = auditLogFromSender(q->sender());
	if (result.error().code()) {
	m_output->cancel();
	} else {
	try {
	kleo_assert(!result.isNull());
	m_output->finalize();
	} catch (const GpgME::Exception &e) {
	emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	return;
	}
	}

	const int drErr = result.error().code();
	const QString errorString = m_output->errorString();
	if ((drErr == GPG_ERR_EIO \|\| drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	emitResult(q->fromDecryptResult(result.error(), errorString, auditLog));
	return;
	}

	emitResult(q->fromVerifyOpaqueResult(result, plainText, auditLog));
	}

	VerifyOpaqueTask::VerifyOpaqueTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
	{
	}

	VerifyOpaqueTask::~VerifyOpaqueTask()
	{
	}

	void VerifyOpaqueTask::setInput(const std::shared_ptr<Input> &input)
	{
	d->m_input = input;
	kleo_assert(d->m_input && d->m_input->ioDevice());
	}

	void VerifyOpaqueTask::setOutput(const std::shared_ptr<Output> &output)
	{
	d->m_output = output;
	kleo_assert(d->m_output && d->m_output->ioDevice());
	}

	void VerifyOpaqueTask::setProtocol(Protocol prot)
	{
	kleo_assert(prot != UnknownProtocol);
	d->m_protocol = prot;
	d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(d->m_backend);
	}

	void VerifyOpaqueTask::autodetectProtocolFromInput()
	{
	if (!d->m_input) {
	return;
	}
	const Protocol p = findProtocol(d->m_input->classification());
	if (p == UnknownProtocol) {
	throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
	}
	setProtocol(p);
	}

	QString VerifyOpaqueTask::label() const
	{
	return i18n("Verifying: %1...", d->m_input->label());
	}

	unsigned long long VerifyOpaqueTask::inputSize() const
	{
	return d->m_input ? d->m_input->size() : 0;
	}

	QString VerifyOpaqueTask::inputLabel() const
	{
	return d->m_input ? d->m_input->label() : QString();
	}

	QString VerifyOpaqueTask::outputLabel() const
	{
	return d->m_output ? d->m_output->label() : QString();
	}

	Protocol VerifyOpaqueTask::protocol() const
	{
	return d->m_protocol;
	}

	void VerifyOpaqueTask::cancel()
	{

	}

	void VerifyOpaqueTask::doStart()
	{
	kleo_assert(d->m_backend);

	try {
	QGpgME::VerifyOpaqueJob *const job = d->m_backend->verifyOpaqueJob();
	kleo_assert(job);
	d->registerJob(job);
	ensureIOOpen(d->m_input->ioDevice().get(), d->m_output ? d->m_output->ioDevice().get() : nullptr);
	job->start(d->m_input->ioDevice(), d->m_output ? d->m_output->ioDevice() : std::shared_ptr<QIODevice>());
	} catch (const GpgME::Exception &e) {
	d->emitResult(fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
	} catch (const std::exception &e) {
	d->emitResult(fromVerifyOpaqueResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
	} catch (...) {
	d->emitResult(fromVerifyOpaqueResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
	}
	}

	class VerifyDetachedTask::Private
	{
	VerifyDetachedTask *const q;
	public:
	explicit Private(VerifyDetachedTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}

	void slotResult(const VerificationResult &);

	void registerJob(QGpgME::VerifyDetachedJob *job)
	{
	q->connect(job, SIGNAL(result(GpgME::VerificationResult)),
	q, SLOT(slotResult(GpgME::VerificationResult)));
	q->connect(job, SIGNAL(progress(QString,int,int)),
	q, SLOT(setProgress(QString,int,int)));
	}

	void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);

	std::shared_ptr<Input> m_input, m_signedData;
	const QGpgME::Protocol *m_backend;
	Protocol m_protocol;
	};

	void VerifyDetachedTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
	{
	q->emitResult(result);
	Q_EMIT q->decryptVerifyResult(result);
	}

	void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
	{
	updateKeys(result);
	{
	std::stringstream ss;
	ss << result;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLog auditLog = auditLogFromSender(q->sender());
	try {
	kleo_assert(!result.isNull());
	emitResult(q->fromVerifyDetachedResult(result, auditLog));
	} catch (const GpgME::Exception &e) {
	emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	} catch (const std::exception &e) {
	emitResult(q->fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	} catch (...) {
	emitResult(q->fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	}
	}

	VerifyDetachedTask::VerifyDetachedTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
	{
	}

	VerifyDetachedTask::~VerifyDetachedTask()
	{
	}

	void VerifyDetachedTask::setInput(const std::shared_ptr<Input> &input)
	{
	d->m_input = input;
	kleo_assert(d->m_input && d->m_input->ioDevice());
	}

	void VerifyDetachedTask::setSignedData(const std::shared_ptr<Input> &signedData)
	{
	d->m_signedData = signedData;
	kleo_assert(d->m_signedData && d->m_signedData->ioDevice());
	}

	void VerifyDetachedTask::setProtocol(Protocol prot)
	{
	kleo_assert(prot != UnknownProtocol);
	d->m_protocol = prot;
	d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(d->m_backend);
	}

	void VerifyDetachedTask::autodetectProtocolFromInput()
	{
	if (!d->m_input) {
	return;
	}
	const Protocol p = findProtocol(d->m_input->classification());
	if (p == UnknownProtocol) {
	throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
	}
	setProtocol(p);
	}

	unsigned long long VerifyDetachedTask::inputSize() const
	{
	return d->m_signedData ? d->m_signedData->size() : 0;
	}

	QString VerifyDetachedTask::label() const
	{
	if (d->m_signedData) {
	return xi18nc("Verification of a detached signature in progress. The first file contains the data."
	"The second file is the signature file.",
	"Verifying: <filename>%1</filename> with <filename>%2</filename>...",
	d->m_signedData->label(),
	d->m_input->label());

	}
	return i18n("Verifying signature: %1...", d->m_input->label());
	}

	QString VerifyDetachedTask::inputLabel() const
	{
	if (d->m_signedData && d->m_input) {
	return xi18nc("Verification of a detached signature summary. The first file contains the data."
	"The second file is signature.",
	"Verified <filename>%1</filename> with <filename>%2</filename>",
	d->m_signedData->label(),
	d->m_input->label());

	}
	return d->m_input ? d->m_input->label() : QString();
	}

	QString VerifyDetachedTask::outputLabel() const
	{
	return QString();
	}

	Protocol VerifyDetachedTask::protocol() const
	{
	kleo_assert(!"not implemented");
	return UnknownProtocol; // ### TODO
	}

	void VerifyDetachedTask::cancel()
	{

	}

	void VerifyDetachedTask::doStart()
	{
	kleo_assert(d->m_backend);
	try {
	QGpgME::VerifyDetachedJob *const job = d->m_backend->verifyDetachedJob();
	kleo_assert(job);
	d->registerJob(job);
	ensureIOOpen(d->m_input->ioDevice().get(), nullptr);
	ensureIOOpen(d->m_signedData->ioDevice().get(), nullptr);
	job->start(d->m_input->ioDevice(), d->m_signedData->ioDevice());
	} catch (const GpgME::Exception &e) {
	d->emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
	} catch (const std::exception &e) {
	d->emitResult(fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
	} catch (...) {
	d->emitResult(fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
	}
	}

	#include "moc_decryptverifytask.cpp"
	diff --git a/src/crypto/decryptverifytask.h b/src/crypto/decryptverifytask.h
	index ff87cdb50..d413057b2 100644
	--- a/src/crypto/decryptverifytask.h
	+++ b/src/crypto/decryptverifytask.h
	@@ -1,278 +1,280 @@
	/* -- mode: c++; c-basic-offset:4 --
	decryptverifytask.h

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2008 Klarälvdalens Datakonsult AB

	Kleopatra 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 2 of the License, or
	(at your option) any later version.

	Kleopatra 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, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#ifndef __KLEOPATRA_CRYPTO_DECRYPTVERIFYTASK_H__
	#define __KLEOPATRA_CRYPTO_DECRYPTVERIFYTASK_H__

	#include "task.h"

	#include <utils/types.h>

	#include <gpgme++/verificationresult.h>

	#include <memory>

	namespace KMime
	{
	namespace Types
	{
	class Mailbox;
	}
	}
	namespace GpgME
	{
	class DecryptionResult;
	class VerificationResult;
	class Key;
	class Signature;
	}

	namespace Kleo
	{
	class Input;
	class Output;
	class AuditLog;
	}

	namespace Kleo
	{
	namespace Crypto
	{

	class DecryptVerifyResult;

	class AbstractDecryptVerifyTask : public Task
	{
	Q_OBJECT
	public:
	explicit AbstractDecryptVerifyTask(QObject *parent = nullptr);
	virtual ~AbstractDecryptVerifyTask();
	virtual void autodetectProtocolFromInput() = 0;

	KMime::Types::Mailbox informativeSender() const;
	void setInformativeSender(const KMime::Types::Mailbox &senders);

	Q_SIGNALS:
	void decryptVerifyResult(const std::shared_ptr<const Kleo::Crypto::DecryptVerifyResult> &);

	protected:
	std::shared_ptr<DecryptVerifyResult> fromDecryptResult(const GpgME::DecryptionResult &dr, const QByteArray &plaintext, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromDecryptResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromDecryptVerifyResult(const GpgME::DecryptionResult &dr, const GpgME::VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromDecryptVerifyResult(const GpgME::Error &err, const QString &what, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromVerifyOpaqueResult(const GpgME::VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromVerifyDetachedResult(const GpgME::VerificationResult &vr, const AuditLog &auditLog);
	std::shared_ptr<DecryptVerifyResult> fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog);

	virtual QString inputLabel() const = 0;
	virtual QString outputLabel() const = 0;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	};

	class DecryptTask : public AbstractDecryptVerifyTask
	{
	Q_OBJECT
	public:
	explicit DecryptTask(QObject *parent = nullptr);
	~DecryptTask() override;

	void setInput(const std::shared_ptr<Input> &input);
	void setOutput(const std::shared_ptr<Output> &output);

	void setProtocol(GpgME::Protocol prot);
	void autodetectProtocolFromInput() override;

	QString label() const override;

	GpgME::Protocol protocol() const override;

	public Q_SLOTS:
	void cancel() override;

	private:
	void doStart() override;
	QString inputLabel() const override;
	QString outputLabel() const override;
	unsigned long long inputSize() const override;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	Q_PRIVATE_SLOT(d, void slotResult(GpgME::DecryptionResult, QByteArray))
	};

	class VerifyDetachedTask : public AbstractDecryptVerifyTask
	{
	Q_OBJECT
	public:
	explicit VerifyDetachedTask(QObject *parent = nullptr);
	~VerifyDetachedTask() override;

	void setInput(const std::shared_ptr<Input> &input);
	void setSignedData(const std::shared_ptr<Input> &signedData);

	void setProtocol(GpgME::Protocol prot);
	void autodetectProtocolFromInput() override;

	QString label() const override;

	GpgME::Protocol protocol() const override;

	public Q_SLOTS:
	void cancel() override;

	private:
	void doStart() override;
	QString inputLabel() const override;
	QString outputLabel() const override;
	unsigned long long inputSize() const override;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	Q_PRIVATE_SLOT(d, void slotResult(GpgME::VerificationResult))
	};

	class VerifyOpaqueTask : public AbstractDecryptVerifyTask
	{
	Q_OBJECT
	public:
	explicit VerifyOpaqueTask(QObject *parent = nullptr);
	~VerifyOpaqueTask() override;

	void setInput(const std::shared_ptr<Input> &input);
	void setOutput(const std::shared_ptr<Output> &output);

	void setProtocol(GpgME::Protocol prot);
	void autodetectProtocolFromInput()override;

	QString label() const override;
	GpgME::Protocol protocol() const override;

	public Q_SLOTS:
	void cancel() override;

	private:
	void doStart() override;
	QString inputLabel() const override;
	QString outputLabel() const override;
	unsigned long long inputSize() const override;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	Q_PRIVATE_SLOT(d, void slotResult(GpgME::VerificationResult, QByteArray))
	};

	class DecryptVerifyTask : public AbstractDecryptVerifyTask
	{
	Q_OBJECT
	public:
	explicit DecryptVerifyTask(QObject *parent = nullptr);
	~DecryptVerifyTask() override;

	void setInput(const std::shared_ptr<Input> &input);
	void setSignedData(const std::shared_ptr<Input> &signedData);
	void setOutput(const std::shared_ptr<Output> &output);

	void setProtocol(GpgME::Protocol prot);
	void autodetectProtocolFromInput() override;

	QString label() const override;

	GpgME::Protocol protocol() const override;

	+ void setIgnoreMDCError(bool value);
	+
	public Q_SLOTS:
	void cancel() override;

	private:
	void doStart() override;
	QString inputLabel() const override;
	QString outputLabel() const override;
	unsigned long long inputSize() const override;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	Q_PRIVATE_SLOT(d, void slotResult(GpgME::DecryptionResult, GpgME::VerificationResult, QByteArray))
	};

	class DecryptVerifyResult : public Task::Result
	{
	friend class ::Kleo::Crypto::AbstractDecryptVerifyTask;
	public:
	class SenderInfo;

	QString overview() const override;
	QString details() const override;
	bool hasError() const;
	int errorCode() const override;
	QString errorString() const override;
	VisualCode code() const override;
	AuditLog auditLog() const override;
	QPointer<Task> parentTask() const override;

	GpgME::VerificationResult verificationResult() const;
	GpgME::DecryptionResult decryptionResult() const;

	private:
	static QString keyToString(const GpgME::Key &key);

	private:
	DecryptVerifyResult();
	DecryptVerifyResult(const DecryptVerifyResult &);
	DecryptVerifyResult &operator=(const DecryptVerifyResult &other);

	DecryptVerifyResult(DecryptVerifyOperation op,
	const GpgME::VerificationResult &vr,
	const GpgME::DecryptionResult &dr,
	const QByteArray &stuff,
	int errCode,
	const QString &errString,
	const QString &inputLabel,
	const QString &outputLabel,
	const AuditLog &auditLog,
	Task *parentTask,
	const KMime::Types::Mailbox &informativeSender);

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	};
	}
	}

	#endif //__KLEOPATRA_CRYPTO_DECRYPTVERIFYTASK_H__
	diff --git a/src/crypto/gui/resultitemwidget.cpp b/src/crypto/gui/resultitemwidget.cpp
	index e105d9964..df6839fdb 100644
	--- a/src/crypto/gui/resultitemwidget.cpp
	+++ b/src/crypto/gui/resultitemwidget.cpp
	@@ -1,336 +1,379 @@
	/* -- mode: c++; c-basic-offset:4 --
	crypto/gui/resultitemwidget.cpp

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2008 Klarälvdalens Datakonsult AB
	2016 by Bundesamt für Sicherheit in der Informationstechnik
	Software engineering by Intevation GmbH

	Kleopatra 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 2 of the License, or
	(at your option) any later version.

	Kleopatra 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, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#include <config-kleopatra.h>

	#include "resultitemwidget.h"

	#include "utils/auditlog.h"
	#include "commands/command.h"
	#include "commands/importcertificatefromfilecommand.h"
	#include "commands/lookupcertificatescommand.h"
	#include "crypto/decryptverifytask.h"

	#include <libkleo/messagebox.h>
	#include <Libkleo/Classify>

	#include <gpgme++/key.h>
	+#include <gpgme++/gpgmepp_version.h>
	+#include <gpgme++/decryptionresult.h>

	#include <KLocalizedString>
	#include <QPushButton>
	#include <KStandardGuiItem>
	#include "kleopatra_debug.h"
	#include <QHBoxLayout>
	#include <QLabel>
	#include <QUrl>
	#include <QVBoxLayout>
	#include <KGuiItem>
	#include <KColorScheme>

	+#if GPGMEPP_VERSION > 0x10B01 // > 1.11.1
	+# define GPGME_HAS_LEGACY_NOMDC
	+#endif

	using namespace Kleo;
	using namespace Kleo::Crypto;
	using namespace Kleo::Crypto::Gui;

	namespace
	{
	// TODO move out of here
	static QColor colorForVisualCode(Task::Result::VisualCode code)
	{
	switch (code) {
	case Task::Result::AllGood:
	return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color();
	case Task::Result::NeutralError:
	case Task::Result::Warning:
	return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NormalBackground).color();
	case Task::Result::Danger:
	return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color();
	case Task::Result::NeutralSuccess:
	default:
	return QColor(0x00, 0x80, 0xFF); // light blue
	}
	}
	static QColor txtColorForVisualCode(Task::Result::VisualCode code)
	{
	switch (code) {
	case Task::Result::AllGood:
	return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::PositiveText).color();
	case Task::Result::NeutralError:
	case Task::Result::Warning:
	return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NormalText).color();
	case Task::Result::Danger:
	return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NegativeText).color();
	case Task::Result::NeutralSuccess:
	default:
	return QColor(0xFF, 0xFF, 0xFF); // white
	}
	}
	}

	class ResultItemWidget::Private
	{
	ResultItemWidget *const q;
	public:
	explicit Private(const std::shared_ptr<const Task::Result> &result, ResultItemWidget *qq) : q(qq), m_result(result), m_detailsLabel(nullptr), m_actionsLabel(nullptr), m_closeButton(nullptr), m_importCanceled(false)
	{
	Q_ASSERT(m_result);
	}

	void slotLinkActivated(const QString &);
	void updateShowDetailsLabel();

	void addKeyImportButton(QBoxLayout *lay, bool search);
	+ void addIgnoreMDCButton(QBoxLayout *lay);

	void oneImportFinished();

	const std::shared_ptr<const Task::Result> m_result;
	QLabel *m_detailsLabel;
	QLabel *m_actionsLabel;
	QPushButton *m_closeButton;
	bool m_importCanceled;
	};

	void ResultItemWidget::Private::oneImportFinished()
	{
	if (m_importCanceled) {
	return;
	}
	if (m_result->parentTask()) {
	m_result->parentTask()->start();
	}
	q->setVisible(false);
	}

	+void ResultItemWidget::Private::addIgnoreMDCButton(QBoxLayout *lay)
	+{
	+ if (!m_result \|\| !lay) {
	+ return;
	+ }
	+
	+ const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
	+ if (!dvResult) {
	+ return;
	+ }
	+ const auto decResult = dvResult->decryptionResult();
	+
	+#ifdef GPGME_HAS_LEGACY_NOMDC
	+ if (decResult.isNull() \|\| !decResult.error() \|\| !decResult.isLegacyCipherNoMDC())
	+#endif
	+ {
	+ return;
	+ }
	+
	+ auto btn = new QPushButton(i18n("Force decryption"));
	+ btn->setFixedSize(btn->sizeHint());
	+
	+ connect (btn, &QPushButton::clicked, q, [this] () {
	+ if (m_result->parentTask()) {
	+ const auto dvTask = dynamic_cast<DecryptVerifyTask*>(m_result->parentTask().data());
	+ dvTask->setIgnoreMDCError(true);
	+ dvTask->start();
	+ q->setVisible(false);
	+ } else {
	+ qCWarning(KLEOPATRA_LOG) << "Failed to get parent task";
	+ }
	+ });
	+ lay->addWidget(btn);
	+}
	+
	void ResultItemWidget::Private::addKeyImportButton(QBoxLayout *lay, bool search)
	{
	if (!m_result \|\| !lay) {
	return;
	}

	const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
	if (!dvResult) {
	return;
	}
	const auto verifyResult = dvResult->verificationResult();

	if (verifyResult.isNull()) {
	return;
	}

	for (const auto sig: verifyResult.signatures()) {
	if (!(sig.summary() & GpgME::Signature::KeyMissing)) {
	continue;
	}

	auto btn = new QPushButton;
	QString suffix;
	const auto keyid = QLatin1String(sig.fingerprint());
	if (verifyResult.numSignatures() > 1) {
	suffix = QLatin1Char(' ') + keyid;
	}
	btn = new QPushButton(search ? i18nc("1 is optional keyid. No space is intended as it can be empty.",
	"Search%1", suffix)
	: i18nc("1 is optional keyid. No space is intended as it can be empty.",
	"Import%1", suffix));

	if (search) {
	btn->setIcon(QIcon::fromTheme("edit-find"));
	connect (btn, &QPushButton::clicked, q, [this, btn, keyid] () {
	btn->setEnabled(false);
	m_importCanceled = false;
	auto cmd = new Kleo::Commands::LookupCertificatesCommand(keyid, nullptr);
	connect(cmd, &Kleo::Commands::LookupCertificatesCommand::canceled,
	q, [this]() { m_importCanceled = true; });
	connect(cmd, &Kleo::Commands::LookupCertificatesCommand::finished,
	q, [this, btn]() {
	btn->setEnabled(true);
	oneImportFinished();
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	} else {
	btn->setIcon(QIcon::fromTheme("view-certificate-import"));
	connect (btn, &QPushButton::clicked, q, [this, btn] () {
	btn->setEnabled(false);
	m_importCanceled = false;
	auto cmd = new Kleo::ImportCertificateFromFileCommand();
	connect(cmd, &Kleo::ImportCertificateFromFileCommand::canceled,
	q, [this]() { m_importCanceled = true; });
	connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished,
	q, [this, btn]() {
	btn->setEnabled(true);
	oneImportFinished();
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	}
	btn->setFixedSize(btn->sizeHint());
	lay->addWidget(btn);
	}
	}

	static QUrl auditlog_url_template()
	{
	QUrl url(QStringLiteral("kleoresultitem://showauditlog"));
	return url;
	}

	void ResultItemWidget::Private::updateShowDetailsLabel()
	{
	if (!m_actionsLabel \|\| !m_detailsLabel) {
	return;
	}

	const QString auditLogLink = m_result->auditLog().formatLink(auditlog_url_template());
	m_actionsLabel->setText(auditLogLink);
	}

	ResultItemWidget::ResultItemWidget(const std::shared_ptr<const Task::Result> &result, QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), d(new Private(result, this))
	{
	const QColor color = colorForVisualCode(d->m_result->code());
	const QColor txtColor = txtColorForVisualCode(d->m_result->code());
	const QString styleSheet = QStringLiteral("QFrame,QLabel { background-color: %1; margin: 0px; }"
	"QFrame#resultFrame{ border-color: %2; border-style: solid; border-radius: 3px; border-width: 1px }"
	"QLabel { color: %3; padding: 5px; border-radius: 3px }").arg(color.name()).arg(color.darker(150).name()).arg(txtColor.name());
	QVBoxLayout *topLayout = new QVBoxLayout(this);
	QFrame *frame = new QFrame;
	frame->setObjectName(QStringLiteral("resultFrame"));
	frame->setStyleSheet(styleSheet);
	topLayout->addWidget(frame);
	QHBoxLayout *layout = new QHBoxLayout(frame);
	QVBoxLayout *vlay = new QVBoxLayout();
	QLabel *overview = new QLabel;
	overview->setWordWrap(true);
	overview->setTextFormat(Qt::RichText);
	overview->setText(d->m_result->overview());
	overview->setFocusPolicy(Qt::StrongFocus);
	overview->setStyleSheet(styleSheet);
	connect(overview, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));

	vlay->addWidget(overview);
	layout->addLayout(vlay);

	const QString details = d->m_result->details();

	QVBoxLayout *actionLayout = new QVBoxLayout;
	layout->addLayout(actionLayout);

	d->addKeyImportButton(actionLayout, false);
	// TODO: Only show if auto-key-retrieve is not set.
	d->addKeyImportButton(actionLayout, true);

	+ d->addIgnoreMDCButton(actionLayout);
	+
	d->m_actionsLabel = new QLabel;
	connect(d->m_actionsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
	actionLayout->addWidget(d->m_actionsLabel);
	d->m_actionsLabel->setFocusPolicy(Qt::StrongFocus);
	d->m_actionsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
	d->m_actionsLabel->setStyleSheet(styleSheet);

	d->m_detailsLabel = new QLabel;
	d->m_detailsLabel->setWordWrap(true);
	d->m_detailsLabel->setTextFormat(Qt::RichText);
	d->m_detailsLabel->setText(details);
	d->m_detailsLabel->setFocusPolicy(Qt::StrongFocus);
	d->m_detailsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
	d->m_detailsLabel->setStyleSheet(styleSheet);

	connect(d->m_detailsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
	vlay->addWidget(d->m_detailsLabel);

	d->m_closeButton = new QPushButton;
	KGuiItem::assign(d->m_closeButton, KStandardGuiItem::close());
	d->m_closeButton->setFixedSize(d->m_closeButton->sizeHint());
	connect(d->m_closeButton, &QAbstractButton::clicked, this, &ResultItemWidget::closeButtonClicked);
	actionLayout->addWidget(d->m_closeButton);
	d->m_closeButton->setVisible(false);

	layout->setStretch(0, 1);
	actionLayout->addStretch(-1);
	vlay->addStretch(-1);

	d->updateShowDetailsLabel();
	setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
	}

	ResultItemWidget::~ResultItemWidget()
	{
	}

	void ResultItemWidget::showCloseButton(bool show)
	{
	d->m_closeButton->setVisible(show);
	}

	bool ResultItemWidget::hasErrorResult() const
	{
	return d->m_result->hasError();
	}

	void ResultItemWidget::Private::slotLinkActivated(const QString &link)
	{
	Q_ASSERT(m_result);
	qCDebug(KLEOPATRA_LOG) << "Link activated: " << link;
	if (link.startsWith(QLatin1String("key:"))) {
	auto split = link.split(QLatin1Char(':'));
	auto fpr = split.value(1);
	if (split.size() == 2 && isFingerprint(fpr)) {
	/* There might be a security consideration here if somehow
	* a short keyid is used in a link and it collides with another.
	* So we additionally check that it really is a fingerprint. */
	auto cmd = Command::commandForQuery(fpr);
	cmd->setParentWId(q->effectiveWinId());
	cmd->start();
	} else {
	qCWarning(KLEOPATRA_LOG) << "key link invalid " << link;
	}
	return;
	}

	const QUrl url(link);

	if (url.host() == QLatin1String("showauditlog")) {
	q->showAuditLog();
	return;
	}
	qCWarning(KLEOPATRA_LOG) << "Unexpected link scheme: " << link;
	}

	void ResultItemWidget::showAuditLog()
	{
	MessageBox::auditLog(parentWidget(), d->m_result->auditLog().text());
	}

	#include "moc_resultitemwidget.cpp"
	diff --git a/src/crypto/taskcollection.cpp b/src/crypto/taskcollection.cpp
	index 18421c7f3..2d4b5d0b5 100644
	--- a/src/crypto/taskcollection.cpp
	+++ b/src/crypto/taskcollection.cpp
	@@ -1,243 +1,244 @@
	/* -- mode: c++; c-basic-offset:4 --
	crypto/taskcollection.cpp

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2008 Klarälvdalens Datakonsult AB
	2016 by Bundesamt für Sicherheit in der Informationstechnik
	Software engineering by Intevation GmbH

	Kleopatra 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 2 of the License, or
	(at your option) any later version.

	Kleopatra 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, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#include <config-kleopatra.h>

	#include "taskcollection.h"
	#include "task.h"
	#include "kleopatra_debug.h"

	#include "utils/gnupg-helper.h"

	#include <algorithm>
	#include <map>

	#include <cmath>

	using namespace Kleo;
	using namespace Kleo::Crypto;

	class TaskCollection::Private
	{
	TaskCollection *const q;
	public:
	explicit Private(TaskCollection *qq);

	void taskProgress(const QString &, int, int);
	void taskResult(const std::shared_ptr<const Task::Result> &);
	void taskStarted();
	void calculateAndEmitProgress();

	std::map<int, std::shared_ptr<Task> > m_tasks;
	mutable quint64 m_totalProgress;
	mutable quint64 m_progress;
	unsigned int m_nCompleted;
	unsigned int m_nErrors;
	QString m_lastProgressMessage;
	bool m_errorOccurred;
	bool m_doneEmitted;
	};

	TaskCollection::Private::Private(TaskCollection *qq):
	q(qq),
	m_totalProgress(0),
	m_progress(0),
	m_nCompleted(0),
	m_nErrors(0),
	m_errorOccurred(false),
	m_doneEmitted(false)
	{
	}

	int TaskCollection::numberOfCompletedTasks() const
	{
	return d->m_nCompleted;
	}

	size_t TaskCollection::size() const
	{
	return d->m_tasks.size();
	}

	bool TaskCollection::allTasksCompleted() const
	{
	Q_ASSERT(d->m_nCompleted <= d->m_tasks.size());
	return d->m_nCompleted == d->m_tasks.size();
	}

	void TaskCollection::Private::taskProgress(const QString &msg, int, int)
	{
	m_lastProgressMessage = msg;
	calculateAndEmitProgress();
	}

	void TaskCollection::Private::taskResult(const std::shared_ptr<const Task::Result> &result)
	{
	Q_ASSERT(result);
	++m_nCompleted;

	if (result->hasError()) {
	m_errorOccurred = true;
	++m_nErrors;
	}
	m_lastProgressMessage.clear();
	calculateAndEmitProgress();
	Q_EMIT q->result(result);
	if (!m_doneEmitted && q->allTasksCompleted()) {
	Q_EMIT q->done();
	m_doneEmitted = true;
	}
	}

	void TaskCollection::Private::taskStarted()
	{
	const Task const task = qobject_cast<Task >(q->sender());
	Q_ASSERT(task);
	Q_ASSERT(m_tasks.find(task->id()) != m_tasks.end());
	Q_EMIT q->started(m_tasks[task->id()]);
	calculateAndEmitProgress(); // start Knight-Rider-Mode right away (gpgsm doesn't report _any_ progress).
	if (m_doneEmitted) {
	// We are not done anymore, one task restarted.
	m_nCompleted--;
	+ m_nErrors--;
	m_doneEmitted = false;
	}
	}

	void TaskCollection::Private::calculateAndEmitProgress()
	{
	typedef std::map<int, std::shared_ptr<Task> >::const_iterator ConstIterator;

	quint64 total = 0;
	quint64 processed = 0;

	static bool haveWorkingProgress = engineIsVersion(2, 1, 15);
	if (!haveWorkingProgress) {
	// GnuPG before 2.1.15 would overflow on progress values > max int.
	// and did not emit a total for our Qt data types.
	// As we can't know if it overflowed or what the total is we just knight
	// rider in that case
	if (m_doneEmitted) {
	Q_EMIT q->progress(m_lastProgressMessage, 1, 1);
	} else {
	Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
	}
	return;
	}

	bool unknowable = false;
	for (ConstIterator it = m_tasks.begin(), end = m_tasks.end(); it != end; ++it) {
	// Sum up progress and totals
	const std::shared_ptr<Task> &i = it->second;
	Q_ASSERT(i);
	if (!i->totalProgress()) {
	// There still might be jobs for which we don't know the progress.
	qCDebug(KLEOPATRA_LOG) << "Task: " << i->label() << " has no total progress set. ";
	unknowable = true;
	break;
	}
	processed += i->currentProgress();
	total += i->totalProgress();
	}

	m_totalProgress = total;
	m_progress = processed;
	if (!unknowable && processed && total >= processed) {
	// Scale down to avoid range issues.
	int scaled = 1000 * (m_progress / static_cast<double>(m_totalProgress));
	qCDebug(KLEOPATRA_LOG) << "Collection Progress: " << scaled << " total: " << 1000;
	Q_EMIT q->progress(m_lastProgressMessage, scaled, 1000);
	} else {
	if (total < processed) {
	qCDebug(KLEOPATRA_LOG) << "Total progress is smaller then current progress.";
	}
	// Knight rider.
	Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
	}
	}

	TaskCollection::TaskCollection(QObject *parent) : QObject(parent), d(new Private(this))
	{
	}

	TaskCollection::~TaskCollection()
	{
	}

	bool TaskCollection::isEmpty() const
	{
	return d->m_tasks.empty();
	}

	bool TaskCollection::errorOccurred() const
	{
	return d->m_errorOccurred;
	}

	bool TaskCollection::allTasksHaveErrors() const
	{
	return d->m_nErrors == d->m_nCompleted;
	}

	std::shared_ptr<Task> TaskCollection::taskById(int id) const
	{
	const std::map<int, std::shared_ptr<Task> >::const_iterator it = d->m_tasks.find(id);
	return it != d->m_tasks.end() ? it->second : std::shared_ptr<Task>();
	}

	std::vector<std::shared_ptr<Task> > TaskCollection::tasks() const
	{
	typedef std::map<int, std::shared_ptr<Task> >::const_iterator ConstIterator;
	std::vector<std::shared_ptr<Task> > res;
	res.reserve(d->m_tasks.size());
	for (ConstIterator it = d->m_tasks.begin(), end = d->m_tasks.end(); it != end; ++it) {
	res.push_back(it->second);
	}
	return res;
	}

	void TaskCollection::setTasks(const std::vector<std::shared_ptr<Task> > &tasks)
	{
	for (const std::shared_ptr<Task> &i : tasks) {
	Q_ASSERT(i);
	d->m_tasks[i->id()] = i;
	connect(i.get(), SIGNAL(progress(QString,int,int)),
	this, SLOT(taskProgress(QString,int,int)));
	connect(i.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
	this, SLOT(taskResult(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
	connect(i.get(), SIGNAL(started()),
	this, SLOT(taskStarted()));
	}
	}

	#include "moc_taskcollection.cpp"
	diff --git a/src/utils/output.cpp b/src/utils/output.cpp
	index 0834e4706..0112a433a 100644
	--- a/src/utils/output.cpp
	+++ b/src/utils/output.cpp
	@@ -1,754 +1,754 @@
	/* -- mode: c++; c-basic-offset:4 --
	utils/output.cpp

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2007 Klarälvdalens Datakonsult AB

	Kleopatra 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 2 of the License, or
	(at your option) any later version.

	Kleopatra 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, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#include <config-kleopatra.h>

	#include "output.h"
	#include "input_p.h"
	#include "detail_p.h"
	#include "kleo_assert.h"
	#include "kdpipeiodevice.h"
	#include "log.h"
	#include "cached.h"

	#include <Libkleo/Exception>

	#include <KLocalizedString>
	#include <KMessageBox>
	#include "kleopatra_debug.h"

	#include <QFileInfo>
	#include <QTemporaryFile>
	#include <QString>
	#include <QClipboard>
	#include <QApplication>
	#include <QBuffer>
	#include <QPointer>
	#include <QWidget>
	#include <QDir>
	#include <QProcess>
	#include <QTimer>

	#ifdef Q_OS_WIN
	# include <windows.h>
	#endif

	#include <errno.h>

	using namespace Kleo;
	using namespace Kleo::_detail;

	static const int PROCESS_MAX_RUNTIME_TIMEOUT = -1; // no timeout
	static const int PROCESS_TERMINATE_TIMEOUT = 5 * 1000; // 5s

	class OverwritePolicy::Private
	{
	public:
	Private(QWidget *p, OverwritePolicy::Policy pol) : policy(pol), widget(p) {}
	OverwritePolicy::Policy policy;
	QWidget *widget;
	};

	OverwritePolicy::OverwritePolicy(QWidget *parent, Policy initialPolicy) : d(new Private(parent, initialPolicy))
	{
	}

	OverwritePolicy::~OverwritePolicy() {}

	OverwritePolicy::Policy OverwritePolicy::policy() const
	{
	return d->policy;
	}

	void OverwritePolicy::setPolicy(Policy policy)
	{
	d->policy = policy;
	}

	QWidget *OverwritePolicy::parentWidget() const
	{
	return d->widget;
	}

	namespace
	{

	class TemporaryFile : public QTemporaryFile
	{
	public:
	explicit TemporaryFile() : QTemporaryFile() {}
	explicit TemporaryFile(const QString &templateName) : QTemporaryFile(templateName) {}
	explicit TemporaryFile(QObject *parent) : QTemporaryFile(parent) {}
	explicit TemporaryFile(const QString &templateName, QObject *parent) : QTemporaryFile(templateName, parent) {}

	void close() override {
	if (isOpen())
	{
	m_oldFileName = fileName();
	}
	QTemporaryFile::close();
	}

	bool openNonInheritable()
	{
	if (!QTemporaryFile::open()) {
	return false;
	}
	#if defined(Q_OS_WIN)
	//QTemporaryFile (tested with 4.3.3) creates the file handle as inheritable.
	//The handle is then inherited by gpgsm, which prevents deletion of the temp file
	//in FileOutput::doFinalize()
	//There are no inheritable handles under wince
	return SetHandleInformation((HANDLE)_get_osfhandle(handle()), HANDLE_FLAG_INHERIT, 0);
	#endif
	return true;
	}

	QString oldFileName() const
	{
	return m_oldFileName;
	}

	private:
	QString m_oldFileName;
	};

	template <typename T_IODevice>
	struct inhibit_close : T_IODevice {
	explicit inhibit_close() : T_IODevice() {}
	template <typename T1>
	explicit inhibit_close(T1 &t1) : T_IODevice(t1) {}

	/* reimp */ void close() override {}
	void reallyClose()
	{
	T_IODevice::close();
	}
	};

	template <typename T_IODevice>
	struct redirect_close : T_IODevice {
	explicit redirect_close() : T_IODevice(), m_closed(false) {}
	template <typename T1>
	explicit redirect_close(T1 &t1) : T_IODevice(t1), m_closed(false) {}

	/* reimp */ void close() override
	{
	this->closeWriteChannel();
	m_closed = true;
	}

	bool isClosed() const
	{
	return m_closed;
	}
	private:
	bool m_closed;
	};

	class FileOutput;
	class OutputInput : public InputImplBase
	{
	public:
	OutputInput(const std::shared_ptr<FileOutput> &output);

	unsigned int classification() const override
	{
	return 0;
	}

	void outputFinalized()
	{
	if (!m_ioDevice->open(QIODevice::ReadOnly)) {
	qCCritical(KLEOPATRA_LOG) << "Failed to open file for reading";
	}
	}

	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_ioDevice;
	}

	unsigned long long size() const override
	{
	return 0;
	}

	private:
	std::shared_ptr<FileOutput> m_output;
	mutable std::shared_ptr<QIODevice> m_ioDevice = nullptr;
	};

	class OutputImplBase : public Output
	{
	public:
	OutputImplBase()
	: Output(),
	m_defaultLabel(),
	m_customLabel(),
	m_errorString(),
	m_isFinalized(false),
	m_isFinalizing(false),
	m_cancelPending(false),
	m_canceled(false),
	m_binaryOpt(false)
	{

	}

	QString label() const override
	{
	return m_customLabel.isEmpty() ? m_defaultLabel : m_customLabel;
	}
	void setLabel(const QString &label) override {
	m_customLabel = label;
	}
	void setDefaultLabel(const QString &l)
	{
	m_defaultLabel = l;
	}
	void setBinaryOpt(bool value) override {
	m_binaryOpt = value;
	}
	bool binaryOpt() const override
	{
	return m_binaryOpt;
	}

	QString errorString() const override
	{
	if (m_errorString.dirty()) {
	m_errorString = doErrorString();
	}
	return m_errorString;
	}

	bool isFinalized() const override
	{
	return m_isFinalized;
	}
	void finalize() override {
	qCDebug(KLEOPATRA_LOG) << this;
	if (m_isFinalized \|\| m_isFinalizing)
	{
	return;
	}
	m_isFinalizing = true;
	try {
	doFinalize();
	} catch (...)
	{
	m_isFinalizing = false;
	throw;
	}
	m_isFinalizing = false;
	m_isFinalized = true;
	if (m_cancelPending)
	{
	cancel();
	}
	}

	void cancel() override {
	qCDebug(KLEOPATRA_LOG) << this;
	if (m_isFinalizing)
	{
	m_cancelPending = true;
	} else if (!m_canceled)
	{
	m_isFinalizing = true;
	try {
	doCancel();
	} catch (...) {}
	m_isFinalizing = false;
	- m_isFinalized = true;
	+ m_isFinalized = false;
	m_canceled = true;
	}
	}
	private:
	virtual QString doErrorString() const
	{
	if (std::shared_ptr<QIODevice> io = ioDevice()) {
	return io->errorString();
	} else {
	return i18n("No output device");
	}
	}
	virtual void doFinalize() = 0;
	virtual void doCancel() = 0;
	private:
	QString m_defaultLabel;
	QString m_customLabel;
	mutable cached<QString> m_errorString;
	bool m_isFinalized : 1;
	bool m_isFinalizing : 1;
	bool m_cancelPending : 1;
	bool m_canceled : 1;
	bool m_binaryOpt : 1;
	};

	class PipeOutput : public OutputImplBase
	{
	public:
	explicit PipeOutput(assuan_fd_t fd);

	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_io;
	}
	void doFinalize() override {
	m_io->reallyClose();
	}
	void doCancel() override {
	doFinalize();
	}
	private:
	std::shared_ptr< inhibit_close<KDPipeIODevice> > m_io;
	};

	class ProcessStdInOutput : public OutputImplBase
	{
	public:
	explicit ProcessStdInOutput(const QString &cmd, const QStringList &args, const QDir &wd);

	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_proc;
	}
	void doFinalize() override {
	/*
	Make sure the data is written in the output here. If this
	is not done the output will be written in small chunks
	trough the eventloop causing an uncessary delay before
	the process has even a chance to work and finish.
	This delay is mainly noticabe on Windows where it can
	take ~30 seconds to write out a 10MB file in the 512 byte
	chunks gpgme serves. */
	qCDebug(KLEOPATRA_LOG) << "Waiting for " << m_proc->bytesToWrite()
	<< " Bytes to be written";
	while (m_proc->waitForBytesWritten(PROCESS_MAX_RUNTIME_TIMEOUT));

	if (!m_proc->isClosed())
	{
	m_proc->close();
	}
	m_proc->waitForFinished(PROCESS_MAX_RUNTIME_TIMEOUT);
	}
	void doCancel() override {
	m_proc->terminate();
	QTimer::singleShot(PROCESS_TERMINATE_TIMEOUT, m_proc.get(), &QProcess::kill);
	}
	QString label() const override;

	private:
	QString doErrorString() const override;

	private:
	const QString m_command;
	const QStringList m_arguments;
	const std::shared_ptr< redirect_close<QProcess> > m_proc;
	};

	class FileOutput : public OutputImplBase
	{
	public:
	explicit FileOutput(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy);
	~FileOutput()
	{
	qCDebug(KLEOPATRA_LOG) << this;
	}

	QString label() const override
	{
	return QFileInfo(m_fileName).fileName();
	}
	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_tmpFile;
	}
	void doFinalize() override;
	void doCancel() override {
	qCDebug(KLEOPATRA_LOG) << this;
	}
	QString fileName() const
	{
	return m_fileName;
	}

	void attachInput(const std::shared_ptr<OutputInput> &input)
	{
	m_attachedInput = std::weak_ptr<OutputInput>(input);
	}

	private:
	bool obtainOverwritePermission();

	private:
	const QString m_fileName;
	std::shared_ptr< TemporaryFile > m_tmpFile;
	const std::shared_ptr<OverwritePolicy> m_policy;
	std::weak_ptr<OutputInput> m_attachedInput;
	};

	#ifndef QT_NO_CLIPBOARD
	class ClipboardOutput : public OutputImplBase
	{
	public:
	explicit ClipboardOutput(QClipboard::Mode mode);

	QString label() const override;
	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_buffer;
	}
	void doFinalize() override;
	void doCancel() override {}

	private:
	QString doErrorString() const override
	{
	return QString();
	}
	private:
	const QClipboard::Mode m_mode;
	std::shared_ptr<QBuffer> m_buffer;
	};
	#endif // QT_NO_CLIPBOARD

	class ByteArrayOutput: public OutputImplBase
	{
	public:
	explicit ByteArrayOutput(QByteArray *data):
	m_buffer(std::shared_ptr<QBuffer>(new QBuffer(data)))
	{
	if (!m_buffer->open(QIODevice::WriteOnly))
	throw Exception(gpg_error(GPG_ERR_EIO),
	QStringLiteral("Could not open bytearray for writing?!"));
	}

	QString label() const override
	{
	return m_label;
	}

	void setLabel(const QString &label) override
	{
	m_label = label;
	}

	std::shared_ptr<QIODevice> ioDevice() const override
	{
	return m_buffer;
	}

	void doFinalize() override
	{
	m_buffer->close();
	}

	void doCancel() override
	{
	m_buffer->close();
	}

	private:
	QString doErrorString() const override
	{
	return QString();
	}
	private:
	QString m_label;
	std::shared_ptr<QBuffer> m_buffer;
	};

	}

	std::shared_ptr<Output> Output::createFromPipeDevice(assuan_fd_t fd, const QString &label)
	{
	std::shared_ptr<PipeOutput> po(new PipeOutput(fd));
	po->setDefaultLabel(label);
	return po;
	}

	PipeOutput::PipeOutput(assuan_fd_t fd)
	: OutputImplBase(),
	m_io(new inhibit_close<KDPipeIODevice>)
	{
	errno = 0;
	if (!m_io->open(fd, QIODevice::WriteOnly))
	throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
	i18n("Could not open FD %1 for writing",
	assuanFD2int(fd)));
	}

	std::shared_ptr<Output> Output::createFromFile(const QString &fileName, bool forceOverwrite)
	{
	return createFromFile(fileName, std::shared_ptr<OverwritePolicy>(new OverwritePolicy(nullptr, forceOverwrite ? OverwritePolicy::Allow : OverwritePolicy::Deny)));

	}
	std::shared_ptr<Output> Output::createFromFile(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy)
	{
	std::shared_ptr<FileOutput> fo(new FileOutput(fileName, policy));
	qCDebug(KLEOPATRA_LOG) << fo.get();
	return fo;
	}

	FileOutput::FileOutput(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy)
	: OutputImplBase(),
	m_fileName(fileName),
	m_tmpFile(new TemporaryFile(fileName)),
	m_policy(policy)
	{
	Q_ASSERT(m_policy);
	errno = 0;
	if (!m_tmpFile->openNonInheritable())
	throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
	i18n("Could not create temporary file for output \"%1\"", fileName));
	}

	bool FileOutput::obtainOverwritePermission()
	{
	if (m_policy->policy() != OverwritePolicy::Ask) {
	return m_policy->policy() == OverwritePolicy::Allow;
	}
	const int sel = KMessageBox::questionYesNoCancel(m_policy->parentWidget(), i18n("The file <b>%1</b> already exists.\n"
	"Overwrite?", m_fileName),
	i18n("Overwrite Existing File?"),
	KStandardGuiItem::overwrite(),
	KGuiItem(i18n("Overwrite All")),
	KStandardGuiItem::cancel());
	if (sel == KMessageBox::No) { //Overwrite All
	m_policy->setPolicy(OverwritePolicy::Allow);
	}
	return sel == KMessageBox::Yes \|\| sel == KMessageBox::No;
	}

	void FileOutput::doFinalize()
	{
	qCDebug(KLEOPATRA_LOG) << this;

	struct Remover {
	QString file;
	~Remover()
	{
	if (QFile::exists(file)) {
	QFile::remove(file);
	}
	}
	} remover;

	kleo_assert(m_tmpFile);

	if (m_tmpFile->isOpen()) {
	m_tmpFile->close();
	}

	const QString tmpFileName = remover.file = m_tmpFile->oldFileName();

	m_tmpFile->setAutoRemove(false);
	QPointer<QObject> guard = m_tmpFile.get();
	m_tmpFile.reset(); // really close the file - needed on Windows for renaming :/
	kleo_assert(!guard); // if this triggers, we need to audit for holder of std::shared_ptr<QIODevice>s.

	qCDebug(KLEOPATRA_LOG) << this << " renaming " << tmpFileName << "->" << m_fileName;

	if (QFile::rename(tmpFileName, m_fileName)) {
	qCDebug(KLEOPATRA_LOG) << this << "succeeded";

	if (!m_attachedInput.expired()) {
	m_attachedInput.lock()->outputFinalized();
	}
	return;
	}

	qCDebug(KLEOPATRA_LOG) << this << "failed";

	if (!obtainOverwritePermission())
	throw Exception(gpg_error(GPG_ERR_CANCELED),
	i18n("Overwriting declined"));

	qCDebug(KLEOPATRA_LOG) << this << "going to overwrite" << m_fileName;

	if (!QFile::remove(m_fileName))
	throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
	i18n("Could not remove file \"%1\" for overwriting.", m_fileName));

	qCDebug(KLEOPATRA_LOG) << this << "succeeded, renaming " << tmpFileName << "->" << m_fileName;

	if (QFile::rename(tmpFileName, m_fileName)) {
	qCDebug(KLEOPATRA_LOG) << this << "succeeded";

	if (!m_attachedInput.expired()) {
	m_attachedInput.lock()->outputFinalized();
	}
	return;
	}

	qCDebug(KLEOPATRA_LOG) << this << "failed";

	throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
	i18n("Could not rename file \"%1\" to \"%2\"",
	tmpFileName, m_fileName));
	}

	std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command)
	{
	return std::shared_ptr<Output>(new ProcessStdInOutput(command, QStringList(), QDir::current()));
	}

	std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command, const QStringList &args)
	{
	return std::shared_ptr<Output>(new ProcessStdInOutput(command, args, QDir::current()));
	}

	std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command, const QStringList &args, const QDir &wd)
	{
	return std::shared_ptr<Output>(new ProcessStdInOutput(command, args, wd));
	}

	ProcessStdInOutput::ProcessStdInOutput(const QString &cmd, const QStringList &args, const QDir &wd)
	: OutputImplBase(),
	m_command(cmd),
	m_arguments(args),
	m_proc(new redirect_close<QProcess>)
	{
	qCDebug(KLEOPATRA_LOG) << "cd" << wd.absolutePath() << endl << cmd << args;
	if (cmd.isEmpty())
	throw Exception(gpg_error(GPG_ERR_INV_ARG),
	i18n("Command not specified"));
	m_proc->setWorkingDirectory(wd.absolutePath());
	m_proc->start(cmd, args);
	m_proc->setReadChannel(QProcess::StandardError);
	if (!m_proc->waitForStarted())
	throw Exception(gpg_error(GPG_ERR_EIO),
	i18n("Could not start %1 process: %2", cmd, m_proc->errorString()));
	}

	QString ProcessStdInOutput::label() const
	{
	if (!m_proc) {
	return OutputImplBase::label();
	}
	// output max. 3 arguments
	const QString cmdline = (QStringList(m_command) + m_arguments.mid(0, 3)).join(QLatin1Char(' '));
	if (m_arguments.size() > 3) {
	return i18nc("e.g. \"Input to tar xf - file1 ...\"", "Input to %1 ...", cmdline);
	} else {
	return i18nc("e.g. \"Input to tar xf - file\"", "Input to %1", cmdline);
	}
	}

	QString ProcessStdInOutput::doErrorString() const
	{
	kleo_assert(m_proc);
	if (m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0) {
	return QString();
	}
	if (m_proc->error() == QProcess::UnknownError)
	return i18n("Error while running %1: %2", m_command,
	QString::fromLocal8Bit(m_proc->readAllStandardError().trimmed().constData()));
	else {
	return i18n("Failed to execute %1: %2", m_command, m_proc->errorString());
	}
	}

	#ifndef QT_NO_CLIPBOARD
	std::shared_ptr<Output> Output::createFromClipboard()
	{
	return std::shared_ptr<Output>(new ClipboardOutput(QClipboard::Clipboard));
	}

	ClipboardOutput::ClipboardOutput(QClipboard::Mode mode)
	: OutputImplBase(),
	m_mode(mode),
	m_buffer(new QBuffer)
	{
	errno = 0;
	if (!m_buffer->open(QIODevice::WriteOnly))
	throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
	i18n("Could not write to clipboard"));
	}

	QString ClipboardOutput::label() const
	{
	switch (m_mode) {
	case QClipboard::Clipboard:
	return i18n("Clipboard");
	case QClipboard::FindBuffer:
	return i18n("Find buffer");
	case QClipboard::Selection:
	return i18n("Selection");
	}
	return QString();
	}

	void ClipboardOutput::doFinalize()
	{
	if (m_buffer->isOpen()) {
	m_buffer->close();
	}
	if (QClipboard *const cb = QApplication::clipboard()) {
	cb->setText(QString::fromUtf8(m_buffer->data()));
	} else
	throw Exception(gpg_error(GPG_ERR_EIO),
	i18n("Could not find clipboard"));
	}
	#endif // QT_NO_CLIPBOARD

	Output::~Output() {}


	OutputInput::OutputInput(const std::shared_ptr<FileOutput> &output)
	: m_output(output)
	, m_ioDevice(new QFile(output->fileName()))
	{
	}



	std::shared_ptr<Input> Input::createFromOutput(const std::shared_ptr<Output> &output)
	{
	if (auto fo = std::dynamic_pointer_cast<FileOutput>(output)) {
	auto input = std::shared_ptr<OutputInput>(new OutputInput(fo));
	fo->attachInput(input);
	return input;
	} else {
	return {};
	}
	}

	std::shared_ptr<Output> Output::createFromByteArray(QByteArray *data, const QString &label)
	{
	auto ret = std::shared_ptr<ByteArrayOutput>(new ByteArrayOutput(data));
	ret->setLabel(label);
	return ret;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Dec 30, 5:48 PM (1 d, 21 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: a2/5a/72e83a52a12de55b7f1606a5fffd

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions