diff --git a/CMakeLists.txt b/CMakeLists.txt
index e371918ca..974e81cd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,159 +1,159 @@
 set(kleopatra_version 3.1.12)
 # The following is for Windows. Keep in line with kleopatra_version.
 set(kleopatra_fileversion 3,1,12,0)
 cmake_minimum_required(VERSION 3.5)
 project(kleopatra VERSION ${kleopatra_version})
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set (RELEASE_SERVICE_VERSION "20.11.80")
 endif()
 
 option(FORCE_DISABLE_KCMUTILS "Force building Kleopatra without KCMUtils. Doing this will disable configuration KCM Plugins. [default=OFF]" OFF)
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.75.0")
 set(KMIME_VERSION "5.15.40")
-set(LIBKLEO_VERSION "5.15.41")
+set(LIBKLEO_VERSION "5.15.81")
 set(QT_REQUIRED_VERSION "5.13.0")
 set(GPGME_REQUIRED_VERSION "1.11.1")
 
 find_package(ECM ${KF5_MIN_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddTests)
 
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 
 include(FeatureSummary)
 include(CheckFunctionExists)
 include(ECMGeneratePriFile)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 # Find KF5 packages
 if (NOT FORCE_DISABLE_KCMUTILS)
   find_package(KF5KCMUtils ${KF5_MIN_VERSION} CONFIG REQUIRED)
 endif()
 find_package(KF5WidgetsAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5Codecs ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5Config ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 find_package(KF5Crash ${KF5_MIN_VERSION} REQUIRED)
 
 set_package_properties(KF5DocTools PROPERTIES DESCRIPTION "Documentation tools" TYPE OPTIONAL PURPOSE "Required to generate Kleopatra documentation.")
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG)
   set_package_properties(KF5DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF5::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt5DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_VERSION} CONFIG REQUIRED)
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 set(HAVE_KCMUTILS ${KF5KCMUtils_FOUND})
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 
 find_package(Boost 1.34.0 REQUIRED)
 
 find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
 if(NOT Boost_TOPOLOGICAL_SORT_DIR)
     message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
 endif()
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_REVISION)
         string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
         string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
         set(kleopatra_version "${kleopatra_version}-git${Kleopatra_WC_REVISION} (${Kleopatra_WC_LAST_CHANGED_DATE})")
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Boost_INCLUDE_DIR}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 #add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
 add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054C00)
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 add_definitions(-DQT_NO_EMIT)
 
 kde_enable_exceptions()
 
 
 add_subdirectory(pics)
 add_subdirectory(src)
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
     add_subdirectory(autotests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT KLEOPATRA
         FILE kleopatra.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
index fde3d4bf9..2518ebd22 100644
--- a/src/crypto/decryptverifytask.cpp
+++ b/src/crypto/decryptverifytask.cpp
@@ -1,1601 +1,1601 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifytask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #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/KleoException>
 #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 <Libkleo/GnuPG>
 
 #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 <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 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(
             Formatting::prettyID(QString::fromLocal8Bit(key.primaryFingerprint()).right(16).toLatin1().constData()));
         return renderKeyLink(QLatin1String(key.primaryFingerprint()), text);
     }
 
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), Formatting::prettyID(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::fromSecsSinceEpoch(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("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature is %1", Formatting::deVsString())
                 : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature <b>is not</b> %1.", Formatting::deVsString())));
     }
 
     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 &rarr; %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>");
     }
 #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, const QPointer<Task> &task)
 {
     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("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption is %1.", Formatting::deVsString())
                      : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption <b>is not</b> %1."), Formatting::deVsString())
                     + QStringLiteral("<br/>"));
     }
 
     if (res.fileName()) {
         const auto decVerifyTask = qobject_cast<AbstractDecryptVerifyTask*> (task.data());
         if (decVerifyTask) {
             const auto embedFileName = QString::fromUtf8(res.fileName()).toHtmlEscaped();
 
             if (embedFileName != decVerifyTask->outputLabel()) {
                 details += i18n("Embedded file name: '%1'", embedFileName);
                 details += 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 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 + 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 QPointer<Task> &task)
 {
     const QString drDetails = formatDecryptionResultDetails(dr, recipients, errorString, relevantInDecryptVerifyContext(vr), task);
     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, d->m_parentTask);
     }
     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(),
                                             d->m_parentTask);
 }
 
 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), 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()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO),
                     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()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     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
 {
     return d->m_protocol;
 }
 
 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()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     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
 {
     return d->m_protocol;
 }
 
 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/encryptemailcontroller.cpp b/src/crypto/encryptemailcontroller.cpp
index 630cd4237..9ebe48142 100644
--- a/src/crypto/encryptemailcontroller.cpp
+++ b/src/crypto/encryptemailcontroller.cpp
@@ -1,313 +1,313 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/encryptemailcontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "encryptemailcontroller.h"
 #include "kleopatra_debug.h"
 #include "encryptemailtask.h"
 #include "taskcollection.h"
 
 #include <crypto/gui/encryptemailwizard.h>
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include "emailoperationspreferences.h"
 
 #include <gpgme++/key.h>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 using namespace KMime::Types;
 
 class EncryptEMailController::Private
 {
     friend class ::Kleo::Crypto::EncryptEMailController;
     EncryptEMailController *const q;
 public:
     explicit Private(Mode mode, EncryptEMailController *qq);
 
 private:
     void slotWizardRecipientsResolved();
     void slotWizardCanceled();
 
 private:
     void ensureWizardCreated() const;
     void ensureWizardVisible();
     void cancelAllTasks();
 
     void schedule();
     std::shared_ptr<EncryptEMailTask> takeRunnable(GpgME::Protocol proto);
 
 private:
     const Mode mode;
     std::vector< std::shared_ptr<EncryptEMailTask> > runnable, completed;
     std::shared_ptr<EncryptEMailTask> cms, openpgp;
     mutable QPointer<EncryptEMailWizard> wizard;
 };
 
 EncryptEMailController::Private::Private(Mode m, EncryptEMailController *qq)
     : q(qq),
       mode(m),
       runnable(),
       cms(),
       openpgp(),
       wizard()
 {
 
 }
 
 EncryptEMailController::EncryptEMailController(const std::shared_ptr<ExecutionContext> &xc, Mode mode, QObject *p)
     : Controller(xc, p), d(new Private(mode, this))
 {
 
 }
 
 EncryptEMailController::EncryptEMailController(Mode mode, QObject *p)
     : Controller(p), d(new Private(mode, this))
 {
 
 }
 
 EncryptEMailController::~EncryptEMailController()
 {
     if (d->wizard && !d->wizard->isVisible()) {
         delete d->wizard;
     }
     //d->wizard->close(); ### ?
 }
 
 EncryptEMailController::Mode EncryptEMailController::mode() const
 {
     return d->mode;
 }
 
 void EncryptEMailController::setProtocol(Protocol proto)
 {
     d->ensureWizardCreated();
     const Protocol protocol = d->wizard->presetProtocol();
     kleo_assert(protocol == UnknownProtocol ||
                 protocol == proto);
 
     d->wizard->setPresetProtocol(proto);
 }
 
 Protocol EncryptEMailController::protocol() const
 {
     d->ensureWizardCreated();
     return d->wizard->selectedProtocol();
 }
 
 const char *EncryptEMailController::protocolAsString() const
 {
     switch (protocol()) {
     case OpenPGP: return "OpenPGP";
     case CMS:     return "CMS";
     default:
         throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                               i18n("Call to EncryptEMailController::protocolAsString() is ambiguous."));
     }
 }
 
 void EncryptEMailController::startResolveRecipients()
 {
     startResolveRecipients(std::vector<Mailbox>(), std::vector<Mailbox>());
 }
 
 void EncryptEMailController::startResolveRecipients(const std::vector<Mailbox> &recipients, const std::vector<Mailbox> &senders)
 {
     d->ensureWizardCreated();
     d->wizard->setRecipients(recipients, senders);
     d->ensureWizardVisible();
 }
 
 void EncryptEMailController::Private::slotWizardRecipientsResolved()
 {
     Q_EMIT q->recipientsResolved();
 }
 
 void EncryptEMailController::Private::slotWizardCanceled()
 {
     q->setLastError(gpg_error(GPG_ERR_CANCELED), i18n("User cancel"));
     q->emitDoneOrError();
 }
 
 void EncryptEMailController::setInputAndOutput(const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output)
 {
     setInputsAndOutputs(std::vector< std::shared_ptr<Input> >(1, input), std::vector< std::shared_ptr<Output> >(1, output));
 }
 
 void EncryptEMailController::setInputsAndOutputs(const std::vector< std::shared_ptr<Input> > &inputs, const std::vector< std::shared_ptr<Output> > &outputs)
 {
 
     kleo_assert(!inputs.empty());
     kleo_assert(outputs.size() == inputs.size());
 
     std::vector< std::shared_ptr<EncryptEMailTask> > tasks;
     tasks.reserve(inputs.size());
 
     d->ensureWizardCreated();
 
     const std::vector<Key> keys = d->wizard->resolvedCertificates();
     kleo_assert(!keys.empty());
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
 
         const std::shared_ptr<EncryptEMailTask> task(new EncryptEMailTask);
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         if (d->mode == ClipboardMode) {
             task->setAsciiArmor(true);
         }
         task->setRecipients(keys);
 
         tasks.push_back(task);
     }
 
     d->runnable.swap(tasks);
 }
 
 void EncryptEMailController::start()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tmp;
     std::copy(d->runnable.begin(), d->runnable.end(), std::back_inserter(tmp));
     coll->setTasks(tmp);
     d->ensureWizardCreated();
     d->wizard->setTaskCollection(coll);
     Q_FOREACH (const std::shared_ptr<Task> &t, tmp) {
         connectTask(t);
     }
     d->schedule();
 }
 
 void EncryptEMailController::Private::schedule()
 {
 
     if (!cms)
         if (const std::shared_ptr<EncryptEMailTask> t = takeRunnable(CMS)) {
             t->start();
             cms = t;
         }
 
     if (!openpgp)
         if (const std::shared_ptr<EncryptEMailTask> t = takeRunnable(OpenPGP)) {
             t->start();
             openpgp = t;
         }
 
     if (cms || openpgp) {
         return;
     }
     kleo_assert(runnable.empty());
     q->emitDoneOrError();
 }
 
 std::shared_ptr<EncryptEMailTask> EncryptEMailController::Private::takeRunnable(GpgME::Protocol proto)
 {
     const auto it = std::find_if(runnable.begin(), runnable.end(),
                        [proto](const std::shared_ptr<Kleo::Crypto::EncryptEMailTask> &task) {
                            return task->protocol() == proto;
                        });
     if (it == runnable.end()) {
         return std::shared_ptr<EncryptEMailTask>();
     }
 
     const std::shared_ptr<EncryptEMailTask> result = *it;
     runnable.erase(it);
     return result;
 }
 
 void EncryptEMailController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_UNUSED(result);
     Q_ASSERT(task);
 
     // We could just delete the tasks here, but we can't use
     // Qt::QueuedConnection here (we need sender()) and other slots
     // might not yet have executed. Therefore, we push completed tasks
     // into a burial container
 
     if (task == d->cms.get()) {
         d->completed.push_back(d->cms);
         d->cms.reset();
     } else if (task == d->openpgp.get()) {
         d->completed.push_back(d->openpgp);
         d->openpgp.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void EncryptEMailController::cancel()
 {
     try {
         if (d->wizard) {
             d->wizard->close();
         }
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 void EncryptEMailController::Private::cancelAllTasks()
 {
 
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     runnable.clear();
 
     // a cancel() will result in a call to
     if (cms) {
         cms->cancel();
     }
     if (openpgp) {
         openpgp->cancel();
     }
 }
 
 void EncryptEMailController::Private::ensureWizardCreated() const
 {
     if (wizard) {
         return;
     }
 
     std::unique_ptr<EncryptEMailWizard> w(new EncryptEMailWizard);
     w->setAttribute(Qt::WA_DeleteOnClose);
     Kleo::EMailOperationsPreferences prefs;
     w->setQuickMode(prefs.quickEncryptEMail());
     connect(w.get(), SIGNAL(recipientsResolved()), q, SLOT(slotWizardRecipientsResolved()), Qt::QueuedConnection);
     connect(w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
 
     wizard = w.release();
 }
 
 void EncryptEMailController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(wizard);
 }
 
 #include "moc_encryptemailcontroller.cpp"
 
diff --git a/src/crypto/newsignencryptemailcontroller.cpp b/src/crypto/newsignencryptemailcontroller.cpp
index d1523c192..f6f076458 100644
--- a/src/crypto/newsignencryptemailcontroller.cpp
+++ b/src/crypto/newsignencryptemailcontroller.cpp
@@ -1,632 +1,632 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/newsignencryptemailcontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009, 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "newsignencryptemailcontroller.h"
 #include "kleopatra_debug.h"
 #include "encryptemailtask.h"
 #include "signemailtask.h"
 #include "taskcollection.h"
 #include "sender.h"
 #include "recipient.h"
 
 #include "emailoperationspreferences.h"
 
 #include <crypto/gui/signencryptemailconflictdialog.h>
 
 #include "utils/input.h"
 #include "utils/output.h"
 #include <Libkleo/GnuPG>
 #include "utils/kleo_assert.h"
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <gpgme++/key.h>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include <KLocalizedString>
 
 #include <KMessageBox>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 using namespace KMime::Types;
 
 //
 // BEGIN Conflict Detection
 //
 
 /*
   This code implements the following conflict detection algorithm:
 
   1. There is no conflict if and only if we have a Perfect Match.
   2. A Perfect Match is defined as:
     a. either a Perfect OpenPGP-Match and not even a Partial S/MIME Match
     b. or a Perfect S/MIME-Match and not even a Partial OpenPGP-Match
     c. or a Perfect OpenPGP-Match and preselected protocol=OpenPGP
     d. or a Perfect S/MIME-Match and preselected protocol=S/MIME
   3. For Protocol \in {OpenPGP,S/MIME}, a Perfect Protocol-Match is defined as:
     a. If signing, \foreach Sender, there is exactly one
          Matching Protocol-Certificate with
      i. can-sign=true
      ii. has-secret=true
     b. and, if encrypting, \foreach Recipient, there is exactly one
          Matching Protocol-Certificate with
      i. can-encrypt=true
      ii. (validity is not considered, cf. msg 24059)
   4. For Protocol \in {OpenPGP,S/MIME}, a Partial Protocol-Match is defined as:
     a. If signing, \foreach Sender, there is at least one
          Matching Protocol-Certificate with
      i. can-sign=true
      ii. has-secret=true
     b. and, if encrypting, \foreach Recipient, there is at least
      one Matching Protocol-Certificate with
      i. can-encrypt=true
      ii. (validity is not considered, cf. msg 24059)
   5. For Protocol \in {OpenPGP,S/MIME}, a Matching Protocol-Certificate is
      defined as matching by email-address. A revoked, disabled, or expired
      certificate is not considered a match.
   6. Sender is defined as those mailboxes that have been set with the SENDER
      command.
   7. Recipient is defined as those mailboxes that have been set with either the
      SENDER or the RECIPIENT commands.
 */
 
 namespace
 {
 
 static size_t count_signing_certificates(Protocol proto, const Sender &sender)
 {
     const size_t result = sender.signingCertificateCandidates(proto).size();
     qDebug("count_signing_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(sender.mailbox().prettyAddress()), result);
     return result;
 }
 
 static size_t count_encrypt_certificates(Protocol proto, const Sender &sender)
 {
     const size_t result = sender.encryptToSelfCertificateCandidates(proto).size();
     qDebug("count_encrypt_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(sender.mailbox().prettyAddress()), result);
     return result;
 }
 
 static size_t count_encrypt_certificates(Protocol proto, const Recipient &recipient)
 {        const size_t result = recipient.encryptionCertificateCandidates(proto).size();
     qDebug("count_encrypt_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(recipient.mailbox().prettyAddress()), result);
     return result;
 }
 
 }
 
 static bool has_perfect_match(bool sign, bool encrypt, Protocol proto, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients)
 {
     if (sign)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_signing_certificates(proto, sender) == 1; })) {
             return false;
         }
     if (encrypt)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_encrypt_certificates(proto, sender) == 1; })
             || !std::all_of(recipients.cbegin(), recipients.cend(),
                            [proto](const Recipient &rec) { return count_encrypt_certificates(proto, rec) == 1; })) {
             return false;
         }
     return true;
 }
 
 static bool has_partial_match(bool sign, bool encrypt, Protocol proto, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients)
 {
     if (sign)
         if (std::all_of(senders.cbegin(), senders.cend(),
                         [proto](const Sender &sender) { return count_signing_certificates(proto, sender) >= 1; })) {
             return false;
         }
     if (encrypt)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_encrypt_certificates(proto, sender) >= 1; })
             || !std::all_of(recipients.cbegin(), recipients.cend(),
                             [proto](const Recipient &rec) { return count_encrypt_certificates(proto, rec) >= 1; })) {
             return false;
         }
     return true;
 }
 
 static bool has_perfect_overall_match(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     return (presetProtocol == OpenPGP   &&   has_perfect_match(sign, encrypt, OpenPGP, senders, recipients))
            || (presetProtocol == CMS    &&   has_perfect_match(sign, encrypt, CMS,     senders, recipients))
            || (has_perfect_match(sign, encrypt, OpenPGP, senders, recipients)   &&   !has_partial_match(sign, encrypt, CMS,     senders, recipients))
            || (has_perfect_match(sign, encrypt, CMS,     senders, recipients)   &&   !has_partial_match(sign, encrypt, OpenPGP, senders, recipients));
 }
 
 static bool has_conflict(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     return !has_perfect_overall_match(sign, encrypt, senders, recipients, presetProtocol);
 }
 
 static bool is_de_vs_compliant(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     if (presetProtocol == Protocol::UnknownProtocol) {
         return false;
     }
     if (sign) {
         for (const auto &sender: senders) {
             const auto &key = sender.resolvedSigningKey(presetProtocol);
             if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
     }
 
     if (encrypt) {
         for (const auto &sender: senders) {
             const auto &key = sender.resolvedSigningKey(presetProtocol);
             if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
 
         for (const auto &recipient: recipients) {
             const auto &key = recipient.resolvedEncryptionKey(presetProtocol);
             if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
     }
 
     return true;
 }
 
 //
 // END Conflict Detection
 //
 
 static std::vector<Sender> mailbox2sender(const std::vector<Mailbox> &mbs)
 {
     std::vector<Sender> senders;
     senders.reserve(mbs.size());
     for (const Mailbox &mb : mbs) {
         senders.push_back(Sender(mb));
     }
     return senders;
 }
 
 static std::vector<Recipient> mailbox2recipient(const std::vector<Mailbox> &mbs)
 {
     std::vector<Recipient> recipients;
     recipients.reserve(mbs.size());
     for (const Mailbox &mb : mbs) {
         recipients.push_back(Recipient(mb));
     }
     return recipients;
 }
 
 class NewSignEncryptEMailController::Private
 {
     friend class ::Kleo::Crypto::NewSignEncryptEMailController;
     NewSignEncryptEMailController *const q;
 public:
     explicit Private(NewSignEncryptEMailController *qq);
     ~Private();
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
 
 private:
     void ensureDialogVisible();
     void cancelAllTasks();
 
     void startSigning();
     void startEncryption();
     void schedule();
     std::shared_ptr<Task> takeRunnable(GpgME::Protocol proto);
 
 private:
     bool sign : 1;
     bool encrypt : 1;
     bool resolvingInProgress : 1;
     bool certificatesResolved : 1;
     bool detached : 1;
     Protocol presetProtocol;
     std::vector<Key> signers, recipients;
     std::vector< std::shared_ptr<Task> > runnable, completed;
     std::shared_ptr<Task> cms, openpgp;
     QPointer<SignEncryptEMailConflictDialog> dialog;
 };
 
 NewSignEncryptEMailController::Private::Private(NewSignEncryptEMailController *qq)
     : q(qq),
       sign(false),
       encrypt(false),
       resolvingInProgress(false),
       certificatesResolved(false),
       detached(false),
       presetProtocol(UnknownProtocol),
       signers(),
       recipients(),
       runnable(),
       cms(),
       openpgp(),
       dialog(new SignEncryptEMailConflictDialog)
 {
     connect(dialog, SIGNAL(accepted()), q, SLOT(slotDialogAccepted()));
     connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
 }
 
 NewSignEncryptEMailController::Private::~Private()
 {
     delete dialog;
 }
 
 NewSignEncryptEMailController::NewSignEncryptEMailController(const std::shared_ptr<ExecutionContext> &xc, QObject *p)
     : Controller(xc, p), d(new Private(this))
 {
 
 }
 
 NewSignEncryptEMailController::NewSignEncryptEMailController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 NewSignEncryptEMailController::~NewSignEncryptEMailController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void NewSignEncryptEMailController::setSubject(const QString &subject)
 {
     d->dialog->setSubject(subject);
 }
 
 void NewSignEncryptEMailController::setProtocol(Protocol proto)
 {
     d->presetProtocol = proto;
     d->dialog->setPresetProtocol(proto);
 }
 
 Protocol NewSignEncryptEMailController::protocol() const
 {
     return d->dialog->selectedProtocol();
 }
 
 const char *NewSignEncryptEMailController::protocolAsString() const
 {
     switch (protocol()) {
     case OpenPGP: return "OpenPGP";
     case CMS:     return "CMS";
     default:
         throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                               i18n("Call to NewSignEncryptEMailController::protocolAsString() is ambiguous."));
     }
 }
 
 void NewSignEncryptEMailController::setSigning(bool sign)
 {
     d->sign = sign;
     d->dialog->setSign(sign);
 }
 
 bool NewSignEncryptEMailController::isSigning() const
 {
     return d->sign;
 }
 
 void NewSignEncryptEMailController::setEncrypting(bool encrypt)
 {
     d->encrypt = encrypt;
     d->dialog->setEncrypt(encrypt);
 }
 
 bool NewSignEncryptEMailController::isEncrypting() const
 {
     return d->encrypt;
 }
 
 void NewSignEncryptEMailController::setDetachedSignature(bool detached)
 {
     d->detached = detached;
 }
 
 bool NewSignEncryptEMailController::isResolvingInProgress() const
 {
     return d->resolvingInProgress;
 }
 
 bool NewSignEncryptEMailController::areCertificatesResolved() const
 {
     return d->certificatesResolved;
 }
 
 static bool is_dialog_quick_mode(bool sign, bool encrypt)
 {
     const EMailOperationsPreferences prefs;
     return (!sign    || prefs.quickSignEMail())
            && (!encrypt || prefs.quickEncryptEMail())
            ;
 }
 
 static void save_dialog_quick_mode(bool on)
 {
     EMailOperationsPreferences prefs;
     prefs.setQuickSignEMail(on);
     prefs.setQuickEncryptEMail(on);
     prefs.save();
 }
 
 void NewSignEncryptEMailController::startResolveCertificates(const std::vector<Mailbox> &r, const std::vector<Mailbox> &s)
 {
     d->certificatesResolved = false;
     d->resolvingInProgress = true;
 
     const std::vector<Sender> senders = mailbox2sender(s);
     const std::vector<Recipient> recipients = mailbox2recipient(r);
     const bool quickMode = is_dialog_quick_mode(d->sign, d->encrypt);
 
     const bool conflict = quickMode && has_conflict(d->sign, d->encrypt, senders, recipients, d->presetProtocol);
 
     d->dialog->setQuickMode(quickMode);
     d->dialog->setSenders(senders);
     d->dialog->setRecipients(recipients);
     d->dialog->pickProtocol();
     d->dialog->setConflict(conflict);
 
     const bool compliant = !Kleo::gpgComplianceP("de-vs") || is_de_vs_compliant(d->sign,
                                                                                 d->encrypt,
                                                                                 senders,
                                                                                 recipients,
                                                                                 d->presetProtocol);
 
     if (quickMode && !conflict && compliant) {
         QMetaObject::invokeMethod(this, "slotDialogAccepted", Qt::QueuedConnection);
     } else {
         d->ensureDialogVisible();
     }
 }
 
 void NewSignEncryptEMailController::Private::slotDialogAccepted()
 {
     if (dialog->isQuickMode() != is_dialog_quick_mode(sign, encrypt)) {
         save_dialog_quick_mode(dialog->isQuickMode());
     }
     resolvingInProgress = false;
     certificatesResolved = true;
     signers = dialog->resolvedSigningKeys();
     recipients = dialog->resolvedEncryptionKeys();
     QMetaObject::invokeMethod(q, "certificatesResolved", Qt::QueuedConnection);
 }
 
 void NewSignEncryptEMailController::Private::slotDialogRejected()
 {
     resolvingInProgress = false;
     certificatesResolved = false;
     QMetaObject::invokeMethod(q, "error", Qt::QueuedConnection,
                               Q_ARG(int, gpg_error(GPG_ERR_CANCELED)),
                               Q_ARG(QString, i18n("User cancel")));
 }
 
 void NewSignEncryptEMailController::startEncryption(const std::vector< std::shared_ptr<Input> > &inputs, const std::vector< std::shared_ptr<Output> > &outputs)
 {
 
     kleo_assert(d->encrypt);
     kleo_assert(!d->resolvingInProgress);
 
     kleo_assert(!inputs.empty());
     kleo_assert(outputs.size() == inputs.size());
 
     std::vector< std::shared_ptr<Task> > tasks;
     tasks.reserve(inputs.size());
 
     kleo_assert(!d->recipients.empty());
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
 
         const std::shared_ptr<EncryptEMailTask> task(new EncryptEMailTask);
 
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         task->setRecipients(d->recipients);
 
         tasks.push_back(task);
     }
 
     // append to runnable stack
     d->runnable.insert(d->runnable.end(), tasks.begin(), tasks.end());
 
     d->startEncryption();
 }
 
 void NewSignEncryptEMailController::Private::startEncryption()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tmp;
     tmp.reserve(runnable.size());
     std::copy(runnable.cbegin(), runnable.cend(), std::back_inserter(tmp));
     coll->setTasks(tmp);
 #if 0
 #warning use a new result dialog
     // ### use a new result dialog
     dialog->setTaskCollection(coll);
 #endif
     Q_FOREACH (const std::shared_ptr<Task> &t, tmp) {
         q->connectTask(t);
     }
     schedule();
 }
 
 void NewSignEncryptEMailController::startSigning(const std::vector< std::shared_ptr<Input> > &inputs, const std::vector< std::shared_ptr<Output> > &outputs)
 {
 
     kleo_assert(d->sign);
     kleo_assert(!d->resolvingInProgress);
 
     kleo_assert(!inputs.empty());
     kleo_assert(!outputs.empty());
 
     std::vector< std::shared_ptr<Task> > tasks;
     tasks.reserve(inputs.size());
 
     kleo_assert(!d->signers.empty());
     kleo_assert(std::none_of(d->signers.cbegin(), d->signers.cend(), std::mem_fn(&Key::isNull)));
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
 
         const std::shared_ptr<SignEMailTask> task(new SignEMailTask);
 
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         task->setSigners(d->signers);
         task->setDetachedSignature(d->detached);
 
         tasks.push_back(task);
     }
 
     // append to runnable stack
     d->runnable.insert(d->runnable.end(), tasks.begin(), tasks.end());
 
     d->startSigning();
 }
 
 void NewSignEncryptEMailController::Private::startSigning()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tmp;
     tmp.reserve(runnable.size());
     std::copy(runnable.cbegin(), runnable.cend(), std::back_inserter(tmp));
     coll->setTasks(tmp);
 #if 0
 #warning use a new result dialog
     // ### use a new result dialog
     dialog->setTaskCollection(coll);
 #endif
     Q_FOREACH (const std::shared_ptr<Task> &t, tmp) {
         q->connectTask(t);
     }
     schedule();
 }
 
 void NewSignEncryptEMailController::Private::schedule()
 {
 
     if (!cms)
         if (const std::shared_ptr<Task> t = takeRunnable(CMS)) {
             t->start();
             cms = t;
         }
 
     if (!openpgp)
         if (const std::shared_ptr<Task> t = takeRunnable(OpenPGP)) {
             t->start();
             openpgp = t;
         }
 
     if (cms || openpgp) {
         return;
     }
     kleo_assert(runnable.empty());
     q->emitDoneOrError();
 }
 
 std::shared_ptr<Task> NewSignEncryptEMailController::Private::takeRunnable(GpgME::Protocol proto)
 {
     const auto it = std::find_if(runnable.begin(), runnable.end(),
                                  [proto](const std::shared_ptr<Task> &task) { return task->protocol() == proto; });
     if (it == runnable.end()) {
         return std::shared_ptr<Task>();
     }
 
     const std::shared_ptr<Task> result = *it;
     runnable.erase(it);
     return result;
 }
 
 void NewSignEncryptEMailController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(task);
 
     if (result && result->hasError()) {
         QPointer<QObject> that = this;
         if (result->details().isEmpty())
             KMessageBox::        sorry(nullptr,
                                        result->overview(),
                                        i18nc("@title:window", "Error"));
         else
             KMessageBox::detailedSorry(nullptr,
                                        result->overview(),
                                        result->details(),
                                        i18nc("@title:window", "Error"));
         if (!that) {
             return;
         }
     }
 
     // We could just delete the tasks here, but we can't use
     // Qt::QueuedConnection here (we need sender()) and other slots
     // might not yet have executed. Therefore, we push completed tasks
     // into a burial container
 
     if (task == d->cms.get()) {
         d->completed.push_back(d->cms);
         d->cms.reset();
     } else if (task == d->openpgp.get()) {
         d->completed.push_back(d->openpgp);
         d->openpgp.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void NewSignEncryptEMailController::cancel()
 {
     try {
         d->dialog->close();
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 void NewSignEncryptEMailController::Private::cancelAllTasks()
 {
 
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     runnable.clear();
 
     // a cancel() will result in a call to
     if (cms) {
         cms->cancel();
     }
     if (openpgp) {
         openpgp->cancel();
     }
 }
 
 void NewSignEncryptEMailController::Private::ensureDialogVisible()
 {
     q->bringToForeground(dialog, true);
 }
 
 #include "moc_newsignencryptemailcontroller.cpp"
diff --git a/src/crypto/signencryptfilescontroller.cpp b/src/crypto/signencryptfilescontroller.cpp
index 7764684a3..d11d42e4f 100644
--- a/src/crypto/signencryptfilescontroller.cpp
+++ b/src/crypto/signencryptfilescontroller.cpp
@@ -1,703 +1,703 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencryptfilescontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptfilescontroller.h"
 
 #include "signencrypttask.h"
 #include "certificateresolver.h"
 
 #include "crypto/gui/signencryptfileswizard.h"
 #include "crypto/taskcollection.h"
 
 #include "fileoperationspreferences.h"
 
 #include "utils/input.h"
 #include "utils/output.h"
 #include "utils/kleo_assert.h"
 #include "utils/archivedefinition.h"
 #include "utils/path-helper.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/Classify>
 
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <QPointer>
 #include <QTimer>
 #include <QFileInfo>
 #include <QDir>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 using namespace KMime::Types;
 
 class SignEncryptFilesController::Private
 {
     friend class ::Kleo::Crypto::SignEncryptFilesController;
     SignEncryptFilesController *const q;
 public:
     explicit Private(SignEncryptFilesController *qq);
     ~Private();
 
 private:
     void slotWizardOperationPrepared();
     void slotWizardCanceled();
 
 private:
     void ensureWizardCreated();
     void ensureWizardVisible();
     void updateWizardMode();
     void cancelAllTasks();
     void reportError(int err, const QString &details)
     {
         q->setLastError(err, details);
         q->emitDoneOrError();
     }
 
     void schedule();
     std::shared_ptr<SignEncryptTask> takeRunnable(GpgME::Protocol proto);
 
     static void assertValidOperation(unsigned int);
     static QString titleForOperation(unsigned int op);
 private:
     std::vector< std::shared_ptr<SignEncryptTask> > runnable, completed;
     std::shared_ptr<SignEncryptTask> cms, openpgp;
     QPointer<SignEncryptFilesWizard> wizard;
     QStringList files;
     unsigned int operation;
     Protocol protocol;
 };
 
 SignEncryptFilesController::Private::Private(SignEncryptFilesController *qq)
     : q(qq),
       runnable(),
       cms(),
       openpgp(),
       wizard(),
       files(),
       operation(SignAllowed | EncryptAllowed | ArchiveAllowed),
       protocol(UnknownProtocol)
 {
 
 }
 
 SignEncryptFilesController::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 QString SignEncryptFilesController::Private::titleForOperation(unsigned int op)
 {
     const bool signDisallowed = (op & SignMask) == SignDisallowed;
     const bool encryptDisallowed = (op & EncryptMask) == EncryptDisallowed;
     const bool archiveSelected = (op & ArchiveMask) == ArchiveForced;
 
     kleo_assert(!signDisallowed || !encryptDisallowed);
 
     if (!signDisallowed && encryptDisallowed) {
         if (archiveSelected) {
             return i18n("Archive and Sign Files");
         } else {
             return i18n("Sign Files");
         }
     }
 
     if (signDisallowed && !encryptDisallowed) {
         if (archiveSelected) {
             return i18n("Archive and Encrypt Files");
         } else {
             return i18n("Encrypt Files");
         }
     }
 
     if (archiveSelected) {
         return i18n("Archive and Sign/Encrypt Files");
     } else {
         return i18n("Sign/Encrypt Files");
     }
 }
 
 SignEncryptFilesController::SignEncryptFilesController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 SignEncryptFilesController::SignEncryptFilesController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *p)
     : Controller(ctx, p), d(new Private(this))
 {
 
 }
 
 SignEncryptFilesController::~SignEncryptFilesController()
 {
     qCDebug(KLEOPATRA_LOG);
     if (d->wizard && !d->wizard->isVisible()) {
         delete d->wizard;
     }
     //d->wizard->close(); ### ?
 }
 
 void SignEncryptFilesController::setProtocol(Protocol proto)
 {
     kleo_assert(d->protocol == UnknownProtocol ||
                 d->protocol == proto);
     d->protocol = proto;
     d->ensureWizardCreated();
 }
 
 Protocol SignEncryptFilesController::protocol() const
 {
     return d->protocol;
 }
 
 // static
 void SignEncryptFilesController::Private::assertValidOperation(unsigned int op)
 {
     kleo_assert((op & SignMask)    == SignDisallowed    ||
                 (op & SignMask)    == SignAllowed       ||
                 (op & SignMask)    == SignSelected);
     kleo_assert((op & EncryptMask) == EncryptDisallowed ||
                 (op & EncryptMask) == EncryptAllowed    ||
                 (op & EncryptMask) == EncryptSelected);
     kleo_assert((op & ArchiveMask) == ArchiveDisallowed ||
                 (op & ArchiveMask) == ArchiveAllowed    ||
                 (op & ArchiveMask) == ArchiveForced);
     kleo_assert((op & ~(SignMask | EncryptMask | ArchiveMask)) == 0);
 }
 
 void SignEncryptFilesController::setOperationMode(unsigned int mode)
 {
     Private::assertValidOperation(mode);
     d->operation = mode;
     d->updateWizardMode();
 }
 
 void SignEncryptFilesController::Private::updateWizardMode()
 {
     if (!wizard) {
         return;
     }
     wizard->setWindowTitle(titleForOperation(operation));
     const unsigned int signOp = (operation & SignMask);
     const unsigned int encrOp = (operation & EncryptMask);
     const unsigned int archOp = (operation & ArchiveMask);
 
     if (signOp == SignDisallowed) {
         wizard->setSigningUserMutable(false);
         wizard->setSigningPreset(false);
     } else {
         wizard->setSigningUserMutable(true);
         wizard->setSigningPreset(signOp == SignSelected);
     }
 
     if (encrOp == EncryptDisallowed) {
         wizard->setEncryptionPreset(false);
         wizard->setEncryptionUserMutable(false);
     } else {
         wizard->setEncryptionUserMutable(true);
         wizard->setEncryptionPreset(false);
         wizard->setEncryptionPreset(encrOp == EncryptSelected);
     }
 
     wizard->setArchiveForced(archOp == ArchiveForced);
     wizard->setArchiveMutable(archOp == ArchiveAllowed);
 }
 
 unsigned int SignEncryptFilesController::operationMode() const
 {
     return d->operation;
 }
 
 static const char *extension(bool pgp, bool sign, bool encrypt, bool ascii, bool detached)
 {
     unsigned int cls = pgp ? Class::OpenPGP : Class::CMS;
     if (encrypt) {
         cls |= Class::CipherText;
     } else if (sign) {
         cls |= detached ? Class::DetachedSignature : Class::OpaqueSignature;
     }
     cls |= ascii ? Class::Ascii : Class::Binary;
     const bool usePGPFileExt = FileOperationsPreferences().usePGPFileExt();
     if (const char *const ext = outputFileExtension(cls, usePGPFileExt)) {
         return ext;
     } else {
         return "out";
     }
 }
 
 static std::shared_ptr<ArchiveDefinition> getDefaultAd()
 {
     std::vector<std::shared_ptr<ArchiveDefinition> > ads = ArchiveDefinition::getArchiveDefinitions();
     Q_ASSERT(!ads.empty());
     std::shared_ptr<ArchiveDefinition> ad = ads.front();
     const FileOperationsPreferences prefs;
     Q_FOREACH (const std::shared_ptr<ArchiveDefinition> toCheck, ads) {
         if (toCheck->id() == prefs.archiveCommand()) {
             ad = toCheck;
             break;
         }
     }
     return ad;
 }
 
 static QMap <int, QString> buildOutputNames(const QStringList &files, const bool archive)
 {
     QMap <int, QString> nameMap;
 
     // Build the default names for the wizard.
     QString baseNameCms;
     QString baseNamePgp;
     const QFileInfo firstFile(files.first());
     if (archive) {
         QString baseName;
         baseName = QDir(heuristicBaseDirectory(files)).absoluteFilePath(files.size() > 1 ?
                 i18nc("base name of an archive file, e.g. archive.zip or archive.tar.gz", "archive") :
                 firstFile.baseName());
 
         const auto ad = getDefaultAd();
         baseNamePgp = baseName + QLatin1Char('.') + ad->extensions(GpgME::OpenPGP).first() + QLatin1Char('.');
         baseNameCms = baseName + QLatin1Char('.') + ad->extensions(GpgME::CMS).first() + QLatin1Char('.');
     } else {
         baseNameCms = baseNamePgp = files.first() + QLatin1Char('.');
     }
     const FileOperationsPreferences prefs;
     const bool ascii = prefs.addASCIIArmor();
 
     nameMap.insert(SignEncryptFilesWizard::SignatureCMS, baseNameCms + QString::fromLatin1(extension(false, true, false, ascii, true)));
     nameMap.insert(SignEncryptFilesWizard::EncryptedCMS, baseNameCms + QString::fromLatin1(extension(false, false, true, ascii, false)));
     nameMap.insert(SignEncryptFilesWizard::CombinedPGP,  baseNamePgp + QString::fromLatin1(extension(true, true, true, ascii, false)));
     nameMap.insert(SignEncryptFilesWizard::EncryptedPGP, baseNamePgp + QString::fromLatin1(extension(true, false, true, ascii, false)));
     nameMap.insert(SignEncryptFilesWizard::SignaturePGP, baseNamePgp + QString::fromLatin1(extension(true, true, false, ascii, true)));
     nameMap.insert(SignEncryptFilesWizard::Directory, heuristicBaseDirectory(files));
     return nameMap;
 }
 
 static QMap <int, QString> buildOutputNamesForDir(const QString &file, const QMap <int, QString> &orig)
 {
     QMap <int, QString> ret;
 
     const QString dir = orig.value(SignEncryptFilesWizard::Directory);
     if (dir.isEmpty()) {
         return orig;
     }
 
     // Build the default names for the wizard.
     const QFileInfo fi(file);
     const QString baseName = dir + QLatin1Char('/') + fi.fileName() + QLatin1Char('.');
 
     const FileOperationsPreferences prefs;
     const bool ascii = prefs.addASCIIArmor();
 
     ret.insert(SignEncryptFilesWizard::SignatureCMS, baseName + QString::fromLatin1(extension(false, true, false, ascii, true)));
     ret.insert(SignEncryptFilesWizard::EncryptedCMS, baseName + QString::fromLatin1(extension(false, false, true, ascii, false)));
     ret.insert(SignEncryptFilesWizard::CombinedPGP,  baseName + QString::fromLatin1(extension(true, true, true, ascii, false)));
     ret.insert(SignEncryptFilesWizard::EncryptedPGP, baseName + QString::fromLatin1(extension(true, false, true, ascii, false)));
     ret.insert(SignEncryptFilesWizard::SignaturePGP, baseName + QString::fromLatin1(extension(true, true, false, ascii, true)));
     return ret;
 }
 
 void SignEncryptFilesController::setFiles(const QStringList &files)
 {
     kleo_assert(!files.empty());
     d->files = files;
     bool archive = false;
 
     if (files.size() > 1) {
         setOperationMode((operationMode() & ~ArchiveMask) | ArchiveAllowed);
         archive = true;
     }
     for (const auto &file: files) {
         if (QFileInfo(file).isDir()) {
             setOperationMode((operationMode() & ~ArchiveMask) | ArchiveForced);
             archive = true;
             break;
         }
     }
     d->ensureWizardCreated();
     d->wizard->setOutputNames(buildOutputNames(files, archive));
 }
 
 void SignEncryptFilesController::Private::slotWizardCanceled()
 {
     qCDebug(KLEOPATRA_LOG);
     reportError(gpg_error(GPG_ERR_CANCELED), i18n("User cancel"));
 }
 
 void SignEncryptFilesController::start()
 {
     d->ensureWizardVisible();
 }
 
 static std::shared_ptr<SignEncryptTask>
 createSignEncryptTaskForFileInfo(const QFileInfo &fi, bool ascii,
                                  const std::vector<Key> &recipients, const std::vector<Key> &signers,
                                  const QString &outputName, bool symmetric)
 {
     const std::shared_ptr<SignEncryptTask> task(new SignEncryptTask);
     Q_ASSERT(!signers.empty() || !recipients.empty() || symmetric);
     task->setAsciiArmor(ascii);
     if (!signers.empty()) {
         task->setSign(true);
         task->setSigners(signers);
         task->setDetachedSignature(true);
     } else {
         task->setSign(false);
     }
     if (!recipients.empty()) {
         task->setEncrypt(true);
         task->setRecipients(recipients);
         task->setDetachedSignature(false);
     } else {
         task->setEncrypt(false);
     }
     task->setEncryptSymmetric(symmetric);
     const QString input = fi.absoluteFilePath();
     task->setInputFileName(input);
     task->setInput(Input::createFromFile(input));
 
     task->setOutputFileName(outputName);
 
     return task;
 }
 
 static std::shared_ptr<SignEncryptTask>
 createArchiveSignEncryptTaskForFiles(const QStringList &files,
                                      const std::shared_ptr<ArchiveDefinition> &ad, bool pgp, bool ascii,
                                      const std::vector<Key> &recipients, const std::vector<Key> &signers,
                                      const QString& outputName, bool symmetric)
 {
     const std::shared_ptr<SignEncryptTask> task(new SignEncryptTask);
     task->setEncryptSymmetric(symmetric);
     Q_ASSERT(!signers.empty() || !recipients.empty() || symmetric);
     task->setAsciiArmor(ascii);
     if (!signers.empty()) {
         task->setSign(true);
         task->setSigners(signers);
         task->setDetachedSignature(false);
     } else {
         task->setSign(false);
     }
     if (!recipients.empty()) {
         task->setEncrypt(true);
         task->setRecipients(recipients);
     } else {
         task->setEncrypt(false);
     }
 
     kleo_assert(ad);
 
     const Protocol proto = pgp ? OpenPGP : CMS;
 
     task->setInputFileNames(files);
     task->setInput(ad->createInputFromPackCommand(proto, files));
 
     task->setOutputFileName(outputName);
 
     return task;
 }
 
 static std::vector< std::shared_ptr<SignEncryptTask> >
 createSignEncryptTasksForFileInfo(const QFileInfo &fi, bool ascii, const std::vector<Key> &pgpRecipients, const std::vector<Key> &pgpSigners,
                                   const std::vector<Key> &cmsRecipients, const std::vector<Key> &cmsSigners, const QMap<int, QString> &outputNames,
                                   bool symmetric)
 {
     std::vector< std::shared_ptr<SignEncryptTask> > result;
 
     const bool pgp = !pgpSigners.empty() || !pgpRecipients.empty();
 
     const bool cms = !cmsSigners.empty() || !cmsRecipients.empty();
 
     result.reserve(pgp + cms);
 
 
     if (pgp || symmetric) {
         // Symmetric encryption is only supported for PGP
         int outKind = 0;
         if ((!pgpRecipients.empty() || symmetric)&& !pgpSigners.empty()) {
             outKind = SignEncryptFilesWizard::CombinedPGP;
         } else if (!pgpRecipients.empty() || symmetric) {
             outKind = SignEncryptFilesWizard::EncryptedPGP;
         } else {
             outKind = SignEncryptFilesWizard::SignaturePGP;
         }
         result.push_back(createSignEncryptTaskForFileInfo(fi, ascii, pgpRecipients, pgpSigners, outputNames[outKind], symmetric));
     }
     if (cms) {
         // There is no combined sign / encrypt in gpgsm so we create one sign task
         // and one encrypt task. Which leaves us with the age old dilemma, encrypt
         // then sign, or sign then encrypt. Ugly.
         if (!cmsSigners.empty()) {
             result.push_back(createSignEncryptTaskForFileInfo(fi, ascii, std::vector<Key>(),
                                                               cmsSigners, outputNames[SignEncryptFilesWizard::SignatureCMS],
                                                               false));
         }
         if (!cmsRecipients.empty()) {
             result.push_back(createSignEncryptTaskForFileInfo(fi, ascii, cmsRecipients,
                                                               std::vector<Key>(), outputNames[SignEncryptFilesWizard::EncryptedCMS],
                                                               false));
         }
     }
 
     return result;
 }
 
 static std::vector< std::shared_ptr<SignEncryptTask> >
 createArchiveSignEncryptTasksForFiles(const QStringList &files, const std::shared_ptr<ArchiveDefinition> &ad,
                                       bool ascii, const std::vector<Key> &pgpRecipients,
                                       const std::vector<Key> &pgpSigners, const std::vector<Key> &cmsRecipients, const std::vector<Key> &cmsSigners,
                                       const QMap<int, QString> &outputNames, bool symmetric)
 {
     std::vector< std::shared_ptr<SignEncryptTask> > result;
 
     const bool pgp = !pgpSigners.empty() || !pgpRecipients.empty();
 
     const bool cms = !cmsSigners.empty() || !cmsRecipients.empty();
 
     result.reserve(pgp + cms);
 
     if (pgp || symmetric) {
         int outKind = 0;
         if ((!pgpRecipients.empty() || symmetric) && !pgpSigners.empty()) {
             outKind = SignEncryptFilesWizard::CombinedPGP;
         } else if (!pgpRecipients.empty() || symmetric) {
             outKind = SignEncryptFilesWizard::EncryptedPGP;
         } else {
             outKind = SignEncryptFilesWizard::SignaturePGP;
         }
         result.push_back(createArchiveSignEncryptTaskForFiles(files, ad, true,  ascii, pgpRecipients, pgpSigners, outputNames[outKind], symmetric));
     }
     if (cms) {
         if (!cmsSigners.empty()) {
             result.push_back(createArchiveSignEncryptTaskForFiles(files, ad, false, ascii,
                                                                   std::vector<Key>(), cmsSigners, outputNames[SignEncryptFilesWizard::SignatureCMS],
                                                                   false));
         }
         if (!cmsRecipients.empty()) {
             result.push_back(createArchiveSignEncryptTaskForFiles(files, ad, false, ascii,
                                                                   cmsRecipients, std::vector<Key>(), outputNames[SignEncryptFilesWizard::EncryptedCMS],
                                                                   false));
         }
     }
 
     return result;
 }
 
 void SignEncryptFilesController::Private::slotWizardOperationPrepared()
 {
 
     try {
         kleo_assert(wizard);
         kleo_assert(!files.empty());
 
         const bool archive = (wizard->outputNames().value(SignEncryptFilesWizard::Directory).isNull() && files.size() > 1) ||
                              ((operation & ArchiveMask) == ArchiveForced);
 
         const QVector<Key> recipients = wizard->resolvedRecipients();
         const QVector<Key> signers = wizard->resolvedSigners();
 
         const FileOperationsPreferences prefs;
         const bool ascii = prefs.addASCIIArmor();
 
         QVector<Key> pgpRecipients, cmsRecipients, pgpSigners, cmsSigners;
         Q_FOREACH (const Key &k, recipients) {
             if (k.protocol() == GpgME::OpenPGP) {
                 pgpRecipients << k;
             } else {
                 cmsRecipients << k;
             }
         }
 
         Q_FOREACH (const Key &k, signers) {
             if (k.protocol() == GpgME::OpenPGP) {
                 pgpSigners << k;
             } else {
                 cmsSigners << k;
             }
         }
 
         std::vector< std::shared_ptr<SignEncryptTask> > tasks;
         if (!archive) {
             tasks.reserve(files.size());
         }
 
         if (archive) {
             tasks = createArchiveSignEncryptTasksForFiles(files,
                     getDefaultAd(),
                     ascii,
                     pgpRecipients.toStdVector(),
                     pgpSigners.toStdVector(),
                     cmsRecipients.toStdVector(),
                     cmsSigners.toStdVector(),
                     wizard->outputNames(),
                     wizard->encryptSymmetric());
 
         } else {
             Q_FOREACH (const QString &file, files) {
                 const std::vector< std::shared_ptr<SignEncryptTask> > created =
                     createSignEncryptTasksForFileInfo(QFileInfo(file), ascii,
                             pgpRecipients.toStdVector(),
                             pgpSigners.toStdVector(),
                             cmsRecipients.toStdVector(),
                             cmsSigners.toStdVector(),
                             buildOutputNamesForDir(file, wizard->outputNames()),
                             wizard->encryptSymmetric());
                 tasks.insert(tasks.end(), created.begin(), created.end());
             }
         }
 
         const std::shared_ptr<OverwritePolicy> overwritePolicy(new OverwritePolicy(wizard));
         Q_FOREACH (const std::shared_ptr<SignEncryptTask> &i, tasks) {
             i->setOverwritePolicy(overwritePolicy);
         }
 
         kleo_assert(runnable.empty());
 
         runnable.swap(tasks);
 
         for (const std::shared_ptr<Task> &task : qAsConst(runnable)) {
             q->connectTask(task);
         }
 
         std::shared_ptr<TaskCollection> coll(new TaskCollection);
 
         std::vector<std::shared_ptr<Task> > tmp;
         std::copy(runnable.begin(), runnable.end(), std::back_inserter(tmp));
         coll->setTasks(tmp);
         wizard->setTaskCollection(coll);
 
         QTimer::singleShot(0, q, SLOT(schedule()));
 
     } catch (const Kleo::Exception &e) {
         reportError(e.error().encodedError(), e.message());
     } catch (const std::exception &e) {
         reportError(gpg_error(GPG_ERR_UNEXPECTED),
                     i18n("Caught unexpected exception in SignEncryptFilesController::Private::slotWizardOperationPrepared: %1",
                          QString::fromLocal8Bit(e.what())));
     } catch (...) {
         reportError(gpg_error(GPG_ERR_UNEXPECTED),
                     i18n("Caught unknown exception in SignEncryptFilesController::Private::slotWizardOperationPrepared"));
     }
 }
 
 void SignEncryptFilesController::Private::schedule()
 {
 
     if (!cms)
         if (const std::shared_ptr<SignEncryptTask> t = takeRunnable(CMS)) {
             t->start();
             cms = t;
         }
 
     if (!openpgp)
         if (const std::shared_ptr<SignEncryptTask> t = takeRunnable(OpenPGP)) {
             t->start();
             openpgp = t;
         }
 
     if (!cms && !openpgp) {
         kleo_assert(runnable.empty());
         q->emitDoneOrError();
     }
 }
 
 std::shared_ptr<SignEncryptTask> SignEncryptFilesController::Private::takeRunnable(GpgME::Protocol proto)
 {
     const auto it = std::find_if(runnable.begin(), runnable.end(),
                                  [proto](const std::shared_ptr<Task> &task) { return task->protocol() == proto; });
     if (it == runnable.end()) {
         return std::shared_ptr<SignEncryptTask>();
     }
 
     const std::shared_ptr<SignEncryptTask> result = *it;
     runnable.erase(it);
     return result;
 }
 
 void SignEncryptFilesController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_UNUSED(result)
     Q_ASSERT(task);
 
     // We could just delete the tasks here, but we can't use
     // Qt::QueuedConnection here (we need sender()) and other slots
     // might not yet have executed. Therefore, we push completed tasks
     // into a burial container
 
     if (task == d->cms.get()) {
         d->completed.push_back(d->cms);
         d->cms.reset();
     } else if (task == d->openpgp.get()) {
         d->completed.push_back(d->openpgp);
         d->openpgp.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void SignEncryptFilesController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     try {
         if (d->wizard) {
             d->wizard->close();
         }
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 void SignEncryptFilesController::Private::cancelAllTasks()
 {
 
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     runnable.clear();
 
     // a cancel() will result in a call to
     if (cms) {
         cms->cancel();
     }
     if (openpgp) {
         openpgp->cancel();
     }
 }
 
 void SignEncryptFilesController::Private::ensureWizardCreated()
 {
     if (wizard) {
         return;
     }
 
     std::unique_ptr<SignEncryptFilesWizard> w(new SignEncryptFilesWizard);
     w->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(w.get(), SIGNAL(operationPrepared()), q, SLOT(slotWizardOperationPrepared()), Qt::QueuedConnection);
     connect(w.get(), SIGNAL(rejected()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
     wizard = w.release();
 
     updateWizardMode();
 }
 
 void SignEncryptFilesController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(wizard);
 }
 
 #include "moc_signencryptfilescontroller.cpp"
diff --git a/src/crypto/signencrypttask.cpp b/src/crypto/signencrypttask.cpp
index 089b2ca9d..c46c861e4 100644
--- a/src/crypto/signencrypttask.cpp
+++ b/src/crypto/signencrypttask.cpp
@@ -1,682 +1,682 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencrypttask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencrypttask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/path-helper.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 #include <QGpgME/SignEncryptJob>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 QString formatInputOutputLabel(const QString &input, const QString &output, bool outputDeleted)
 {
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  input.toHtmlEscaped(),
                  outputDeleted ? QStringLiteral("<s>%1</s>").arg(output.toHtmlEscaped()) : output.toHtmlEscaped());
 }
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(bool sign, bool encrypt, const Error &err, const QString &errStr, const QString &input, const QString &output, const AuditLog &auditLog)
         : Task::Result(), m_sign(sign), m_encrypt(encrypt), m_error(err), m_errString(errStr), m_inputLabel(input), m_outputLabel(output), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override
     {
         return m_error.encodedError();
     }
     QString errorString() const override
     {
         return m_errString;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLog auditLog() const override
     {
         return m_auditLog;
     }
 private:
     const bool m_sign;
     const bool m_encrypt;
     const Error m_error;
     const QString m_errString;
     const QString m_inputLabel;
     const QString m_outputLabel;
     const AuditLog m_auditLog;
 };
 
 class SignEncryptFilesResult : public Task::Result
 {
 public:
     SignEncryptFilesResult(const SigningResult &sr, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull());
     }
     SignEncryptFilesResult(const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_eresult.isNull());
     }
     SignEncryptFilesResult(const SigningResult &sr, const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated,  const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull() || !m_eresult.isNull());
     }
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLog auditLog() const override;
 
 private:
     const SigningResult m_sresult;
     const EncryptionResult m_eresult;
     const QString m_inputLabel;
     const QString m_inputErrorString;
     const QString m_outputLabel;
     const QString m_outputErrorString;
     const bool m_outputCreated;
     const AuditLog m_auditLog;
 };
 
 static QString makeSigningOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed.");
     }
     return i18n("Signing succeeded.");
 }
 
 static QString makeResultOverview(const SigningResult &result)
 {
     return makeSigningOverview(result.error());
 }
 
 static QString makeEncryptionOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed.");
     }
 
     return i18n("Encryption succeeded.");
 }
 
 static QString makeResultOverview(const EncryptionResult &result)
 {
     return makeEncryptionOverview(result.error());
 }
 
 static QString makeResultOverview(const SigningResult &sr, const EncryptionResult &er)
 {
     if (er.isNull() && sr.isNull()) {
         return QString();
     }
     if (er.isNull()) {
         return makeResultOverview(sr);
     }
     if (sr.isNull()) {
         return makeResultOverview(er);
     }
     if (sr.error().isCanceled() || sr.error()) {
         return makeResultOverview(sr);
     }
     if (er.error().isCanceled() || er.error()) {
         return makeResultOverview(er);
     }
     return i18n("Signing and encryption succeeded.");
 }
 
 static QString escape(QString s)
 {
     s = s.toHtmlEscaped();
     s.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
     return s;
 }
 
 static QString makeResultDetails(const SigningResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return QString();
 }
 
 static QString makeResultDetails(const EncryptionResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return i18n(" Encryption succeeded.");
 }
 
 }
 
 QString ErrorResult::overview() const
 {
     Q_ASSERT(m_error || m_error.isCanceled());
     Q_ASSERT(m_sign || m_encrypt);
     const QString label = formatInputOutputLabel(m_inputLabel, m_outputLabel, true);
     const bool canceled = m_error.isCanceled();
     if (m_sign && m_encrypt) {
         return canceled ? i18n("%1: <b>Sign/encrypt canceled.</b>", label) : i18n(" %1: Sign/encrypt failed.", label);
     }
     return i18nc("label: result. Example: foo -> foo.gpg: Encryption failed.", "%1: <b>%2</b>", label,
                  m_sign ? makeSigningOverview(m_error) : makeEncryptionOverview(m_error));
 }
 
 QString ErrorResult::details() const
 {
     return m_errString;
 }
 
 class SignEncryptTask::Private
 {
     friend class ::Kleo::Crypto::SignEncryptTask;
     SignEncryptTask *const q;
 public:
     explicit Private(SignEncryptTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createSignJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptJob> createSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptJob> createEncryptJob(GpgME::Protocol proto);
     std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog);
 
 private:
     void slotResult(const SigningResult &);
     void slotResult(const SigningResult &, const EncryptionResult &);
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     QStringList inputFileNames;
     QString outputFileName;
     std::vector<Key> signers;
     std::vector<Key> recipients;
 
     bool sign     : 1;
     bool encrypt  : 1;
     bool detached : 1;
     bool symmetric: 1;
     bool clearsign: 1;
 
     QPointer<QGpgME::Job> job;
     std::shared_ptr<OverwritePolicy> m_overwritePolicy;
 };
 
 SignEncryptTask::Private::Private(SignEncryptTask *qq)
     : q(qq),
       input(),
       output(),
       inputFileNames(),
       outputFileName(),
       signers(),
       recipients(),
       sign(true),
       encrypt(true),
       detached(false),
       clearsign(false),
       job(nullptr),
       m_overwritePolicy(new OverwritePolicy(nullptr))
 {
     q->setAsciiArmor(true);
 }
 
 std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog)
 {
     return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, input->label(), output->label(), auditLog));
 }
 
 SignEncryptTask::SignEncryptTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEncryptTask::~SignEncryptTask() {}
 
 void SignEncryptTask::setInputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->inputFileNames = QStringList(fileName);
 }
 
 void SignEncryptTask::setInputFileNames(const QStringList &fileNames)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileNames.empty());
     d->inputFileNames = fileNames;
 }
 
 void SignEncryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEncryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEncryptTask::setOutputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->outputFileName = fileName;
 }
 
 void SignEncryptTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     d->signers = signers;
 }
 
 void SignEncryptTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     d->recipients = recipients;
 }
 
 void SignEncryptTask::setOverwritePolicy(const std::shared_ptr<OverwritePolicy> &policy)
 {
     kleo_assert(!d->job);
     d->m_overwritePolicy = policy;
 }
 
 void SignEncryptTask::setSign(bool sign)
 {
     kleo_assert(!d->job);
     d->sign = sign;
 }
 
 void SignEncryptTask::setEncrypt(bool encrypt)
 {
     kleo_assert(!d->job);
     d->encrypt = encrypt;
 }
 
 void SignEncryptTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
 }
 
 void SignEncryptTask::setEncryptSymmetric(bool symmetric)
 {
     kleo_assert(!d->job);
     d->symmetric = symmetric;
 }
 
 void SignEncryptTask::setClearsign(bool clearsign)
 {
     kleo_assert(!d->job);
     d->clearsign = clearsign;
 }
 
 Protocol SignEncryptTask::protocol() const
 {
     if (d->sign && !d->signers.empty()) {
         return d->signers.front().protocol();
     }
     if (d->encrypt || d->symmetric) {
         if (!d->recipients.empty()) {
             return d->recipients.front().protocol();
         } else {
             return GpgME::OpenPGP;    // symmetric OpenPGP encryption
         }
     }
     throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                           i18n("Cannot determine protocol for task"));
 }
 
 QString SignEncryptTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 QString SignEncryptTask::tag() const
 {
     return Formatting::displayName(protocol());
 }
 
 unsigned long long SignEncryptTask::inputSize() const
 {
     return d->input ? d->input->size() : 0U;
 }
 
 void SignEncryptTask::doStart()
 {
     kleo_assert(!d->job);
     if (d->sign) {
         kleo_assert(!d->signers.empty());
     }
 
     kleo_assert(d->input);
 
     if (!d->output) {
         d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
     }
 
     if (d->encrypt || d->symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (d->symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (d->sign) {
             std::unique_ptr<QGpgME::SignEncryptJob> job = d->createSignEncryptJob(protocol());
             kleo_assert(job.get());
 
             job->start(d->signers, d->recipients,
                        d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptJob> job = d->createEncryptJob(protocol());
             kleo_assert(job.get());
 
             job->start(d->recipients, d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         }
     } else if (d->sign) {
         std::unique_ptr<QGpgME::SignJob> job = d->createSignJob(protocol());
         kleo_assert(job.get());
         kleo_assert(! (d->detached && d->clearsign));
 
         job->start(d->signers,
                    d->input->ioDevice(), d->output->ioDevice(),
                    d->detached ? GpgME::Detached : d->clearsign ?
                               GpgME::Clearsigned : GpgME::NormalSignatureMode);
 
         d->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 void SignEncryptTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEncryptTask::Private::createSignJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signJob.get());
     connect(signJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptJob> SignEncryptTask::Private::createSignEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptJob> signEncryptJob(backend->signEncryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signEncryptJob.get());
     connect(signEncryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signEncryptJob.get(), SIGNAL(result(GpgME::SigningResult,GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult,GpgME::EncryptionResult)));
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptJob> SignEncryptTask::Private::createEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(encryptJob.get());
     connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &result)
 {
     const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (sresult.error().code() || eresult.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!sresult.isNull() || !eresult.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
 {
     const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape(input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 QString SignEncryptFilesResult::overview() const
 {
     const QString files = formatInputOutputLabel(m_inputLabel, m_outputLabel, !m_outputCreated);
     return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
 }
 
 QString SignEncryptFilesResult::details() const
 {
     return errorString();
 }
 
 int SignEncryptFilesResult::errorCode() const
 {
     if (m_sresult.error().code()) {
         return m_sresult.error().encodedError();
     }
     if (m_eresult.error().code()) {
         return m_eresult.error().encodedError();
     }
     return 0;
 }
 
 QString SignEncryptFilesResult::errorString() const
 {
     const bool sign = !m_sresult.isNull();
     const bool encrypt = !m_eresult.isNull();
 
     kleo_assert(sign || encrypt);
 
     if (sign && encrypt) {
         return
             m_sresult.error().code() ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
             m_eresult.error().code() ? makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString) :
             QString();
     }
 
     return
         sign   ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
         /*else*/ makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString);
 }
 
 Task::Result::VisualCode SignEncryptFilesResult::code() const
 {
     if (m_sresult.error().isCanceled() || m_eresult.error().isCanceled()) {
         return Warning;
     }
     return (m_sresult.error().code() || m_eresult.error().code()) ? NeutralError : NeutralSuccess;
 }
 
 AuditLog SignEncryptFilesResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signencrypttask.cpp"
diff --git a/src/crypto/task.cpp b/src/crypto/task.cpp
index 1ab516537..f19ccb806 100644
--- a/src/crypto/task.cpp
+++ b/src/crypto/task.cpp
@@ -1,235 +1,235 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/task.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include "task.h"
 #include "task_p.h"
 #include "kleopatra_debug.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <Libkleo/GnuPG>
 #include <utils/auditlog.h>
 
 #include <gpgme++/exception.h>
 
 #include <gpg-error.h>
 
 #include <KIconLoader>
 #include <KLocalizedString>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(int code, const QString &details)
         : Task::Result(), m_code(code), m_details(details) {}
 
     QString overview() const override
     {
         return makeOverview(m_details);
     }
     QString details() const override
     {
         return QString();
     }
     int errorCode() const override
     {
         return m_code;
     }
     QString errorString() const override
     {
         return m_details;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLog auditLog() const override
     {
         return AuditLog();
     }
 private:
     const int m_code;
     const QString m_details;
 };
 }
 
 class Task::Private
 {
     friend class ::Kleo::Crypto::Task;
     Task *const q;
 public:
     explicit Private(Task *qq);
 
 private:
     QString m_progressLabel;
     int m_progress;
     int m_totalProgress;
     bool m_asciiArmor;
     int m_id;
 };
 
 namespace
 {
 static int nextTaskId = 0;
 }
 
 Task::Private::Private(Task *qq)
     : q(qq), m_progressLabel(), m_progress(0), m_totalProgress(0), m_asciiArmor(false), m_id(nextTaskId++)
 {
 
 }
 
 Task::Task(QObject *p)
     : QObject(p), d(new Private(this))
 {
 
 }
 
 Task::~Task() {}
 
 void Task::setAsciiArmor(bool armor)
 {
     d->m_asciiArmor = armor;
 }
 
 bool Task::asciiArmor() const
 {
     return d->m_asciiArmor;
 }
 
 std::shared_ptr<Task> Task::makeErrorTask(int code, const QString &details, const QString &label)
 {
     const std::shared_ptr<SimpleTask> t(new SimpleTask(label));
     t->setResult(t->makeErrorResult(code, details));
     return t;
 }
 
 int Task::id() const
 {
     return d->m_id;
 }
 
 int Task::currentProgress() const
 {
     return d->m_progress;
 }
 
 int Task::totalProgress() const
 {
     return d->m_totalProgress;
 }
 
 QString Task::tag() const
 {
     return QString();
 }
 
 QString Task::progressLabel() const
 {
     return d->m_progressLabel;
 }
 
 void Task::setProgress(const QString &label, int processed, int total)
 {
     d->m_progress = processed;
     d->m_totalProgress = total;
     d->m_progressLabel = label;
     Q_EMIT progress(label, processed, total, QPrivateSignal());
 }
 
 void Task::start()
 {
     try {
         doStart();
     } catch (const Kleo::Exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(int, e.error().encodedError()), Q_ARG(QString, e.message()));
     } catch (const GpgME::Exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(int, e.error().encodedError()), Q_ARG(QString, QString::fromLocal8Bit(e.what())));
     } catch (const std::exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(int, makeGnuPGError(GPG_ERR_UNEXPECTED)), Q_ARG(QString, QString::fromLocal8Bit(e.what())));
     } catch (...) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(int, makeGnuPGError(GPG_ERR_UNEXPECTED)), Q_ARG(QString, i18n("Unknown exception in Task::start()")));
     }
     Q_EMIT started(QPrivateSignal());
 }
 
 void Task::emitError(int errCode, const QString &details)
 {
     emitResult(makeErrorResult(errCode, details));
 }
 
 void Task::emitResult(const std::shared_ptr<const Task::Result> &r)
 {
     d->m_progress = d->m_totalProgress;
     Q_EMIT progress(progressLabel(), currentProgress(), totalProgress(), QPrivateSignal());
     Q_EMIT result(r, QPrivateSignal());
 }
 
 std::shared_ptr<Task::Result> Task::makeErrorResult(int errCode, const QString &details)
 {
     return std::shared_ptr<Task::Result>(new ErrorResult(errCode, details));
 }
 
 class Task::Result::Private
 {
 public:
     Private() {}
 };
 
 Task::Result::Result() : d(new Private()) {}
 Task::Result::~Result() {}
 
 bool Task::Result::hasError() const
 {
     return errorCode() != 0;
 }
 
 static QString image(const char *img)
 {
     // ### escape?
     return KIconLoader::global()->iconPath(QLatin1String(img), KIconLoader::Small);
 }
 
 QString Task::Result::makeOverview(const QString &msg)
 {
     return QLatin1String("<b>") + msg + QLatin1String("</b>");
 }
 
 QString Task::Result::iconPath(VisualCode code)
 {
     switch (code) {
     case Danger:
         return image("dialog-error");
     case AllGood:
         return image("dialog-ok");
     case Warning:
         return image("dialog-warning");
     case NeutralError:
     case NeutralSuccess:
     default:
         return QString();
 
     }
 }
 
 QString Task::Result::icon() const
 {
     return iconPath(code());
 }
 
 #include "moc_task_p.cpp"
diff --git a/src/uiserver/assuanserverconnection.cpp b/src/uiserver/assuanserverconnection.cpp
index 9f72b5797..95aa8ec02 100644
--- a/src/uiserver/assuanserverconnection.cpp
+++ b/src/uiserver/assuanserverconnection.cpp
@@ -1,1690 +1,1690 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/assuanserverconnection.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #ifndef QT_NO_CAST_TO_ASCII
 # define QT_NO_CAST_TO_ASCII
 #endif
 #ifndef QT_NO_CAST_FROM_ASCII
 # define QT_NO_CAST_FROM_ASCII
 #endif
 
 #include <config-kleopatra.h>
 #include <version-kleopatra.h>
 
 #include "assuanserverconnection.h"
 #include "assuancommand.h"
 #include "sessiondata.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <Libkleo/GnuPG>
 #include <utils/detail_p.h>
 #include <utils/hex.h>
 #include <utils/log.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/data.h>
 #include <gpgme++/key.h>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 #include <KWindowSystem>
 
 #include <QSocketNotifier>
 #include <QTimer>
 #include <QVariant>
 #include <QPointer>
 #include <QFileInfo>
 #include <QStringList>
 #include <QRegExp>
 #include <QWidget>
 #include <QCoreApplication>
 
 
 #include <map>
 #include <algorithm>
 #include <functional>
 #include <type_traits>
 
 #include <errno.h>
 
 #ifdef __GLIBCXX__
 # include <ext/algorithm> // for is_sorted
 #endif
 
 #ifdef Q_OS_WIN32
 # include <io.h>
 # include <process.h>
 #else
 # include <sys/types.h>
 # include <unistd.h>
 #endif
 using namespace Kleo;
 
 static const unsigned int INIT_SOCKET_FLAGS = 3; // says info assuan...
 //static int(*USE_DEFAULT_HANDLER)(assuan_context_t,char*) = 0;
 static const int FOR_READING = 0;
 static const unsigned int MAX_ACTIVE_FDS = 32;
 
 #ifdef HAVE_ASSUAN2
 static void my_assuan_release(assuan_context_t ctx)
 {
     if (ctx) {
         assuan_release(ctx);
     }
 }
 
 #endif
 // std::shared_ptr for assuan_context_t w/ deleter enforced to assuan_deinit_server:
 typedef std::shared_ptr<std::remove_pointer<assuan_context_t>::type> AssuanContextBase;
 struct AssuanContext : AssuanContextBase {
     AssuanContext() : AssuanContextBase() {}
 #ifndef HAVE_ASSUAN2
     explicit AssuanContext(assuan_context_t ctx) : AssuanContextBase(ctx, &assuan_deinit_server) {}
 #else
     explicit AssuanContext(assuan_context_t ctx) : AssuanContextBase(ctx, &my_assuan_release) {}
 #endif
 
 #ifndef HAVE_ASSUAN2
     void reset(assuan_context_t ctx = 0)
     {
         AssuanContextBase::reset(ctx, &assuan_deinit_server);
     }
 #else
     void reset(assuan_context_t ctx = nullptr)
     {
         AssuanContextBase::reset(ctx, &my_assuan_release);
     }
 #endif
 };
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const char *err_msg)
 {
     return assuan_process_done(ctx, assuan_set_error(ctx, err, err_msg));
 }
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const std::string &err_msg)
 {
     return assuan_process_done_msg(ctx, err, err_msg.c_str());
 }
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const QString &err_msg)
 {
     return assuan_process_done_msg(ctx, err, err_msg.toUtf8().constData());
 }
 
 static std::map<std::string, std::string> upcase_option(const char *option, std::map<std::string, std::string> options)
 {
     std::string value;
     bool value_found = false;
     std::map<std::string, std::string>::iterator it = options.begin();
     while (it != options.end())
         if (qstricmp(it->first.c_str(), option) == 0) {
             value = it->second;
             options.erase(it++);
             value_found = true;
         } else {
             ++it;
         }
     if (value_found) {
         options[option] = value;
     }
     return options;
 }
 
 static std::map<std::string, std::string> parse_commandline(const char *line)
 {
     std::map<std::string, std::string> result;
     if (line) {
         const char *begin = line;
         const char *lastEQ = nullptr;
         while (*line) {
             if (*line == ' ' || *line == '\t') {
                 if (begin != line) {
                     if (begin[0] == '-' && begin[1] == '-') {
                         begin += 2;    // skip initial "--"
                     }
                     if (lastEQ && lastEQ > begin) {
                         result[ std::string(begin, lastEQ - begin) ] = hexdecode(std::string(lastEQ + 1, line - (lastEQ + 1)));
                     } else {
                         result[ std::string(begin,  line  - begin) ] = std::string();
                     }
                 }
                 begin = line + 1;
             } else if (*line == '=') {
                 if (line == begin)
                     throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX),
                                     i18n("No option name given"));
                 else {
                     lastEQ = line;
                 }
             }
             ++line;
         }
         if (begin != line) {
             if (begin[0] == '-' && begin[1] == '-') {
                 begin += 2;    // skip initial "--"
             }
             if (lastEQ && lastEQ > begin) {
                 result[ std::string(begin, lastEQ - begin) ] = hexdecode(std::string(lastEQ + 1, line - (lastEQ + 1)));
             } else {
                 result[ begin ] = std::string();
             }
         }
     }
 
     return result;
 }
 
 static WId wid_from_string(const QString &winIdStr, bool *ok = nullptr)
 {
     return static_cast<WId>(winIdStr.toULongLong(ok, 16));
 }
 
 static void apply_window_id(QWidget *widget, const QString &winIdStr)
 {
     if (!widget || winIdStr.isEmpty()) {
         return;
     }
     bool ok = false;
     const WId wid = wid_from_string(winIdStr, &ok);
     if (!ok) {
         qCDebug(KLEOPATRA_LOG) << "window-id value" << wid << "doesn't look like a number";
         return;
     }
     if (QWidget *pw = QWidget::find(wid)) {
         widget->setParent(pw, widget->windowFlags());
     } else {
         widget->setAttribute(Qt::WA_NativeWindow, true);
         KWindowSystem::setMainWindow(widget->windowHandle(), wid);
     }
 }
 
 //
 //
 // AssuanServerConnection:
 //
 //
 
 class AssuanServerConnection::Private : public QObject
 {
     Q_OBJECT
     friend class ::Kleo::AssuanServerConnection;
     friend class ::Kleo::AssuanCommandFactory;
     friend class ::Kleo::AssuanCommand;
     AssuanServerConnection *const q;
 public:
     Private(assuan_fd_t fd_, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories_, AssuanServerConnection *qq);
     ~Private();
 
 Q_SIGNALS:
     void startKeyManager();
 
 public Q_SLOTS:
     void slotReadActivity(int)
     {
         Q_ASSERT(ctx);
 #ifndef HAVE_ASSUAN2
         if (const int err = assuan_process_next(ctx.get())) {
 #else
         int done = false;
         if (const int err = assuan_process_next(ctx.get(), &done) || done) {
 #endif
             //if ( err == -1 || gpg_err_code(err) == GPG_ERR_EOF ) {
             topHalfDeletion();
             if (nohupedCommands.empty()) {
                 bottomHalfDeletion();
             }
             //} else {
             //assuan_process_done( ctx.get(), err );
             //return;
             //}
         }
     }
 
     int startCommandBottomHalf();
 
 private:
     void nohupDone(AssuanCommand *cmd)
     {
         const auto it = std::find_if(nohupedCommands.begin(), nohupedCommands.end(),
                                      [cmd](const std::shared_ptr<AssuanCommand> &other) {
                                         return other.get() == cmd;
                                      });
         Q_ASSERT(it != nohupedCommands.end());
         nohupedCommands.erase(it);
         if (nohupedCommands.empty() && closed) {
             bottomHalfDeletion();
         }
     }
 
     void commandDone(AssuanCommand *cmd)
     {
         if (!cmd || cmd != currentCommand.get()) {
             return;
         }
         currentCommand.reset();
     }
 
     void topHalfDeletion()
     {
         if (currentCommand) {
             currentCommand->canceled();
         }
         if (fd != ASSUAN_INVALID_FD) {
 #if defined(Q_OS_WIN32)
             CloseHandle(fd);
 #else
             ::close(fd);
 #endif
         }
         notifiers.clear();
         closed = true;
     }
 
     void bottomHalfDeletion()
     {
         if (sessionId) {
             SessionDataHandler::instance()->exitSession(sessionId);
         }
         cleanup();
         const QPointer<Private> that = this;
         Q_EMIT q->closed(q);
         if (that) { // still there
             q->deleteLater();
         }
     }
 
 private:
 #ifndef HAVE_ASSUAN2
     static void reset_handler(assuan_context_t ctx_)
     {
 #else
     static gpg_error_t reset_handler(assuan_context_t ctx_, char *)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
 
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         conn.reset();
 #ifdef HAVE_ASSUAN2
 
         return 0;
 #endif
     }
 
 #ifndef HAVE_ASSUAN2
     static int option_handler(assuan_context_t ctx_, const char *key, const char *value)
     {
 #else
     static gpg_error_t option_handler(assuan_context_t ctx_, const char *key, const char *value)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
 
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (key && key[0] == '-' && key[1] == '-') {
             key += 2;    // skip "--"
         }
         conn.options[key] = QString::fromUtf8(value);
 
         return 0;
         //return gpg_error( GPG_ERR_UNKNOWN_OPTION );
     }
 
 #ifndef HAVE_ASSUAN2
     static int session_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t session_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         const QString str = QString::fromUtf8(line);
         QRegExp rx(QLatin1String("(\\d+)(?:\\s+(.*))?"));
         if (!rx.exactMatch(str)) {
             static const QString errorString = i18n("Parse error");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_SYNTAX), errorString);
         }
         bool ok = false;
         if (const qulonglong id = rx.cap(1).toULongLong(&ok)) {
             if (ok && id <= std::numeric_limits<unsigned int>::max()) {
                 SessionDataHandler::instance()->enterSession(id);
                 conn.sessionId = id;
             } else {
                 static const QString errorString = i18n("Parse error: numeric session id too large");
                 return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_SYNTAX), errorString);
             }
         }
         if (!rx.cap(2).isEmpty()) {
             conn.sessionTitle = rx.cap(2);
         }
         qCDebug(KLEOPATRA_LOG) << "session_handler: "
                                << "id=" << static_cast<unsigned long>(conn.sessionId)
                                << ", title=" << qPrintable(conn.sessionTitle);
         return assuan_process_done(ctx_, 0);
     }
 
 #ifndef HAVE_ASSUAN2
     static int capabilities_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t capabilities_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         if (!QByteArray(line).trimmed().isEmpty()) {
             static const QString errorString = i18n("CAPABILITIES does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
         static const char capabilities[] =
             "SENDER=info\n"
             "RECIPIENT=info\n"
             "SESSION\n"
             ;
         return assuan_process_done(ctx_, assuan_send_data(ctx_, capabilities, sizeof capabilities - 1));
     }
 
 #ifndef HAVE_ASSUAN2
     static int getinfo_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t getinfo_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (qstrcmp(line, "version") == 0) {
             static const char version[] = "Kleopatra " KLEOPATRA_VERSION_STRING;
             return assuan_process_done(ctx_, assuan_send_data(ctx_, version, sizeof version - 1));
         }
 
         QByteArray ba;
         if (qstrcmp(line, "pid") == 0) {
             ba = QByteArray::number(QCoreApplication::applicationPid());
         } else if (qstrcmp(line, "options") == 0) {
             ba = conn.dumpOptions();
         } else if (qstrcmp(line, "x-mementos") == 0) {
             ba = conn.dumpMementos();
         } else if (qstrcmp(line, "senders") == 0) {
             ba = conn.dumpSenders();
         } else if (qstrcmp(line, "recipients") == 0) {
             ba = conn.dumpRecipients();
         } else if (qstrcmp(line, "x-files") == 0) {
             ba = conn.dumpFiles();
         } else {
             static const QString errorString = i18n("Unknown value for WHAT");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
         return assuan_process_done(ctx_, assuan_send_data(ctx_, ba.constData(), ba.size()));
     }
 
 #ifndef HAVE_ASSUAN2
     static int start_keymanager_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t start_keymanager_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (line && *line) {
             static const QString errorString = i18n("START_KEYMANAGER does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
 
         Q_EMIT conn.q->startKeyManagerRequested();
 
         return assuan_process_done(ctx_, 0);
     }
 
 #ifndef HAVE_ASSUAN2
     static int start_confdialog_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t start_confdialog_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (line && *line) {
             static const QString errorString = i18n("START_CONFDIALOG does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
 
         Q_EMIT conn.q->startConfigDialogRequested();
 
         return assuan_process_done(ctx_, 0);
     }
 
     template <bool in>
     struct Input_or_Output : std::conditional<in, Input, Output> {};
 
     // format: TAG (FD|FD=\d+|FILE=...)
     template <bool in, typename T_memptr>
 #ifndef HAVE_ASSUAN2
     static int IO_handler(assuan_context_t ctx_, char *line_, T_memptr which)
     {
 #else
     static gpg_error_t IO_handler(assuan_context_t ctx_, char *line_, T_memptr which)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         char *binOpt = strstr(line_, "--binary");
 
         if (binOpt && !in) {
             /* Note there is also --armor and --base64 allowed but we don't need
              * to parse those because they are default.
              * We remove it here so that it is not parsed as an Option.*/
             memset(binOpt, ' ', 8);
         }
 
         try {
 
             /*const*/ std::map<std::string, std::string> options = upcase_option("FD", upcase_option("FILE", parse_commandline(line_)));
             if (options.size() < 1 || options.size() > 2) {
                 throw gpg_error(GPG_ERR_ASS_SYNTAX);
             }
 
             std::shared_ptr< typename Input_or_Output<in>::type > io;
 
             if (options.count("FD")) {
 
                 if (options.count("FILE")) {
                     throw gpg_error(GPG_ERR_CONFLICT);
                 }
 
                 assuan_fd_t fd = ASSUAN_INVALID_FD;
 
                 const std::string fdstr = options["FD"];
 
                 if (fdstr.empty()) {
                     if (const gpg_error_t err = assuan_receivefd(conn.ctx.get(), &fd)) {
                         throw err;
                     }
                 } else {
 #if defined(Q_OS_WIN32)
                     fd = (assuan_fd_t)std::stoi(fdstr);
 #else
                     fd = std::stoi(fdstr);
 #endif
                 }
 
                 io = Input_or_Output<in>::type::createFromPipeDevice(fd, in ? i18n("Message #%1", (conn.*which).size() + 1) : QString());
 
                 options.erase("FD");
 
             } else if (options.count("FILE")) {
 
                 if (options.count("FD")) {
                     throw gpg_error(GPG_ERR_CONFLICT);
                 }
 
                 const QString filePath = QFile::decodeName(options["FILE"].c_str());
                 if (filePath.isEmpty()) {
                     throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX), i18n("Empty file path"));
                 }
                 const QFileInfo fi(filePath);
                 if (!fi.isAbsolute()) {
                     throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only absolute file paths are allowed"));
                 }
                 if (!fi.isFile()) {
                     throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only files are allowed in INPUT/OUTPUT FILE"));
                 } else {
                     io = Input_or_Output<in>::type::createFromFile(fi.absoluteFilePath(), true);
                 }
 
                 options.erase("FILE");
 
             } else {
 
                 throw gpg_error(GPG_ERR_ASS_PARAMETER);
 
             }
 
             if (options.size()) {
                 throw gpg_error(GPG_ERR_UNKNOWN_OPTION);
             }
 
             (conn.*which).push_back(io);
 
             if (binOpt && !in) {
                 Output *out = reinterpret_cast <Output *>(io.get());
                 out->setBinaryOpt(true);
                 qCDebug(KLEOPATRA_LOG) << "Configured output for binary data";
             }
 
             qCDebug(KLEOPATRA_LOG) << "AssuanServerConnection: added" << io->label();
 
             return assuan_process_done(conn.ctx.get(), 0);
         } catch (const GpgME::Exception &e) {
             return assuan_process_done_msg(conn.ctx.get(), e.error().encodedError(), e.message().c_str());
         } catch (const std::exception &) {
             return assuan_process_done(conn.ctx.get(), gpg_error(GPG_ERR_ASS_SYNTAX));
         } catch (const gpg_error_t &e) {
             return assuan_process_done(conn.ctx.get(), e);
         } catch (...) {
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), "unknown exception caught");
         }
 
     }
 
 #ifndef HAVE_ASSUAN2
     static int input_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t input_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<true>(ctx, line, &Private::inputs);
     }
 
 #ifndef HAVE_ASSUAN2
     static int output_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t output_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<false>(ctx, line, &Private::outputs);
     }
 
 #ifndef HAVE_ASSUAN2
     static int message_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t message_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<true>(ctx, line, &Private::messages);
     }
 
 #ifndef HAVE_ASSUAN2
     static int file_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t file_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         try {
             const QFileInfo fi(QFile::decodeName(hexdecode(line).c_str()));
             if (!fi.isAbsolute()) {
                 throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only absolute file paths are allowed"));
             }
             if (!fi.exists()) {
                 throw gpg_error(GPG_ERR_ENOENT);
             }
             if (!fi.isReadable() || (fi.isDir() && !fi.isExecutable())) {
                 throw gpg_error(GPG_ERR_EPERM);
             }
 
             conn.files.push_back(fi.absoluteFilePath());
 
             return assuan_process_done(conn.ctx.get(), 0);
         } catch (const Exception &e) {
             return assuan_process_done_msg(conn.ctx.get(), e.error().encodedError(), e.message().toUtf8().constData());
         } catch (const gpg_error_t &e) {
             return assuan_process_done(conn.ctx.get(), e);
         } catch (...) {
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("unknown exception caught").toUtf8().constData());
         }
     }
 
     static bool parse_informative(const char *&begin, GpgME::Protocol &protocol)
     {
         protocol = GpgME::UnknownProtocol;
         bool informative = false;
         const char *pos = begin;
         while (true) {
             while (*pos == ' ' || *pos == '\t') {
                 ++pos;
             }
             if (qstrnicmp(pos, "--info", strlen("--info")) == 0) {
                 informative = true;
                 pos += strlen("--info");
                 if (*pos == '=') {
                     ++pos;
                     break;
                 }
             } else if (qstrnicmp(pos, "--protocol=", strlen("--protocol=")) == 0) {
                 pos += strlen("--protocol=");
                 if (qstrnicmp(pos, "OpenPGP", strlen("OpenPGP")) == 0) {
                     protocol = GpgME::OpenPGP;
                     pos += strlen("OpenPGP");
                 } else if (qstrnicmp(pos, "CMS", strlen("CMS")) == 0) {
                     protocol = GpgME::CMS;
                     pos += strlen("CMS");
                 } else {
                     ;
                 }
             } else if (qstrncmp(pos, "-- ", strlen("-- ")) == 0) {
                 pos += 3;
                 while (*pos == ' ' || *pos == '\t') {
                     ++pos;
                 }
                 break;
             } else {
                 break;
             }
         }
         begin = pos;
         return informative;
     }
 
     template <typename T_memptr, typename T_memptr2>
 #ifndef HAVE_ASSUAN2
     static int recipient_sender_handler(T_memptr mp, T_memptr2 info, assuan_context_t ctx, char *line, bool sender = false)
     {
 #else
     static gpg_error_t recipient_sender_handler(T_memptr mp, T_memptr2 info, assuan_context_t ctx, char *line, bool sender = false)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx));
 
         if (!line || !*line) {
             return assuan_process_done(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG));
         }
         const char *begin     = line;
         const char *const end = begin + qstrlen(line);
         GpgME::Protocol proto = GpgME::UnknownProtocol;
         const bool informative = parse_informative(begin, proto);
         if (!(conn.*mp).empty() && informative != (conn.*info))
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_CONFLICT),
                                            i18n("Cannot mix --info with non-info SENDER or RECIPIENT").toUtf8().constData());
         KMime::Types::Mailbox mb;
         if (!KMime::HeaderParsing::parseMailbox(begin, end, mb))
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG),
                                            i18n("Argument is not a valid RFC-2822 mailbox").toUtf8().constData());
         if (begin != end)
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG),
                                            i18n("Garbage after valid RFC-2822 mailbox detected").toUtf8().constData());
         (conn.*info) = informative;
         (conn.*mp).push_back(mb);
 
         const QString email = mb.addrSpec().asString();
         (void)assuan_write_line(conn.ctx.get(), qPrintable(QString::asprintf("# ok, parsed as \"%s\"", qPrintable(email))));
         if (sender && !informative) {
             return AssuanCommandFactory::_handle(conn.ctx.get(), line, "PREP_SIGN");
         } else {
             return assuan_process_done(ctx, 0);
         }
     }
 
 #ifndef HAVE_ASSUAN2
     static int recipient_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t recipient_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return recipient_sender_handler(&Private::recipients, &Private::informativeRecipients, ctx, line);
     }
 
 #ifndef HAVE_ASSUAN2
     static int sender_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t sender_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return recipient_sender_handler(&Private::senders, &Private::informativeSenders, ctx, line, true);
     }
 
     QByteArray dumpOptions() const
     {
         QByteArray result;
         for (std::map<std::string, QVariant>::const_iterator it = options.begin(), end = options.end(); it != end; ++it) {
             result += it->first.c_str() + it->second.toString().toUtf8() + '\n';
         }
         return result;
     }
 
     static QByteArray dumpStringList(const QStringList &sl)
     {
         return sl.join(QLatin1Char('\n')).toUtf8();
     }
 
     template <typename T_container>
     static QByteArray dumpStringList(const T_container &c)
     {
         QStringList sl;
         std::copy(c.begin(), c.end(), std::back_inserter(sl));
         return dumpStringList(sl);
     }
 
     template <typename T_container>
     static QByteArray dumpMailboxes(const T_container &c)
     {
         QStringList sl;
         std::transform(c.begin(), c.end(),
                        std::back_inserter(sl),
                        [](typename T_container::const_reference val) {
                            return val.prettyAddress();
                        });
         return dumpStringList(sl);
     }
 
     QByteArray dumpSenders() const
     {
         return dumpMailboxes(senders);
     }
 
     QByteArray dumpRecipients() const
     {
         return dumpMailboxes(recipients);
     }
 
     QByteArray dumpMementos() const
     {
         QByteArray result;
         for (std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> >::const_iterator it = mementos.begin(), end = mementos.end(); it != end; ++it) {
             char buf[2 + 2 * sizeof(void *) + 2];
             sprintf(buf, "0x%p\n", (void *)it->second.get());
             buf[sizeof(buf) - 1] = '\0';
             result += it->first + QByteArray::fromRawData(buf, sizeof buf);
         }
         return result;
     }
 
     QByteArray dumpFiles() const
     {
         QStringList rv;
         rv.reserve(files.size());
         std::copy(files.cbegin(), files.cend(), std::back_inserter(rv));
         return dumpStringList(rv);
     }
 
     void cleanup();
     void reset()
     {
         options.clear();
         senders.clear();
         informativeSenders = false;
         recipients.clear();
         informativeRecipients = false;
         sessionTitle.clear();
         sessionId = 0;
         mementos.clear();
         files.clear();
         std::for_each(inputs.begin(), inputs.end(), std::mem_fn(&Input::finalize));
         inputs.clear();
         std::for_each(outputs.begin(), outputs.end(), std::mem_fn(&Output::finalize));
         outputs.clear();
         std::for_each(messages.begin(), messages.end(), std::mem_fn(&Input::finalize));
         messages.clear();
         bias = GpgME::UnknownProtocol;
     }
 
     assuan_fd_t fd;
     AssuanContext ctx;
     bool closed                : 1;
     bool cryptoCommandsEnabled : 1;
     bool commandWaitingForCryptoCommandsEnabled : 1;
     bool currentCommandIsNohup : 1;
     bool informativeSenders;    // address taken, so no : 1
     bool informativeRecipients; // address taken, so no : 1
     GpgME::Protocol bias;
     QString sessionTitle;
     unsigned int sessionId;
     std::vector< std::shared_ptr<QSocketNotifier> > notifiers;
     std::vector< std::shared_ptr<AssuanCommandFactory> > factories; // sorted: _detail::ByName<std::less>
     std::shared_ptr<AssuanCommand> currentCommand;
     std::vector< std::shared_ptr<AssuanCommand> > nohupedCommands;
     std::map<std::string, QVariant> options;
     std::vector<KMime::Types::Mailbox> senders, recipients;
     std::vector< std::shared_ptr<Input> > inputs, messages;
     std::vector< std::shared_ptr<Output> > outputs;
     std::vector<QString> files;
     std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> > mementos;
 };
 
 void AssuanServerConnection::Private::cleanup()
 {
     Q_ASSERT(nohupedCommands.empty());
     reset();
     currentCommand.reset();
     currentCommandIsNohup = false;
     commandWaitingForCryptoCommandsEnabled = false;
     notifiers.clear();
     ctx.reset();
     fd = ASSUAN_INVALID_FD;
 }
 
 AssuanServerConnection::Private::Private(assuan_fd_t fd_, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories_, AssuanServerConnection *qq)
     : QObject(),
       q(qq),
       fd(fd_),
       closed(false),
       cryptoCommandsEnabled(false),
       commandWaitingForCryptoCommandsEnabled(false),
       currentCommandIsNohup(false),
       informativeSenders(false),
       informativeRecipients(false),
       bias(GpgME::UnknownProtocol),
       sessionId(0),
       factories(factories_)
 {
 #ifdef __GLIBCXX__
     Q_ASSERT(__gnu_cxx::is_sorted(factories_.begin(), factories_.end(), _detail::ByName<std::less>()));
 #endif
 
     if (fd == ASSUAN_INVALID_FD) {
         throw Exception(gpg_error(GPG_ERR_INV_ARG), "pre-assuan_init_socket_server_ext");
     }
 
 #ifndef HAVE_ASSUAN2
     assuan_context_t naked_ctx = 0;
     if (const gpg_error_t err = assuan_init_socket_server_ext(&naked_ctx, fd, INIT_SOCKET_FLAGS))
 #else
     {
         assuan_context_t naked_ctx = nullptr;
         if (const gpg_error_t err = assuan_new(&naked_ctx)) {
             throw Exception(err, "assuan_new");
         }
         ctx.reset(naked_ctx);
     }
     if (const gpg_error_t err = assuan_init_socket_server(ctx.get(), fd, INIT_SOCKET_FLAGS))
 #endif
         throw Exception(err, "assuan_init_socket_server_ext");
 
 #ifndef HAVE_ASSUAN2
     ctx.reset(naked_ctx); naked_ctx = 0;
 #endif
 
     // for callbacks, associate the context with this connection:
     assuan_set_pointer(ctx.get(), this);
 
     FILE *const logFile = Log::instance()->logFile();
     assuan_set_log_stream(ctx.get(), logFile ? logFile : stderr);
 
     // register FDs with the event loop:
     assuan_fd_t fds[MAX_ACTIVE_FDS];
     const int numFDs = assuan_get_active_fds(ctx.get(), FOR_READING, fds, MAX_ACTIVE_FDS);
     Q_ASSERT(numFDs != -1);   // == 1
 
     if (!numFDs || fds[0] != fd) {
         const std::shared_ptr<QSocketNotifier> sn(new QSocketNotifier((intptr_t)fd, QSocketNotifier::Read), std::mem_fn(&QObject::deleteLater));
         connect(sn.get(), &QSocketNotifier::activated, this, &Private::slotReadActivity);
         notifiers.push_back(sn);
     }
 
     notifiers.reserve(notifiers.size() + numFDs);
     for (int i = 0; i < numFDs; ++i) {
         const std::shared_ptr<QSocketNotifier> sn(new QSocketNotifier((intptr_t)fds[i], QSocketNotifier::Read), std::mem_fn(&QObject::deleteLater));
         connect(sn.get(), &QSocketNotifier::activated, this, &Private::slotReadActivity);
         notifiers.push_back(sn);
     }
 
     // register our INPUT/OUTPUT/MESSGAE/FILE handlers:
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "INPUT",  input_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "INPUT",  input_handler, ""))
 #endif
         throw Exception(err, "register \"INPUT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "MESSAGE",  message_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "MESSAGE",  message_handler, ""))
 #endif
         throw Exception(err, "register \"MESSAGE\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "OUTPUT", output_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "OUTPUT", output_handler, ""))
 #endif
         throw Exception(err, "register \"OUTPUT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "FILE", file_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "FILE", file_handler, ""))
 #endif
         throw Exception(err, "register \"FILE\" handler");
 
     // register user-defined commands:
     Q_FOREACH (std::shared_ptr<AssuanCommandFactory> fac, factories)
 #ifndef HAVE_ASSUAN2
         if (const gpg_error_t err = assuan_register_command(ctx.get(), fac->name(), fac->_handler()))
 #else
         if (const gpg_error_t err = assuan_register_command(ctx.get(), fac->name(), fac->_handler(), ""))
 #endif
             throw Exception(err, std::string("register \"") + fac->name() + "\" handler");
 
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "GETINFO", getinfo_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "GETINFO", getinfo_handler, ""))
 #endif
         throw Exception(err, "register \"GETINFO\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_KEYMANAGER", start_keymanager_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_KEYMANAGER", start_keymanager_handler, ""))
 #endif
         throw Exception(err, "register \"START_KEYMANAGER\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_CONFDIALOG", start_confdialog_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_CONFDIALOG", start_confdialog_handler, ""))
 #endif
         throw Exception(err, "register \"START_CONFDIALOG\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "RECIPIENT", recipient_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "RECIPIENT", recipient_handler, ""))
 #endif
         throw Exception(err, "register \"RECIPIENT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SENDER", sender_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SENDER", sender_handler, ""))
 #endif
         throw Exception(err, "register \"SENDER\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SESSION", session_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SESSION", session_handler, ""))
 #endif
         throw Exception(err, "register \"SESSION\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "CAPABILITIES", capabilities_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "CAPABILITIES", capabilities_handler, ""))
 #endif
         throw Exception(err, "register \"CAPABILITIES\" handler");
 
     assuan_set_hello_line(ctx.get(), "GPG UI server (Kleopatra/" KLEOPATRA_VERSION_STRING ") ready to serve");
     //assuan_set_hello_line( ctx.get(), GPG UI server (qApp->applicationName() + " v" + kapp->applicationVersion() + "ready to serve" )
 
     // some notifiers we're interested in:
     if (const gpg_error_t err = assuan_register_reset_notify(ctx.get(), reset_handler)) {
         throw Exception(err, "register reset notify");
     }
     if (const gpg_error_t err = assuan_register_option_handler(ctx.get(), option_handler)) {
         throw Exception(err, "register option handler");
     }
 
     // and last, we need to call assuan_accept, which doesn't block
     // (d/t INIT_SOCKET_FLAGS), but performs vital connection
     // establishing handling:
     if (const gpg_error_t err = assuan_accept(ctx.get())) {
         throw Exception(err, "assuan_accept");
     }
 }
 
 AssuanServerConnection::Private::~Private()
 {
     cleanup();
 }
 
 AssuanServerConnection::AssuanServerConnection(assuan_fd_t fd, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories, QObject *p)
     : QObject(p), d(new Private(fd, factories, this))
 {
 
 }
 
 AssuanServerConnection::~AssuanServerConnection() {}
 
 void AssuanServerConnection::enableCryptoCommands(bool on)
 {
     if (on == d->cryptoCommandsEnabled) {
         return;
     }
     d->cryptoCommandsEnabled = on;
     if (d->commandWaitingForCryptoCommandsEnabled) {
         QTimer::singleShot(0, d.get(), &Private::startCommandBottomHalf);
     }
 }
 
 //
 //
 // AssuanCommand:
 //
 //
 
 namespace Kleo
 {
 
 class InquiryHandler : public QObject
 {
     Q_OBJECT
 public:
 
 #if defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
     explicit InquiryHandler(const char *keyword_, QObject *p = nullptr)
         : QObject(p),
 # if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
           buffer(0),
           buflen(0),
 # endif
           keyword(keyword_)
     {
 
     }
 
 # if defined(HAVE_ASSUAN2) || defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
 #  ifndef HAVE_ASSUAN2
     static int handler(void *cb_data, int rc, unsigned char *buffer, size_t buflen)
 #  else
     static gpg_error_t handler(void *cb_data, gpg_error_t rc, unsigned char *buffer, size_t buflen)
 #  endif
     {
         Q_ASSERT(cb_data);
         InquiryHandler *this_ = static_cast<InquiryHandler *>(cb_data);
         Q_EMIT this_->signal(rc, QByteArray::fromRawData(reinterpret_cast<const char *>(buffer), buflen), this_->keyword);
         std::free(buffer);
         delete this_;
         return 0;
     }
 # else
     static int handler(void *cb_data, int rc)
     {
         Q_ASSERT(cb_data);
         InquiryHandler *this_ = static_cast<InquiryHandler *>(cb_data);
         Q_EMIT this_->signal(rc, QByteArray::fromRawData(reinterpret_cast<const char *>(this_->buffer), this_->buflen), this_->keyword);
         std::free(this_->buffer);
         delete this_;
         return 0;
     }
 # endif
 
 private:
 #if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
     friend class ::Kleo::AssuanCommand;
     unsigned char *buffer;
     size_t buflen;
 #endif
     const char *keyword;
 #endif // defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
 
 Q_SIGNALS:
     void signal(int rc, const QByteArray &data, const QByteArray &keyword);
 };
 
 } // namespace Kleo
 
 class AssuanCommand::Private
 {
 public:
     Private()
         : informativeRecipients(false),
           informativeSenders(false),
           bias(GpgME::UnknownProtocol),
           done(false),
           nohup(false)
     {
 
     }
 
     std::map<std::string, QVariant> options;
     std::vector< std::shared_ptr<Input> > inputs, messages;
     std::vector< std::shared_ptr<Output> > outputs;
     std::vector<QString> files;
     std::vector<KMime::Types::Mailbox> recipients, senders;
     bool informativeRecipients, informativeSenders;
     GpgME::Protocol bias;
     QString sessionTitle;
     unsigned int sessionId;
     QByteArray utf8ErrorKeepAlive;
     AssuanContext ctx;
     bool done;
     bool nohup;
 };
 
 AssuanCommand::AssuanCommand()
     : d(new Private)
 {
 
 }
 
 AssuanCommand::~AssuanCommand()
 {
 
 }
 
 int AssuanCommand::start()
 {
     try {
         if (const int err = doStart())
             if (!d->done) {
                 done(err);
             }
         return 0;
     } catch (const Exception &e) {
         if (!d->done) {
             done(e.error_code(), e.message());
         }
         return 0;
     } catch (const GpgME::Exception &e) {
         if (!d->done) {
             done(e.error(), QString::fromLocal8Bit(e.message().c_str()));
         }
         return 0;
     } catch (const std::exception &e) {
         if (!d->done) {
             done(makeError(GPG_ERR_INTERNAL), i18n("Caught unexpected exception: %1", QString::fromLocal8Bit(e.what())));
         }
         return 0;
     } catch (...) {
         if (!d->done) {
             done(makeError(GPG_ERR_INTERNAL), i18n("Caught unknown exception - please report this error to the developers."));
         }
         return 0;
     }
 }
 
 void AssuanCommand::canceled()
 {
     d->done = true;
     doCanceled();
 }
 
 // static
 int AssuanCommand::makeError(int code)
 {
     return makeGnuPGError(code);
 }
 
 bool AssuanCommand::hasOption(const char *opt) const
 {
     return d->options.count(opt);
 }
 
 QVariant AssuanCommand::option(const char *opt) const
 {
     const std::map<std::string, QVariant>::const_iterator it = d->options.find(opt);
     if (it == d->options.end()) {
         return QVariant();
     } else {
         return it->second;
     }
 }
 
 const std::map<std::string, QVariant> &AssuanCommand::options() const
 {
     return d->options;
 }
 
 namespace
 {
 template <typename U, typename V>
 std::vector<U> keys(const std::map<U, V> &map)
 {
     std::vector<U> result;
     result.resize(map.size());
     for (typename std::map<U, V>::const_iterator it = map.begin(), end = map.end(); it != end; ++it) {
         result.push_back(it->first);
     }
     return result;
 }
 }
 
 const std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> > &AssuanCommand::mementos() const
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     const AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
     return conn.mementos;
 }
 
 bool AssuanCommand::hasMemento(const QByteArray &tag) const
 {
     if (const unsigned int id = sessionId()) {
         return SessionDataHandler::instance()->sessionData(id)->mementos.count(tag) || mementos().count(tag);
     } else {
         return mementos().count(tag);
     }
 }
 
 std::shared_ptr<AssuanCommand::Memento> AssuanCommand::memento(const QByteArray &tag) const
 {
     if (const unsigned int id = sessionId()) {
         const std::shared_ptr<SessionDataHandler> sdh = SessionDataHandler::instance();
         const std::shared_ptr<SessionData> sd = sdh->sessionData(id);
         const std::map< QByteArray, std::shared_ptr<Memento> >::const_iterator it = sd->mementos.find(tag);
         if (it != sd->mementos.end()) {
             return it->second;
         }
     }
     const std::map< QByteArray, std::shared_ptr<Memento> >::const_iterator it = mementos().find(tag);
     if (it == mementos().end()) {
         return std::shared_ptr<Memento>();
     } else {
         return it->second;
     }
 }
 
 QByteArray AssuanCommand::registerMemento(const std::shared_ptr<Memento> &mem)
 {
     const QByteArray tag = QByteArray::number(reinterpret_cast<qulonglong>(mem.get()), 36);
     return registerMemento(tag, mem);
 }
 
 QByteArray AssuanCommand::registerMemento(const QByteArray &tag, const std::shared_ptr<Memento> &mem)
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     if (const unsigned int id = sessionId()) {
         SessionDataHandler::instance()->sessionData(id)->mementos[tag] = mem;
     } else {
         conn.mementos[tag] = mem;
     }
     return tag;
 }
 
 void AssuanCommand::removeMemento(const QByteArray &tag)
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     conn.mementos.erase(tag);
     if (const unsigned int id = sessionId()) {
         SessionDataHandler::instance()->sessionData(id)->mementos.erase(tag);
     }
 }
 
 const std::vector< std::shared_ptr<Input> > &AssuanCommand::inputs() const
 {
     return d->inputs;
 }
 
 const std::vector< std::shared_ptr<Input> > &AssuanCommand::messages() const
 {
     return d->messages;
 }
 
 const std::vector< std::shared_ptr<Output> > &AssuanCommand::outputs() const
 {
     return d->outputs;
 }
 
 QStringList AssuanCommand::fileNames() const
 {
     QStringList rv;
     rv.reserve(d->files.size());
     std::copy(d->files.cbegin(), d->files.cend(), std::back_inserter(rv));
     return rv;
 }
 
 unsigned int AssuanCommand::numFiles() const
 {
     return d->files.size();
 }
 
 void AssuanCommand::sendStatus(const char *keyword, const QString &text)
 {
     sendStatusEncoded(keyword, text.toUtf8().constData());
 }
 
 void AssuanCommand::sendStatusEncoded(const char *keyword, const std::string &text)
 {
     if (d->nohup) {
         return;
     }
     if (const int err = assuan_write_status(d->ctx.get(), keyword, text.c_str())) {
         throw Exception(err, i18n("Cannot send \"%1\" status", QString::fromLatin1(keyword)));
     }
 }
 
 void  AssuanCommand::sendData(const QByteArray &data, bool moreToCome)
 {
     if (d->nohup) {
         return;
     }
     if (const gpg_error_t err = assuan_send_data(d->ctx.get(), data.constData(), data.size())) {
         throw Exception(err, i18n("Cannot send data"));
     }
     if (!moreToCome)
         if (const gpg_error_t err = assuan_send_data(d->ctx.get(), nullptr, 0)) {   // flush
             throw Exception(err, i18n("Cannot flush data"));
         }
 }
 
 int AssuanCommand::inquire(const char *keyword, QObject *receiver, const char *slot, unsigned int maxSize)
 {
     Q_ASSERT(keyword);
     Q_ASSERT(receiver);
     Q_ASSERT(slot);
 
     if (d->nohup) {
         return makeError(GPG_ERR_INV_OP);
     }
 
 #if defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
     std::unique_ptr<InquiryHandler> ih(new InquiryHandler(keyword, receiver));
     receiver->connect(ih.get(), SIGNAL(signal(int,QByteArray,QByteArray)), slot);
     if (const gpg_error_t err = assuan_inquire_ext(d->ctx.get(), keyword,
 # if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
                                 &ih->buffer, &ih->buflen,
 # endif
                                 maxSize, InquiryHandler::handler, ih.get())) {
         return err;
     }
     ih.release();
     return 0;
 #else
     return makeError(GPG_ERR_NOT_SUPPORTED);   // libassuan too old
 #endif // defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
 }
 
 void AssuanCommand::done(const GpgME::Error &err, const QString &details)
 {
     if (d->ctx && !d->done && !details.isEmpty()) {
         qCDebug(KLEOPATRA_LOG) << "Error: " << details;
         d->utf8ErrorKeepAlive = details.toUtf8();
         if (!d->nohup) {
             assuan_set_error(d->ctx.get(), err.encodedError(), d->utf8ErrorKeepAlive.constData());
         }
     }
     done(err);
 }
 
 void AssuanCommand::done(const GpgME::Error &err)
 {
     if (!d->ctx) {
         qCDebug(KLEOPATRA_LOG) << err.asString() << ": called with NULL ctx.";
         return;
     }
     if (d->done) {
         qCDebug(KLEOPATRA_LOG) << err.asString() << ": called twice!";
         return;
     }
 
     d->done = true;
 
     std::for_each(d->messages.begin(), d->messages.end(), std::mem_fn(&Input::finalize));
     std::for_each(d->inputs.begin(), d->inputs.end(), std::mem_fn(&Input::finalize));
     std::for_each(d->outputs.begin(), d->outputs.end(), std::mem_fn(&Output::finalize));
     d->messages.clear();
     d->inputs.clear();
     d->outputs.clear();
     d->files.clear();
 
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     if (d->nohup) {
         conn.nohupDone(this);
         return;
     }
 
     const gpg_error_t rc = assuan_process_done(d->ctx.get(), err.encodedError());
     if (gpg_err_code(rc) != GPG_ERR_NO_ERROR)
         qFatal("AssuanCommand::done: assuan_process_done returned error %d (%s)",
                static_cast<int>(rc), gpg_strerror(rc));
 
     d->utf8ErrorKeepAlive.clear();
 
     conn.commandDone(this);
 }
 
 void AssuanCommand::setNohup(bool nohup)
 {
     d->nohup = nohup;
 }
 
 bool AssuanCommand::isNohup() const
 {
     return d->nohup;
 }
 
 bool AssuanCommand::isDone() const
 {
     return d->done;
 }
 
 QString AssuanCommand::sessionTitle() const
 {
     return d->sessionTitle;
 }
 
 unsigned int AssuanCommand::sessionId() const
 {
     return d->sessionId;
 }
 
 bool AssuanCommand::informativeSenders() const
 {
     return d->informativeSenders;
 }
 
 bool AssuanCommand::informativeRecipients() const
 {
     return d->informativeRecipients;
 }
 
 const std::vector<KMime::Types::Mailbox> &AssuanCommand::recipients() const
 {
     return d->recipients;
 }
 
 const std::vector<KMime::Types::Mailbox> &AssuanCommand::senders() const
 {
     return d->senders;
 }
 
 #ifndef HAVE_ASSUAN2
 int AssuanCommandFactory::_handle(assuan_context_t ctx, char *line, const char *commandName)
 {
 #else
 gpg_error_t AssuanCommandFactory::_handle(assuan_context_t ctx, char *line, const char *commandName)
 {
 #endif
     Q_ASSERT(assuan_get_pointer(ctx));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx));
 
     try {
 
         const std::vector< std::shared_ptr<AssuanCommandFactory> >::const_iterator it
             = std::lower_bound(conn.factories.begin(), conn.factories.end(), commandName, _detail::ByName<std::less>());
         kleo_assert(it != conn.factories.end());
         kleo_assert(*it);
         kleo_assert(qstricmp((*it)->name(), commandName) == 0);
 
         const std::shared_ptr<AssuanCommand> cmd = (*it)->create();
         kleo_assert(cmd);
 
         cmd->d->ctx     = conn.ctx;
         cmd->d->options = conn.options;
         cmd->d->inputs.swap(conn.inputs);     kleo_assert(conn.inputs.empty());
         cmd->d->messages.swap(conn.messages); kleo_assert(conn.messages.empty());
         cmd->d->outputs.swap(conn.outputs);   kleo_assert(conn.outputs.empty());
         cmd->d->files.swap(conn.files);       kleo_assert(conn.files.empty());
         cmd->d->senders.swap(conn.senders);   kleo_assert(conn.senders.empty());
         cmd->d->recipients.swap(conn.recipients); kleo_assert(conn.recipients.empty());
         cmd->d->informativeRecipients = conn.informativeRecipients;
         cmd->d->informativeSenders    = conn.informativeSenders;
         cmd->d->bias                  = conn.bias;
         cmd->d->sessionTitle          = conn.sessionTitle;
         cmd->d->sessionId             = conn.sessionId;
 
         const std::map<std::string, std::string> cmdline_options = parse_commandline(line);
         for (std::map<std::string, std::string>::const_iterator it = cmdline_options.begin(), end = cmdline_options.end(); it != end; ++it) {
             cmd->d->options[it->first] = QString::fromUtf8(it->second.c_str());
         }
 
         bool nohup = false;
         if (cmd->d->options.count("nohup")) {
             if (!cmd->d->options["nohup"].toString().isEmpty()) {
                 return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_ASS_PARAMETER), "--nohup takes no argument");
             }
             nohup = true;
             cmd->d->options.erase("nohup");
         }
 
         conn.currentCommand = cmd;
         conn.currentCommandIsNohup = nohup;
 
         QTimer::singleShot(0, &conn, &AssuanServerConnection::Private::startCommandBottomHalf);
 
         return 0;
 
     } catch (const Exception &e) {
         return assuan_process_done_msg(conn.ctx.get(), e.error_code(), e.message());
     } catch (const std::exception &e) {
         return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), e.what());
     } catch (...) {
         return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("Caught unknown exception"));
     }
 }
 
 int AssuanServerConnection::Private::startCommandBottomHalf()
 {
 
     commandWaitingForCryptoCommandsEnabled = currentCommand && !cryptoCommandsEnabled;
 
     if (!cryptoCommandsEnabled) {
         return 0;
     }
 
     const std::shared_ptr<AssuanCommand> cmd = currentCommand;
     if (!cmd) {
         return 0;
     }
 
     currentCommand.reset();
 
     const bool nohup = currentCommandIsNohup;
     currentCommandIsNohup = false;
 
     try {
 
         if (const int err = cmd->start()) {
             if (cmd->isDone()) {
                 return err;
             } else {
                 return assuan_process_done(ctx.get(), err);
             }
         }
 
         if (cmd->isDone()) {
             return 0;
         }
 
         if (nohup) {
             cmd->setNohup(true);
             nohupedCommands.push_back(cmd);
             return assuan_process_done_msg(ctx.get(), 0, "Command put in the background to continue executing after connection end.");
         } else {
             currentCommand = cmd;
             return 0;
         }
 
     } catch (const Exception &e) {
         return assuan_process_done_msg(ctx.get(), e.error_code(), e.message());
     } catch (const std::exception &e) {
         return assuan_process_done_msg(ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), e.what());
     } catch (...) {
         return assuan_process_done_msg(ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("Caught unknown exception"));
     }
 
 }
 
 //
 //
 // AssuanCommand convenience methods
 //
 //
 
 /*!
   Checks the \c --mode parameter.
 
   \returns The parameter as an AssuanCommand::Mode enum value.
 
   If no \c --mode was given, or it's value wasn't recognized, throws
   an Kleo::Exception.
 */
 AssuanCommand::Mode AssuanCommand::checkMode() const
 {
     if (!hasOption("mode")) {
         throw Exception(makeError(GPG_ERR_MISSING_VALUE), i18n("Required --mode option missing"));
     }
 
     const QString modeString = option("mode").toString().toLower();
     if (modeString == QLatin1String("filemanager")) {
         return FileManager;
     }
     if (modeString == QLatin1String("email")) {
         return EMail;
     }
     throw Exception(makeError(GPG_ERR_INV_ARG), i18n("invalid mode: \"%1\"", modeString));
 }
 
 /*!
   Checks the \c --protocol parameter.
 
   \returns The parameter as a GpgME::Protocol enum value.
 
   If \c --protocol was given, but has an invalid value, throws an
   Kleo::Exception.
 
   If no \c --protocol was given, checks the connection bias, if
   available, otherwise, in FileManager mode, returns
   GpgME::UnknownProtocol, but if \a mode == \c EMail, throws an
   Kleo::Exception instead.
 */
 GpgME::Protocol AssuanCommand::checkProtocol(Mode mode, int options) const
 {
     if (!hasOption("protocol"))
         if (d->bias != GpgME::UnknownProtocol) {
             return d->bias;
         } else if (mode == AssuanCommand::EMail && (options & AllowProtocolMissing) == 0) {
             throw Exception(makeError(GPG_ERR_MISSING_VALUE), i18n("Required --protocol option missing"));
         } else {
             return GpgME::UnknownProtocol;
         }
     else if (mode == AssuanCommand::FileManager) {
         throw Exception(makeError(GPG_ERR_INV_FLAG), i18n("--protocol is not allowed here"));
     }
 
     const QString protocolString = option("protocol").toString().toLower();
     if (protocolString == QLatin1String("openpgp")) {
         return GpgME::OpenPGP;
     }
     if (protocolString == QLatin1String("cms")) {
         return GpgME::CMS;
     }
     throw Exception(makeError(GPG_ERR_INV_ARG), i18n("invalid protocol \"%1\"", protocolString));
 }
 
 void AssuanCommand::doApplyWindowID(QWidget *widget) const
 {
     if (!widget || !hasOption("window-id")) {
         return;
     }
     apply_window_id(widget, option("window-id").toString());
 }
 
 WId AssuanCommand::parentWId() const
 {
     return wid_from_string(option("window-id").toString());
 }
 
 #include "assuanserverconnection.moc"
diff --git a/src/uiserver/createchecksumscommand.cpp b/src/uiserver/createchecksumscommand.cpp
index 4af58ba95..80f1a197b 100644
--- a/src/uiserver/createchecksumscommand.cpp
+++ b/src/uiserver/createchecksumscommand.cpp
@@ -1,87 +1,87 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/createchecksumscommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "createchecksumscommand.h"
 
 #include <crypto/createchecksumscontroller.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class CreateChecksumsCommand::Private
 {
 private:
     friend class ::Kleo::CreateChecksumsCommand;
     CreateChecksumsCommand *const q;
 public:
     explicit Private(CreateChecksumsCommand *qq)
         : q(qq),
           controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private:
     std::shared_ptr<CreateChecksumsController> controller;
 };
 
 CreateChecksumsCommand::CreateChecksumsCommand()
     : AssuanCommandMixin<CreateChecksumsCommand>(), d(new Private(this))
 {
 
 }
 
 CreateChecksumsCommand::~CreateChecksumsCommand() {}
 
 void CreateChecksumsCommand::Private::checkForErrors() const
 {
 
     if (!q->numFiles())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one FILE must be present"));
 
 }
 
 int CreateChecksumsCommand::doStart()
 {
 
     d->checkForErrors();
 
     d->controller.reset(new CreateChecksumsController(shared_from_this()));
 
     d->controller->setAllowAddition(hasOption("allow-addition"));
 
     d->controller->setFiles(fileNames());
 
     connect(d->controller.get(), SIGNAL(done()),
             this, SLOT(done()), Qt::QueuedConnection);
     connect(d->controller.get(), SIGNAL(error(int,QString)),
             this, SLOT(done(int,QString)), Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 void CreateChecksumsCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
diff --git a/src/uiserver/decryptverifycommandemailbase.cpp b/src/uiserver/decryptverifycommandemailbase.cpp
index 8b2f54d5e..3ffac8ce5 100644
--- a/src/uiserver/decryptverifycommandemailbase.cpp
+++ b/src/uiserver/decryptverifycommandemailbase.cpp
@@ -1,212 +1,212 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/decryptverifycommandemailbase.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "decryptverifycommandemailbase.h"
 
 #include <crypto/decryptverifytask.h>
 #include <crypto/decryptverifyemailcontroller.h>
 
 #include <utils/hex.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <QGpgME/Protocol>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 
 #include <KLocalizedString>
 
 #include <gpg-error.h>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Formatting;
 using namespace GpgME;
 
 class DecryptVerifyCommandEMailBase::Private : public QObject
 {
     Q_OBJECT
     friend class ::Kleo::DecryptVerifyCommandEMailBase;
     DecryptVerifyCommandEMailBase *const q;
 public:
     explicit Private(DecryptVerifyCommandEMailBase *qq)
         : QObject(),
           q(qq),
           controller()
     {
     }
 
     ~Private()
     {
     }
 
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotProgress(const QString &what, int current, int total);
     void verificationResult(const GpgME::VerificationResult &);
     void slotDone()
     {
         q->done();
     }
     void slotError(int err, const QString &details)
     {
         q->done(err, details);
     }
 
 public:
 
 private:
     std::shared_ptr<DecryptVerifyEMailController> controller;
 };
 
 DecryptVerifyCommandEMailBase::DecryptVerifyCommandEMailBase()
     : AssuanCommandMixin<DecryptVerifyCommandEMailBase>(), d(new Private(this))
 {
 
 }
 
 DecryptVerifyCommandEMailBase::~DecryptVerifyCommandEMailBase() {}
 
 int DecryptVerifyCommandEMailBase::doStart()
 {
 
     d->checkForErrors();
 
     d->controller.reset(new DecryptVerifyEMailController(shared_from_this()));
 
     const QString st = sessionTitle();
     if (!st.isEmpty())
         Q_FOREACH (const std::shared_ptr<Input> &i, inputs()) {
             i->setLabel(st);
         }
 
     d->controller->setSessionId(sessionId());
     d->controller->setOperation(operation());
     d->controller->setVerificationMode(messages().empty() ? Opaque : Detached);
     d->controller->setInputs(inputs());
     d->controller->setSignedData(messages());
     d->controller->setOutputs(outputs());
     d->controller->setWizardShown(!hasOption("silent"));
     d->controller->setProtocol(checkProtocol(mode()));
     if (informativeSenders()) {
         d->controller->setInformativeSenders(senders());
     }
     QObject::connect(d->controller.get(), SIGNAL(done()),
                      d.get(), SLOT(slotDone()), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)),
                      d.get(), SLOT(slotError(int,QString)), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), &DecryptVerifyEMailController::verificationResult,
                      d.get(), &Private::verificationResult, Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 void DecryptVerifyCommandEMailBase::Private::checkForErrors() const
 {
     if (!q->senders().empty() && !q->informativeSenders())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use non-info SENDER"));
 
     if (!q->recipients().empty() && !q->informativeRecipients())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use non-info RECIPIENT"));
 
     // ### use informative recipients and senders
 
     const unsigned int numInputs = q->inputs().size();
     const unsigned int numMessages = q->messages().size();
     const unsigned int numOutputs  = q->outputs().size();
     const unsigned int numInformativeSenders = q->informativeSenders() ? q->senders().size() : 0;
 
     const DecryptVerifyOperation op = q->operation();
     const GpgME::Protocol proto = q->checkProtocol(q->mode());
 
     const unsigned int numFiles = q->numFiles();
 
     if (numFiles) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("FILES present"));
     }
 
     if (!numInputs)
         throw Kleo::Exception(q->makeError(GPG_ERR_ASS_NO_INPUT),
                               i18n("At least one INPUT needs to be provided"));
 
     if (numInformativeSenders != 0)
         if (numInformativeSenders != numInputs)
             throw Kleo::Exception(q->makeError(GPG_ERR_ASS_NO_INPUT),     //TODO use better error code if possible
                                   i18n("INPUT/SENDER --info count mismatch"));
 
     if (numMessages) {
         if (numMessages != numInputs)
             throw Kleo::Exception(q->makeError(GPG_ERR_ASS_NO_INPUT),     //TODO use better error code if possible
                                   i18n("INPUT/MESSAGE count mismatch"));
         else if (op != Verify)
             throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                                   i18n("MESSAGE can only be given for detached signature verification"));
     }
 
     if (numOutputs) {
         if (numOutputs != numInputs)
             throw Kleo::Exception(q->makeError(GPG_ERR_ASS_NO_OUTPUT),    //TODO use better error code if possible
                                   i18n("INPUT/OUTPUT count mismatch"));
         else if (numMessages)
             throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                                   i18n("Cannot use OUTPUT and MESSAGE simultaneously"));
     }
 
     kleo_assert(proto != UnknownProtocol);
 
     const auto backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!backend)
         throw Kleo::Exception(q->makeError(GPG_ERR_UNSUPPORTED_PROTOCOL),
                               proto == OpenPGP ? i18n("No backend support for OpenPGP") :
                               proto == CMS     ? i18n("No backend support for S/MIME") : QString());
 }
 
 void DecryptVerifyCommandEMailBase::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 void DecryptVerifyCommandEMailBase::Private::slotProgress(const QString &what, int current, int total)
 {
     Q_UNUSED(what);
     Q_UNUSED(current);
     Q_UNUSED(total);
     // ### FIXME report progress, via sendStatus()
 }
 
 void DecryptVerifyCommandEMailBase::Private::verificationResult(const VerificationResult &vResult)
 {
     try {
         const std::vector<Signature> sigs = vResult.signatures();
         Q_FOREACH (const Signature &sig, sigs) {
             const QString s = signatureToString(sig, sig.key(true, true));
             const char *color = summaryToString(sig.summary());
             q->sendStatusEncoded("SIGSTATUS",
                                  color + (' ' + hexencode(s.toUtf8().constData())));
         }
     } catch (...) {}
 }
 
 #include "decryptverifycommandemailbase.moc"
diff --git a/src/uiserver/decryptverifycommandfilesbase.cpp b/src/uiserver/decryptverifycommandfilesbase.cpp
index 26a5853cd..2298e14d5 100644
--- a/src/uiserver/decryptverifycommandfilesbase.cpp
+++ b/src/uiserver/decryptverifycommandfilesbase.cpp
@@ -1,193 +1,193 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/decryptverifycommandfilesbase.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "decryptverifycommandfilesbase.h"
 #include "fileoperationspreferences.h"
 
 #include <crypto/decryptverifytask.h>
 
 #include "crypto/decryptverifyfilescontroller.h"
 #include "crypto/autodecryptverifyfilescontroller.h"
 
 #include <utils/hex.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <KLocalizedString>
 
 #include <QFileInfo>
 
 #include <gpg-error.h>
 
 #include <memory>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Formatting;
 using namespace GpgME;
 
 class DecryptVerifyCommandFilesBase::Private : public QObject
 {
     Q_OBJECT
     friend class ::Kleo::DecryptVerifyCommandFilesBase;
     DecryptVerifyCommandFilesBase *const q;
 public:
     explicit Private(DecryptVerifyCommandFilesBase *qq)
         : QObject(),
           q(qq),
           controller()
     {
     }
 
     ~Private()
     {
     }
 
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotProgress(const QString &what, int current, int total);
     void verificationResult(const GpgME::VerificationResult &);
     void slotDone()
     {
         q->done();
     }
     void slotError(int err, const QString &details)
     {
         q->done(err, details);
     }
 
 public:
 
 private:
     std::shared_ptr<DecryptVerifyFilesController> controller;
 };
 
 DecryptVerifyCommandFilesBase::DecryptVerifyCommandFilesBase()
     : AssuanCommandMixin<DecryptVerifyCommandFilesBase>(), d(new Private(this))
 {
 
 }
 
 DecryptVerifyCommandFilesBase::~DecryptVerifyCommandFilesBase() {}
 
 int DecryptVerifyCommandFilesBase::doStart()
 {
 
     d->checkForErrors();
 
     FileOperationsPreferences prefs;
     if (prefs.autoDecryptVerify()) {
         d->controller.reset(new AutoDecryptVerifyFilesController());
     } else {
         d->controller.reset(new DecryptVerifyFilesController(shared_from_this()));
     }
 
     d->controller->setOperation(operation());
     d->controller->setFiles(fileNames());
 
     QObject::connect(d->controller.get(), SIGNAL(done()),
                      d.get(), SLOT(slotDone()), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)),
                      d.get(), SLOT(slotError(int,QString)), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), &DecryptVerifyFilesController::verificationResult,
                      d.get(), &Private::verificationResult, Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 namespace
 {
 
 struct is_file : std::unary_function<QString, bool> {
     bool operator()(const QString &file) const
     {
         return QFileInfo(file).isFile();
     }
 };
 
 }
 
 void DecryptVerifyCommandFilesBase::Private::checkForErrors() const
 {
     if (!q->senders().empty())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use SENDER"));
 
     if (!q->recipients().empty())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use RECIPIENT"));
 
     const unsigned int numInputs = q->inputs().size();
     const unsigned int numMessages = q->messages().size();
     const unsigned int numOutputs  = q->outputs().size();
 
     if (numInputs) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("INPUT present"));
     }
     if (numMessages) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("MESSAGE present"));
     }
     if (numOutputs) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("OUTPUT present"));
     }
     const QStringList fileNames = q->fileNames();
     if (fileNames.empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one FILE must be present"));
     if (!std::all_of(fileNames.cbegin(), fileNames.cend(), is_file()))
         throw Exception(makeError(GPG_ERR_INV_ARG),
                         i18n("DECRYPT/VERIFY_FILES cannot use directories as input"));
 
 }
 
 void DecryptVerifyCommandFilesBase::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 void DecryptVerifyCommandFilesBase::Private::slotProgress(const QString &what, int current, int total)
 {
     Q_UNUSED(what);
     Q_UNUSED(current);
     Q_UNUSED(total);
     // ### FIXME report progress, via sendStatus()
 }
 
 void DecryptVerifyCommandFilesBase::Private::verificationResult(const VerificationResult &vResult)
 {
     try {
         const std::vector<Signature> sigs = vResult.signatures();
         for (const Signature &sig : sigs) {
             const QString s = signatureToString(sig, sig.key(true, true));
             const char *color = summaryToString(sig.summary());
             q->sendStatusEncoded("SIGSTATUS",
                                  color + (' ' + hexencode(s.toUtf8().constData())));
         }
     } catch (...) {}
 }
 
 #include "decryptverifycommandfilesbase.moc"
diff --git a/src/uiserver/echocommand.cpp b/src/uiserver/echocommand.cpp
index df6deb3e7..ea850e09e 100644
--- a/src/uiserver/echocommand.cpp
+++ b/src/uiserver/echocommand.cpp
@@ -1,191 +1,191 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/echocommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "echocommand.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <gpg-error.h>
 
 #include <KLocalizedString>
 
 #include <QByteArray>
 #include <QIODevice>
 #include <QVariant>
 
 #include <string>
 #include <algorithm>
 
 using namespace Kleo;
 
 static const char option_prefix[] = "prefix";
 
 class EchoCommand::Private
 {
 public:
     int operationsInFlight = 0;
     QByteArray buffer;
 };
 
 EchoCommand::EchoCommand()
     : QObject(), AssuanCommandMixin<EchoCommand>(), d(new Private) {}
 
 EchoCommand::~EchoCommand() {}
 
 int EchoCommand::doStart()
 {
 
     const std::vector< std::shared_ptr<Input> > in = inputs(), msg = messages();
     const std::vector< std::shared_ptr<Output> > out = outputs();
 
     if (!in.empty() && out.empty()) {
         return makeError(GPG_ERR_NOT_SUPPORTED);
     }
 
     if (!msg.empty()) {
         return makeError(GPG_ERR_NOT_SUPPORTED);
     }
 
     if (hasOption(option_prefix) && !option(option_prefix).toByteArray().isEmpty()) {
         return makeError(GPG_ERR_NOT_IMPLEMENTED);
     }
 
     std::string keyword;
     if (hasOption("inquire")) {
         keyword = option("inquire").toString().toStdString();
         if (keyword.empty()) {
             return makeError(GPG_ERR_INV_ARG);
         }
     }
 
     const std::string output = option("text").toString().toStdString();
 
     // aaand ACTION:
 
     // 1. echo the command line though the status channel
     sendStatus("ECHO", output.empty() ? QString() : QLatin1String(output.c_str()));
 
     // 2. if --inquire was given, inquire more data from the client:
     if (!keyword.empty()) {
         if (const int err = inquire(keyword.c_str(), this,
                                     SLOT(slotInquireData(int,QByteArray)))) {
             return err;
         } else {
             ++d->operationsInFlight;
         }
     }
 
     // 3. if INPUT was given, start the data pump for input->output
     if (const std::shared_ptr<QIODevice> i = in.at(0)->ioDevice()) {
         const std::shared_ptr<QIODevice> o = out.at(0)->ioDevice();
 
         ++d->operationsInFlight;
 
         connect(i.get(), &QIODevice::readyRead, this, &EchoCommand::slotInputReadyRead);
         connect(o.get(), &QIODevice::bytesWritten, this, &EchoCommand::slotOutputBytesWritten);
 
         if (i->bytesAvailable()) {
             slotInputReadyRead();
         }
     }
 
     if (!d->operationsInFlight) {
         done();
     }
     return 0;
 }
 
 void EchoCommand::doCanceled()
 {
 
 }
 
 void EchoCommand::slotInquireData(int rc, const QByteArray &data)
 {
 
     --d->operationsInFlight;
 
     if (rc) {
         done(rc);
         return;
     }
 
     try {
         sendStatus("ECHOINQ", QLatin1String(data));
         if (!d->operationsInFlight) {
             done();
         }
     } catch (const Exception &e) {
         done(e.error(), e.message());
     } catch (const std::exception &e) {
         done(makeError(GPG_ERR_UNEXPECTED),
              i18n("Caught unexpected exception in SignCommand::Private::slotMicAlgDetermined: %1",
                   QString::fromLocal8Bit(e.what())));
     } catch (...) {
         done(makeError(GPG_ERR_UNEXPECTED),
              i18n("Caught unknown exception in SignCommand::Private::slotMicAlgDetermined"));
     }
 
 }
 
 void EchoCommand::slotInputReadyRead()
 {
     const std::shared_ptr<QIODevice> in = inputs().at(0)->ioDevice();
     Q_ASSERT(in);
 
     QByteArray buffer;
     buffer.resize(in->bytesAvailable());
     const qint64 read = in->read(buffer.data(), buffer.size());
     if (read == - 1) {
         done(makeError(GPG_ERR_EIO));
         return;
     }
     if (read == 0 || (!in->isSequential() && read == in->size())) {
         in->close();
     }
 
     buffer.resize(read);
     d->buffer += buffer;
 
     slotOutputBytesWritten();
 }
 
 void EchoCommand::slotOutputBytesWritten()
 {
     const std::shared_ptr<QIODevice> out = outputs().at(0)->ioDevice();
     Q_ASSERT(out);
 
     if (!d->buffer.isEmpty()) {
 
         if (out->bytesToWrite()) {
             return;
         }
 
         const qint64 written = out->write(d->buffer);
         if (written == -1) {
             done(makeError(GPG_ERR_EIO));
             return;
         }
         d->buffer.remove(0, written);
 
     }
 
     if (out->isOpen() && d->buffer.isEmpty() && !inputs().at(0)->ioDevice()->isOpen()) {
         out->close();
         if (!--d->operationsInFlight) {
             done();
         }
     }
 }
 
diff --git a/src/uiserver/encryptcommand.cpp b/src/uiserver/encryptcommand.cpp
index 26bae21ee..ac0f4cca2 100644
--- a/src/uiserver/encryptcommand.cpp
+++ b/src/uiserver/encryptcommand.cpp
@@ -1,208 +1,208 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/encryptcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "encryptcommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 #include <utils/input.h>
 #include <utils/output.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class EncryptCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::EncryptCommand;
     EncryptCommand *const q;
 public:
     explicit Private(EncryptCommand *qq)
         : q(qq),
           controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private Q_SLOTS:
     void slotDone();
     void slotError(int, const QString &);
     void slotRecipientsResolved();
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 EncryptCommand::EncryptCommand()
     : AssuanCommandMixin<EncryptCommand>(), d(new Private(this))
 {
 
 }
 
 EncryptCommand::~EncryptCommand() {}
 
 void EncryptCommand::Private::checkForErrors() const
 {
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("ENCRYPT is an email mode command, connection seems to be in filmanager mode"));
 
     if (!q->senders().empty() && !q->informativeSenders())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("SENDER may not be given prior to ENCRYPT, except with --info"));
 
     if (q->inputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one INPUT must be present"));
 
     if (q->outputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_OUTPUT),
                         i18n("At least one OUTPUT must be present"));
 
     if (q->outputs().size() != q->inputs().size())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("INPUT/OUTPUT count mismatch"));
 
     if (!q->messages().empty())
         throw Exception(makeError(GPG_ERR_INV_VALUE),
                         i18n("MESSAGE command is not allowed before ENCRYPT"));
 
     const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
     kleo_assert(m);
 
     if (m && m->isEncrypting()) {
 
         if (m->protocol() != q->checkProtocol(EMail))
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT"));
 
         if (!q->recipients().empty())
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("New recipients added after PREP_ENCRYPT command"));
         if (!q->senders().empty())
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("New senders added after PREP_ENCRYPT command"));
 
     } else {
 
         if (q->recipients().empty() || q->informativeRecipients())
             throw Exception(makeError(GPG_ERR_MISSING_VALUE),
                             i18n("No recipients given, or only with --info"));
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
 
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotRecipientsResolved()));
     QObject::connect(controller, SIGNAL(done()), d, SLOT(slotDone()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 
 }
 
 int EncryptCommand::doStart()
 {
 
     d->checkForErrors();
 
     const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isEncrypting()) {
         // reuse the controller from a previous PREP_ENCRYPT, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         removeMemento(NewSignEncryptEMailController::mementoName());
         d->controller->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotRecipientsResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         d->controller->setEncrypting(true);
         d->controller->setSigning(false);
         d->controller->setProtocol(checkProtocol(EMail));
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void EncryptCommand::Private::slotRecipientsResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
         const QString sessionTitle = q->sessionTitle();
         if (!sessionTitle.isEmpty())
             Q_FOREACH (const std::shared_ptr<Input> &i, q->inputs()) {
                 i->setLabel(sessionTitle);
             }
 
         cont->startEncryption(q->inputs(), q->outputs());
 
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in EncryptCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in EncryptCommand::Private::slotRecipientsResolved"));
     }
     cont->cancel();
 }
 
 void EncryptCommand::Private::slotDone()
 {
     q->done();
 }
 
 void EncryptCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void EncryptCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "encryptcommand.moc"
diff --git a/src/uiserver/importfilescommand.cpp b/src/uiserver/importfilescommand.cpp
index 867101f51..55dcd3cab 100644
--- a/src/uiserver/importfilescommand.cpp
+++ b/src/uiserver/importfilescommand.cpp
@@ -1,79 +1,79 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/importfilescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "importfilescommand.h"
 
 #include <commands/importcertificatefromfilecommand.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <gpgme++/key.h>
 
 #include <gpg-error.h>
 
 
 #include <string>
 #include <algorithm>
 
 using namespace Kleo;
 
 
 class ImportFilesCommand::Private
 {
     friend class ::Kleo::ImportFilesCommand;
     ImportFilesCommand *const q;
 public:
     Private(ImportFilesCommand *qq) :
         q(qq),
         command(nullptr)
     {
         KDAB_SET_OBJECT_NAME(command);
         command.setAutoDelete(false);
 
         connect(&command, SIGNAL(finished()), q, SLOT(slotCommandFinished()));
         connect(&command, SIGNAL(canceled()), q, SLOT(slotCommandCanceled()));
     }
 
 private:
     void slotCommandFinished()
     {
         q->done();
     }
     void slotCommandCanceled()
     {
         q->done(makeError(GPG_ERR_CANCELED));
     }
 
 private:
     ImportCertificateFromFileCommand command;
 };
 
 ImportFilesCommand::ImportFilesCommand()
     : QObject(), AssuanCommandMixin<ImportFilesCommand>(), d(new Private(this)) {}
 
 ImportFilesCommand::~ImportFilesCommand() {}
 
 int ImportFilesCommand::doStart()
 {
 
     d->command.setParentWId(parentWId());
     d->command.setFiles(fileNames());
     d->command.start();
 
     return 0;
 }
 
 void ImportFilesCommand::doCanceled()
 {
     d->command.cancel();
 }
 
 #include "moc_importfilescommand.cpp"
diff --git a/src/uiserver/prepencryptcommand.cpp b/src/uiserver/prepencryptcommand.cpp
index bf490b7db..1c4fd684e 100644
--- a/src/uiserver/prepencryptcommand.cpp
+++ b/src/uiserver/prepencryptcommand.cpp
@@ -1,148 +1,148 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/prepencryptcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "prepencryptcommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class PrepEncryptCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::PrepEncryptCommand;
     PrepEncryptCommand *const q;
 public:
     explicit Private(PrepEncryptCommand *qq)
         : q(qq), controller() {}
 
 private:
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotRecipientsResolved();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 PrepEncryptCommand::PrepEncryptCommand()
     : AssuanCommandMixin<PrepEncryptCommand>(), d(new Private(this))
 {
 
 }
 
 PrepEncryptCommand::~PrepEncryptCommand() {}
 
 void PrepEncryptCommand::Private::checkForErrors() const
 {
 
     if (!q->inputs().empty() || !q->outputs().empty() || !q->messages().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("INPUT/OUTPUT/MESSAGE may only be given after PREP_ENCRYPT"));
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("PREP_ENCRYPT is an email mode command, connection seems to be in filemanager mode"));
 
     if (!q->senders().empty() && !q->informativeSenders())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("SENDER may not be given prior to PREP_ENCRYPT, except with --info"));
 
     if (q->recipients().empty() || q->informativeRecipients())
         throw Exception(makeError(GPG_ERR_MISSING_VALUE),
                         i18n("No recipients given, or only with --info"));
 
 }
 
 int PrepEncryptCommand::doStart()
 {
 
     removeMemento(NewSignEncryptEMailController::mementoName());
 
     d->checkForErrors();
 
     d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
     d->controller->setEncrypting(true);
 
     const QString session = sessionTitle();
     if (!session.isEmpty()) {
         d->controller->setSubject(session);
     }
 
     if (hasOption("protocol"))
         // --protocol is optional for PREP_ENCRYPT
     {
         d->controller->setProtocol(checkProtocol(EMail));
     }
 
     d->controller->setSigning(hasOption("expect-sign"));
 
     QObject::connect(d->controller.get(), &NewSignEncryptEMailController::certificatesResolved, d.get(), &Private::slotRecipientsResolved);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)), d.get(), SLOT(slotError(int,QString)));
 
     d->controller->startResolveCertificates(recipients(), senders());
 
     return 0;
 }
 
 void PrepEncryptCommand::Private::slotRecipientsResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont = controller;
     QPointer<Private> that(this);
 
     try {
 
         q->sendStatus("PROTOCOL", QLatin1String(controller->protocolAsString()));
         q->registerMemento(NewSignEncryptEMailController::mementoName(),
                            make_typed_memento(controller));
         q->done();
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in PrepEncryptCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in PrepEncryptCommand::Private::slotRecipientsResolved"));
     }
     if (that) { // isn't this always deleted here and thus unnecessary?
         q->removeMemento(NewSignEncryptEMailController::mementoName());
     }
     cont->cancel();
 }
 
 void PrepEncryptCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void PrepEncryptCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "prepencryptcommand.moc"
diff --git a/src/uiserver/prepsigncommand.cpp b/src/uiserver/prepsigncommand.cpp
index 803d1c3dc..7021a2a63 100644
--- a/src/uiserver/prepsigncommand.cpp
+++ b/src/uiserver/prepsigncommand.cpp
@@ -1,178 +1,178 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/prepsigncommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "prepsigncommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class PrepSignCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::PrepSignCommand;
     PrepSignCommand *const q;
 public:
     explicit Private(PrepSignCommand *qq)
         : q(qq), controller() {}
 
 private:
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotSignersResolved();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 PrepSignCommand::PrepSignCommand()
     : AssuanCommandMixin<PrepSignCommand>(), d(new Private(this))
 {
 
 }
 
 PrepSignCommand::~PrepSignCommand() {}
 
 void PrepSignCommand::Private::checkForErrors() const
 {
 
     if (!q->inputs().empty() || !q->outputs().empty() || !q->messages().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("INPUT/OUTPUT/MESSAGE may only be given after PREP_SIGN"));
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("PREP_SIGN is an email mode command, connection seems to be in filemanager mode"));
 
     if (q->senders().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("No SENDER given"));
 
     const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (m && m->isSigning()) {
 
         if (q->hasOption("protocol"))
             if (m->protocol() != q->checkProtocol(EMail))
                 throw Exception(makeError(GPG_ERR_CONFLICT),
                                 i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT in this session"));
 
         // ### check that any SENDER here is the same as the one for PREP_ENCRYPT
 
         // ### ditto RECIPIENT
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotSignersResolved()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 }
 
 int PrepSignCommand::doStart()
 {
 
     d->checkForErrors();
 
     const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isSigning()) {
         // reuse the controller from a previous PREP_ENCRYPT --expect-sign, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         seec->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotSignersResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         if (hasOption("protocol"))
             // --protocol is optional for PREP_SIGN
         {
             d->controller->setProtocol(checkProtocol(EMail));
         }
 
         d->controller->setEncrypting(false);
         d->controller->setSigning(true);
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void PrepSignCommand::Private::slotSignersResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont = controller;
     QPointer<Private> that(this);
 
     try {
 
         q->sendStatus("PROTOCOL", QLatin1String(controller->protocolAsString()));
         q->registerMemento(NewSignEncryptEMailController::mementoName(),
                            make_typed_memento(controller));
         q->done();
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in PrepSignCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in PrepSignCommand::Private::slotRecipientsResolved"));
     }
     if (that) { // isn't this always deleted here and thus unnecessary?
         q->removeMemento(NewSignEncryptEMailController::mementoName());
     }
     cont->cancel();
 }
 
 void PrepSignCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void PrepSignCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "prepsigncommand.moc"
diff --git a/src/uiserver/selectcertificatecommand.cpp b/src/uiserver/selectcertificatecommand.cpp
index 7810b4e41..bb14e0ede 100644
--- a/src/uiserver/selectcertificatecommand.cpp
+++ b/src/uiserver/selectcertificatecommand.cpp
@@ -1,177 +1,177 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/selectcertificatecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "selectcertificatecommand.h"
 
 #include <dialogs/certificateselectiondialog.h>
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/key.h>
 
 #include <gpg-error.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 #include <QByteArray>
 #include <QPointer>
 
 #include <string>
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 class SelectCertificateCommand::Private
 {
     friend class ::Kleo::SelectCertificateCommand;
     SelectCertificateCommand *const q;
 public:
     Private(SelectCertificateCommand *qq) :
         q(qq),
         dialog()
     {
 
     }
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
     void slotSelectedCertificates(int, const QByteArray &);
 
 private:
     void ensureDialogCreated()
     {
         if (dialog) {
             return;
         }
         dialog = new CertificateSelectionDialog;
         q->applyWindowID(dialog);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         //dialog->setWindowTitle( i18nc( "@title", "Certificate Selection" ) );
         connect(dialog, SIGNAL(accepted()), q, SLOT(slotDialogAccepted()));
         connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
     }
     void ensureDialogShown()
     {
         ensureDialogCreated();
         if (dialog->isVisible()) {
             dialog->raise();
         } else {
             dialog->show();
         }
     }
 
 private:
     QPointer<CertificateSelectionDialog> dialog;
 };
 
 SelectCertificateCommand::SelectCertificateCommand()
     : QObject(), AssuanCommandMixin<SelectCertificateCommand>(), d(new Private(this)) {}
 
 SelectCertificateCommand::~SelectCertificateCommand() {}
 
 static const struct {
     const char *name;
     CertificateSelectionDialog::Option option;
 } option_table[] = {
     { "multi",        CertificateSelectionDialog::MultiSelection },
     { "sign-only",    CertificateSelectionDialog::SignOnly       },
     { "encrypt-only", CertificateSelectionDialog::EncryptOnly    },
     { "openpgp-only", CertificateSelectionDialog::OpenPGPFormat  },
     { "x509-only",    CertificateSelectionDialog::CMSFormat      },
     { "secret-only",  CertificateSelectionDialog::SecretKeys     },
 };
 
 int SelectCertificateCommand::doStart()
 {
 
     d->ensureDialogCreated();
 
     CertificateSelectionDialog::Options opts;
     for (unsigned int i = 0; i < sizeof option_table / sizeof * option_table; ++i)
         if (hasOption(option_table[i].name)) {
             opts |= option_table[i].option;
         }
 
     d->dialog->setOptions(opts);
 
     if (const int err = inquire("SELECTED_CERTIFICATES",
                                 this, SLOT(slotSelectedCertificates(int,QByteArray)))) {
         return err;
     }
 
     d->ensureDialogShown();
 
     return 0;
 }
 
 void SelectCertificateCommand::Private::slotSelectedCertificates(int err, const QByteArray &data)
 {
     qCDebug(KLEOPATRA_LOG) << err << ", " << data.constData();
     if (err) {
         return;
     }
     const auto split = data.split('\n');
     std::vector<std::string> fprs;
     fprs.reserve(split.size());
     std::transform(split.cbegin(), split.cend(), std::back_inserter(fprs), std::mem_fn(&QByteArray::constData));
     const std::vector<Key> keys = KeyCache::instance()->findByKeyIDOrFingerprint(fprs);
     for (const Key &key : keys) {
         qCDebug(KLEOPATRA_LOG) << "found key " << key.userID(0).id();
     }
     if (dialog) {
         dialog->selectCertificates(keys);
     } else {
         qCWarning(KLEOPATRA_LOG) << "dialog == NULL in slotSelectedCertificates";
     }
 }
 
 void SelectCertificateCommand::doCanceled()
 {
     if (d->dialog) {
         d->dialog->close();
     }
 }
 
 void SelectCertificateCommand::Private::slotDialogAccepted()
 {
     try {
         QByteArray data;
         Q_FOREACH (const Key &key, dialog->selectedCertificates()) {
             data += key.primaryFingerprint();
             data += '\n';
         }
         q->sendData(data);
         q->done();
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in SelectCertificateCommand::Private::slotDialogAccepted: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in SelectCertificateCommand::Private::slotDialogAccepted"));
     }
 }
 
 void SelectCertificateCommand::Private::slotDialogRejected()
 {
     dialog = nullptr;
     q->done(makeError(GPG_ERR_CANCELED));
 }
 
 #include "moc_selectcertificatecommand.cpp"
diff --git a/src/uiserver/signcommand.cpp b/src/uiserver/signcommand.cpp
index 2a17415de..78e46822e 100644
--- a/src/uiserver/signcommand.cpp
+++ b/src/uiserver/signcommand.cpp
@@ -1,228 +1,228 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/signcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signcommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 #include <utils/input.h>
 #include <utils/output.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class SignCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::SignCommand;
     SignCommand *const q;
 public:
     explicit Private(SignCommand *qq)
         : q(qq), controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private Q_SLOTS:
     void slotSignersResolved();
     void slotMicAlgDetermined(const QString &);
     void slotDone();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 SignCommand::SignCommand()
     : AssuanCommandMixin<SignCommand>(), d(new Private(this))
 {
 
 }
 
 SignCommand::~SignCommand() {}
 
 void SignCommand::Private::checkForErrors() const
 {
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("SIGN is an email mode command, connection seems to be in filemanager mode"));
 
     if (!q->recipients().empty() && !q->informativeRecipients())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("RECIPIENT may not be given prior to SIGN, except with --info"));
 
     if (q->inputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one INPUT must be present"));
 
     if (q->outputs().size() != q->inputs().size())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("INPUT/OUTPUT count mismatch"));
 
     if (!q->messages().empty())
         throw Exception(makeError(GPG_ERR_INV_VALUE),
                         i18n("MESSAGE command is not allowed before SIGN"));
 
     const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (m && m->isSigning()) {
 
         if (m->protocol() != q->checkProtocol(EMail))
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT in this session"));
 
         // ### check that any SENDER here is the same as the one for PREP_ENCRYPT
 
         // ### ditto RECIPIENT
 
     } else {
 
         // ### support the stupid "default signer" semantics of GpgOL
         // ### where SENDER is missing
         if (false)
             if (q->senders().empty() || q->informativeSenders())
                 throw Exception(makeError(GPG_ERR_MISSING_VALUE),
                                 i18n("No senders given, or only with --info"));
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotSignersResolved()));
     QObject::connect(controller, SIGNAL(reportMicAlg(QString)), d, SLOT(slotMicAlgDetermined(QString)));
     QObject::connect(controller, SIGNAL(done()), d, SLOT(slotDone()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 }
 
 int SignCommand::doStart()
 {
 
     d->checkForErrors();
 
     const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isSigning()) {
         // reuse the controller from a previous PREP_ENCRYPT --expect-sign, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         if (!seec->isEncrypting()) {
             removeMemento(NewSignEncryptEMailController::mementoName());
         }
         seec->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotSignersResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         d->controller->setSigning(true);
         d->controller->setEncrypting(false);
         d->controller->setProtocol(checkProtocol(EMail, AssuanCommand::AllowProtocolMissing));
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void SignCommand::Private::slotSignersResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
         const QString sessionTitle = q->sessionTitle();
         if (!sessionTitle.isEmpty())
             Q_FOREACH (const std::shared_ptr<Input> &i, q->inputs()) {
                 i->setLabel(sessionTitle);
             }
 
         cont->setDetachedSignature(q->hasOption("detached"));
         cont->startSigning(q->inputs(), q->outputs());
 
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in SignCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in SignCommand::Private::slotRecipientsResolved"));
     }
     cont->cancel();
 }
 
 void SignCommand::Private::slotMicAlgDetermined(const QString &micalg)
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
 
         q->sendStatus("MICALG", micalg);
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in SignCommand::Private::slotMicAlgDetermined: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in SignCommand::Private::slotMicAlgDetermined"));
     }
     cont->cancel();
 }
 
 void SignCommand::Private::slotDone()
 {
     q->done();
 }
 
 void SignCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void SignCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "signcommand.moc"
diff --git a/src/uiserver/signencryptfilescommand.cpp b/src/uiserver/signencryptfilescommand.cpp
index 94d6c4c01..594c1b666 100644
--- a/src/uiserver/signencryptfilescommand.cpp
+++ b/src/uiserver/signencryptfilescommand.cpp
@@ -1,135 +1,135 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/signencryptfilescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptfilescommand.h"
 
 #include <crypto/signencryptfilescontroller.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class SignEncryptFilesCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::SignEncryptFilesCommand;
     SignEncryptFilesCommand *const q;
 public:
     explicit Private(SignEncryptFilesCommand *qq)
         : q(qq),
           controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private Q_SLOTS:
     void slotDone();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<SignEncryptFilesController> controller;
 };
 
 SignEncryptFilesCommand::SignEncryptFilesCommand()
     : AssuanCommandMixin<SignEncryptFilesCommand>(), d(new Private(this))
 {
 
 }
 
 SignEncryptFilesCommand::~SignEncryptFilesCommand() {}
 
 void SignEncryptFilesCommand::Private::checkForErrors() const
 {
 
     if (!q->numFiles())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one FILE must be present"));
 
     if (!q->senders().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("%1 is a filemanager mode command, "
                              "connection seems to be in email mode (%2 present)",
                              QString::fromLatin1(q->name()), QStringLiteral("SENDER")));
     if (!q->recipients().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("%1 is a filemanager mode command, "
                              "connection seems to be in email mode (%2 present)",
                              QString::fromLatin1(q->name()), QStringLiteral("RECIPIENT")));
 
     if (!q->inputs().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("%1 is a filemanager mode command, "
                              "connection seems to be in email mode (%2 present)",
                              QString::fromLatin1(q->name()), QStringLiteral("INPUT")));
     if (!q->outputs().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("%1 is a filemanager mode command, "
                              "connection seems to be in email mode (%2 present)",
                              QString::fromLatin1(q->name()), QStringLiteral("OUTPUT")));
     if (!q->messages().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("%1 is a filemanager mode command, "
                              "connection seems to be in email mode (%2 present)",
                              QString::fromLatin1(q->name()), QStringLiteral("MESSAGE")));
 }
 
 int SignEncryptFilesCommand::doStart()
 {
 
     d->checkForErrors();
 
     d->controller.reset(new SignEncryptFilesController(shared_from_this()));
 
     d->controller->setProtocol(checkProtocol(FileManager));
 
     unsigned int op = operation();
     if (hasOption("archive")) {
         op |= SignEncryptFilesController::ArchiveForced;
     } else {
         op |= SignEncryptFilesController::ArchiveAllowed;
     }
     d->controller->setOperationMode(op);
     d->controller->setFiles(fileNames());
 
     QObject::connect(d->controller.get(), SIGNAL(done()), d.get(), SLOT(slotDone()), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)), d.get(), SLOT(slotError(int,QString)), Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 void SignEncryptFilesCommand::Private::slotDone()
 {
     q->done();
 }
 
 void SignEncryptFilesCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void SignEncryptFilesCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "signencryptfilescommand.moc"
 
diff --git a/src/uiserver/uiserver.cpp b/src/uiserver/uiserver.cpp
index 080651327..643c2bddc 100644
--- a/src/uiserver/uiserver.cpp
+++ b/src/uiserver/uiserver.cpp
@@ -1,282 +1,282 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/uiserver.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "uiserver.h"
 #include "uiserver_p.h"
 
 #include "sessiondata.h"
 
 #include <utils/detail_p.h>
 #include <Libkleo/GnuPG>
 
 #include <Libkleo/Stl_Util>
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 #include <QTcpSocket>
 #include <QDir>
 #include <QEventLoop>
 #include <QTimer>
 #include <QFile>
 
 #include <algorithm>
 #include <cerrno>
 
 using namespace Kleo;
 
 // static
 void UiServer::setLogStream(FILE *stream)
 {
     assuan_set_assuan_log_stream(stream);
 }
 
 UiServer::Private::Private(UiServer *qq)
     : QTcpServer(),
       q(qq),
       file(),
       factories(),
       connections(),
       suggestedSocketName(),
       actualSocketName(),
       cryptoCommandsEnabled(false)
 {
 #ifndef HAVE_ASSUAN2
     assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
 #else
     assuan_set_gpg_err_source(GPG_ERR_SOURCE_DEFAULT);
     assuan_sock_init();
 #endif
 }
 
 bool UiServer::Private::isStaleAssuanSocket(const QString &fileName)
 {
     assuan_context_t ctx = nullptr;
 #ifndef HAVE_ASSUAN2
     const bool error = assuan_socket_connect_ext(&ctx, QFile::encodeName(fileName).constData(), -1, 0);
 #else
     const bool error = assuan_new(&ctx) || assuan_socket_connect(ctx, QFile::encodeName(fileName).constData(), ASSUAN_INVALID_PID, 0);
 #endif
     if (!error)
 #ifndef HAVE_ASSUAN2
         assuan_disconnect(ctx);
 #else
         assuan_release(ctx);
 #endif
     return error;
 }
 
 UiServer::UiServer(const QString &socket, QObject *p)
     : QObject(p), d(new Private(this))
 {
     d->suggestedSocketName = d->makeFileName(socket);
 }
 
 UiServer::~UiServer()
 {
     if (QFile::exists(d->actualSocketName)) {
         QFile::remove(d->actualSocketName);
     }
 }
 
 namespace {
 using Iterator = std::vector<std::shared_ptr<AssuanCommandFactory>>::iterator;
 static bool empty(std::pair<Iterator, Iterator> iters)
 {
     return iters.first == iters.second;
 }
 }
 
 bool UiServer::registerCommandFactory(const std::shared_ptr<AssuanCommandFactory> &cf)
 {
     if (cf && empty(std::equal_range(d->factories.begin(), d->factories.end(), cf, _detail::ByName<std::less>()))) {
         d->factories.push_back(cf);
         std::inplace_merge(d->factories.begin(), d->factories.end() - 1, d->factories.end(), _detail::ByName<std::less>());
         return true;
     } else {
         if (!cf) {
             qCWarning(KLEOPATRA_LOG) << "NULL factory";
         } else {
             qCWarning(KLEOPATRA_LOG) << (void *)cf.get() << " factory already registered";
         }
 
         return false;
     }
 }
 
 void UiServer::start()
 {
     d->makeListeningSocket();
 }
 
 void UiServer::stop()
 {
 
     d->close();
 
     if (d->file.exists()) {
         d->file.remove();
     }
 
     if (isStopped()) {
         SessionDataHandler::instance()->clear();
         Q_EMIT stopped();
     }
 
 }
 
 void UiServer::enableCryptoCommands(bool on)
 {
     if (on == d->cryptoCommandsEnabled) {
         return;
     }
     d->cryptoCommandsEnabled = on;
     std::for_each(d->connections.cbegin(), d->connections.cend(),
                   [on](std::shared_ptr<AssuanServerConnection> conn) {
                       conn->enableCryptoCommands(on);
                   });
 }
 
 QString UiServer::socketName() const
 {
     return d->actualSocketName;
 }
 
 bool UiServer::waitForStopped(unsigned int ms)
 {
     if (isStopped()) {
         return true;
     }
     QEventLoop loop;
     QTimer timer;
     timer.setInterval(ms);
     timer.setSingleShot(true);
     connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
     connect(this, &UiServer::stopped, &loop, &QEventLoop::quit);
     loop.exec();
     return !timer.isActive();
 }
 
 bool UiServer::isStopped() const
 {
     return d->connections.empty() && !d->isListening();
 }
 
 bool UiServer::isStopping() const
 {
     return !d->connections.empty() && !d->isListening();
 }
 
 void UiServer::Private::slotConnectionClosed(Kleo::AssuanServerConnection *conn)
 {
     qCDebug(KLEOPATRA_LOG) << "UiServer: connection " << (void *)conn << " closed";
     connections.erase(std::remove_if(connections.begin(), connections.end(),
                                      [conn](const std::shared_ptr<AssuanServerConnection> &other) {
                                          return conn == other.get();
                                      }),
                       connections.end());
     if (q->isStopped()) {
         SessionDataHandler::instance()->clear();
         Q_EMIT q->stopped();
     }
 }
 
 void UiServer::Private::incomingConnection(qintptr fd)
 {
     try {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connect on fd " << fd;
 #if defined(HAVE_ASSUAN_SOCK_GET_NONCE) || defined(HAVE_ASSUAN2)
         if (assuan_sock_check_nonce((assuan_fd_t)fd, &nonce)) {
             qCDebug(KLEOPATRA_LOG) << "UiServer: nonce check failed";
             assuan_sock_close((assuan_fd_t)fd);
             return;
         }
 #endif
         const std::shared_ptr<AssuanServerConnection> c(new AssuanServerConnection((assuan_fd_t)fd, factories));
         connect(c.get(), &AssuanServerConnection::closed,
                 this, &Private::slotConnectionClosed);
         connect(c.get(), &AssuanServerConnection::startKeyManagerRequested,
                 q, &UiServer::startKeyManagerRequested, Qt::QueuedConnection);
         connect(c.get(), &AssuanServerConnection::startConfigDialogRequested,
                 q, &UiServer::startConfigDialogRequested, Qt::QueuedConnection);
         c->enableCryptoCommands(cryptoCommandsEnabled);
         connections.push_back(c);
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection " << (void *)c.get() << " established successfully";
     } catch (const Exception &e) {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection failed: " << e.what();
         QTcpSocket s;
         s.setSocketDescriptor(fd);
         QTextStream(&s) << "ERR " << e.error_code() << " " << e.what() << "\r\n";
         s.waitForBytesWritten();
         s.close();
     } catch (...) {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection failed: unknown exception caught";
         // this should never happen...
         QTcpSocket s;
         s.setSocketDescriptor(fd);
         QTextStream(&s) << "ERR 63 unknown exception caught\r\n";
         s.waitForBytesWritten();
         s.close();
     }
 }
 
 QString UiServer::Private::makeFileName(const QString &socket) const
 {
     if (!socket.isEmpty()) {
         return socket;
     }
     const QString gnupgHome = gnupgHomeDirectory();
     if (gnupgHome.isEmpty()) {
         throw_<std::runtime_error>(i18n("Could not determine the GnuPG home directory. Consider setting the GNUPGHOME environment variable."));
     }
     ensureDirectoryExists(gnupgHome);
     const QDir dir(gnupgHome);
     Q_ASSERT(dir.exists());
     return dir.absoluteFilePath(QStringLiteral("S.uiserver"));
 }
 
 void UiServer::Private::ensureDirectoryExists(const QString &path) const
 {
     const QFileInfo info(path);
     if (info.exists() && !info.isDir()) {
         throw_<std::runtime_error>(i18n("Cannot determine the GnuPG home directory: %1 exists but is not a directory.", path));
     }
     if (info.exists()) {
         return;
     }
     const QDir dummy; //there is no static QDir::mkpath()...
     errno = 0;
     if (!dummy.mkpath(path)) {
         throw_<std::runtime_error>(i18n("Could not create GnuPG home directory %1: %2", path, systemErrorString()));
     }
 }
 
 void UiServer::Private::makeListeningSocket()
 {
 
     // First, create a file (we do this only for the name, gmpfh)
     const QString fileName = suggestedSocketName;
 
     if (QFile::exists(fileName)) {
         if (isStaleAssuanSocket(fileName)) {
             QFile::remove(fileName);
         } else {
             throw_<std::runtime_error>(i18n("Detected another running gnupg UI server listening at %1.", fileName));
         }
     }
 
     doMakeListeningSocket(QFile::encodeName(fileName));
 
     actualSocketName = suggestedSocketName;
 }
 
 #include "moc_uiserver_p.cpp"
diff --git a/src/uiserver/verifychecksumscommand.cpp b/src/uiserver/verifychecksumscommand.cpp
index de34f6bcf..b659f66af 100644
--- a/src/uiserver/verifychecksumscommand.cpp
+++ b/src/uiserver/verifychecksumscommand.cpp
@@ -1,88 +1,88 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/verifychecksumscommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "verifychecksumscommand.h"
 
 #ifndef QT_NO_DIRMODEL
 
 #include <crypto/verifychecksumscontroller.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class VerifyChecksumsCommand::Private
 {
 private:
     friend class ::Kleo::VerifyChecksumsCommand;
     VerifyChecksumsCommand *const q;
 public:
     explicit Private(VerifyChecksumsCommand *qq)
         : q(qq),
           controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private:
     std::shared_ptr<VerifyChecksumsController> controller;
 };
 
 VerifyChecksumsCommand::VerifyChecksumsCommand()
     : AssuanCommandMixin<VerifyChecksumsCommand>(), d(new Private(this))
 {
 
 }
 
 VerifyChecksumsCommand::~VerifyChecksumsCommand() {}
 
 void VerifyChecksumsCommand::Private::checkForErrors() const
 {
 
     if (!q->numFiles())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one FILE must be present"));
 
 }
 
 int VerifyChecksumsCommand::doStart()
 {
 
     d->checkForErrors();
 
     d->controller.reset(new VerifyChecksumsController(shared_from_this()));
 
     d->controller->setFiles(fileNames());
 
     QObject::connect(d->controller.get(), SIGNAL(done()),
                      this, SLOT(done()), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)),
                      this, SLOT(done(int,QString)), Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 void VerifyChecksumsCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #endif // QT_NO_DIRMODEL
diff --git a/src/utils/hex.cpp b/src/utils/hex.cpp
index b5c4519ec..eea5d54f3 100644
--- a/src/utils/hex.cpp
+++ b/src/utils/hex.cpp
@@ -1,132 +1,132 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/hex.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "hex.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QString>
 #include <QByteArray>
 
 using namespace Kleo;
 
 static unsigned char unhex(unsigned char ch)
 {
     if (ch >= '0' && ch <= '9') {
         return ch - '0';
     }
     if (ch >= 'A' && ch <= 'F') {
         return ch - 'A' + 10;
     }
     if (ch >= 'a' && ch <= 'f') {
         return ch - 'a' + 10;
     }
     const char cch = ch;
     throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX),
                     i18n("Invalid hex char '%1' in input stream.",
                          QString::fromLatin1(&cch, 1)));
 }
 
 std::string Kleo::hexdecode(const std::string &in)
 {
     std::string result;
     result.reserve(in.size());
     for (std::string::const_iterator it = in.begin(), end = in.end(); it != end; ++it)
         if (*it == '%') {
             ++it;
             unsigned char ch = '\0';
             if (it == end)
                 throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX),
                                 i18n("Premature end of hex-encoded char in input stream"));
             ch |= unhex(*it) << 4;
             ++it;
             if (it == end)
                 throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX),
                                 i18n("Premature end of hex-encoded char in input stream"));
             ch |= unhex(*it);
             result.push_back(ch);
         } else if (*it == '+') {
             result += ' ';
         } else  {
             result.push_back(*it);
         }
     return result;
 }
 
 std::string Kleo::hexencode(const std::string &in)
 {
     std::string result;
     result.reserve(3 * in.size());
 
     static const char hex[] = "0123456789ABCDEF";
 
     for (std::string::const_iterator it = in.begin(), end = in.end(); it != end; ++it)
         switch (const unsigned char ch = *it) {
         default:
             if ((ch >= '!' && ch <= '~') || ch > 0xA0) {
                 result += ch;
                 break;
             }
         // else fall through
         case ' ':
             result += '+';
             break;
         case '"':
         case '#':
         case '$':
         case '%':
         case '\'':
         case '+':
         case '=':
             result += '%';
             result += hex[(ch & 0xF0) >> 4 ];
             result += hex[(ch & 0x0F)      ];
             break;
         }
 
     return result;
 }
 
 std::string Kleo::hexdecode(const char *in)
 {
     if (!in) {
         return std::string();
     }
     return hexdecode(std::string(in));
 }
 
 std::string Kleo::hexencode(const char *in)
 {
     if (!in) {
         return std::string();
     }
     return hexencode(std::string(in));
 }
 
 QByteArray Kleo::hexdecode(const QByteArray &in)
 {
     if (in.isNull()) {
         return QByteArray();
     }
     const std::string result = hexdecode(std::string(in.constData()));
     return QByteArray(result.data(), result.size());
 }
 
 QByteArray Kleo::hexencode(const QByteArray &in)
 {
     if (in.isNull()) {
         return QByteArray();
     }
     const std::string result = hexencode(std::string(in.constData()));
     return QByteArray(result.data(), result.size());
 }
diff --git a/src/utils/input.cpp b/src/utils/input.cpp
index 93513080e..0517ad697 100644
--- a/src/utils/input.cpp
+++ b/src/utils/input.cpp
@@ -1,460 +1,460 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/input.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "input.h"
 #include "input_p.h"
 
 #include "detail_p.h"
 #include "kdpipeiodevice.h"
 #include "windowsprocessdevice.h"
 #include "log.h"
 #include "kleo_assert.h"
 #include "cached.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/Classify>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 #include <QFile>
 #include <QString>
 #include <QClipboard>
 #include <QApplication>
 #include <QByteArray>
 #include <QBuffer>
 #include <QDir>
 #include <QFileInfo>
 #include <QProcess>
 
 #include <errno.h>
 
 using namespace Kleo;
 
 namespace
 {
 
 class PipeInput : public InputImplBase
 {
 public:
     explicit PipeInput(assuan_fd_t fd);
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_io;
     }
     unsigned int classification() const override;
     unsigned long long size() const override
     {
         return 0;
     }
 
 private:
     std::shared_ptr<QIODevice> m_io;
 };
 
 class ProcessStdOutInput : public InputImplBase
 {
 public:
     ~ProcessStdOutInput()
     {
         finalize();
     }
 
     explicit ProcessStdOutInput(const QString &cmd, const QStringList &args, const QDir &wd, const QByteArray &stdin_ = QByteArray());
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_proc;
     }
     unsigned int classification() const override
     {
         return 0U;    // plain text
     }
     unsigned long long size() const override
     {
         return 0;
     }
     QString label() const override;
     bool failed() const override;
 
 private:
     QString doErrorString() const override;
 
 private:
     const QString m_command;
     const QStringList m_arguments;
 #ifdef Q_OS_WIN
     std::shared_ptr<WindowsProcessDevice> m_proc;
 #else
     std::shared_ptr<QProcess> m_proc;
 #endif
 };
 
 class FileInput : public InputImplBase
 {
 public:
     explicit FileInput(const QString &fileName);
     explicit FileInput(const std::shared_ptr<QFile> &file);
 
     QString label() const override
     {
         return m_io ? QFileInfo(m_fileName).fileName() : InputImplBase::label();
     }
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_io;
     }
     unsigned int classification() const override;
     unsigned long long size() const override
     {
         return QFileInfo(m_fileName).size();
     }
 
 private:
     std::shared_ptr<QIODevice> m_io;
     QString m_fileName;
 };
 
 #ifndef QT_NO_CLIPBOARD
 class ClipboardInput : public Input
 {
 public:
     explicit ClipboardInput(QClipboard::Mode mode);
 
     void setLabel(const QString &label) override;
     QString label() const override;
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_buffer;
     }
     unsigned int classification() const override;
     unsigned long long size() const override
     {
         return m_buffer ? m_buffer->buffer().size() : 0;
     }
     QString errorString() const override
     {
         return QString();
     }
 
 private:
     const QClipboard::Mode m_mode;
     std::shared_ptr<QBuffer> m_buffer;
 };
 #endif // QT_NO_CLIPBOARD
 
 class ByteArrayInput: public Input
 {
 public:
     explicit ByteArrayInput(QByteArray *data):
         m_buffer(std::shared_ptr<QBuffer>(new QBuffer(data)))
     {
         if (!m_buffer->open(QIODevice::ReadOnly))
             throw Exception(gpg_error(GPG_ERR_EIO),
                             QStringLiteral("Could not open bytearray for reading?!"));
     }
 
     void setLabel(const QString &label) override
     {
         m_label = label;
     }
     QString label() const override
     {
         return m_label;
     }
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_buffer;
     }
     unsigned long long size() const override
     {
         return m_buffer ? m_buffer->buffer().size() : 0;
     }
     QString errorString() const override
     {
         return QString();
     }
     unsigned int classification() const override
     {
         return classifyContent(m_buffer->data());
     }
 
 private:
     std::shared_ptr<QBuffer> m_buffer;
     QString m_label;
 };
 
 }
 
 std::shared_ptr<Input> Input::createFromByteArray(QByteArray *data, const QString &label)
 {
     std::shared_ptr<ByteArrayInput> po(new ByteArrayInput(data));
     po->setLabel(label);
     return po;
 }
 
 std::shared_ptr<Input> Input::createFromPipeDevice(assuan_fd_t fd, const QString &label)
 {
     std::shared_ptr<PipeInput> po(new PipeInput(fd));
     po->setDefaultLabel(label);
     return po;
 }
 
 PipeInput::PipeInput(assuan_fd_t fd)
     : InputImplBase(),
       m_io()
 {
     std::shared_ptr<KDPipeIODevice> kdp(new KDPipeIODevice);
     errno = 0;
     if (!kdp->open(fd, QIODevice::ReadOnly))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not open FD %1 for reading",
                              _detail::assuanFD2int(fd)));
     m_io = Log::instance()->createIOLogger(kdp, QStringLiteral("pipe-input"), Log::Read);
 }
 
 unsigned int PipeInput::classification() const
 {
     notImplemented();
     return 0;
 }
 
 std::shared_ptr<Input> Input::createFromFile(const QString &fileName, bool)
 {
     return std::shared_ptr<Input>(new FileInput(fileName));
 }
 
 std::shared_ptr<Input> Input::createFromFile(const std::shared_ptr<QFile> &file)
 {
     return std::shared_ptr<Input>(new FileInput(file));
 }
 
 FileInput::FileInput(const QString &fileName)
     : InputImplBase(),
       m_io(), m_fileName(fileName)
 {
     std::shared_ptr<QFile> file(new QFile(fileName));
 
     errno = 0;
     if (!file->open(QIODevice::ReadOnly))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not open file \"%1\" for reading", fileName));
     m_io = Log::instance()->createIOLogger(file, QStringLiteral("file-in"), Log::Read);
 
 }
 
 FileInput::FileInput(const std::shared_ptr<QFile> &file)
     : InputImplBase(),
       m_io(), m_fileName(file->fileName())
 {
     kleo_assert(file);
     errno = 0;
     if (file->isOpen() && !file->isReadable())
         throw Exception(gpg_error(GPG_ERR_INV_ARG),
                         i18n("File \"%1\" is already open, but not for reading", file->fileName()));
     if (!file->isOpen() && !file->open(QIODevice::ReadOnly))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not open file \"%1\" for reading", m_fileName));
     m_io = Log::instance()->createIOLogger(file, QStringLiteral("file-in"), Log::Read);
 }
 
 unsigned int FileInput::classification() const
 {
     return classify(m_fileName);
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, QStringList(), QDir::current()));
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command, const QStringList &args)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, args, QDir::current()));
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command, const QStringList &args, const QDir &wd)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, args, wd));
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command, const QByteArray &stdin_)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, QStringList(), QDir::current(), stdin_));
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command, const QStringList &args, const QByteArray &stdin_)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, args, QDir::current(), stdin_));
 }
 
 std::shared_ptr<Input> Input::createFromProcessStdOut(const QString &command, const QStringList &args, const QDir &wd, const QByteArray &stdin_)
 {
     return std::shared_ptr<Input>(new ProcessStdOutInput(command, args, wd, stdin_));
 }
 
 namespace
 {
 struct Outputter {
     const QByteArray &data;
     explicit Outputter(const QByteArray &data) : data(data) {}
 };
 static QDebug operator<<(QDebug s, const Outputter &o)
 {
     if (const quint64 size = o.data.size()) {
         s << " << (" << size << "bytes)";
     }
     return s;
 }
 }
 
 ProcessStdOutInput::ProcessStdOutInput(const QString &cmd, const QStringList &args, const QDir &wd, const QByteArray &stdin_)
     : InputImplBase(),
       m_command(cmd),
       m_arguments(args)
 {
     const QIODevice::OpenMode openMode =
         stdin_.isEmpty() ? QIODevice::ReadOnly : QIODevice::ReadWrite;
     qCDebug(KLEOPATRA_LOG) << "cd" << wd.absolutePath() << '\n' << cmd << args << Outputter(stdin_);
     if (cmd.isEmpty())
         throw Exception(gpg_error(GPG_ERR_INV_ARG),
                         i18n("Command not specified"));
 
 #ifndef Q_OS_WIN
     m_proc = std::shared_ptr<QProcess> (new QProcess);
     m_proc->setWorkingDirectory(wd.absolutePath());
     m_proc->start(cmd, args, openMode);
     if (!m_proc->waitForStarted())
         throw Exception(gpg_error(GPG_ERR_EIO),
                         i18n("Could not start %1 process: %2", cmd, m_proc->errorString()));
 #else
     m_proc = std::shared_ptr<Kleo::WindowsProcessDevice> (new WindowsProcessDevice(cmd, args, wd.absolutePath()));
     if (!m_proc->open(openMode)) {
         throw Exception(gpg_error(GPG_ERR_EIO),
                         i18n("Could not start %1 process: %2", cmd, m_proc->errorString()));
     }
 #endif
     if (!stdin_.isEmpty()) {
         if (m_proc->write(stdin_) != stdin_.size())
             throw Exception(gpg_error(GPG_ERR_EIO),
                             i18n("Failed to write input to %1 process: %2", cmd, m_proc->errorString()));
         m_proc->closeWriteChannel();
     }
 }
 
 QString ProcessStdOutInput::label() const
 {
     if (!m_proc) {
         return InputImplBase::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. \"Output of tar xf - file1 ...\"", "Output of %1 ...", cmdline);
     } else {
         return i18nc("e.g. \"Output of tar xf - file\"",      "Output of %1",     cmdline);
     }
 }
 
 QString ProcessStdOutInput::doErrorString() const
 {
     kleo_assert(m_proc);
 #ifdef Q_OS_WIN
     const auto err = m_proc->errorString();
     if (!err.isEmpty()) {
         return QStringLiteral("%1:\n%2").arg(m_command).arg(err);
     }
     return QString();
 #else
     if (m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0) {
         return QString();
     }
     if (m_proc->error() == QProcess::UnknownError)
         return i18n("Error while running %1:\n%2", m_command,
                     QString::fromLocal8Bit(m_proc->readAllStandardError().trimmed().constData()));
     else {
         return i18n("Failed to execute %1: %2", m_command, m_proc->errorString());
     }
 #endif
 }
 
 bool ProcessStdOutInput::failed() const
 {
     kleo_assert(m_proc);
 #ifdef Q_OS_WIN
     return !m_proc->errorString().isEmpty();
 #else
     return !(m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0);
 #endif
 }
 
 #ifndef QT_NO_CLIPBOARD
 std::shared_ptr<Input> Input::createFromClipboard()
 {
     return std::shared_ptr<Input>(new ClipboardInput(QClipboard::Clipboard));
 }
 
 static QByteArray dataFromClipboard(QClipboard::Mode mode)
 {
     Q_UNUSED(mode);
     if (QClipboard *const cb = QApplication::clipboard()) {
         return cb->text().toUtf8();
     } else {
         return QByteArray();
     }
 }
 
 ClipboardInput::ClipboardInput(QClipboard::Mode mode)
     : Input(),
       m_mode(mode),
       m_buffer(new QBuffer)
 {
     m_buffer->setData(dataFromClipboard(mode));
     if (!m_buffer->open(QIODevice::ReadOnly))
         throw Exception(gpg_error(GPG_ERR_EIO),
                         i18n("Could not open clipboard for reading"));
 }
 
 void ClipboardInput::setLabel(const QString &)
 {
     notImplemented();
 }
 
 QString ClipboardInput::label() const
 {
     switch (m_mode) {
     case QClipboard::Clipboard:
         return i18n("Clipboard contents");
     case QClipboard::FindBuffer:
         return i18n("FindBuffer contents");
     case QClipboard::Selection:
         return i18n("Current selection");
     };
     return QString();
 }
 
 unsigned int ClipboardInput::classification() const
 {
     return classifyContent(m_buffer->data());
 }
 #endif // QT_NO_CLIPBOARD
 
 Input::~Input() {}
 
 void Input::finalize()
 {
     if (const std::shared_ptr<QIODevice> io = ioDevice())
         if (io->isOpen()) {
             qCDebug(KLEOPATRA_LOG)  << "closing input";
             io->close();
         }
 }
diff --git a/src/utils/kleo_assert.h b/src/utils/kleo_assert.h
index 3c556970f..24a6e7f91 100644
--- a/src/utils/kleo_assert.h
+++ b/src/utils/kleo_assert.h
@@ -1,74 +1,74 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/kleo_assert.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef __KLEOPATRA_UTILS_KLEO_ASSERT_H__
 #define __KLEOPATRA_UTILS_KLEO_ASSERT_H__
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <assert.h>
 
 #define S(x) #x
 #define S_(x) S(x)
 #define S_LINE S_(__LINE__)
 
 #define kleo_assert_fail_impl( cond, file, line )                       \
     throw Kleo::Exception( gpg_error( GPG_ERR_INTERNAL ),               \
                            "assertion \"" #cond "\" failed at " file ":" line )
 #define kleo_assert_fail_impl_func( cond, file, line, func )            \
     throw Kleo::Exception( gpg_error( GPG_ERR_INTERNAL ),               \
                            std::string( "assertion \"" #cond "\" failed in " ) + func + " (" file ":" line ")" )
 
 #define kleo_assert_impl( cond, file, line )                  \
     if ( cond ) {}                                            \
     else kleo_assert_fail_impl( cond, file, line )
 #define kleo_assert_impl_func( cond, file, line, func )       \
     if ( cond ) {}                                            \
     else kleo_assert_fail_impl_func( cond, file, line, func )
 
 // from glibc's assert.h:
 /* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
    which contains the name of the function currently being defined.
    This is broken in G++ before version 2.6.
    C9x has a similar variable called __func__, but prefer the GCC one since
    it demangles C++ function names.  */
 
 #if defined (__GNUC_PREREQ)
 # define KLEO_GNUC_PREREQ __GNUC_PREREQ
 #elif defined (__MINGW_GNUC_PREREQ)
 # define KLEO_GNUC_PREREQ __MINGW_GNUC_PREREQ
 #else
 # define KLEO_GNUC_PREREQ(maj, min) 0
 #endif
 
 #if KLEO_GNUC_PREREQ(2, 6)
 # define kleo_assert( cond ) kleo_assert_impl_func( cond, __FILE__, S_LINE, __PRETTY_FUNCTION__ )
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl_func( cond, __FILE__, S_LINE, __PRETTY_FUNCTION__ )
 # define notImplemented() throw Exception( gpg_error( GPG_ERR_NOT_IMPLEMENTED ), __PRETTY_FUNCTION__ )
 #elif defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
 # define kleo_assert( cond ) kleo_assert_impl_func( cond, __FILE__, S_LINE, __func__ )
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl_func( cond, __FILE__, S_LINE, __func__ )
 # define notImplemented() throw Exception( gpg_error( GPG_ERR_NOT_IMPLEMENTED ), __func__ )
 #endif
 
 #undef KLEO_GNUC_PREREQ
 
 #ifndef kleo_assert
 # define kleo_assert( cond ) kleo_assert_impl( cond, __FILE__, S_LINE )
 #endif
 
 #ifndef kleo_assert_fail
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl( cond, __FILE__, S_LINE )
 #endif
 
 #ifndef notImplemented
 # define notImplemented() kleo_assert( !"Sorry, not yet implemented" )
 #endif
 
 #endif /* __KLEOPATRA_UTILS_KLEO_ASSERT_H__ */
diff --git a/src/utils/log.cpp b/src/utils/log.cpp
index 2d3e46316..7c3a716d0 100644
--- a/src/utils/log.cpp
+++ b/src/utils/log.cpp
@@ -1,151 +1,151 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/log.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "log.h"
 #include "iodevicelogger.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 #include <KRandom>
 
 #include <QDateTime>
 #include <QDir>
 #include <QFile>
 #include <QString>
 
 
 using namespace Kleo;
 
 class Log::Private
 {
     Log *const q;
 public:
     explicit Private(Log *qq) : q(qq), m_ioLoggingEnabled(false), m_logFile(nullptr) {}
     ~Private();
     bool m_ioLoggingEnabled;
     QString m_outputDirectory;
     FILE *m_logFile;
 };
 
 Log::Private::~Private()
 {
     if (m_logFile) {
         fclose(m_logFile);
     }
 }
 
 void Log::messageHandler(QtMsgType type, const QMessageLogContext &ctx, const QString& msg)
 {
     const QString formattedMessage = qFormatLogMessage(type, ctx, msg);
     const QByteArray local8str = formattedMessage.toLocal8Bit();
     FILE *const file = Log::instance()->logFile();
     if (!file) {
         fprintf(stderr, "Log::messageHandler[!file]: %s", local8str.constData());
         return;
     }
 
     qint64 toWrite = local8str.size();
     while (toWrite > 0) {
         const qint64 written = fprintf(file, "%s", local8str.constData());
         if (written == -1) {
             return;
         }
         toWrite -= written;
     }
     //append newline:
     while (fprintf(file, "\n") == 0);
     fflush(file);
 }
 
 std::shared_ptr<const Log> Log::instance()
 {
     return mutableInstance();
 }
 
 std::shared_ptr<Log> Log::mutableInstance()
 {
     static std::weak_ptr<Log> self;
     try {
         return std::shared_ptr<Log>(self);
     } catch (const std::bad_weak_ptr &) {
         const std::shared_ptr<Log> s(new Log);
         self = s;
         return s;
     }
 }
 
 Log::Log() : d(new Private(this))
 {
 }
 
 Log::~Log()
 {
 }
 
 FILE *Log::logFile() const
 {
     return d->m_logFile;
 }
 
 void Log::setIOLoggingEnabled(bool enabled)
 {
     d->m_ioLoggingEnabled = enabled;
 }
 
 bool Log::ioLoggingEnabled() const
 {
     return d->m_ioLoggingEnabled;
 }
 
 QString Log::outputDirectory() const
 {
     return d->m_outputDirectory;
 }
 
 void Log::setOutputDirectory(const QString &path)
 {
     if (d->m_outputDirectory == path) {
         return;
     }
     d->m_outputDirectory = path;
     Q_ASSERT(!d->m_logFile);
     const QString lfn = path + QLatin1String("/kleo-log");
     d->m_logFile = fopen(QDir::toNativeSeparators(lfn).toLocal8Bit().constData(), "a");
     Q_ASSERT(d->m_logFile);
 }
 
 std::shared_ptr<QIODevice> Log::createIOLogger(const std::shared_ptr<QIODevice> &io, const QString &prefix, OpenMode mode) const
 {
     if (!d->m_ioLoggingEnabled) {
         return io;
     }
 
     std::shared_ptr<IODeviceLogger> logger(new IODeviceLogger(io));
 
     const QString timestamp = QDateTime::currentDateTime().toString(QStringLiteral("yyMMdd-hhmmss"));
 
     const QString fn = d->m_outputDirectory + QLatin1Char('/') + prefix + QLatin1Char('-') + timestamp + QLatin1Char('-') + KRandom::randomString(4);
     std::shared_ptr<QFile> file(new QFile(fn));
 
     if (!file->open(QIODevice::WriteOnly)) {
         throw Exception(gpg_error(GPG_ERR_EIO), i18n("Log Error: Could not open log file \"%1\" for writing.", fn));
     }
 
     if (mode & Read) {
         logger->setReadLogDevice(file);
     } else { // Write
         logger->setWriteLogDevice(file);
     }
 
     return logger;
 }
 
diff --git a/src/utils/output.cpp b/src/utils/output.cpp
index 108d482d4..9bf16ad4f 100644
--- a/src/utils/output.cpp
+++ b/src/utils/output.cpp
@@ -1,740 +1,740 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/output.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #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 <Libkleo/KleoException>
 
 #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 = 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 unnecessary delay before
           the process has even a chance to work and finish.
           This delay is mainly noticeable 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);
     }
 
     bool failed() const override
     {
         if (!m_proc) {
             return false;
         }
         return !(m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0);
     }
 
     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() << '\n' << 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;
 }
diff --git a/src/utils/path-helper.cpp b/src/utils/path-helper.cpp
index 6943decd5..d4ab5f80b 100644
--- a/src/utils/path-helper.cpp
+++ b/src/utils/path-helper.cpp
@@ -1,150 +1,150 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/path-helper.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "path-helper.h"
 
 #include <Libkleo/Stl_Util>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 #include <QString>
 #include <QStringList>
 #include <QStorageInfo>
 #include <QFileInfo>
 #include <QDir>
 
 #include <algorithm>
 
 using namespace Kleo;
 
 static QString commonPrefix(const QString &s1, const QString &s2)
 {
     return QString(s1.data(), std::mismatch(s1.data(), s1.data() + std::min(s1.size(), s2.size()), s2.data()).first - s1.data());
 }
 
 static QString longestCommonPrefix(const QStringList &sl)
 {
     if (sl.empty()) {
         return QString();
     }
     QString result = sl.front();
     for (const QString &s : sl) {
         result = commonPrefix(s, result);
     }
     return result;
 }
 
 QString Kleo::heuristicBaseDirectory(const QStringList &fileNames)
 {
     QStringList dirs;
     for (const QString &fileName : fileNames) {
         dirs.push_back(QFileInfo(fileName).path() + QLatin1Char('/'));
     }
     qCDebug(KLEOPATRA_LOG) << "dirs" << dirs;
     const QString candidate = longestCommonPrefix(dirs);
     const int idx = candidate.lastIndexOf(QLatin1Char('/'));
     return candidate.left(idx);
 }
 
 QStringList Kleo::makeRelativeTo(const QString &base, const QStringList &fileNames)
 {
 
     if (base.isEmpty()) {
         return fileNames;
     } else {
         return makeRelativeTo(QDir(base), fileNames);
     }
 
 }
 
 QStringList Kleo::makeRelativeTo(const QDir &baseDir, const QStringList &fileNames)
 {
     QStringList rv;
     rv.reserve(fileNames.size());
     std::transform(fileNames.cbegin(), fileNames.cend(),
                    std::back_inserter(rv),
                    [&baseDir](const QString &file) {
                        return baseDir.relativeFilePath(file);
                    });
     return rv;
 }
 
 void Kleo::recursivelyRemovePath(const QString &path)
 {
     const QFileInfo fi(path);
     if (fi.isDir()) {
         QDir dir(path);
         Q_FOREACH (const QString &fname, dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot)) {
             recursivelyRemovePath(dir.filePath(fname));
         }
         const QString dirName = fi.fileName();
         dir.cdUp();
         if (!dir.rmdir(dirName)) {
             throw Exception(GPG_ERR_EPERM, i18n("Cannot remove directory %1", path));
         }
     } else {
         QFile file(path);
         if (!file.remove()) {
             throw Exception(GPG_ERR_EPERM, i18n("Cannot remove file %1: %2", path, file.errorString()));
         }
     }
 }
 
 bool Kleo::recursivelyCopy(const QString &src,const QString &dest)
 {
     QDir srcDir(src);
 
     if(!srcDir.exists()) {
         return false;
     }
 
     QDir destDir(dest);
     if(!destDir.exists() && !destDir.mkdir(dest)) {
         return false;
     }
 
     for(const auto &file: srcDir.entryList(QDir::Files)) {
         const QString srcName = src + QLatin1Char('/') + file;
         const QString destName = dest + QLatin1Char('/') + file;
         if(!QFile::copy(srcName, destName)) {
             return false;
         }
     }
 
     for (const auto &dir: srcDir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot)) {
         const QString srcName = src + QLatin1Char('/') + dir;
         const QString destName = dest + QLatin1Char('/') + dir;
         if (!recursivelyCopy(srcName, destName)) {
             return false;
         }
     }
 
     return true;
 }
 
 bool Kleo::moveDir(const QString &src, const QString &dest)
 {
     if (QStorageInfo(src).device() == QStorageInfo(dest).device()) {
         // Easy same partition we can use qt.
         return QFile::rename(src, dest);
     }
     // first copy
     if (!recursivelyCopy(src, dest)) {
         return false;
     }
     // Then delete original
     recursivelyRemovePath(src);
 
     return true;
 }
diff --git a/src/view/padwidget.cpp b/src/view/padwidget.cpp
index cd192422e..0c85284ef 100644
--- a/src/view/padwidget.cpp
+++ b/src/view/padwidget.cpp
@@ -1,507 +1,507 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     padwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "padwidget.h"
 
 #include "kleopatra_debug.h"
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include "crypto/gui/signencryptwidget.h"
 #include "crypto/gui/resultitemwidget.h"
 
 #include "crypto/signencrypttask.h"
 #include "crypto/decryptverifytask.h"
 #include <Libkleo/GnuPG>
 #include "utils/input.h"
 #include "utils/output.h"
 
 #include "commands/importcertificatefromdatacommand.h"
 
 #include <gpgme++/data.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <QGpgME/DataProvider>
 
 #include <QButtonGroup>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QLabel>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QTabWidget>
 #include <QTextEdit>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 #include <KMessageBox>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 static GpgME::Protocol getProtocol(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
 {
     const auto dvResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
     if (dvResult) {
         for (const auto &key: KeyCache::instance()->findRecipients(dvResult->decryptionResult())) {
             return key.protocol();
         }
         for (const auto &key: KeyCache::instance()->findSigners(dvResult->verificationResult())) {
             return key.protocol();
         }
     }
     return GpgME::UnknownProtocol;
 }
 
 class PadWidget::Private
 {
 public:
     Private(PadWidget *qq):
         q(qq),
         mEdit(new QTextEdit),
         mCryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-sign-encrypt")), i18n("Sign / Encrypt Notepad"))),
         mDecryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-decrypt-verify")), i18n("Decrypt / Verify Notepad"))),
         mRevertBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("edit-undo")), i18n("Revert"))),
         mAdditionalInfoLabel(new QLabel),
         mSigEncWidget(new SignEncryptWidget(nullptr, true)),
         mProgressBar(new QProgressBar),
         mProgressLabel(new QLabel),
         mLastResultWidget(nullptr),
         mPGPRB(nullptr),
         mCMSRB(nullptr),
         mImportProto(GpgME::UnknownProtocol)
     {
         auto vLay = new QVBoxLayout(q);
 
         auto btnLay = new QHBoxLayout;
         vLay->addLayout(btnLay);
         btnLay->addWidget(mCryptBtn);
         btnLay->addWidget(mDecryptBtn);
         btnLay->addWidget(mRevertBtn);
 
         mRevertBtn->setVisible(false);
 
         btnLay->addWidget(mAdditionalInfoLabel);
 
         btnLay->addStretch(-1);
 
         mProgressBar->setRange(0, 0);
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
         auto progLay = new QHBoxLayout;
 
         progLay->addWidget(mProgressLabel);
         progLay->addWidget(mProgressBar);
 
         mStatusLay = new QVBoxLayout;
         mStatusLay->addLayout(progLay);
         vLay->addLayout(mStatusLay, 0);
 
         auto tabWidget = new QTabWidget;
         vLay->addWidget(tabWidget, 1);
 
         tabWidget->addTab(mEdit, QIcon::fromTheme(QStringLiteral("edittext")), i18n("Notepad"));
 
         // The recipients area
         auto recipientsWidget = new QWidget;
         auto recipientsVLay = new QVBoxLayout(recipientsWidget);
         auto protocolSelectionLay = new QHBoxLayout;
 
         bool pgpOnly = KeyCache::instance()->pgpOnly();
         if (!pgpOnly) {
             recipientsVLay->addLayout(protocolSelectionLay);
         }
 
         protocolSelectionLay->addWidget(new QLabel(i18n("<h3>Protocol:</h3>")));
         protocolSelectionLay->addStretch(-1);
         // Once S/MIME is supported add radio for S/MIME here.
 
         recipientsVLay->addWidget(mSigEncWidget);
         tabWidget->addTab(recipientsWidget, QIcon::fromTheme(QStringLiteral("contact-new-symbolic")),
                           i18n("Recipients"));
 
         mEdit->setPlaceholderText(i18n("Enter a message to encrypt or decrypt..."));
 
         auto fixedFont = QFont(QStringLiteral("Monospace"));
         fixedFont.setStyleHint(QFont::TypeWriter);
         // This does not work well
         // QFontDatabase::systemFont(QFontDatabase::FixedFont);
 
         mEdit->setFont(fixedFont);
         mEdit->setAcceptRichText(false);
         mEdit->setMinimumWidth(QFontMetrics(fixedFont).averageCharWidth() * 70);
 
         if (KeyCache::instance()->pgpOnly()) {
             mSigEncWidget->setProtocol(GpgME::OpenPGP);
         } else {
             auto grp = new QButtonGroup(q);
             auto mPGPRB = new QRadioButton(i18n("OpenPGP"));
             auto mCMSRB = new QRadioButton(i18n("S/MIME"));
             grp->addButton(mPGPRB);
             grp->addButton(mCMSRB);
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             if (config.readEntry("wasCMS", false)) {
                 mCMSRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::CMS);
             } else {
                 mPGPRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::OpenPGP);
             }
 
             protocolSelectionLay->addWidget(mPGPRB);
             protocolSelectionLay->addWidget(mCMSRB);
             connect(mPGPRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::OpenPGP);
                     }
                 });
             connect(mCMSRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::CMS);
                     }
                 });
         }
 
         updateCommitButton();
 
         connect(mEdit, &QTextEdit::textChanged, q, [this] () {
                 updateCommitButton();
             });
 
         connect(mCryptBtn, &QPushButton::clicked, q, [this] () {
                 if (mImportProto != GpgME::UnknownProtocol) {
                     doImport();
                 } else {
                     doEncryptSign();
                 }
             });
 
         connect(mSigEncWidget, &SignEncryptWidget::operationChanged, q, [this] (const QString &) {
                 updateCommitButton();
             });
 
         connect(mDecryptBtn, &QPushButton::clicked, q, [this] () {
                 doDecryptVerify();
             });
 
         connect(mRevertBtn, &QPushButton::clicked, q, [this] () {
                 revert();
             });
     }
 
     void revert()
     {
         mEdit->setPlainText(QString::fromUtf8(mInputData));
         mRevertBtn->setVisible(false);
     }
 
     void updateRecipientsFromResult(const Kleo::Crypto::DecryptVerifyResult &result)
     {
         const auto decResult = result.decryptionResult();
 
         for (const auto &recipient: decResult.recipients()) {
             if (!recipient.keyID()) {
                 continue;
             }
 
             GpgME::Key key;
             if (strlen(recipient.keyID()) < 16) {
                 key = KeyCache::instance()->findByShortKeyID(recipient.keyID());
             } else {
                 key = KeyCache::instance()->findByKeyIDOrFingerprint(recipient.keyID());
             }
 
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(recipient.keyID()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                     break;
                 }
             }
 
             if (key.isNull()) {
                 qCDebug(KLEOPATRA_LOG) << "Unknown key" << recipient.keyID();
                 mSigEncWidget->addUnknownRecipient(recipient.keyID());
                 continue;
             }
 
             bool keyFound = false;
             for (const auto &existingKey: mSigEncWidget->recipients()) {
                 if (existingKey.primaryFingerprint() && key.primaryFingerprint() &&
                     !strcmp (existingKey.primaryFingerprint(), key.primaryFingerprint())) {
                     keyFound = true;
                     break;
                 }
             }
             if (!keyFound) {
                 mSigEncWidget->addRecipient(key);
             }
         }
     }
 
     void cryptDone(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
     {
         updateCommitButton();
         mDecryptBtn->setEnabled(true);
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
 
         mLastResultWidget = new ResultItemWidget(result);
         mLastResultWidget->showCloseButton(true);
         mStatusLay->addWidget(mLastResultWidget);
 
         connect(mLastResultWidget, &ResultItemWidget::closeButtonClicked, q, [this] () {
             removeLastResultItem();
         });
 
         // Check result protocol
         if (mPGPRB) {
             auto proto = getProtocol(result);
             if (proto == GpgME::UnknownProtocol) {
                 proto = mPGPRB->isChecked() ? GpgME::OpenPGP : GpgME::CMS;
             } else if (proto == GpgME::OpenPGP) {
                 mPGPRB->setChecked(true);
             } else if (proto == GpgME::CMS) {
                 mCMSRB->setChecked(true);
             }
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             config.writeEntry("wasCMS", proto == GpgME::CMS);
         }
 
         if (result->errorCode()) {
             if (!result->errorString().isEmpty()) {
                 KMessageBox::error(q,
                         result->errorString(),
                         i18nc("@title", "Error in crypto action"));
             }
             return;
         }
         mEdit->setPlainText(QString::fromUtf8(mOutputData));
         mOutputData.clear();
         mRevertBtn->setVisible(true);
 
         const auto decryptVerifyResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
         if (decryptVerifyResult) {
             updateRecipientsFromResult(*decryptVerifyResult);
         }
     }
 
     void doDecryptVerify()
     {
         doCryptoCommon();
         mSigEncWidget->clearAddedRecipients();
         mProgressLabel->setText(i18n("Decrypt / Verify") + QStringLiteral("..."));
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         AbstractDecryptVerifyTask *task;
         auto classification = input->classification();
         if (classification & Class::OpaqueSignature ||
             classification & Class::ClearsignedMessage) {
             auto verifyTask = new VerifyOpaqueTask();
             verifyTask->setInput(input);
             verifyTask->setOutput(output);
             task = verifyTask;
         } else {
             auto decTask = new DecryptVerifyTask();
             decTask->setInput(input);
             decTask->setOutput(output);
             task = decTask;
         }
         try {
             task->autodetectProtocolFromInput();
         } catch (const Kleo::Exception &e) {
             KMessageBox::error(q,
                     e.message(),
                     i18nc("@title", "Error in crypto action"));
             mCryptBtn->setEnabled(true);
             mDecryptBtn->setEnabled(true);
             mProgressBar->setVisible(false);
             mProgressLabel->setVisible(false);
             return;
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Decrypt / Verify done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void removeLastResultItem()
     {
         if (mLastResultWidget) {
             mStatusLay->removeWidget(mLastResultWidget);
             delete mLastResultWidget;
             mLastResultWidget = nullptr;
         }
     }
 
     void doCryptoCommon()
     {
         mCryptBtn->setEnabled(false);
         mDecryptBtn->setEnabled(false);
         mProgressBar->setVisible(true);
         mProgressLabel->setVisible(true);
         mInputData = mEdit->toPlainText().toUtf8();
         removeLastResultItem();
     }
 
     void doEncryptSign()
     {
         doCryptoCommon();
         mProgressLabel->setText(mSigEncWidget->currentOp() + QStringLiteral("..."));
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         auto task = new SignEncryptTask();
         task->setInput(input);
         task->setOutput(output);
 
         const auto sigKey = mSigEncWidget->signKey();
 
         bool encrypt = mSigEncWidget->encryptSymmetric() || !mSigEncWidget->recipients().isEmpty();
         bool sign = !sigKey.isNull();
 
         if (sign) {
             task->setSign(true);
             std::vector<GpgME::Key> signVector;
             signVector.push_back(sigKey);
             task->setSigners(signVector);
         } else {
             task->setSign(false);
         }
         task->setEncrypt(encrypt);
         task->setRecipients(mSigEncWidget->recipients().toStdVector());
         task->setEncryptSymmetric(mSigEncWidget->encryptSymmetric());
         task->setAsciiArmor(true);
 
         if (sign && !encrypt && sigKey.protocol() == GpgME::OpenPGP) {
             task->setClearsign(true);
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Encrypt / Sign done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void doImport()
     {
         doCryptoCommon();
         mProgressLabel->setText(i18n("Importing..."));
         auto cmd = new Kleo::ImportCertificateFromDataCommand(mInputData, mImportProto);
         connect(cmd, &Kleo::ImportCertificatesCommand::finished, q, [this] () {
                 mCryptBtn->setEnabled(true);
                 mDecryptBtn->setEnabled(true);
                 mProgressBar->setVisible(false);
                 mProgressLabel->setVisible(false);
 
                 updateCommitButton();
                 mRevertBtn->setVisible(true);
                 mEdit->setPlainText(QString());
             });
         cmd->start();
     }
 
     void checkImportProtocol()
     {
         QGpgME::QByteArrayDataProvider dp(mEdit->toPlainText().toUtf8());
         GpgME::Data data(&dp);
         auto type = data.type();
         if (type == GpgME::Data::PGPKey) {
             mImportProto = GpgME::OpenPGP;
         } else if (type == GpgME::Data::X509Cert ||
                    type == GpgME::Data::PKCS12) {
             mImportProto = GpgME::CMS;
         } else {
             mImportProto = GpgME::UnknownProtocol;
         }
     }
 
     void updateCommitButton()
     {
         mAdditionalInfoLabel->setVisible(false);
 
         checkImportProtocol();
 
         if (mImportProto != GpgME::UnknownProtocol) {
             mCryptBtn->setText(i18nc("1 is an operation to apply to the notepad. "
                                      "Like Sign/Encrypt or just Encrypt.", "%1 Notepad",
                                      i18n("Import")));
             mCryptBtn->setDisabled(false);
             return;
         }
 
         if (!mSigEncWidget->currentOp().isEmpty()) {
             mCryptBtn->setDisabled(false);
             mCryptBtn->setText(i18nc("1 is an operation to apply to the notepad. "
                                      "Like Sign/Encrypt or just Encrypt.", "%1 Notepad",
                                      mSigEncWidget->currentOp()));
         } else {
             mCryptBtn->setText(i18n("Sign / Encrypt Notepad"));
             mCryptBtn->setDisabled(true);
         }
 
         if (Kleo::gpgComplianceP("de-vs")) {
             bool de_vs = mSigEncWidget->isDeVsAndValid();
             mCryptBtn->setIcon(QIcon::fromTheme(de_vs
                         ? QStringLiteral("security-high")
                         : QStringLiteral("security-medium")));
             mCryptBtn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                         ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                         : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
             mAdditionalInfoLabel->setText(de_vs
                     ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "%1 communication possible.", Formatting::deVsString())
                     : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "%1 communication not possible.", Formatting::deVsString()));
             mAdditionalInfoLabel->setVisible(true);
         }
     }
 
 private:
     PadWidget *const q;
     QTextEdit *mEdit;
     QPushButton *mCryptBtn;
     QPushButton *mDecryptBtn;
     QPushButton *mRevertBtn;
     QLabel *mAdditionalInfoLabel;
     QByteArray mInputData;
     QByteArray mOutputData;
     SignEncryptWidget *mSigEncWidget;
     QProgressBar *mProgressBar;
     QLabel *mProgressLabel;
     QVBoxLayout *mStatusLay;
     ResultItemWidget *mLastResultWidget;
     QList<GpgME::Key> mAutoAddedKeys;
     QRadioButton *mPGPRB;
     QRadioButton *mCMSRB;
     GpgME::Protocol mImportProto;
 };
 
 PadWidget::PadWidget(QWidget *parent):
     QWidget(parent),
     d(new Private(this))
 {
 }
diff --git a/tests/test_uiserver.cpp b/tests/test_uiserver.cpp
index 3ed96f003..983569f80 100644
--- a/tests/test_uiserver.cpp
+++ b/tests/test_uiserver.cpp
@@ -1,298 +1,298 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     tests/test_uiserver.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 //
 // Usage: test_uiserver <socket> --verify-detached <signed data> <signature>
 //
 
 #include <config-kleopatra.h>
 
 #include <kleo-assuan.h>
 #include <gpg-error.h>
 
-#include <Libkleo/Exception>
+#include <Libkleo/KleoException>
 
 #include "utils/wsastarter.h"
 #include "utils/hex.h"
 
 #ifndef Q_OS_WIN32
 # include <unistd.h>
 # include <sys/types.h>
 # include <sys/stat.h>
 # include <fcntl.h>
 # include <errno.h>
 #endif
 
 #include <cstdlib>
 #include <iostream>
 #include <map>
 #include <string>
 #include <vector>
 
 using namespace Kleo;
 
 #ifdef Q_OS_WIN32
 static const bool HAVE_FD_PASSING = false;
 #else
 static const bool HAVE_FD_PASSING = true;
 #endif
 
 static const unsigned int ASSUAN_CONNECT_FLAGS = HAVE_FD_PASSING ? 1 : 0;
 
 static std::vector<int> inFDs, outFDs, msgFDs;
 static std::vector<std::string> inFiles, outFiles, msgFiles;
 static std::map<std::string, std::string> inquireData;
 
 static void usage(const std::string &msg = std::string())
 {
     std::cerr << msg << std::endl <<
               "\n"
               "Usage: test_uiserver <socket> [<io>] [<options>] [<inquire>] command [<args>]\n"
               "where:\n"
 #ifdef Q_OS_WIN32
               "      <io>: [--input[-fd] <file>] [--output[-fd] <file>] [--message[-fd] <file>]\n"
 #else
               "      <io>: [--input <file>] [--output <file>] [--message <file>]\n"
 #endif
               " <options>: *[--option name=value]\n"
               " <inquire>: [--inquire keyword=<file>]\n";
     exit(1);
 }
 
 #ifndef HAVE_ASSUAN2
 static assuan_error_t data(void *void_ctx, const void *buffer, size_t len)
 {
 #else
 static gpg_error_t data(void *void_ctx, const void *buffer, size_t len)
 {
 #endif
     (void)void_ctx; (void)buffer; (void)len;
     return 0; // ### implement me
 }
 
 #ifndef HAVE_ASSUAN2
 static assuan_error_t status(void *void_ctx, const char *line)
 {
 #else
 static gpg_error_t status(void *void_ctx, const char *line)
 {
 #endif
     (void)void_ctx; (void)line;
     return 0;
 }
 
 #ifndef HAVE_ASSUAN2
 static assuan_error_t inquire(void *void_ctx, const char *keyword)
 {
 #else
 static gpg_error_t inquire(void *void_ctx, const char *keyword)
 {
 #endif
     assuan_context_t ctx = (assuan_context_t)void_ctx;
     Q_ASSERT(ctx);
     const std::map<std::string, std::string>::const_iterator it = inquireData.find(keyword);
     if (it == inquireData.end()) {
         return gpg_error(GPG_ERR_UNKNOWN_COMMAND);
     }
 
     if (!it->second.empty() && it->second[0] == '@') {
         return gpg_error(GPG_ERR_NOT_IMPLEMENTED);
     }
 
     if (const gpg_error_t err = assuan_send_data(ctx, it->second.c_str(), it->second.size())) {
         qDebug("assuan_write_data: %s", gpg_strerror(err));
         return err;
     }
 
     return 0;
 }
 
 int main(int argc, char *argv[])
 {
 
     const Kleo::WSAStarter _wsastarter;
 
 #ifndef HAVE_ASSUAN2
     assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
 #else
     assuan_set_gpg_err_source(GPG_ERR_SOURCE_DEFAULT);
 #endif
 
     if (argc < 3) {
         usage();    // need socket and command, at least
     }
 
     const char *socket = argv[1];
 
     std::vector<const char *> options;
 
     std::string command;
     for (int optind = 2; optind < argc; ++optind) {
         const char *const arg = argv[optind];
         if (qstrcmp(arg, "--input") == 0) {
             const std::string file = argv[++optind];
             inFiles.push_back(file);
         } else if (qstrcmp(arg, "--output") == 0) {
             const std::string file = argv[++optind];
             outFiles.push_back(file);
         } else if (qstrcmp(arg, "--message") == 0) {
             const std::string file = argv[++optind];
             msgFiles.push_back(file);
 #ifndef Q_OS_WIN32
         } else if (qstrcmp(arg, "--input-fd") == 0) {
             int inFD;
             if ((inFD = open(argv[++optind], O_RDONLY)) == -1) {
                 perror("--input-fd open()");
                 return 1;
             }
             inFDs.push_back(inFD);
         } else if (qstrcmp(arg, "--output-fd") == 0) {
             int outFD;
             if ((outFD = open(argv[++optind], O_WRONLY | O_CREAT, 0666)) ==  -1) {
                 perror("--output-fd open()");
                 return 1;
             }
             outFDs.push_back(outFD);
         } else if (qstrcmp(arg, "--message-fd") == 0) {
             int msgFD;
             if ((msgFD = open(argv[++optind], O_RDONLY)) ==  -1) {
                 perror("--message-fd open()");
                 return 1;
             }
             msgFDs.push_back(msgFD);
 #endif
         } else if (qstrcmp(arg, "--option") == 0) {
             options.push_back(argv[++optind]);
         } else if (qstrcmp(arg, "--inquire") == 0) {
             const std::string inqval = argv[++optind];
             const size_t pos = inqval.find('=');
             // ### implement indirection with "@file"...
             inquireData[inqval.substr(0, pos)] = inqval.substr(pos + 1);
         } else {
             while (optind < argc) {
                 if (!command.empty()) {
                     command += ' ';
                 }
                 command += argv[optind++];
             }
         }
     }
     if (command.empty()) {
         usage("Command expected, but only options found");
     }
 
     assuan_context_t ctx = nullptr;
 
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_socket_connect_ext(&ctx, socket, -1, ASSUAN_CONNECT_FLAGS)) {
         qDebug("%s", Exception(err, "assuan_socket_connect_ext").what());
 #else
     if (const gpg_error_t err = assuan_new(&ctx)) {
         qDebug("%s", Exception(err, "assuan_new").what());
         return 1;
     }
 
     if (const gpg_error_t err = assuan_socket_connect(ctx, socket, -1, ASSUAN_CONNECT_FLAGS)) {
         qDebug("%s", Exception(err, "assuan_socket_connect").what());
 #endif
         return 1;
     }
 
     assuan_set_log_stream(ctx, stderr);
 
 #ifndef Q_OS_WIN32
     for (std::vector<int>::const_iterator it = inFDs.begin(), end = inFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( inFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "INPUT FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "INPUT FD").what());
             return 1;
         }
     }
 
     for (std::vector<int>::const_iterator it = msgFDs.begin(), end = msgFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( msgFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "MESSAGE FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "MESSAGE FD").what());
             return 1;
         }
     }
 
     for (std::vector<int>::const_iterator it = outFDs.begin(), end = outFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( outFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "OUTPUT FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "OUTPUT FD").what());
             return 1;
         }
     }
 #endif
 
     for (std::vector<std::string>::const_iterator it = inFiles.begin(), end = inFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "INPUT FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     for (std::vector<std::string>::const_iterator it = msgFiles.begin(), end = msgFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "MESSAGE FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     for (std::vector<std::string>::const_iterator it = outFiles.begin(), end = outFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "OUTPUT FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     Q_FOREACH (const char *opt, options) {
         std::string line = "OPTION ";
         line += opt;
         if (const gpg_error_t err = assuan_transact(ctx, line.c_str(), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, line).what());
             return 1;
         }
     }
 
     if (const gpg_error_t err = assuan_transact(ctx, command.c_str(), data, ctx, inquire, ctx, status, ctx)) {
         qDebug("%s", Exception(err, command).what());
         return 1;
     }
 
 #ifndef HAVE_ASSUAN2
     assuan_disconnect(ctx);
 #else
     assuan_release(ctx);
 #endif
 
     return 0;
 }