No OneTemporary
Actions

Size

589 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index a37df7982..6d03ab10c 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,298 +1,271 @@
	# SPDX-FileCopyrightText: none
	# SPDX-License-Identifier: BSD-3-Clause
	cmake_minimum_required(VERSION 3.16 FATAL_ERROR)

	set(RELEASE_SERVICE_VERSION_MAJOR "23")
	set(RELEASE_SERVICE_VERSION_MINOR "11")
	set(RELEASE_SERVICE_VERSION_MICRO "70")

	# The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
	if (NOT RELEASE_SERVICE_VERSION)
	set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
	endif()
	if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
	else()
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
	endif()

	set(KLEOPATRA_VERSION_MAJOR "3")
	set(KLEOPATRA_VERSION_MINOR "1")
	set(KLEOPATRA_VERSION_MICRO "28")

	set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
	# The following is for Windows
	set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
	set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")
	if (NOT KLEOPATRA_DISTRIBUTION_TEXT)
	# This is only used on Windows for the file attributes of Kleopatra
	set(KLEOPATRA_DISTRIBUTION_TEXT "KDE")
	endif()

	project(kleopatra VERSION ${kleopatra_version})

	option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)

	# Standalone build. Find / include everything necessary.
	set(KF_MIN_VERSION "5.105.0")
	set(KIDENTITYMANAGEMENT_VERSION "5.24.0")
	set(KMAILTRANSPORT_VERSION "5.24.0")
	set(AKONADI_MIME_VERSION "5.24.0")
	set(KMIME_VERSION "5.24.0")
	set(LIBKLEO_VERSION "5.24.47")
	set(MIMETREEPARSER_VERSION "5.24.41")
	set(QT_REQUIRED_VERSION "5.15.2")
	if (QT_MAJOR_VERSION STREQUAL "6")
	set(QT_REQUIRED_VERSION "6.4.0")
	endif()
	set(GPGME_REQUIRED_VERSION "1.20.0")
	set(LIBASSUAN_REQUIRED_VERSION "2.4.2")
	set(GPG_ERROR_REQUIRED_VERSION "1.36")

	if (WIN32)
	set(KF5_WANT_VERSION "5.104.0")
	set(KMIME_WANT_VERSION "5.12.0")
	else ()
	set(KF5_WANT_VERSION ${KF_MIN_VERSION})
	set(KMIME_WANT_VERSION ${KMIME_VERSION})
	endif ()

	set(CMAKE_CXX_STANDARD 20)
	set(CMAKE_CXX_STANDARD_REQUIRED ON)

	find_package(ECM ${KF5_WANT_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(KDEInstallDirs)
	include(KDECMakeSettings)
	include(KDECompilerSettings NO_POLICY_SCOPE)
	include(ECMAddAppIcon)
	include(ECMQtDeclareLoggingCategory)
	include(ECMDeprecationSettings)
	include(KDEClangFormat)
	include(KDEGitCommitHooks)

	if (QT_MAJOR_VERSION STREQUAL "6")
	set(QT_REQUIRED_VERSION "6.4.0")
	set(KF_MIN_VERSION "5.240.0")
	set(KF_MAJOR_VERSION "6")
	else()
	set(KF_MIN_VERSION "5.105.0")
	set(KF_MAJOR_VERSION "5")
	endif()

	# Find KF5 packages
	find_package(KF${KF_MAJOR_VERSION} ${KF5_WANT_VERSION}
	REQUIRED COMPONENTS
	Codecs
	Config
	ConfigWidgets
	CoreAddons
	Crash
	I18n
	IconThemes
	ItemModels
	KCMUtils
	KIO
	WidgetsAddons
	WindowSystem
	XmlGui

	OPTIONAL_COMPONENTS
	DocTools
	)

	set_package_properties(KF${KF_MAJOR_VERSION}DocTools PROPERTIES
	DESCRIPTION "Documentation tools"
	PURPOSE "Required to generate Kleopatra documentation."
	TYPE OPTIONAL)

	# Optional packages
	if (WIN32)
	# Only a replacement available for Windows so this
	# is required on other platforms.
	find_package(KF${KF_MAJOR_VERSION}DBusAddons ${KF5_WANT_VERSION} CONFIG)
	set_package_properties(KF${KF_MAJOR_VERSION}DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
	PURPOSE "DBus session integration"
	URL "https://inqlude.org/libraries/kdbusaddons.html"
	TYPE OPTIONAL)
	else()
	find_package(KF${KF_MAJOR_VERSION}DBusAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
	set(_kleopatra_dbusaddons_libs KF${KF_MAJOR_VERSION}::DBusAddons)
	endif()

	set(HAVE_QDBUS ${Qt${QT_MAJOR_VERSION}DBus_FOUND})

	find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	-if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.19.0")
	- set(GPGMEPP_SUPPORTS_SET_CURVE 1)
	-endif()
	-if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.19.1")
	- set(GPGMEPP_KEY_CANSIGN_IS_FIXED 1)
	-endif()
	set(QGPGME_NAME "QGpgme")
	find_package(${QGPGME_NAME} ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	-if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.17.0")
	- set(QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1)
	- set(QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1)
	- set(QGPGME_SUPPORTS_WKDLOOKUP 1)
	- set(QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1)
	- set(QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1)
	- set(QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1)
	- set(QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1)
	- set(QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1)
	-endif()
	-if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.18.0")
	- set(QGPGME_SUPPORTS_KEY_REVOCATION 1)
	- set(QGPGME_SUPPORTS_KEY_REFRESH 1)
	- set(QGPGME_SUPPORTS_SET_FILENAME 1)
	- set(QGPGME_SUPPORTS_SET_PRIMARY_UID 1)
	-endif()
	-if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.19.0")
	- set(QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB 1)
	- set(QGPGME_SUPPORTS_ARCHIVE_JOBS 1)
	- set(QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS 1)
	-endif()
	if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.21.0")
	set(QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME 1)
	set(QGPGME_ARCHIVE_JOBS_SUPPORT_INPUT_FILENAME 1)
	endif()
	-if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.21.1")
	+if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.22.0")
	set(QGPGME_HAS_TOLOGSTRING 1)
	set(QGPGME_SUPPORTS_IS_MIME 1)
	endif()
	-if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.22.1")
	+if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.23.0")
	set(QGPGME_SUPPORTS_WKD_REFRESH_JOB 1)
	endif()

	if (QT_MAJOR_VERSION STREQUAL "6")
	find_package(Qt6Core5Compat)
	endif()

	# Kdepimlibs packages
	find_package(KPim${KF_MAJOR_VERSION}Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
	find_package(KPim${KF_MAJOR_VERSION}Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
	find_package(KPim${KF_MAJOR_VERSION}IdentityManagement ${KIDENTITYMANAGEMENT_VERSION} CONFIG)
	find_package(KPim${KF_MAJOR_VERSION}MailTransport ${KMAILTRANSPORT_VERSION} CONFIG)
	find_package(KPim${KF_MAJOR_VERSION}AkonadiMime ${AKONADI_MIME_VERSION} CONFIG)
	find_package(KPim${KF_MAJOR_VERSION}MimeTreeParserWidgets ${MIMETREEPARSER_VERSION} CONFIG REQUIRED)

	find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)

	find_package(LibAssuan ${LIBASSUAN_REQUIRED_VERSION} REQUIRED)
	set_package_properties(LibAssuan PROPERTIES
	TYPE REQUIRED
	PURPOSE "Needed for Kleopatra to act as the GnuPG UI Server"
	)
	find_package(LibGpgError ${GPG_ERROR_REQUIRED_VERSION} REQUIRED)
	set_package_properties(LibGpgError PROPERTIES
	TYPE REQUIRED
	)

	set(kleopatra_release FALSE)

	if(NOT kleopatra_release)
	find_package(Git)
	if(GIT_FOUND)
	execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	RESULT_VARIABLE rc
	ERROR_QUIET)
	if(rc EQUAL 0)
	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	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 ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
	string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
	Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")

	set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
	endif()
	endif()
	endif()

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
	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}
	)

	if (WIN32)
	# On Windows, we need to use stuff deprecated since Qt 5.11, e.g. from QDesktopWidget
	ecm_set_disabled_deprecation_versions(QT 5.10.0 KF 5.103.0)
	else ()
	ecm_set_disabled_deprecation_versions(QT 6.4 KF 5.103.0)
	endif ()

	if(CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
	endif()
	if(MINGW)
	# we do not care about different signedness of passed pointer arguments
	add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wno-pointer-sign>)
	endif()

	add_definitions(-DQT_NO_EMIT)
	remove_definitions(-DQT_NO_FOREACH)

	# Disable the use of QStringBuilder for operator+ to prevent crashes when
	# returning the result of concatenating string temporaries in lambdas. We do
	# this for example in some std::transform expressions.
	# This is a known issue: https://bugreports.qt.io/browse/QTBUG-47066
	# Alternatively, one would always have to remember to force the lambdas to
	# return a QString instead of QStringBuilder, but that's just too easy to
	# forget and, unfortunately, the compiler doesn't issue a warning if one forgets
	# this. So, it's just too dangerous.
	# One can still use QStringBuilder explicitly with the operator% if necessary.
	remove_definitions(-DQT_USE_FAST_OPERATOR_PLUS)
	remove_definitions(-DQT_USE_QSTRINGBUILDER)

	kde_enable_exceptions()
	option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)

	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
	if (USE_UNITY_CMAKE_SUPPORT)
	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
	endif()


	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}
	)

	ki18n_install(po)
	if(KF${KF_MAJOR_VERSION}DocTools_FOUND)
	kdoctools_install(po)
	add_subdirectory(doc)
	endif()
	feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

	# add clang-format target for all our real source files
	file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES .cpp .h *.c)
	kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
	kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)

	diff --git a/config-kleopatra.h.cmake b/config-kleopatra.h.cmake
	index 38dfd6760..7db43c96b 100644
	--- a/config-kleopatra.h.cmake
	+++ b/config-kleopatra.h.cmake
	@@ -1,68 +1,17 @@
	/* DBus available */
	#cmakedefine01 HAVE_QDBUS

	-/* Whether QGpgME supports changing the expiration date of the primary key and the subkeys simultaneously */
	-#cmakedefine01 QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
	-
	-/* Whether QGpgME supports retrieving the default value of a config entry */
	-#cmakedefine01 QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE
	-
	-/* Whether QGpgME supports WKD lookup */
	-#cmakedefine01 QGPGME_SUPPORTS_WKDLOOKUP
	-
	-/* Whether QGpgME supports specifying an import filter when importing keys */
	-#cmakedefine01 QGPGME_SUPPORTS_IMPORT_WITH_FILTER
	-
	-/* Whether QGpgME supports setting key origin when importing keys */
	-#cmakedefine01 QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN
	-
	-/* Whether QGpgME supports the export of secret keys */
	-#cmakedefine01 QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	-
	-/* Whether QGpgME supports the export of secret subkeys */
	-#cmakedefine01 QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	-
	-/* Whether QGpgME supports receiving keys by their key ids */
	-#cmakedefine01 QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	-
	-/* Whether QGpgME supports revoking own OpenPGP keys */
	-#cmakedefine01 QGPGME_SUPPORTS_KEY_REVOCATION
	-
	-/* Whether QGpgME supports refreshing keys */
	-#cmakedefine01 QGPGME_SUPPORTS_KEY_REFRESH
	-
	-/* Whether QGpgME supports setting the file name of encrypted data */
	-#cmakedefine01 QGPGME_SUPPORTS_SET_FILENAME
	-
	-/* Whether QGpgME supports setting the primary user id of a key */
	-#cmakedefine01 QGPGME_SUPPORTS_SET_PRIMARY_UID
	-
	-/* Whether GpgME++ supports setting the curve when generating ECC card keys */
	-#cmakedefine01 GPGMEPP_SUPPORTS_SET_CURVE
	-
	-/* Whether QGpgME supports deferred start of ImportJob */
	-#cmakedefine01 QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	-
	-/* Whether QGpgME supports the sign/encrypt/decrypt/verify archive jobs */
	-#cmakedefine01 QGPGME_SUPPORTS_ARCHIVE_JOBS
	-
	-/* Whether QGpgME::Job provides the new progress signals */
	-#cmakedefine01 QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	-
	-/* Whether Key::canSign should be used instead of deprecated Key::canReallySign */
	-#cmakedefine01 GPGMEPP_KEY_CANSIGN_IS_FIXED
	-
	/* Whether the archive jobs allow setting an output filename instead of passing an output IO device */
	#cmakedefine01 QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME

	/* Whether the archive jobs allow setting an input filename instead of passing an input IO device */
	#cmakedefine01 QGPGME_ARCHIVE_JOBS_SUPPORT_INPUT_FILENAME

	/* Whether QGpgMe supports isMime on an decryptionResult */
	#cmakedefine01 QGPGME_SUPPORTS_IS_MIME

	/* Whether QGpgME provides the toLogString helper */
	#cmakedefine01 QGPGME_HAS_TOLOGSTRING

	/* Whether QGpgME supports the WKD refresh job */
	#cmakedefine01 QGPGME_SUPPORTS_WKD_REFRESH_JOB
	diff --git a/src/commands/adduseridcommand.cpp b/src/commands/adduseridcommand.cpp
	index e8697814b..f41a62c9e 100644
	--- a/src/commands/adduseridcommand.cpp
	+++ b/src/commands/adduseridcommand.cpp
	@@ -1,225 +1,219 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/adduseridcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "adduseridcommand.h"

	#include "command_p.h"

	#include "dialogs/adduseriddialog.h"

	#include <Libkleo/Formatting>
	#include <QGpgME/Protocol>
	#include <QGpgME/QuickJob>

	#include <QObjectCleanupHandler>

	#include <gpgme++/key.h>

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

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;

	class AddUserIDCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::AddUserIDCommand;
	AddUserIDCommand *q_func() const
	{
	return static_cast<AddUserIDCommand *>(q);
	}

	public:
	explicit Private(AddUserIDCommand qq, KeyListController c);
	~Private() override;

	private:
	void slotDialogAccepted();
	void slotDialogRejected();
	void slotResult(const Error &err);

	private:
	void ensureDialogCreated();
	void createJob();
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	GpgME::Key key;
	QObjectCleanupHandler cleaner;
	QPointer<AddUserIDDialog> dialog;
	QPointer<QGpgME::QuickJob> job;
	};

	AddUserIDCommand::Private *AddUserIDCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const AddUserIDCommand::Private *AddUserIDCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	AddUserIDCommand::Private::Private(AddUserIDCommand qq, KeyListController c)
	: Command::Private{qq, c}
	{
	}

	AddUserIDCommand::Private::~Private() = default;

	AddUserIDCommand::AddUserIDCommand(QAbstractItemView v, KeyListController c)
	: Command{v, new Private{this, c}}
	{
	}

	AddUserIDCommand::AddUserIDCommand(const GpgME::Key &key)
	: Command{key, new Private{this, nullptr}}
	{
	}

	AddUserIDCommand::~AddUserIDCommand()
	{
	qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
	}

	void AddUserIDCommand::doStart()
	{
	const std::vector<Key> keys = d->keys();
	if (keys.size() != 1) {
	d->finished();
	return;
	}

	d->key = keys.front();
	if (d->key.protocol() != GpgME::OpenPGP //
	\|\| !d->key.hasSecret()) {
	d->finished();
	return;
	}

	d->ensureDialogCreated();

	const UserID uid = d->key.userID(0);

	d->dialog->setName(QString::fromUtf8(uid.name()));
	d->dialog->setEmail(Formatting::prettyEMail(uid.email(), uid.id()));

	d->dialog->show();
	}

	void AddUserIDCommand::Private::slotDialogAccepted()
	{
	Q_ASSERT(dialog);

	createJob();
	if (!job) {
	finished();
	return;
	}
	job->startAddUid(key, dialog->userID());
	}

	void AddUserIDCommand::Private::slotDialogRejected()
	{
	Q_EMIT q->canceled();
	finished();
	}

	void AddUserIDCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled()) {
	} else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void AddUserIDCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
	if (d->job) {
	d->job->slotCancel();
	}
	}

	void AddUserIDCommand::Private::ensureDialogCreated()
	{
	if (dialog) {
	return;
	}

	dialog = new AddUserIDDialog;
	cleaner.add(dialog);
	applyWindowID(dialog);

	connect(dialog, &QDialog::accepted, q, [this]() {
	slotDialogAccepted();
	});
	connect(dialog, &QDialog::rejected, q, [this]() {
	slotDialogRejected();
	});
	}

	void AddUserIDCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	const auto backend = QGpgME::openpgp();
	if (!backend) {
	return;
	}

	const auto j = backend->quickJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &QGpgME::QuickJob::result, q, [this](const GpgME::Error &err) {
	slotResult(err);
	});

	job = j;
	}

	void AddUserIDCommand::Private::showErrorDialog(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred while trying to add the user ID: "
	"<message>%1</message></para>",
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Add User ID Error"));
	}

	void AddUserIDCommand::Private::showSuccessDialog()
	{
	information(i18nc("@info", "User ID successfully added."), //
	i18nc("@title:window", "Add User ID Succeeded"));
	}

	#undef d
	#undef q

	#include "moc_adduseridcommand.cpp"
	diff --git a/src/commands/certifycertificatecommand.cpp b/src/commands/certifycertificatecommand.cpp
	index b3dc6c6f0..b8e60edef 100644
	--- a/src/commands/certifycertificatecommand.cpp
	+++ b/src/commands/certifycertificatecommand.cpp
	@@ -1,344 +1,338 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/signcertificatecommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2019 g10code GmbH

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "certifycertificatecommand.h"
	#include "newopenpgpcertificatecommand.h"

	#include "command_p.h"

	#include "dialogs/certifycertificatedialog.h"
	#include "exportopenpgpcertstoservercommand.h"
	#include "utils/tags.h"

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compat>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyHelpers>

	#include <QGpgME/Protocol>
	#include <QGpgME/SignKeyJob>

	#include <QDate>
	#include <QEventLoop>

	#include <gpgme++/key.h>

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

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;
	using namespace QGpgME;

	class CertifyCertificateCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::CertifyCertificateCommand;
	CertifyCertificateCommand *q_func() const
	{
	return static_cast<CertifyCertificateCommand *>(q);
	}

	public:
	explicit Private(CertifyCertificateCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotDialogRejected();
	void slotResult(const Error &err);
	void slotCertificationPrepared();

	private:
	void ensureDialogCreated();
	void createJob();

	private:
	GpgME::Key target;
	std::vector<UserID> uids;
	QPointer<CertifyCertificateDialog> dialog;
	QPointer<QGpgME::SignKeyJob> job;
	};

	CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	CertifyCertificateCommand::Private::Private(CertifyCertificateCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, uids()
	, dialog()
	, job()
	{
	}

	CertifyCertificateCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	if (dialog) {
	delete dialog;
	dialog = nullptr;
	}
	}

	CertifyCertificateCommand::CertifyCertificateCommand(KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::Key &key)
	: Command(key, new Private(this, nullptr))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::UserID &uid)
	: Command(uid.parent(), new Private(this, nullptr))
	{
	std::vector<UserID>(1, uid).swap(d->uids);
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const std::vector<GpgME::UserID> &uids)
	: Command(uids.empty() ? Key() : uids.front().parent(), new Private(this, nullptr))
	{
	d->uids = uids;
	d->init();
	}

	void CertifyCertificateCommand::Private::init()
	{
	}

	CertifyCertificateCommand::~CertifyCertificateCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	void CertifyCertificateCommand::doStart()
	{
	const std::vector<Key> keys = d->keys();
	if (keys.size() != 1 \|\| keys.front().protocol() != GpgME::OpenPGP) {
	d->finished();
	return;
	}
	// hold on to the key to certify to avoid invalidation during refreshes of the key cache
	d->target = keys.front();

	if (d->target.isExpired() \|\| d->target.isRevoked()) {
	const auto title = d->target.isRevoked() ? i18nc("@title:window", "Key is Revoked") : i18nc("@title:window", "Key is Expired");
	const auto message = d->target.isRevoked() //
	? i18nc("@info", "This key has been revoked. You cannot certify it.")
	: i18nc("@info", "This key has expired. You cannot certify it.");
	d->information(message, title);
	d->finished();
	return;
	}

	auto findAnyGoodKey = []() {
	const std::vector<Key> secKeys = KeyCache::instance()->secretKeys();
	return std::any_of(secKeys.cbegin(), secKeys.cend(), [](const Key &secKey) {
	return Kleo::keyHasCertify(secKey) && secKey.protocol() == OpenPGP && !secKey.isRevoked() && !secKey.isExpired() && !secKey.isInvalid();
	});
	};

	if (!findAnyGoodKey()) {
	auto sel =
	KMessageBox::questionTwoActions(d->parentWidgetOrView(),
	xi18nc("@info", "To certify other certificates, you first need to create an OpenPGP certificate for yourself.")
	+ QStringLiteral("<br><br>") + i18n("Do you wish to create one now?"),
	i18n("Certification Not Possible"),
	KGuiItem(i18n("Create")),
	KStandardGuiItem::cancel());
	if (sel == KMessageBox::ButtonCode::PrimaryAction) {
	QEventLoop loop;
	auto cmd = new NewOpenPGPCertificateCommand;
	cmd->setParentWidget(d->parentWidgetOrView());
	connect(cmd, &Command::finished, &loop, &QEventLoop::quit);
	QMetaObject::invokeMethod(cmd, &NewOpenPGPCertificateCommand::start, Qt::QueuedConnection);
	loop.exec();
	} else {
	Q_EMIT(canceled());
	d->finished();
	return;
	}

	// Check again for secret keys
	if (!findAnyGoodKey()) {
	qCDebug(KLEOPATRA_LOG) << "Sec Keys still empty after keygen.";
	Q_EMIT(canceled());
	d->finished();
	return;
	}
	}

	const char *primary = keys.front().primaryFingerprint();
	const bool anyMismatch = std::any_of(d->uids.cbegin(), d->uids.cend(), [primary](const UserID &uid) {
	return qstricmp(uid.parent().primaryFingerprint(), primary) != 0;
	});
	if (anyMismatch) {
	qCWarning(KLEOPATRA_LOG) << "User ID <-> Key mismatch!";
	d->finished();
	return;
	}

	d->ensureDialogCreated();
	Q_ASSERT(d->dialog);

	d->dialog->setCertificateToCertify(d->target, d->uids);
	d->dialog->show();
	}

	void CertifyCertificateCommand::Private::slotDialogRejected()
	{
	Q_EMIT q->canceled();
	finished();
	}

	void CertifyCertificateCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled()) {
	// do nothing
	} else if (err) {
	error(i18n("<p>An error occurred while trying to certify<br/><br/>"
	"<b>%1</b>:</p><p>\t%2</p>",
	Formatting::formatForComboBox(target),
	Formatting::errorAsString(err)),
	i18n("Certification Error"));
	} else if (dialog && dialog->exportableCertificationSelected() && dialog->sendToServer()) {
	auto const cmd = new ExportOpenPGPCertsToServerCommand(target);
	cmd->start();
	} else {
	information(i18n("Certification successful."), i18n("Certification Succeeded"));
	}

	if (!dialog->tags().isEmpty()) {
	Tags::enableTags();
	}
	finished();
	}

	void CertifyCertificateCommand::Private::slotCertificationPrepared()
	{
	Q_ASSERT(dialog);

	const auto selectedUserIds = dialog->selectedUserIDs();
	std::vector<unsigned int> userIdIndexes;
	userIdIndexes.reserve(selectedUserIds.size());
	for (unsigned int i = 0, numUserIds = target.numUserIDs(); i < numUserIds; ++i) {
	const auto userId = target.userID(i);
	const bool userIdIsSelected = Kleo::any_of(selectedUserIds, [userId](const auto &uid) {
	return Kleo::userIDsAreEqual(userId, uid);
	});
	if (userIdIsSelected) {
	userIdIndexes.push_back(i);
	}
	}

	createJob();
	Q_ASSERT(job);
	job->setExportable(dialog->exportableCertificationSelected());
	job->setUserIDsToSign(userIdIndexes);
	job->setSigningKey(dialog->selectedSecretKey());
	if (!dialog->tags().isEmpty()) {
	// do not set an empty remark to avoid an empty signature notation (GnuPG bug T5142)
	job->setRemark(dialog->tags());
	}
	job->setDupeOk(true);
	if (dialog->trustSignatureSelected() && !dialog->trustSignatureDomain().isEmpty()) {
	// always create level 1 trust signatures with complete trust
	job->setTrustSignature(TrustSignatureTrust::Complete, 1, dialog->trustSignatureDomain());
	}
	if (!dialog->expirationDate().isNull()) {
	job->setExpirationDate(dialog->expirationDate());
	}

	if (const Error err = job->start(target)) {
	slotResult(err);
	}
	}

	void CertifyCertificateCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	if (d->job) {
	d->job->slotCancel();
	}
	}

	void CertifyCertificateCommand::Private::ensureDialogCreated()
	{
	if (dialog) {
	return;
	}

	dialog = new CertifyCertificateDialog;
	applyWindowID(dialog);

	connect(dialog, &QDialog::rejected, q, [this]() {
	slotDialogRejected();
	});
	connect(dialog, &QDialog::accepted, q, [this]() {
	slotCertificationPrepared();
	});
	}

	void CertifyCertificateCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	Q_ASSERT(target.protocol() == OpenPGP);
	const auto backend = QGpgME::openpgp();
	if (!backend) {
	return;
	}

	SignKeyJob *const j = backend->signKeyJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &SignKeyJob::result, q, [this](const GpgME::Error &result) {
	slotResult(result);
	});

	job = j;
	}

	#undef d
	#undef q

	#include "moc_certifycertificatecommand.cpp"
	diff --git a/src/commands/changeexpirycommand.cpp b/src/commands/changeexpirycommand.cpp
	index 4b325dafc..d95f0d6ca 100644
	--- a/src/commands/changeexpirycommand.cpp
	+++ b/src/commands/changeexpirycommand.cpp
	@@ -1,322 +1,308 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/changeexpirycommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2021 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "changeexpirycommand.h"
	#include "command_p.h"

	#include "dialogs/expirydialog.h"
	#include "utils/expiration.h"

	#include <Libkleo/Formatting>

	#include <KLocalizedString>

	#include <QGpgME/ChangeExpiryJob>
	#include <QGpgME/Protocol>

	#include <QDateTime>

	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Dialogs;
	using namespace GpgME;
	using namespace QGpgME;

	namespace
	{
	-#if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
	bool subkeyHasSameExpirationAsPrimaryKey(const Subkey &subkey)
	{
	// we allow for a difference in expiration of up to 10 seconds
	static const auto maxExpirationDifference = 10;

	Q_ASSERT(!subkey.isNull());
	const auto key = subkey.parent();
	const auto primaryKey = key.subkey(0);
	const auto primaryExpiration = quint32(primaryKey.expirationTime());
	const auto subkeyExpiration = quint32(subkey.expirationTime());
	if (primaryExpiration != 0 && subkeyExpiration != 0) {
	return (primaryExpiration == subkeyExpiration) //
	\|\| ((primaryExpiration > subkeyExpiration) && (primaryExpiration - subkeyExpiration <= maxExpirationDifference)) //
	\|\| ((primaryExpiration < subkeyExpiration) && (subkeyExpiration - primaryExpiration <= maxExpirationDifference));
	}
	return primaryKey.neverExpires() && subkey.neverExpires();
	}

	bool allNotRevokedSubkeysHaveSameExpirationAsPrimaryKey(const Key &key)
	{
	Q_ASSERT(!key.isNull() && key.numSubkeys() > 0);
	const auto subkeys = key.subkeys();
	return std::all_of(std::begin(subkeys), std::end(subkeys), [](const auto &subkey) {
	// revoked subkeys are ignored by gpg --quick-set-expire when updating the expiration of all subkeys;
	// check if expiration of subkey is (more or less) the same as the expiration of the primary key
	return subkey.isRevoked() \|\| subkeyHasSameExpirationAsPrimaryKey(subkey);
	});
	}
	-#endif
	}

	class ChangeExpiryCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::ChangeExpiryCommand;
	ChangeExpiryCommand *q_func() const
	{
	return static_cast<ChangeExpiryCommand *>(q);
	}

	public:
	explicit Private(ChangeExpiryCommand qq, KeyListController c);
	~Private() override;

	private:
	void slotDialogAccepted();
	void slotDialogRejected();
	void slotResult(const Error &err);

	private:
	void ensureDialogCreated(ExpiryDialog::Mode mode);
	void createJob();
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	GpgME::Key key;
	GpgME::Subkey subkey;
	QPointer<ExpiryDialog> dialog;
	QPointer<ChangeExpiryJob> job;
	};

	ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ChangeExpiryCommand::Private::Private(ChangeExpiryCommand qq, KeyListController c)
	: Command::Private{qq, c}
	{
	}

	ChangeExpiryCommand::Private::~Private() = default;

	void ChangeExpiryCommand::Private::slotDialogAccepted()
	{
	Q_ASSERT(dialog);

	static const QTime END_OF_DAY{23, 59, 00};

	const QDateTime expiry{dialog->dateOfExpiry(), END_OF_DAY};

	qCDebug(KLEOPATRA_LOG) << "expiry" << expiry;

	createJob();
	Q_ASSERT(job);

	std::vector<Subkey> subkeysToUpdate;
	if (!subkey.isNull()) {
	// change expiration of a single subkey
	if (subkey.keyID() != key.keyID()) { // ignore the primary subkey
	subkeysToUpdate.push_back(subkey);
	}
	} else {
	-#if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
	// change expiration of the (primary) key and, optionally, of some subkeys
	job->setOptions(ChangeExpiryJob::UpdatePrimaryKey);
	if (dialog->updateExpirationOfAllSubkeys() && key.numSubkeys() > 1) {
	// explicitly list the subkeys for which the expiration should be changed
	// together with the expiration of the (primary) key, so that already expired
	// subkeys are also updated
	const auto subkeys = key.subkeys();
	std::copy_if(std::next(subkeys.begin()), subkeys.end(), std::back_inserter(subkeysToUpdate), [](const auto &subkey) {
	// skip revoked subkeys which would anyway be ignored by gpg;
	// also skip subkeys without explicit expiration because they inherit the primary key's expiration;
	// include all subkeys that are not yet expired or that expired around the same time as the primary key
	return !subkey.isRevoked() //
	&& !subkey.neverExpires() //
	&& (!subkey.isExpired() \|\| subkeyHasSameExpirationAsPrimaryKey(subkey));
	});
	}
	-#else
	- // nothing to do
	-#endif
	}

	if (const Error err = job->start(key, expiry, subkeysToUpdate)) {
	showErrorDialog(err);
	finished();
	}
	}

	void ChangeExpiryCommand::Private::slotDialogRejected()
	{
	Q_EMIT q->canceled();
	finished();
	}

	void ChangeExpiryCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled())
	;
	else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void ChangeExpiryCommand::Private::ensureDialogCreated(ExpiryDialog::Mode mode)
	{
	if (dialog) {
	return;
	}

	dialog = new ExpiryDialog{mode};
	applyWindowID(dialog);
	dialog->setAttribute(Qt::WA_DeleteOnClose);

	connect(dialog, &QDialog::accepted, q, [this]() {
	slotDialogAccepted();
	});
	connect(dialog, &QDialog::rejected, q, [this]() {
	slotDialogRejected();
	});
	}

	void ChangeExpiryCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	const auto backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	if (!backend) {
	return;
	}

	ChangeExpiryJob *const j = backend->changeExpiryJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &ChangeExpiryJob::result, q, [this](const auto &err) {
	slotResult(err);
	});

	job = j;
	}

	void ChangeExpiryCommand::Private::showErrorDialog(const Error &err)
	{
	error(
	i18n("<p>An error occurred while trying to change "
	"the end of the validity period for <b>%1</b>:</p><p>%2</p>",
	Formatting::formatForComboBox(key),
	Formatting::errorAsString(err)));
	}

	void ChangeExpiryCommand::Private::showSuccessDialog()
	{
	success(i18n("End of validity period changed successfully."));
	}

	ChangeExpiryCommand::ChangeExpiryCommand(KeyListController *c)
	: Command{new Private{this, c}}
	{
	}

	ChangeExpiryCommand::ChangeExpiryCommand(QAbstractItemView v, KeyListController c)
	: Command{v, new Private{this, c}}
	{
	}

	ChangeExpiryCommand::ChangeExpiryCommand(const GpgME::Key &key)
	: Command{key, new Private{this, nullptr}}
	{
	}

	ChangeExpiryCommand::~ChangeExpiryCommand() = default;

	void ChangeExpiryCommand::setSubkey(const GpgME::Subkey &subkey)
	{
	d->subkey = subkey;
	}

	void ChangeExpiryCommand::doStart()
	{
	const std::vector<Key> keys = d->keys();
	if (keys.size() != 1 //
	\|\| keys.front().protocol() != GpgME::OpenPGP //
	\|\| !keys.front().hasSecret() //
	\|\| keys.front().subkey(0).isNull()) {
	d->finished();
	return;
	}

	d->key = keys.front();

	if (!d->subkey.isNull() && d->subkey.parent().primaryFingerprint() != d->key.primaryFingerprint()) {
	qDebug() << "Invalid subkey" << d->subkey.fingerprint() << ": Not a subkey of key" << d->key.primaryFingerprint();
	d->finished();
	return;
	}

	ExpiryDialog::Mode mode;
	if (!d->subkey.isNull()) {
	mode = ExpiryDialog::Mode::UpdateIndividualSubkey;
	} else if (d->key.numSubkeys() == 1) {
	mode = ExpiryDialog::Mode::UpdateCertificateWithoutSubkeys;
	} else {
	mode = ExpiryDialog::Mode::UpdateCertificateWithSubkeys;
	}
	d->ensureDialogCreated(mode);
	Q_ASSERT(d->dialog);
	const Subkey subkey = !d->subkey.isNull() ? d->subkey : d->key.subkey(0);
	d->dialog->setDateOfExpiry((subkey.neverExpires() //
	? QDate{} //
	: defaultExpirationDate(ExpirationOnUnlimitedValidity::InternalDefaultExpiration)));
	-#if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
	if (mode == ExpiryDialog::Mode::UpdateCertificateWithSubkeys) {
	d->dialog->setUpdateExpirationOfAllSubkeys(allNotRevokedSubkeysHaveSameExpirationAsPrimaryKey(d->key));
	}
	-#endif

	d->dialog->show();
	}

	void ChangeExpiryCommand::doCancel()
	{
	if (d->job) {
	d->job->slotCancel();
	}
	}

	#undef d
	#undef q

	#include "moc_changeexpirycommand.cpp"
	diff --git a/src/commands/changeownertrustcommand.cpp b/src/commands/changeownertrustcommand.cpp
	index 76733714b..b5cfca164 100644
	--- a/src/commands/changeownertrustcommand.cpp
	+++ b/src/commands/changeownertrustcommand.cpp
	@@ -1,283 +1,277 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/changeownertrustcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "changeownertrustcommand.h"

	#include "command_p.h"

	#include <Libkleo/Compliance>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>

	#include <KLocalizedString>

	#include <QGpgME/ChangeOwnerTrustJob>
	#include <QGpgME/Protocol>

	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;
	using namespace QGpgME;

	class ChangeOwnerTrustCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::ChangeOwnerTrustCommand;
	ChangeOwnerTrustCommand *q_func() const
	{
	return static_cast<ChangeOwnerTrustCommand *>(q);
	}

	public:
	Private(ChangeOwnerTrustCommand qq, KeyListController c);

	private:
	void startJob(Key::OwnerTrust trust);
	void createJob();
	void slotResult(const Error &err);
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	QPointer<ChangeOwnerTrustJob> job;
	Key::OwnerTrust trustToSet = Key::OwnerTrust::Unknown;
	};

	ChangeOwnerTrustCommand::Private *ChangeOwnerTrustCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ChangeOwnerTrustCommand::Private *ChangeOwnerTrustCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ChangeOwnerTrustCommand::Private::Private(ChangeOwnerTrustCommand qq, KeyListController c)
	: Command::Private{qq, c}
	{
	}

	ChangeOwnerTrustCommand::ChangeOwnerTrustCommand(QAbstractItemView v, KeyListController c)
	: Command{v, new Private{this, c}}
	{
	}

	ChangeOwnerTrustCommand::~ChangeOwnerTrustCommand()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	}

	void ChangeOwnerTrustCommand::doStart()
	{
	if (d->keys().size() != 1) {
	d->finished();
	return;
	}

	const Key key = d->key();
	if (key.protocol() != GpgME::OpenPGP) {
	d->finished();
	return;
	}

	const auto keyInfo = Formatting::formatForComboBox(key);

	if (key.hasSecret()) {
	const auto answer = KMessageBox::questionTwoActionsCancel(d->parentWidgetOrView(),
	xi18nc("@info", "Is '%1' your own certificate?", keyInfo),
	i18nc("@title:window", "Mark Own Certificate"),
	KGuiItem(i18nc("@action:button", "Yes, it's mine")),
	KGuiItem(i18nc("@action:button", "No, it's not mine")),
	KStandardGuiItem::cancel());
	switch (answer) {
	case KMessageBox::ButtonCode::PrimaryAction: {
	if (key.ownerTrust() < Key::Ultimate) {
	d->startJob(Key::OwnerTrust::Ultimate);
	}
	return;
	}
	case KMessageBox::ButtonCode::SecondaryAction: {
	if (key.ownerTrust() == Key::Ultimate) {
	d->startJob(Key::OwnerTrust::Unknown);
	return;
	}
	// else ask next question
	break;
	}
	case KMessageBox::Cancel: {
	d->canceled();
	return;
	}
	default:; // cannot happen
	}
	}

	if (key.ownerTrust() < Key::OwnerTrust::Full) {
	const auto text = (DeVSCompliance::isCompliant() && DeVSCompliance::allSubkeysAreCompliant(key))
	? xi18nc("@info %1: a certificate, %2: name of a compliance mode",
	"<para>Do you want to grant '%1' the power to mark certificates as %2 for you?</para>"
	"<para><emphasis>This means that the owner of this certificate properly checks fingerprints "
	"and confirms the identities of others.</emphasis></para>",
	keyInfo,
	DeVSCompliance::name())
	: xi18nc("@info %1: a certificate",
	"<para>Do you want to grant '%1' the power to mark certificates as valid for you?</para>"
	"<para><emphasis>This means that the owner of this certificate properly checks fingerprints "
	"and confirms the identities of others.</emphasis></para>",
	keyInfo);
	const auto answer = KMessageBox::questionTwoActions(d->parentWidgetOrView(),
	text,
	i18nc("@title:window", "Grant Certification Power"),
	KGuiItem(i18nc("@action:button", "Grant Power")),
	KStandardGuiItem::cancel());
	if (answer == KMessageBox::ButtonCode::PrimaryAction) {
	d->startJob(Key::OwnerTrust::Full);
	} else {
	d->canceled();
	}
	} else {
	const auto text = (DeVSCompliance::isCompliant() && DeVSCompliance::allSubkeysAreCompliant(key))
	? xi18nc("@info %1: a certificate, %2: name of a compliance mode",
	"<para>The certificate '%1' is empowered to mark other certificates as %2 for you.</para>"
	"<para>Do you want to revoke this power?</para>",
	keyInfo,
	DeVSCompliance::name())
	: xi18nc("@info %1: a certificate",
	"<para>The certificate '%1' is empowered to mark other certificates as valid for you.</para>"
	"<para>Do you want to revoke this power?</para>",
	keyInfo);
	const auto answer = KMessageBox::questionTwoActions(d->parentWidgetOrView(),
	text,
	i18nc("@title:window", "Revoke Certification Power"),
	KGuiItem(i18nc("@action:button", "Revoke Power")),
	KStandardGuiItem::cancel());
	if (answer == KMessageBox::ButtonCode::PrimaryAction) {
	d->startJob(Key::OwnerTrust::Unknown);
	} else {
	d->canceled();
	}
	}
	}

	void ChangeOwnerTrustCommand::Private::startJob(Key::OwnerTrust trust)
	{
	trustToSet = trust;

	createJob();
	Q_ASSERT(job);

	if (const Error err = job->start(key(), trust)) {
	showErrorDialog(err);
	finished();
	}
	}

	void ChangeOwnerTrustCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled())
	;
	else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void ChangeOwnerTrustCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	if (d->job) {
	d->job->slotCancel();
	}
	}

	void ChangeOwnerTrustCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	ChangeOwnerTrustJob *const j = QGpgME::openpgp()->changeOwnerTrustJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &ChangeOwnerTrustJob::result, q, [this](const GpgME::Error &result) {
	slotResult(result);
	});

	job = j;
	}

	void ChangeOwnerTrustCommand::Private::showErrorDialog(const Error &err)
	{
	const auto keyInfo = Formatting::formatForComboBox(key());
	switch (trustToSet) {
	case Key::OwnerTrust::Ultimate:
	error(xi18nc("@info",
	"<para>An error occurred while marking certificate '%1' as your certificate.</para>"
	"<para><message>%2</message></para>",
	keyInfo,
	Formatting::errorAsString(err)));
	break;
	case Key::OwnerTrust::Full:
	error(xi18nc("@info",
	"<para>An error occurred while granting certification power to '%1'.</para>"
	"<para><message>%2</message></para>",
	keyInfo,
	Formatting::errorAsString(err)));
	break;
	default:
	error(xi18nc("@info",
	"<para>An error occurred while revoking the certification power of '%1'.</para>"
	"<para><message>%2</message></para>",
	keyInfo,
	Formatting::errorAsString(err)));
	}
	}

	void ChangeOwnerTrustCommand::Private::showSuccessDialog()
	{
	auto updatedKey = key();
	updatedKey.update();
	KeyCache::mutableInstance()->insert(updatedKey);

	const auto keyInfo = Formatting::formatForComboBox(updatedKey);
	switch (updatedKey.ownerTrust()) {
	case Key::OwnerTrust::Ultimate:
	success(i18nc("@info", "Certificate '%1' was marked as your certificate.", keyInfo));
	break;
	case Key::OwnerTrust::Full:
	success(i18nc("@info", "Certification power was granted to '%1'.", keyInfo));
	break;
	default:
	success(i18nc("@info", "The certification power of '%1' was revoked.", keyInfo));
	}
	}

	#undef d
	#undef q

	#include "moc_changeownertrustcommand.cpp"
	diff --git a/src/commands/changepassphrasecommand.cpp b/src/commands/changepassphrasecommand.cpp
	index 5c9e7233f..b3c9d1b04 100644
	--- a/src/commands/changepassphrasecommand.cpp
	+++ b/src/commands/changepassphrasecommand.cpp
	@@ -1,200 +1,194 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/changepassphrasecommand.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 "changepassphrasecommand.h"

	#include "command_p.h"

	#include <Libkleo/Formatting>

	#include <QGpgME/ChangePasswdJob>
	#include <QGpgME/Protocol>

	#include <gpgme++/key.h>

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

	#include <gpg-error.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;
	using namespace QGpgME;

	class ChangePassphraseCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::ChangePassphraseCommand;
	ChangePassphraseCommand *q_func() const
	{
	return static_cast<ChangePassphraseCommand *>(q);
	}

	public:
	explicit Private(ChangePassphraseCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotResult(const Error &err);

	private:
	void createJob();
	void startJob();
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	GpgME::Key key;
	QPointer<ChangePasswdJob> job;
	};

	ChangePassphraseCommand::Private *ChangePassphraseCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ChangePassphraseCommand::Private *ChangePassphraseCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ChangePassphraseCommand::Private::Private(ChangePassphraseCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, key()
	, job()
	{
	}

	ChangePassphraseCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	ChangePassphraseCommand::ChangePassphraseCommand(KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	}

	ChangePassphraseCommand::ChangePassphraseCommand(QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	}

	ChangePassphraseCommand::ChangePassphraseCommand(const GpgME::Key &key)
	: Command(key, new Private(this, nullptr))
	{
	d->init();
	}

	void ChangePassphraseCommand::Private::init()
	{
	}

	ChangePassphraseCommand::~ChangePassphraseCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	void ChangePassphraseCommand::doStart()
	{
	const std::vector<Key> keys = d->keys();
	if (keys.size() != 1 \|\| !keys.front().hasSecret()) {
	d->finished();
	return;
	}

	d->key = keys.front();

	d->createJob();
	d->startJob();
	}

	void ChangePassphraseCommand::Private::startJob()
	{
	const Error err = job ? job->start(key) : Error::fromCode(GPG_ERR_NOT_SUPPORTED);
	if (err) {
	showErrorDialog(err);
	finished();
	}
	}

	void ChangePassphraseCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled())
	;
	else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void ChangePassphraseCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	if (d->job) {
	d->job->slotCancel();
	}
	}

	void ChangePassphraseCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	const auto backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	if (!backend) {
	return;
	}

	ChangePasswdJob *const j = backend->changePasswdJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &ChangePasswdJob::result, q, [this](const GpgME::Error &result) {
	slotResult(result);
	});

	job = j;
	}

	void ChangePassphraseCommand::Private::showErrorDialog(const Error &err)
	{
	error(i18n("<p>An error occurred while trying to change "
	"the passphrase for <b>%1</b>:</p><p>%2</p>",
	Formatting::formatForComboBox(key),
	Formatting::errorAsString(err)),
	i18n("Passphrase Change Error"));
	}

	void ChangePassphraseCommand::Private::showSuccessDialog()
	{
	information(i18n("Passphrase changed successfully."), i18n("Passphrase Change Succeeded"));
	}

	#undef d
	#undef q

	#include "moc_changepassphrasecommand.cpp"
	diff --git a/src/commands/deletecertificatescommand.cpp b/src/commands/deletecertificatescommand.cpp
	index 64402c5fb..0b736c2ae 100644
	--- a/src/commands/deletecertificatescommand.cpp
	+++ b/src/commands/deletecertificatescommand.cpp
	@@ -1,401 +1,395 @@
	/* -- mode: c++; c-basic-offset:4 --
	deleteCertificatescommand.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 "deletecertificatescommand.h"

	#include "command_p.h"

	#include <dialogs/deletecertificatesdialog.h>

	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/Predicates>

	#include <Libkleo/Stl_Util>

	#include <QGpgME/DeleteJob>
	#include <QGpgME/MultiDeleteJob>
	#include <QGpgME/Protocol>

	#include <gpgme++/key.h>

	#include <KLocalizedString>

	#include <QAbstractItemView>
	#include <QPointer>

	#include <KLazyLocalizedString>
	#include <algorithm>
	#include <vector>
	using namespace GpgME;
	using namespace Kleo;
	using namespace Kleo::Dialogs;
	using namespace QGpgME;

	class DeleteCertificatesCommand::Private : public Command::Private
	{
	friend class ::Kleo::DeleteCertificatesCommand;
	DeleteCertificatesCommand *q_func() const
	{
	return static_cast<DeleteCertificatesCommand *>(q);
	}

	public:
	explicit Private(DeleteCertificatesCommand qq, KeyListController c);
	~Private() override;

	void startDeleteJob(GpgME::Protocol protocol);

	void cancelJobs();
	void pgpDeleteResult(const GpgME::Error &);
	void cmsDeleteResult(const GpgME::Error &);
	void showErrorsAndFinish();

	bool canDelete(GpgME::Protocol proto) const
	{
	if (const auto cbp = (proto == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime()))
	if (DeleteJob *const job = cbp->deleteJob()) {
	job->slotCancel();
	return true;
	}
	return false;
	}

	void ensureDialogCreated()
	{
	if (dialog) {
	return;
	}
	dialog = new DeleteCertificatesDialog;
	applyWindowID(dialog);
	dialog->setAttribute(Qt::WA_DeleteOnClose);
	dialog->setWindowTitle(i18nc("@title:window", "Delete Certificates"));
	connect(dialog, &QDialog::accepted, q_func(), [this]() {
	slotDialogAccepted();
	});
	connect(dialog, &QDialog::rejected, q_func(), [this]() {
	slotDialogRejected();
	});
	}
	void ensureDialogShown()
	{
	if (dialog) {
	dialog->show();
	}
	}

	void slotDialogAccepted();
	void slotDialogRejected()
	{
	canceled();
	}

	private:
	QPointer<DeleteCertificatesDialog> dialog;
	QPointer<MultiDeleteJob> cmsJob, pgpJob;
	GpgME::Error cmsError, pgpError;
	std::vector<Key> cmsKeys, pgpKeys;
	};

	DeleteCertificatesCommand::Private *DeleteCertificatesCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const DeleteCertificatesCommand::Private *DeleteCertificatesCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	DeleteCertificatesCommand::Private::Private(DeleteCertificatesCommand qq, KeyListController c)
	: Command::Private(qq, c)
	{
	}

	DeleteCertificatesCommand::Private::~Private()
	{
	}

	DeleteCertificatesCommand::DeleteCertificatesCommand(KeyListController *p)
	: Command(new Private(this, p))
	{
	}

	DeleteCertificatesCommand::DeleteCertificatesCommand(QAbstractItemView v, KeyListController p)
	: Command(v, new Private(this, p))
	{
	}

	DeleteCertificatesCommand::~DeleteCertificatesCommand()
	{
	}

	namespace
	{

	enum Action { Nothing = 0, Failure = 1, ClearCMS = 2, ClearPGP = 4 };

	// const unsigned int errorCase =
	// openpgp.empty() << 3U \| d->canDelete( OpenPGP ) << 2U \|
	// cms.empty() << 1U \| d->canDelete( CMS ) << 0U ;

	static const struct {
	const KLazyLocalizedString text;
	Action actions;
	} deletionErrorCases[16] = {
	// if havePGP
	// if cantPGP
	// if haveCMS
	{kli18n("Neither the OpenPGP nor the CMS "
	"backends support certificate deletion.\n"
	"Check your installation."),
	Failure}, // cantCMS
	{kli18n("The OpenPGP backend does not support "
	"certificate deletion.\n"
	"Check your installation.\n"
	"Only the selected CMS certificates "
	"will be deleted."),
	ClearPGP}, // canCMS
	// if !haveCMS
	{kli18n("The OpenPGP backend does not support "
	"certificate deletion.\n"
	"Check your installation."),
	Failure},
	{kli18n("The OpenPGP backend does not support "
	"certificate deletion.\n"
	"Check your installation."),
	Failure},
	// if canPGP
	// if haveCMS
	{kli18n("The CMS backend does not support "
	"certificate deletion.\n"
	"Check your installation.\n"
	"Only the selected OpenPGP certificates "
	"will be deleted."),
	ClearCMS}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	// if !haveCMS
	{KLazyLocalizedString(), Nothing}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	// if !havePGP
	// if cantPGP
	// if haveCMS
	{kli18n("The CMS backend does not support "
	"certificate deletion.\n"
	"Check your installation."),
	Failure}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	// if !haveCMS
	{KLazyLocalizedString(), Nothing}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	// if canPGP
	// if haveCMS
	{kli18n("The CMS backend does not support "
	"certificate deletion.\n"
	"Check your installation."),
	Failure}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	// if !haveCMS
	{KLazyLocalizedString(), Nothing}, // cantCMS
	{KLazyLocalizedString(), Nothing}, // canCMS
	};
	} // anon namespace

	void DeleteCertificatesCommand::doStart()
	{
	std::vector<Key> selected = d->keys();
	if (selected.empty()) {
	d->finished();
	return;
	}

	std::sort(selected.begin(), selected.end(), _detail::ByFingerprint<std::less>());

	// Calculate the closure of the selected keys (those that need to
	// be deleted with them, though not selected themselves):

	std::vector<Key> toBeDeleted = KeyCache::instance()->findSubjects(selected);
	std::sort(toBeDeleted.begin(), toBeDeleted.end(), _detail::ByFingerprint<std::less>());

	std::vector<Key> unselected;
	unselected.reserve(toBeDeleted.size());
	std::set_difference(toBeDeleted.begin(),
	toBeDeleted.end(),
	selected.begin(),
	selected.end(),
	std::back_inserter(unselected),
	_detail::ByFingerprint<std::less>());

	d->ensureDialogCreated();

	d->dialog->setSelectedKeys(selected);
	d->dialog->setUnselectedKeys(unselected);

	d->ensureDialogShown();
	}

	void DeleteCertificatesCommand::Private::slotDialogAccepted()
	{
	std::vector<Key> keys = dialog->keys();
	Q_ASSERT(!keys.empty());

	auto pgpBegin = keys.begin();
	auto pgpEnd = std::stable_partition(pgpBegin, keys.end(), [](const GpgME::Key &key) {
	return key.protocol() != GpgME::CMS;
	});
	auto cmsBegin = pgpEnd;
	auto cmsEnd = keys.end();

	std::vector<Key> openpgp(pgpBegin, pgpEnd);
	std::vector<Key> cms(cmsBegin, cmsEnd);

	const unsigned int errorCase = //
	openpgp.empty() << 3U //
	\| canDelete(OpenPGP) << 2U //
	\| cms.empty() << 1U //
	\| canDelete(CMS) << 0U;

	if (const unsigned int actions = deletionErrorCases[errorCase].actions) {
	information(KLocalizedString(deletionErrorCases[errorCase].text).toString(),
	(actions & Failure) ? i18n("Certificate Deletion Failed") : i18n("Certificate Deletion Problem"));

	if (actions & ClearCMS) {
	cms.clear();
	}
	if (actions & ClearPGP) {
	openpgp.clear();
	}
	if (actions & Failure) {
	canceled();
	return;
	}
	}

	Q_ASSERT(!openpgp.empty() \|\| !cms.empty());

	pgpKeys.swap(openpgp);
	cmsKeys.swap(cms);

	if (!pgpKeys.empty()) {
	startDeleteJob(GpgME::OpenPGP);
	}
	if (!cmsKeys.empty()) {
	startDeleteJob(GpgME::CMS);
	}

	if ((pgpKeys.empty() \|\| pgpError.code()) && (cmsKeys.empty() \|\| cmsError.code())) {
	showErrorsAndFinish();
	}
	}

	void DeleteCertificatesCommand::Private::startDeleteJob(GpgME::Protocol protocol)
	{
	Q_ASSERT(protocol != GpgME::UnknownProtocol);

	const std::vector<Key> &keys = protocol == CMS ? cmsKeys : pgpKeys;

	const auto backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	Q_ASSERT(backend);

	std::unique_ptr<MultiDeleteJob> job(new MultiDeleteJob(backend));

	connect(job.get(), &QGpgME::MultiDeleteJob::result, q_func(), [this, protocol](const GpgME::Error &result) {
	if (protocol == CMS) {
	cmsDeleteResult(result);
	} else {
	pgpDeleteResult(result);
	}
	});

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(job.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	if (const Error err = job->start(keys, true /allowSecretKeyDeletion/)) {
	(protocol == CMS ? cmsError : pgpError) = err;
	} else {
	(protocol == CMS ? cmsJob : pgpJob) = job.release();
	}
	}

	void DeleteCertificatesCommand::Private::showErrorsAndFinish()
	{
	Q_ASSERT(!pgpJob);
	Q_ASSERT(!cmsJob);

	if (pgpError \|\| cmsError) {
	QString pgpErrorString;
	if (pgpError) {
	pgpErrorString = i18n("OpenPGP backend: %1", Formatting::errorAsString(pgpError));
	}
	QString cmsErrorString;
	if (cmsError) {
	cmsErrorString = i18n("CMS backend: %1", Formatting::errorAsString(cmsError));
	}

	const QString msg = i18n(
	"<qt><p>An error occurred while trying to delete "
	"the certificate:</p>"
	"<p><b>%1</b></p></qt>",
	pgpError ? cmsError ? pgpErrorString + QLatin1String("</br>") + cmsErrorString : pgpErrorString : cmsErrorString);
	error(msg, i18n("Certificate Deletion Failed"));
	} else if (!pgpError.isCanceled() && !cmsError.isCanceled()) {
	std::vector<Key> keys = pgpKeys;
	keys.insert(keys.end(), cmsKeys.begin(), cmsKeys.end());
	KeyCache::mutableInstance()->remove(keys);
	}

	finished();
	}

	void DeleteCertificatesCommand::doCancel()
	{
	d->cancelJobs();
	}

	void DeleteCertificatesCommand::Private::pgpDeleteResult(const Error &err)
	{
	pgpError = err;
	pgpJob = nullptr;
	if (!cmsJob) {
	showErrorsAndFinish();
	}
	}

	void DeleteCertificatesCommand::Private::cmsDeleteResult(const Error &err)
	{
	cmsError = err;
	cmsJob = nullptr;
	if (!pgpJob) {
	showErrorsAndFinish();
	}
	}

	void DeleteCertificatesCommand::Private::cancelJobs()
	{
	if (cmsJob) {
	cmsJob->slotCancel();
	}
	if (pgpJob) {
	pgpJob->slotCancel();
	}
	}

	#undef d
	#undef q

	#include "moc_deletecertificatescommand.cpp"
	diff --git a/src/commands/exportcertificatecommand.cpp b/src/commands/exportcertificatecommand.cpp
	index 277c1a860..1492dc486 100644
	--- a/src/commands/exportcertificatecommand.cpp
	+++ b/src/commands/exportcertificatecommand.cpp
	@@ -1,415 +1,409 @@
	/* -- mode: c++; c-basic-offset:4 --
	exportcertificatecommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2021 g10 Code GmbH

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "exportcertificatecommand.h"
	#include "fileoperationspreferences.h"

	#include "command_p.h"

	#include <utils/applicationstate.h>
	#include <utils/filedialog.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Classify>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyHelpers>

	#include <QGpgME/ExportJob>
	#include <QGpgME/Protocol>

	#include <gpgme++/key.h>

	#include <KLocalizedString>
	#include <QSaveFile>

	#include <QFileInfo>
	#include <QMap>
	#include <QPointer>

	#include <algorithm>
	#include <vector>

	using namespace Kleo;
	using namespace GpgME;
	using namespace QGpgME;

	class ExportCertificateCommand::Private : public Command::Private
	{
	friend class ::ExportCertificateCommand;
	ExportCertificateCommand *q_func() const
	{
	return static_cast<ExportCertificateCommand *>(q);
	}

	public:
	explicit Private(ExportCertificateCommand qq, KeyListController c);
	~Private() override;
	void startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys);
	void cancelJobs();
	void exportResult(const GpgME::Error &, const QByteArray &);
	void showError(const GpgME::Error &error);

	bool confirmExport(const std::vector<Key> &pgpKeys);
	bool requestFileNames(GpgME::Protocol prot);
	void finishedIfLastJob();

	private:
	QMap<GpgME::Protocol, QString> fileNames;
	uint jobsPending = 0;
	QMap<QObject *, QString> outFileForSender;
	QPointer<ExportJob> cmsJob;
	QPointer<ExportJob> pgpJob;
	};

	ExportCertificateCommand::Private *ExportCertificateCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ExportCertificateCommand::Private *ExportCertificateCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ExportCertificateCommand::Private::Private(ExportCertificateCommand qq, KeyListController c)
	: Command::Private(qq, c)
	{
	}

	ExportCertificateCommand::Private::~Private()
	{
	}

	ExportCertificateCommand::ExportCertificateCommand(KeyListController *p)
	: Command(new Private(this, p))
	{
	}

	ExportCertificateCommand::ExportCertificateCommand(QAbstractItemView v, KeyListController p)
	: Command(v, new Private(this, p))
	{
	}

	ExportCertificateCommand::ExportCertificateCommand(const Key &key)
	: Command(key, new Private(this, nullptr))
	{
	}

	ExportCertificateCommand::~ExportCertificateCommand()
	{
	}

	void ExportCertificateCommand::setOpenPGPFileName(const QString &fileName)
	{
	if (!d->jobsPending) {
	d->fileNames[OpenPGP] = fileName;
	}
	}

	QString ExportCertificateCommand::openPGPFileName() const
	{
	return d->fileNames[OpenPGP];
	}

	void ExportCertificateCommand::setX509FileName(const QString &fileName)
	{
	if (!d->jobsPending) {
	d->fileNames[CMS] = fileName;
	}
	}

	QString ExportCertificateCommand::x509FileName() const
	{
	return d->fileNames[CMS];
	}

	void ExportCertificateCommand::doStart()
	{
	if (d->keys().empty()) {
	d->finished();
	return;
	}

	const auto keys = Kleo::partitionKeysByProtocol(d->keys());

	if (!keys.openpgp.empty() && !d->confirmExport(keys.openpgp)) {
	d->canceled();
	return;
	}

	const bool haveBoth = !keys.cms.empty() && !keys.openpgp.empty();
	const GpgME::Protocol prot = haveBoth ? UnknownProtocol : (!keys.cms.empty() ? CMS : OpenPGP);
	if (!d->requestFileNames(prot)) {
	d->canceled();
	return;
	}

	if (!keys.openpgp.empty()) {
	d->startExportJob(GpgME::OpenPGP, keys.openpgp);
	}
	if (!keys.cms.empty()) {
	d->startExportJob(GpgME::CMS, keys.cms);
	}
	}

	bool ExportCertificateCommand::Private::confirmExport(const std::vector<Key> &pgpKeys)
	{
	auto notCertifiedKeys = std::accumulate(pgpKeys.cbegin(), pgpKeys.cend(), QStringList{}, [](auto keyNames, const auto &key) {
	const bool allValidUserIDsAreCertifiedByUser = Kleo::all_of(key.userIDs(), [](const UserID &userId) {
	return userId.isBad() \|\| Kleo::userIDIsCertifiedByUser(userId);
	});
	if (!allValidUserIDsAreCertifiedByUser) {
	keyNames.push_back(Formatting::formatForComboBox(key));
	}
	return keyNames;
	});
	if (!notCertifiedKeys.empty()) {
	if (pgpKeys.size() == 1) {
	const auto answer = KMessageBox::warningContinueCancel( //
	parentWidgetOrView(),
	xi18nc("@info",
	"<para>You haven't certified all valid user IDs of this certificate "
	"with an exportable certification. People relying on your certifications "
	"may not be able to verify the certificate.</para>"
	"<para>Do you want to continue the export?</para>"),
	i18nc("@title:window", "Confirm Certificate Export"),
	KGuiItem{i18ncp("@action:button", "Export Certificate", "Export Certificates", 1)},
	KStandardGuiItem::cancel(),
	QStringLiteral("confirm-export-of-uncertified-keys"));
	return answer == KMessageBox::Continue;
	} else {
	std::sort(notCertifiedKeys.begin(), notCertifiedKeys.end());
	const auto answer = KMessageBox::warningContinueCancelList( //
	parentWidgetOrView(),
	xi18nc("@info",
	"<para>You haven't certified all valid user IDs of the certificates listed below "
	"with exportable certifications. People relying on your certifications "
	"may not be able to verify the certificates.</para>"
	"<para>Do you want to continue the export?</para>"),
	notCertifiedKeys,
	i18nc("@title:window", "Confirm Certificate Export"),
	KGuiItem{i18ncp("@action:button", "Export Certificate", "Export Certificates", pgpKeys.size())},
	KStandardGuiItem::cancel(),
	QStringLiteral("confirm-export-of-uncertified-keys"));
	return answer == KMessageBox::Continue;
	}
	}

	return true;
	}

	bool ExportCertificateCommand::Private::requestFileNames(GpgME::Protocol protocol)
	{
	if (protocol == UnknownProtocol) {
	if (!fileNames[GpgME::OpenPGP].isEmpty() && !fileNames[GpgME::CMS].isEmpty()) {
	return true;
	}

	/* Unknown protocol ask for first PGP Export file name */
	if (fileNames[GpgME::OpenPGP].isEmpty() && !requestFileNames(GpgME::OpenPGP)) {
	return false;
	}
	/* And then for CMS */
	return requestFileNames(GpgME::CMS);
	}

	if (!fileNames[protocol].isEmpty()) {
	return true;
	}

	const auto lastDir = ApplicationState::lastUsedExportDirectory();

	QString proposedFileName = lastDir + QLatin1Char('/');
	if (keys().size() == 1) {
	const bool usePGPFileExt = FileOperationsPreferences().usePGPFileExt();
	const auto key = keys().front();
	auto name = Formatting::prettyName(key);
	if (name.isEmpty()) {
	name = Formatting::prettyEMail(key);
	}
	const auto asciiArmoredCertificateClass = (protocol == OpenPGP ? Class::OpenPGP : Class::CMS) \| Class::Ascii \| Class::Certificate;
	/* Not translated so it's better to use in tutorials etc. */
	proposedFileName += QStringLiteral("%1_%2_public.%3")
	.arg(name)
	.arg(Formatting::prettyKeyID(key.shortKeyID()))
	.arg(outputFileExtension(asciiArmoredCertificateClass, usePGPFileExt));
	}
	if (protocol == GpgME::CMS) {
	if (!fileNames[GpgME::OpenPGP].isEmpty()) {
	/* If the user has already selected a PGP file name then use that as basis
	* for a proposal for the S/MIME file. */
	proposedFileName = fileNames[GpgME::OpenPGP];
	const int idx = proposedFileName.size() - 4;
	if (proposedFileName.endsWith(QLatin1String(".asc"))) {
	proposedFileName.replace(idx, 4, QLatin1String(".pem"));
	}
	if (proposedFileName.endsWith(QLatin1String(".gpg")) \|\| proposedFileName.endsWith(QLatin1String(".pgp"))) {
	proposedFileName.replace(idx, 4, QLatin1String(".der"));
	}
	}
	}

	if (proposedFileName.isEmpty()) {
	proposedFileName = lastDir;
	proposedFileName += i18nc("A generic filename for exported certificates", "certificates");
	proposedFileName += protocol == GpgME::OpenPGP ? QStringLiteral(".asc") : QStringLiteral(".pem");
	}

	auto fname = FileDialog::getSaveFileNameEx(parentWidgetOrView(),
	i18nc("1 is protocol", "Export %1 Certificates", Formatting::displayName(protocol)),
	QStringLiteral("imp"),
	proposedFileName,
	protocol == GpgME::OpenPGP ? i18n("OpenPGP Certificates") + QLatin1String(" (.asc .gpg *.pgp)")
	: i18n("S/MIME Certificates") + QLatin1String(" (.pem .der)"));

	if (!fname.isEmpty() && protocol == GpgME::CMS && fileNames[GpgME::OpenPGP] == fname) {
	KMessageBox::error(parentWidgetOrView(), i18n("You have to select different filenames for different protocols."), i18n("Export Error"));
	return false;
	}
	const QFileInfo fi(fname);
	if (fi.suffix().isEmpty()) {
	fname += protocol == GpgME::OpenPGP ? QStringLiteral(".asc") : QStringLiteral(".pem");
	}

	fileNames[protocol] = fname;
	ApplicationState::setLastUsedExportDirectory(fi.absolutePath());
	return !fname.isEmpty();
	}

	void ExportCertificateCommand::Private::startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys)
	{
	Q_ASSERT(protocol != GpgME::UnknownProtocol);

	const QGpgME::Protocol *const backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	Q_ASSERT(backend);
	const QString fileName = fileNames[protocol];
	const bool binary = protocol == GpgME::OpenPGP
	? fileName.endsWith(QLatin1String(".gpg"), Qt::CaseInsensitive) \|\| fileName.endsWith(QLatin1String(".pgp"), Qt::CaseInsensitive)
	: fileName.endsWith(QLatin1String(".der"), Qt::CaseInsensitive);
	std::unique_ptr<ExportJob> job(backend->publicKeyExportJob(!binary));
	Q_ASSERT(job.get());

	connect(job.get(), &QGpgME::ExportJob::result, q, [this](const GpgME::Error &result, const QByteArray &keyData) {
	exportResult(result, keyData);
	});

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(job.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	QStringList fingerprints;
	fingerprints.reserve(keys.size());
	for (const Key &i : keys) {
	fingerprints << QLatin1String(i.primaryFingerprint());
	}

	const GpgME::Error err = job->start(fingerprints);
	if (err) {
	showError(err);
	finished();
	return;
	}
	Q_EMIT q->info(i18n("Exporting certificates..."));
	++jobsPending;
	const QPointer<ExportJob> exportJob(job.release());

	outFileForSender[exportJob.data()] = fileName;
	(protocol == CMS ? cmsJob : pgpJob) = exportJob;
	}

	void ExportCertificateCommand::Private::showError(const GpgME::Error &err)
	{
	Q_ASSERT(err);
	const QString msg = i18n(
	"<qt><p>An error occurred while trying to export "
	"the certificate:</p>"
	"<p><b>%1</b></p></qt>",
	Formatting::errorAsString(err));
	error(msg, i18n("Certificate Export Failed"));
	}

	void ExportCertificateCommand::doCancel()
	{
	d->cancelJobs();
	}

	void ExportCertificateCommand::Private::finishedIfLastJob()
	{
	if (jobsPending <= 0) {
	finished();
	}
	}

	static bool write_complete(QIODevice &iod, const QByteArray &data)
	{
	qint64 total = 0;
	qint64 toWrite = data.size();
	while (total < toWrite) {
	const qint64 written = iod.write(data.data() + total, toWrite);
	if (written < 0) {
	return false;
	}
	total += written;
	toWrite -= written;
	}
	return true;
	}

	void ExportCertificateCommand::Private::exportResult(const GpgME::Error &err, const QByteArray &data)
	{
	Q_ASSERT(jobsPending > 0);
	--jobsPending;

	Q_ASSERT(outFileForSender.contains(q->sender()));
	const QString outFile = outFileForSender[q->sender()];

	if (err) {
	showError(err);
	finishedIfLastJob();
	return;
	}
	QSaveFile savefile(outFile);
	// TODO: use KIO
	const QString writeErrorMsg = i18n("Could not write to file %1.", outFile);
	const QString errorCaption = i18n("Certificate Export Failed");
	if (!savefile.open(QIODevice::WriteOnly)) {
	error(writeErrorMsg, errorCaption);
	finishedIfLastJob();
	return;
	}

	if (!write_complete(savefile, data) \|\| !savefile.commit()) {
	error(writeErrorMsg, errorCaption);
	}
	finishedIfLastJob();
	}

	void ExportCertificateCommand::Private::cancelJobs()
	{
	if (cmsJob) {
	cmsJob->slotCancel();
	}
	if (pgpJob) {
	pgpJob->slotCancel();
	}
	}

	#undef d
	#undef q

	#include "moc_exportcertificatecommand.cpp"
	diff --git a/src/commands/exportgroupscommand.cpp b/src/commands/exportgroupscommand.cpp
	index c89925637..5f4a6afbc 100644
	--- a/src/commands/exportgroupscommand.cpp
	+++ b/src/commands/exportgroupscommand.cpp
	@@ -1,341 +1,335 @@
	/* -- mode: c++; c-basic-offset:4 --
	exportgroupscommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2021 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "command_p.h"
	#include "exportgroupscommand.h"

	#include "utils/filedialog.h"
	#include <utils/applicationstate.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyGroup>
	#include <Libkleo/KeyGroupImportExport>
	#include <Libkleo/KeyHelpers>

	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <QGpgME/ExportJob>
	#include <QGpgME/Protocol>

	#include <QFileInfo>
	#include <QStandardPaths>

	#include <memory>
	#include <vector>

	using namespace Kleo;
	using namespace GpgME;
	using namespace QGpgME;

	namespace
	{

	static const QString certificateGroupFileExtension{QLatin1String{".kgrp"}};

	QString proposeFilename(const std::vector<KeyGroup> &groups)
	{
	QString filename;

	filename = ApplicationState::lastUsedExportDirectory() + QLatin1Char{'/'};
	if (groups.size() == 1) {
	filename += groups.front().name().replace(QLatin1Char{'/'}, QLatin1Char{'_'});
	} else {
	filename += i18nc("A generic filename for exported certificate groups", "certificate groups");
	}

	return filename + certificateGroupFileExtension;
	}

	QString requestFilename(QWidget *parent, const std::vector<KeyGroup> &groups)
	{
	const QString proposedFilename = proposeFilename(groups);

	auto filename =
	FileDialog::getSaveFileNameEx(parent,
	i18ncp("@title:window", "Export Certificate Group", "Export Certificate Groups", groups.size()),
	QStringLiteral("imp"),
	proposedFilename,
	i18nc("filename filter like Certificate Groups (.foo)", "Certificate Groups (%1)", certificateGroupFileExtension));
	if (!filename.isEmpty()) {
	const QFileInfo fi{filename};
	if (fi.suffix().isEmpty()) {
	filename += certificateGroupFileExtension;
	}
	ApplicationState::setLastUsedExportDirectory(filename);
	}

	return filename;
	}

	}

	class ExportGroupsCommand::Private : public Command::Private
	{
	friend class ::ExportGroupsCommand;
	ExportGroupsCommand *q_func() const
	{
	return static_cast<ExportGroupsCommand *>(q);
	}

	public:
	explicit Private(ExportGroupsCommand *qq);
	~Private() override;

	void start();

	bool confirmExport();
	bool exportGroups();
	bool startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys);

	void onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData);

	void cancelJobs();
	void showError(const GpgME::Error &err);

	void finishedIfLastJob(const QGpgME::Job *job);

	private:
	std::vector<KeyGroup> groups;
	QString filename;
	std::vector<QPointer<QGpgME::Job>> exportJobs;
	};

	ExportGroupsCommand::Private *ExportGroupsCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ExportGroupsCommand::Private *ExportGroupsCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ExportGroupsCommand::Private::Private(ExportGroupsCommand *qq)
	: Command::Private(qq)
	{
	}

	ExportGroupsCommand::Private::~Private() = default;

	void ExportGroupsCommand::Private::start()
	{
	if (groups.empty()) {
	finished();
	return;
	}

	if (!confirmExport()) {
	canceled();
	return;
	}

	filename = requestFilename(parentWidgetOrView(), groups);
	if (filename.isEmpty()) {
	canceled();
	return;
	}

	const auto groupKeys = std::accumulate(std::begin(groups), std::end(groups), KeyGroup::Keys{}, [](auto allKeys, const auto &group) {
	const auto keys = group.keys();
	allKeys.insert(std::begin(keys), std::end(keys));
	return allKeys;
	});
	const auto keys = Kleo::partitionKeysByProtocol(groupKeys);

	// remove/overwrite existing file
	if (QFile::exists(filename) && !QFile::remove(filename)) {
	error(xi18n("Cannot overwrite existing <filename>%1</filename>.", filename), i18nc("@title:window", "Export Failed"));
	finished();
	return;
	}
	if (!exportGroups()) {
	finished();
	return;
	}
	if (!keys.openpgp.empty()) {
	if (!startExportJob(GpgME::OpenPGP, keys.openpgp)) {
	finished();
	return;
	}
	}
	if (!keys.cms.empty()) {
	if (!startExportJob(GpgME::CMS, keys.cms)) {
	finishedIfLastJob(nullptr);
	}
	}
	}

	bool ExportGroupsCommand::Private::confirmExport()
	{
	auto notFullyCertifiedGroups = std::accumulate(groups.cbegin(), groups.cend(), QStringList{}, [](auto groupNames, const auto &group) {
	const bool allOpenPGPKeysAreCertifiedByUser = Kleo::all_of(group.keys(), [](const Key &key) {
	// we only check the primary user ID of OpenPGP keys because currently group certification only certifies the primary user ID
	return key.protocol() != GpgME::OpenPGP \|\| Kleo::userIDIsCertifiedByUser(key.userID(0));
	});
	if (!allOpenPGPKeysAreCertifiedByUser) {
	groupNames.push_back(group.name());
	}
	return groupNames;
	});
	if (!notFullyCertifiedGroups.empty()) {
	if (groups.size() == 1) {
	const auto answer = KMessageBox::warningContinueCancel( //
	parentWidgetOrView(),
	xi18nc("@info",
	"<para>You haven't certified all OpenPGP certificates in this group "
	"with an exportable certification. People relying on your certifications "
	"may not be able to verify the certificates.</para>"
	"<para>Do you want to continue the export?</para>"),
	i18nc("@title:window", "Confirm Group Export"),
	KGuiItem{i18nc("@action:button", "Export Group")},
	KStandardGuiItem::cancel(),
	QStringLiteral("confirm-export-of-uncertified-groups"));
	return answer == KMessageBox::Continue;
	} else {
	std::sort(notFullyCertifiedGroups.begin(), notFullyCertifiedGroups.end());
	const auto answer = KMessageBox::warningContinueCancelList( //
	parentWidgetOrView(),
	xi18nc("@info",
	"<para>You haven't certified all OpenPGP certificates in the groups listed below "
	"with exportable certifications. People relying on your certifications "
	"may not be able to verify the certificates.</para>"
	"<para>Do you want to continue the export?</para>"),
	notFullyCertifiedGroups,
	i18nc("@title:window", "Confirm Group Export"),
	KGuiItem{i18nc("@action:button", "Export Groups")},
	KStandardGuiItem::cancel(),
	QStringLiteral("confirm-export-of-uncertified-groups"));
	return answer == KMessageBox::Continue;
	}
	}

	return true;
	}

	bool ExportGroupsCommand::Private::exportGroups()
	{
	const auto result = writeKeyGroups(filename, groups);
	if (result != WriteKeyGroups::Success) {
	error(xi18n("Writing groups to file <filename>%1</filename> failed.", filename), i18nc("@title:window", "Export Failed"));
	}
	return result == WriteKeyGroups::Success;
	}

	bool ExportGroupsCommand::Private::startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys)
	{
	const QGpgME::Protocol *const backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	Q_ASSERT(backend);
	std::unique_ptr<ExportJob> jobOwner(backend->publicKeyExportJob(/armor=/true));
	auto job = jobOwner.get();
	Q_ASSERT(job);

	connect(job, &ExportJob::result, q, [this, job](const GpgME::Error &err, const QByteArray &keyData) {
	onExportJobResult(job, err, keyData);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(job, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const GpgME::Error err = job->start(Kleo::getFingerprints(keys));
	if (err) {
	showError(err);
	return false;
	}
	Q_EMIT q->info(i18n("Exporting certificate groups..."));

	exportJobs.push_back(jobOwner.release());
	return true;
	}

	void ExportGroupsCommand::Private::onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData)
	{
	Q_ASSERT(Kleo::contains(exportJobs, job));

	if (err) {
	showError(err);
	finishedIfLastJob(job);
	return;
	}

	QFile f{filename};
	if (!f.open(QIODevice::WriteOnly \| QIODevice::Append)) {
	error(xi18n("Cannot open file <filename>%1</filename> for writing.", filename), i18nc("@title:window", "Export Failed"));
	finishedIfLastJob(job);
	return;
	}

	const auto bytesWritten = f.write(keyData);
	if (bytesWritten != keyData.size()) {
	error(xi18n("Writing certificates to file <filename>%1</filename> failed.", filename), i18nc("@title:window", "Export Failed"));
	}

	finishedIfLastJob(job);
	}

	void ExportGroupsCommand::Private::showError(const GpgME::Error &err)
	{
	error(xi18n("<para>An error occurred during the export:</para>"
	"<para><message>%1</message></para>",
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Export Failed"));
	}

	void ExportGroupsCommand::Private::finishedIfLastJob(const QGpgME::Job *job)
	{
	if (job) {
	exportJobs.erase(std::remove(exportJobs.begin(), exportJobs.end(), job), exportJobs.end());
	}
	if (exportJobs.size() == 0) {
	finished();
	}
	}

	void ExportGroupsCommand::Private::cancelJobs()
	{
	std::for_each(std::cbegin(exportJobs), std::cend(exportJobs), [](const auto &job) {
	if (job) {
	job->slotCancel();
	}
	});
	exportJobs.clear();
	}

	ExportGroupsCommand::ExportGroupsCommand(const std::vector<KeyGroup> &groups)
	: Command{new Private{this}}
	{
	d->groups = groups;
	}

	ExportGroupsCommand::~ExportGroupsCommand() = default;

	void ExportGroupsCommand::doStart()
	{
	d->start();
	}

	void ExportGroupsCommand::doCancel()
	{
	d->cancelJobs();
	}

	#undef d
	#undef q

	#include "moc_exportgroupscommand.cpp"
	diff --git a/src/commands/exportsecretkeycommand.cpp b/src/commands/exportsecretkeycommand.cpp
	index 3901d018c..53d71b71f 100644
	--- a/src/commands/exportsecretkeycommand.cpp
	+++ b/src/commands/exportsecretkeycommand.cpp
	@@ -1,310 +1,299 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/exportsecretkeycommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "command_p.h"
	#include "exportsecretkeycommand.h"

	#include "fileoperationspreferences.h"
	#include "utils/filedialog.h"
	#include <utils/applicationstate.h>

	#include <Libkleo/Classify>
	#include <Libkleo/Formatting>

	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <QGpgME/ExportJob>
	#include <QGpgME/Protocol>

	#include <QFileInfo>
	#include <QStandardPaths>

	#include <gpgme++/context.h>

	#include <algorithm>
	#include <memory>
	#include <vector>

	#include <kleopatra_debug.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;

	namespace
	{

	QString openPGPCertificateFileExtension()
	{
	return outputFileExtension(Class::OpenPGP \| Class::Ascii \| Class::Certificate, FileOperationsPreferences().usePGPFileExt());
	}

	QString cmsCertificateFileExtension()
	{
	return outputFileExtension(Class::CMS \| Class::Binary \| Class::ExportedPSM,
	/usePGPFileExt=/false);
	}

	QString certificateFileExtension(GpgME::Protocol protocol)
	{
	switch (protocol) {
	case GpgME::OpenPGP:
	return openPGPCertificateFileExtension();
	case GpgME::CMS:
	return cmsCertificateFileExtension();
	default:
	qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Unknown protocol" << protocol;
	return QStringLiteral("txt");
	}
	}

	QString proposeFilename(const Key &key)
	{
	QString filename;

	auto name = Formatting::prettyName(key);
	if (name.isEmpty()) {
	name = Formatting::prettyEMail(key);
	}
	const auto shortKeyID = Formatting::prettyKeyID(key.shortKeyID());
	/* Not translated so it's better to use in tutorials etc. */
	filename = QStringView{u"%1_%2_SECRET"}.arg(name, shortKeyID);
	filename.replace(u'/', u'_');

	return ApplicationState::lastUsedExportDirectory() + u'/' + filename + u'.' + certificateFileExtension(key.protocol());
	}

	QString secretKeyFileFilters(GpgME::Protocol protocol)
	{
	switch (protocol) {
	case GpgME::OpenPGP:
	return i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (.asc .gpg *.pgp)"};
	case GpgME::CMS:
	return i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (*.p12)"};
	default:
	qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Unknown protocol" << protocol;
	return i18nc("description of filename filter", "All Files") + QLatin1String{" (*)"};
	}
	}

	QString requestFilename(const Key &key, const QString &proposedFilename, QWidget *parent)
	{
	auto filename = FileDialog::getSaveFileNameEx(parent,
	i18nc("@title:window", "Secret Key Backup"),
	QStringLiteral("imp"),
	proposedFilename,
	secretKeyFileFilters(key.protocol()));

	if (!filename.isEmpty()) {
	const QFileInfo fi{filename};
	if (fi.suffix().isEmpty()) {
	filename += u'.' + certificateFileExtension(key.protocol());
	}
	ApplicationState::setLastUsedExportDirectory(filename);
	}

	return filename;
	}

	QString errorCaption()
	{
	return i18nc("@title:window", "Secret Key Backup Error");
	}

	}

	class ExportSecretKeyCommand::Private : public Command::Private
	{
	friend class ::ExportSecretKeyCommand;
	ExportSecretKeyCommand *q_func() const
	{
	return static_cast<ExportSecretKeyCommand *>(q);
	}

	public:
	explicit Private(ExportSecretKeyCommand qq, KeyListController c = nullptr);
	~Private() override;

	void start();
	void cancel();

	private:
	std::unique_ptr<QGpgME::ExportJob> startExportJob(const Key &key);
	void onExportJobResult(const Error &err, const QByteArray &keyData);
	void showError(const Error &err);

	private:
	QString filename;
	QPointer<QGpgME::ExportJob> job;
	};

	ExportSecretKeyCommand::Private *ExportSecretKeyCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ExportSecretKeyCommand::Private *ExportSecretKeyCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ExportSecretKeyCommand::Private::Private(ExportSecretKeyCommand qq, KeyListController c)
	: Command::Private{qq, c}
	{
	}

	ExportSecretKeyCommand::Private::~Private() = default;

	void ExportSecretKeyCommand::Private::start()
	{
	const Key key = this->key();

	if (key.isNull()) {
	finished();
	return;
	}

	filename = requestFilename(key, proposeFilename(key), parentWidgetOrView());
	if (filename.isEmpty()) {
	canceled();
	return;
	}

	auto exportJob = startExportJob(key);
	if (!exportJob) {
	finished();
	return;
	}
	job = exportJob.release();
	}

	void ExportSecretKeyCommand::Private::cancel()
	{
	if (job) {
	job->slotCancel();
	}
	job.clear();
	}

	std::unique_ptr<QGpgME::ExportJob> ExportSecretKeyCommand::Private::startExportJob(const Key &key)
	{
	-#if QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	const bool armor = key.protocol() == GpgME::OpenPGP && filename.endsWith(u".asc", Qt::CaseInsensitive);
	const QGpgME::Protocol *const backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	Q_ASSERT(backend);
	std::unique_ptr<QGpgME::ExportJob> exportJob{backend->secretKeyExportJob(armor)};
	Q_ASSERT(exportJob);

	if (key.protocol() == GpgME::CMS) {
	exportJob->setExportFlags(GpgME::Context::ExportPKCS12);
	}

	connect(exportJob.get(), &QGpgME::ExportJob::result, q, [this](const GpgME::Error &err, const QByteArray &keyData) {
	onExportJobResult(err, keyData);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(exportJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(exportJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const GpgME::Error err = exportJob->start({QLatin1String{key.primaryFingerprint()}});
	if (err) {
	showError(err);
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Backing up secret key..."));

	return exportJob;
	-#else
	- Q_UNUSED(key)
	- return {};
	-#endif
	}

	void ExportSecretKeyCommand::Private::onExportJobResult(const Error &err, const QByteArray &keyData)
	{
	if (err.isCanceled()) {
	finished();
	return;
	}

	if (err) {
	showError(err);
	finished();
	return;
	}

	if (keyData.isEmpty()) {
	error(i18nc("@info", "The result of the backup is empty. Maybe you entered an empty or a wrong passphrase."), errorCaption());
	finished();
	return;
	}

	QFile f{filename};
	if (!f.open(QIODevice::WriteOnly)) {
	error(xi18nc("@info", "Cannot open file <filename>%1</filename> for writing.", filename), errorCaption());
	finished();
	return;
	}

	const auto bytesWritten = f.write(keyData);
	if (bytesWritten != keyData.size()) {
	error(xi18nc("@info", "Writing key to file <filename>%1</filename> failed.", filename), errorCaption());
	finished();
	return;
	}

	information(i18nc("@info", "The backup of the secret key was created successfully."), i18nc("@title:window", "Secret Key Backup"));
	finished();
	}

	void ExportSecretKeyCommand::Private::showError(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred during the backup of the secret key:</para>"
	"<para><message>%1</message></para>",
	Formatting::errorAsString(err)),
	errorCaption());
	}

	ExportSecretKeyCommand::ExportSecretKeyCommand(QAbstractItemView view, KeyListController controller)
	: Command{view, new Private{this, controller}}
	{
	}

	ExportSecretKeyCommand::ExportSecretKeyCommand(const GpgME::Key &key)
	: Command{key, new Private{this}}
	{
	}

	ExportSecretKeyCommand::~ExportSecretKeyCommand() = default;

	void ExportSecretKeyCommand::doStart()
	{
	d->start();
	}

	void ExportSecretKeyCommand::doCancel()
	{
	d->cancel();
	}

	#undef d
	#undef q

	#include "moc_exportsecretkeycommand.cpp"
	diff --git a/src/commands/exportsecretsubkeycommand.cpp b/src/commands/exportsecretsubkeycommand.cpp
	index 91a7466e5..d39884aa5 100644
	--- a/src/commands/exportsecretsubkeycommand.cpp
	+++ b/src/commands/exportsecretsubkeycommand.cpp
	@@ -1,294 +1,272 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/exportsecretsubkeycommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "command_p.h"
	#include "exportsecretsubkeycommand.h"

	#include "fileoperationspreferences.h"
	#include <utils/applicationstate.h>
	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	-#include "utils/filedialog.h"
	-#endif
	+#include <utils/filedialog.h>

	#include <Libkleo/Classify>
	#include <Libkleo/Formatting>

	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <QGpgME/ExportJob>
	#include <QGpgME/Protocol>

	#include <QFileInfo>
	#include <QStandardPaths>

	#include <algorithm>
	#include <memory>
	#include <vector>

	using namespace Kleo;
	using namespace GpgME;

	namespace
	{

	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	QString openPGPCertificateFileExtension()
	{
	return outputFileExtension(Class::OpenPGP \| Class::Ascii \| Class::Certificate, FileOperationsPreferences().usePGPFileExt());
	}

	QString proposeFilename(const std::vector<Subkey> &subkeys)
	{
	QString filename;

	if (subkeys.size() == 1) {
	const auto subkey = subkeys.front();
	const auto key = subkey.parent();
	auto name = Formatting::prettyName(key);
	if (name.isEmpty()) {
	name = Formatting::prettyEMail(key);
	}
	const auto shortKeyID = Formatting::prettyKeyID(key.shortKeyID());
	const auto shortSubkeyID = Formatting::prettyKeyID(QByteArray{subkey.keyID()}.right(8).constData());
	const auto usage = Formatting::usageString(subkey).replace(QLatin1String{", "}, QLatin1String{"_"});
	/* Not translated so it's better to use in tutorials etc. */
	filename = QStringView{u"%1_%2_SECRET_SUBKEY_%3_%4"}.arg(name, shortKeyID, shortSubkeyID, usage);
	} else {
	filename = i18nc("Generic filename for exported subkeys", "subkeys");
	}
	filename.replace(u'/', u'_');

	return ApplicationState::lastUsedExportDirectory() + u'/' + filename + u'.' + openPGPCertificateFileExtension();
	}

	QString requestFilename(const std::vector<Subkey> &subkeys, const QString &proposedFilename, QWidget *parent)
	{
	auto filename = FileDialog::getSaveFileNameEx(parent,
	i18ncp("@title:window", "Export Subkey", "Export Subkeys", subkeys.size()),
	QStringLiteral("imp"),
	proposedFilename,
	i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (.asc .gpg *.pgp)"});

	if (!filename.isEmpty()) {
	const QFileInfo fi{filename};
	if (fi.suffix().isEmpty()) {
	filename += u'.' + openPGPCertificateFileExtension();
	}
	ApplicationState::setLastUsedExportDirectory(filename);
	}

	return filename;
	}

	template<typename SubkeyContainer>
	QStringList getSubkeyFingerprints(const SubkeyContainer &subkeys)
	{
	QStringList fingerprints;

	fingerprints.reserve(subkeys.size());
	std::transform(std::begin(subkeys), std::end(subkeys), std::back_inserter(fingerprints), [](const auto &subkey) {
	return QLatin1String{subkey.fingerprint()} + u'!';
	});

	return fingerprints;
	}
	-#endif
	-
	}

	class ExportSecretSubkeyCommand::Private : public Command::Private
	{
	friend class ::ExportSecretSubkeyCommand;
	ExportSecretSubkeyCommand *q_func() const
	{
	return static_cast<ExportSecretSubkeyCommand *>(q);
	}

	public:
	explicit Private(ExportSecretSubkeyCommand *qq);
	~Private() override;

	void start();
	void cancel();

	private:
	std::unique_ptr<QGpgME::ExportJob> startExportJob(const std::vector<Subkey> &subkeys);
	void onExportJobResult(const Error &err, const QByteArray &keyData);
	void showError(const Error &err);

	private:
	std::vector<Subkey> subkeys;
	QString filename;
	QPointer<QGpgME::ExportJob> job;
	};

	ExportSecretSubkeyCommand::Private *ExportSecretSubkeyCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ExportSecretSubkeyCommand::Private *ExportSecretSubkeyCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	ExportSecretSubkeyCommand::Private::Private(ExportSecretSubkeyCommand *qq)
	: Command::Private{qq}
	{
	}

	ExportSecretSubkeyCommand::Private::~Private() = default;

	void ExportSecretSubkeyCommand::Private::start()
	{
	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	if (subkeys.empty()) {
	finished();
	return;
	}

	filename = requestFilename(subkeys, proposeFilename(subkeys), parentWidgetOrView());
	if (filename.isEmpty()) {
	canceled();
	return;
	}

	auto exportJob = startExportJob(subkeys);
	if (!exportJob) {
	finished();
	return;
	}
	job = exportJob.release();
	-#else
	- Q_ASSERT(!"This command is not supported by the backend it was compiled against");
	- finished();
	- return;
	-#endif
	}

	void ExportSecretSubkeyCommand::Private::cancel()
	{
	if (job) {
	job->slotCancel();
	}
	job.clear();
	}

	std::unique_ptr<QGpgME::ExportJob> ExportSecretSubkeyCommand::Private::startExportJob(const std::vector<Subkey> &subkeys)
	{
	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	const bool armor = filename.endsWith(u".asc", Qt::CaseInsensitive);
	std::unique_ptr<QGpgME::ExportJob> exportJob{QGpgME::openpgp()->secretSubkeyExportJob(armor)};
	Q_ASSERT(exportJob);

	connect(exportJob.get(), &QGpgME::ExportJob::result, q, [this](const GpgME::Error &err, const QByteArray &keyData) {
	onExportJobResult(err, keyData);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(exportJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(exportJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const GpgME::Error err = exportJob->start(getSubkeyFingerprints(subkeys));
	if (err) {
	showError(err);
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Exporting subkeys..."));

	return exportJob;
	-#else
	- Q_UNUSED(subkeys)
	- return {};
	-#endif
	}

	void ExportSecretSubkeyCommand::Private::onExportJobResult(const Error &err, const QByteArray &keyData)
	{
	if (err) {
	showError(err);
	finished();
	return;
	}

	if (err.isCanceled()) {
	finished();
	return;
	}

	if (keyData.isEmpty()) {
	error(i18nc("@info", "The result of the export is empty."), i18nc("@title:window", "Export Failed"));
	finished();
	return;
	}

	QFile f{filename};
	if (!f.open(QIODevice::WriteOnly)) {
	error(xi18nc("@info", "Cannot open file <filename>%1</filename> for writing.", filename), i18nc("@title:window", "Export Failed"));
	finished();
	return;
	}

	const auto bytesWritten = f.write(keyData);
	if (bytesWritten != keyData.size()) {
	error(xi18ncp("@info",
	"Writing subkey to file <filename>%2</filename> failed.",
	"Writing subkeys to file <filename>%2</filename> failed.",
	subkeys.size(),
	filename),
	i18nc("@title:window", "Export Failed"));
	finished();
	return;
	}

	information(i18ncp("@info", "The subkey was exported successfully.", "%1 subkeys were exported successfully.", subkeys.size()),
	i18nc("@title:window", "Secret Key Backup"));
	finished();
	}

	void ExportSecretSubkeyCommand::Private::showError(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred during the export:</para>"
	"<para><message>%1</message></para>",
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Export Failed"));
	}

	ExportSecretSubkeyCommand::ExportSecretSubkeyCommand(const std::vector<GpgME::Subkey> &subkeys)
	: Command{new Private{this}}
	{
	d->subkeys = subkeys;
	}

	ExportSecretSubkeyCommand::~ExportSecretSubkeyCommand() = default;

	void ExportSecretSubkeyCommand::doStart()
	{
	d->start();
	}

	void ExportSecretSubkeyCommand::doCancel()
	{
	d->cancel();
	}

	#undef d
	#undef q

	#include "moc_exportsecretsubkeycommand.cpp"
	diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp
	index d09f14799..a02d2c9c1 100644
	--- a/src/commands/importcertificatescommand.cpp
	+++ b/src/commands/importcertificatescommand.cpp
	@@ -1,1120 +1,1081 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/importcertificatescommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH
	SPDX-FileCopyrightText: 2021, 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "importcertificatescommand.h"
	#include "importcertificatescommand_p.h"

	#include "certifycertificatecommand.h"
	#include "kleopatra_debug.h"
	#include <settings.h>
	#include <utils/memory-helpers.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyGroupImportExport>
	#include <Libkleo/KeyHelpers>
	#include <Libkleo/KeyList>
	#include <Libkleo/KeyListSortFilterProxyModel>
	#include <Libkleo/MessageBox>
	#include <Libkleo/Predicates>
	#include <Libkleo/Stl_Util>

	#include <QGpgME/ChangeOwnerTrustJob>
	#include <QGpgME/ImportFromKeyserverJob>
	#include <QGpgME/ImportJob>
	#include <QGpgME/Protocol>
	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	#include <QGpgME/ReceiveKeysJob>
	-#endif

	#include <gpgme++/context.h>
	#include <gpgme++/global.h>
	#include <gpgme++/importresult.h>
	#include <gpgme++/key.h>
	#include <gpgme++/keylistresult.h>

	#include <KLocalizedString>
	#include <KMessageBox>

	#include <QByteArray>
	#include <QEventLoop>
	#include <QProgressDialog>
	#include <QString>
	#include <QTextDocument> // for Qt::escape
	#include <QTreeView>
	#include <QWidget>

	#include <algorithm>
	#include <map>
	#include <memory>
	#include <set>
	#include <unordered_set>

	using namespace GpgME;
	using namespace Kleo;
	using namespace QGpgME;

	static void disconnectConnection(const QMetaObject::Connection &connection)
	{
	// trivial function for disconnecting a signal-slot connection
	QObject::disconnect(connection);
	}

	bool operator==(const ImportJobData &lhs, const ImportJobData &rhs)
	{
	return lhs.job == rhs.job;
	}

	namespace
	{

	make_comparator_str(ByImportFingerprint, .fingerprint());

	class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel
	{
	Q_OBJECT
	public:
	ImportResultProxyModel(const std::vector<ImportResultData> &results, QObject *parent = nullptr)
	: AbstractKeyListSortFilterProxyModel(parent)
	{
	updateFindCache(results);
	}

	~ImportResultProxyModel() override
	{
	}

	ImportResultProxyModel *clone() const override
	{
	// compiler-generated copy ctor is fine!
	return new ImportResultProxyModel(*this);
	}

	void setImportResults(const std::vector<ImportResultData> &results)
	{
	updateFindCache(results);
	invalidateFilter();
	}

	protected:
	QVariant data(const QModelIndex &index, int role) const override
	{
	if (!index.isValid() \|\| role != Qt::ToolTipRole) {
	return AbstractKeyListSortFilterProxyModel::data(index, role);
	}
	const QString fpr = index.data(KeyList::FingerprintRole).toString();
	// find information:
	const std::vector<Import>::const_iterator it =
	Kleo::binary_find(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), fpr.toLatin1().constData(), ByImportFingerprint<std::less>());
	if (it == m_importsByFingerprint.end()) {
	return AbstractKeyListSortFilterProxyModel::data(index, role);
	} else {
	QStringList rv;
	const auto ids = m_idsByFingerprint[it->fingerprint()];
	rv.reserve(ids.size());
	std::copy(ids.cbegin(), ids.cend(), std::back_inserter(rv));
	return Formatting::importMetaData(*it, rv);
	}
	}
	bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
	{
	//
	// 0. Keep parents of matching children:
	//
	const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
	Q_ASSERT(index.isValid());
	for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i)
	if (filterAcceptsRow(i, index)) {
	return true;
	}
	//
	// 1. Check that this is an imported key:
	//
	const QString fpr = index.data(KeyList::FingerprintRole).toString();

	return std::binary_search(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), fpr.toLatin1().constData(), ByImportFingerprint<std::less>());
	}

	private:
	void updateFindCache(const std::vector<ImportResultData> &results)
	{
	m_importsByFingerprint.clear();
	m_idsByFingerprint.clear();
	m_results = results;
	for (const auto &r : results) {
	const std::vector<Import> imports = r.result.imports();
	m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end());
	for (std::vector<Import>::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) {
	m_idsByFingerprint[it->fingerprint()].insert(r.id);
	}
	}
	std::sort(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), ByImportFingerprint<std::less>());
	}

	private:
	mutable std::vector<Import> m_importsByFingerprint;
	mutable std::map<const char *, std::set<QString>, ByImportFingerprint<std::less>> m_idsByFingerprint;
	std::vector<ImportResultData> m_results;
	};

	bool importFailed(const ImportResultData &r)
	{
	// ignore GPG_ERR_EOF error to handle the "failed" import of files
	// without X.509 certificates by gpgsm gracefully
	return r.result.error() && r.result.error().code() != GPG_ERR_EOF;
	}

	bool importWasCanceled(const ImportResultData &r)
	{
	return r.result.error().isCanceled();
	}

	}

	ImportCertificatesCommand::Private::Private(ImportCertificatesCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, progressWindowTitle{i18nc("@title:window", "Importing Certificates")}
	, progressLabelText{i18n("Importing certificates... (this can take a while)")}
	{
	}

	ImportCertificatesCommand::Private::~Private()
	{
	if (progressDialog) {
	delete progressDialog;
	}
	}

	#define d d_func()
	#define q q_func()

	ImportCertificatesCommand::ImportCertificatesCommand(KeyListController *p)
	: Command(new Private(this, p))
	{
	}

	ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView v, KeyListController p)
	: Command(v, new Private(this, p))
	{
	}

	ImportCertificatesCommand::~ImportCertificatesCommand() = default;

	static QString format_ids(const std::vector<QString> &ids)
	{
	QStringList escapedIds;
	for (const QString &id : ids) {
	if (!id.isEmpty()) {
	escapedIds << id.toHtmlEscaped();
	}
	}
	return escapedIds.join(QLatin1String("<br>"));
	}

	static QString make_tooltip(const std::vector<ImportResultData> &results)
	{
	if (results.empty()) {
	return {};
	}

	std::vector<QString> ids;
	ids.reserve(results.size());
	std::transform(std::begin(results), std::end(results), std::back_inserter(ids), [](const auto &r) {
	return r.id;
	});
	std::sort(std::begin(ids), std::end(ids));
	ids.erase(std::unique(std::begin(ids), std::end(ids)), std::end(ids));

	if (ids.size() == 1)
	if (ids.front().isEmpty()) {
	return {};
	} else
	return i18nc("@info:tooltip", "Imported Certificates from %1", ids.front().toHtmlEscaped());
	else
	return i18nc("@info:tooltip", "Imported certificates from these sources:<br/>%1", format_ids(ids));
	}

	void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector<ImportResultData> &results)
	{
	if (std::none_of(std::begin(results), std::end(results), [](const auto &r) {
	return r.result.numConsidered() > 0;
	})) {
	return;
	}
	q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"), new ImportResultProxyModel(results), make_tooltip(results));
	if (QTreeView const tv = qobject_cast<QTreeView >(parentWidgetOrView())) {
	tv->expandAll();
	}
	}

	int sum(const std::vector<ImportResult> &res, int (ImportResult::*fun)() const)
	{
	return kdtools::accumulate_transform(res.begin(), res.end(), std::mem_fn(fun), 0);
	}

	static QString make_report(const std::vector<ImportResultData> &results, const std::vector<ImportedGroup> &groups)
	{
	const KLocalizedString normalLine = ki18n("<tr><td align=\"right\">%1</td><td>%2</td></tr>");
	const KLocalizedString boldLine = ki18n("<tr><td align=\"right\"><b>%1</b></td><td>%2</td></tr>");
	const KLocalizedString headerLine = ki18n("<tr><th colspan=\"2\" align=\"center\">%1</th></tr>");

	std::vector<ImportResult> res;
	res.reserve(results.size());
	std::transform(std::begin(results), std::end(results), std::back_inserter(res), [](const auto &r) {
	return r.result;
	});

	const auto numProcessedCertificates = sum(res, &ImportResult::numConsidered);

	QStringList lines;

	if (numProcessedCertificates > 0 \|\| groups.size() == 0) {
	lines.push_back(headerLine.subs(i18n("Certificates")).toString());
	lines.push_back(normalLine.subs(i18n("Total number processed:")).subs(numProcessedCertificates).toString());
	lines.push_back(normalLine.subs(i18n("Imported:")).subs(sum(res, &ImportResult::numImported)).toString());
	if (const int n = sum(res, &ImportResult::newSignatures))
	lines.push_back(normalLine.subs(i18n("New signatures:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::newUserIDs))
	lines.push_back(normalLine.subs(i18n("New user IDs:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numKeysWithoutUserID))
	lines.push_back(normalLine.subs(i18n("Certificates without user IDs:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::newSubkeys))
	lines.push_back(normalLine.subs(i18n("New subkeys:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::newRevocations))
	lines.push_back(boldLine.subs(i18n("Newly revoked:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::notImported))
	lines.push_back(boldLine.subs(i18n("Not imported:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numUnchanged))
	lines.push_back(normalLine.subs(i18n("Unchanged:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numSecretKeysConsidered))
	lines.push_back(normalLine.subs(i18n("Secret keys processed:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numSecretKeysImported))
	lines.push_back(normalLine.subs(i18n("Secret keys imported:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numSecretKeysConsidered) - sum(res, &ImportResult::numSecretKeysImported)
	- sum(res, &ImportResult::numSecretKeysUnchanged))
	if (n > 0)
	lines.push_back(boldLine.subs(i18n("Secret keys <em>not</em> imported:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numSecretKeysUnchanged))
	lines.push_back(normalLine.subs(i18n("Secret keys unchanged:")).subs(n).toString());
	if (const int n = sum(res, &ImportResult::numV3KeysSkipped))
	lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:")).subs(n).toString());
	}

	if (!lines.empty()) {
	lines.push_back(headerLine.subs(QLatin1String{" "}).toString());
	}

	if (groups.size() > 0) {
	const auto newGroups = std::count_if(std::begin(groups), std::end(groups), [](const auto &g) {
	return g.status == ImportedGroup::Status::New;
	});
	const auto updatedGroups = groups.size() - newGroups;
	lines.push_back(headerLine.subs(i18n("Certificate Groups")).toString());
	lines.push_back(normalLine.subs(i18n("Total number processed:")).subs(groups.size()).toString());
	lines.push_back(normalLine.subs(i18n("New groups:")).subs(newGroups).toString());
	lines.push_back(normalLine.subs(i18n("Updated groups:")).subs(updatedGroups).toString());
	}

	return lines.join(QLatin1String{});
	}

	static bool isImportFromSingleSource(const std::vector<ImportResultData> &res)
	{
	return (res.size() == 1) \|\| (res.size() == 2 && res[0].id == res[1].id);
	}

	static QString make_message_report(const std::vector<ImportResultData> &res, const std::vector<ImportedGroup> &groups)
	{
	QString report{QLatin1String{"<html>"}};
	if (res.empty()) {
	report += i18n("No imports (should not happen, please report a bug).");
	} else {
	const QString title = isImportFromSingleSource(res) && !res.front().id.isEmpty() ? i18n("Detailed results of importing %1:", res.front().id)
	: i18n("Detailed results of import:");
	report += QLatin1String{"<p>"} + title + QLatin1String{"</p>"};
	report += QLatin1String{"<p><table width=\"100%\">"};
	report += make_report(res, groups);
	report += QLatin1String{"</table></p>"};
	}
	report += QLatin1String{"</html>"};
	return report;
	}

	// Returns false on error, true if please certify was shown.
	bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp)
	{
	if (!Kleo::userHasCertificationKey()) {
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "No certification key available";
	return false;
	}

	const char *fpr = imp.fingerprint();
	if (!fpr) {
	// WTF
	qCWarning(KLEOPATRA_LOG) << "Import without fingerprint";
	return false;
	}
	// Exactly one public key imported. Let's see if it is openpgp. We are async here so
	// we can just fetch it.

	auto ctx = wrap_unique(GpgME::Context::createForProtocol(GpgME::OpenPGP));
	if (!ctx) {
	// WTF
	qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto";
	return false;
	}
	ctx->addKeyListMode(KeyListMode::WithSecret);
	GpgME::Error err;
	const auto key = ctx->key(fpr, err, false);

	if (key.isNull() \|\| err) {
	// No such key most likely not OpenPGP
	return false;
	}
	if (!Kleo::canBeCertified(key)) {
	// key is expired or revoked
	return false;
	}
	if (key.hasSecret()) {
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "Secret key is available -> skipping certification";
	return false;
	}

	for (const auto &uid : key.userIDs()) {
	if (uid.validity() >= GpgME::UserID::Marginal) {
	// Already marginal so don't bug the user
	return false;
	}
	}

	const QStringList suggestions = {
	i18n("A phone call to the person."),
	i18n("Using a business card."),
	i18n("Confirming it on a trusted website."),
	};

	auto sel = KMessageBox::questionTwoActions(parentWidgetOrView(),
	i18n("In order to mark the certificate as valid it needs to be certified.") + QStringLiteral("<br>")
	+ i18n("Certifying means that you check the Fingerprint.") + QStringLiteral("<br>")
	+ i18n("Some suggestions to do this are:")
	+ QStringLiteral("<li><ul>%1").arg(suggestions.join(QStringLiteral("</ul><ul>")))
	+ QStringLiteral("</ul></li>") + i18n("Do you wish to start this process now?"),
	i18nc("@title", "You have imported a new certificate (public key)"),
	KGuiItem(i18nc("@action:button", "Certify")),
	KStandardGuiItem::cancel(),
	QStringLiteral("CertifyQuestion"));
	if (sel == KMessageBox::ButtonCode::PrimaryAction) {
	QEventLoop loop;
	auto cmd = new Commands::CertifyCertificateCommand(key);
	cmd->setParentWidget(parentWidgetOrView());
	connect(cmd, &Command::finished, &loop, &QEventLoop::quit);
	QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection);
	loop.exec();
	}
	return true;
	}

	namespace
	{
	/**
	* Returns the Import of an OpenPGP key, if a single certificate was imported and this was an OpenPGP key.
	* Otherwise, returns a null Import.
	*/
	auto getSingleOpenPGPImport(const std::vector<ImportResultData> &res)
	{
	static const Import nullImport;
	if (!isImportFromSingleSource(res)) {
	return nullImport;
	}
	const auto numImported = std::accumulate(res.cbegin(), res.cend(), 0, [](auto s, const auto &r) {
	return s + r.result.numImported();
	});
	if (numImported > 1) {
	return nullImport;
	}
	if ((res.size() >= 1) && (res[0].protocol == GpgME::OpenPGP) && (res[0].result.numImported() == 1) && (res[0].result.imports().size() == 1)) {
	return res[0].result.imports()[0];
	} else if ((res.size() == 2) && (res[1].protocol == GpgME::OpenPGP) && (res[1].result.numImported() == 1) && (res[1].result.imports().size() == 1)) {
	return res[1].result.imports()[0];
	}
	return nullImport;
	}

	auto consolidatedAuditLogEntries(const std::vector<ImportResultData> &res)
	{
	static const QString gpg = QStringLiteral("gpg");
	static const QString gpgsm = QStringLiteral("gpgsm");

	if (res.size() == 1) {
	return res.front().auditLog;
	}
	QStringList auditLogs;
	auto extractAndAnnotateAuditLog = [](const ImportResultData &r) {
	QString s;
	if (!r.id.isEmpty()) {
	const auto program = r.protocol == GpgME::OpenPGP ? gpg : gpgsm;
	const auto headerLine = i18nc("file name (imported with gpg/gpgsm)", "%1 (imported with %2)").arg(r.id, program);
	s += QStringLiteral("<div><b>%1</b></div>").arg(headerLine);
	}
	if (r.auditLog.error().code() == GPG_ERR_NO_DATA) {
	s += QStringLiteral("<em>") + i18nc("@info", "Audit log is empty.") + QStringLiteral("</em>");
	} else if (r.result.error().isCanceled()) {
	s += QStringLiteral("<em>") + i18nc("@info", "Import was canceled.") + QStringLiteral("</em>");
	} else {
	s += r.auditLog.text();
	}
	return s;
	};
	std::transform(res.cbegin(), res.cend(), std::back_inserter(auditLogs), extractAndAnnotateAuditLog);
	return AuditLogEntry{auditLogs.join(QLatin1String{"<hr>"}), Error{}};
	}
	}

	void ImportCertificatesCommand::Private::showDetails(const std::vector<ImportResultData> &res, const std::vector<ImportedGroup> &groups)
	{
	const auto singleOpenPGPImport = getSingleOpenPGPImport(res);
	if (!singleOpenPGPImport.isNull()) {
	if (showPleaseCertify(singleOpenPGPImport)) {
	return;
	}
	}
	setImportResultProxyModel(res);
	MessageBox::information(parentWidgetOrView(), make_message_report(res, groups), consolidatedAuditLogEntries(res), i18n("Certificate Import Result"));
	}

	static QString make_error_message(const Error &err, const QString &id)
	{
	Q_ASSERT(err);
	Q_ASSERT(!err.isCanceled());
	if (id.isEmpty()) {
	return i18n(
	"<qt><p>An error occurred while trying to import the certificate:</p>"
	"<p><b>%1</b></p></qt>",
	Formatting::errorAsString(err));
	} else {
	return i18n(
	"<qt><p>An error occurred while trying to import the certificate %1:</p>"
	"<p><b>%2</b></p></qt>",
	id,
	Formatting::errorAsString(err));
	}
	}

	void ImportCertificatesCommand::Private::showError(const ImportResultData &result)
	{
	MessageBox::error(parentWidgetOrView(), make_error_message(result.result.error(), result.id), result.auditLog);
	}

	void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait)
	{
	if (wait == waitForMoreJobs) {
	return;
	}
	waitForMoreJobs = wait;
	if (!waitForMoreJobs) {
	tryToFinish();
	}
	}

	void ImportCertificatesCommand::Private::onImportResult(const ImportResult &result, QGpgME::Job *finishedJob)
	{
	if (!finishedJob) {
	finishedJob = qobject_cast<QGpgME::Job *>(q->sender());
	}
	Q_ASSERT(finishedJob);
	qCDebug(KLEOPATRA_LOG) << q << __func__ << finishedJob;

	auto it = std::find_if(std::begin(runningJobs), std::end(runningJobs), [finishedJob](const auto &job) {
	return job.job == finishedJob;
	});
	Q_ASSERT(it != std::end(runningJobs));
	if (it == std::end(runningJobs)) {
	qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Finished job not found";
	return;
	}

	Kleo::for_each(it->connections, &disconnectConnection);
	it->connections.clear();

	increaseProgressValue();

	const auto job = *it;
	addImportResult({job.id, job.protocol, job.type, result, AuditLogEntry::fromJob(finishedJob)}, job);
	}

	void ImportCertificatesCommand::Private::addImportResult(const ImportResultData &result, const ImportJobData &job)
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__ << result.id << "Result:" << Formatting::errorAsString(result.result.error());
	results.push_back(result);

	if (importFailed(result)) {
	showError(result);
	}

	if (job.job) {
	const auto count = std::erase(runningJobs, job);
	Q_ASSERT(count == 1);
	}

	tryToFinish();
	}

	static void handleOwnerTrust(const std::vector<ImportResultData> &results, QWidget *dialog)
	{
	std::unordered_set<std::string> askedAboutFingerprints;
	for (const auto &r : results) {
	if (r.protocol != GpgME::Protocol::OpenPGP) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping non-OpenPGP import";
	continue;
	}
	const auto imports = r.result.imports();
	for (const auto &import : imports) {
	if (!(import.status() & (Import::Status::NewKey \| Import::Status::ContainedSecretKey))) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping already known imported public key";
	continue;
	}
	const char *fpr = import.fingerprint();
	if (!fpr) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping import without fingerprint";
	continue;
	}
	if (Kleo::contains(askedAboutFingerprints, fpr)) {
	// imports of secret keys can result in multiple Imports for the same key
	qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping import for already handled fingerprint";
	continue;
	}

	GpgME::Error err;
	auto ctx = wrap_unique(Context::createForProtocol(GpgME::Protocol::OpenPGP));
	if (!ctx) {
	qCWarning(KLEOPATRA_LOG) << "Failed to get context";
	continue;
	}

	ctx->addKeyListMode(KeyListMode::WithSecret);
	const Key toTrustOwner = ctx->key(fpr, err, false);

	if (toTrustOwner.isNull() \|\| !toTrustOwner.hasSecret()) {
	continue;
	}
	if (toTrustOwner.ownerTrust() == Key::OwnerTrust::Ultimate) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping key with ultimate ownertrust";
	continue;
	}

	const auto toTrustOwnerUserIDs{toTrustOwner.userIDs()};
	// ki18n(" ") as initializer because initializing with empty string leads to
	// (I18N_EMPTY_MESSAGE)
	const KLocalizedString uids = std::accumulate(toTrustOwnerUserIDs.cbegin(),
	toTrustOwnerUserIDs.cend(),
	KLocalizedString{ki18n(" ")},
	[](KLocalizedString temp, const auto &uid) {
	return kxi18nc("@info", "%1<item>%2</item>").subs(temp).subs(Formatting::prettyNameAndEMail(uid));
	});

	const QString str = xi18nc("@info",
	"<para>You have imported a certificate with fingerprint</para>"
	"<para><numid>%1</numid></para>"
	"<para>"
	"and user IDs"
	"<list>%2</list>"
	"</para>"
	"<para>Is this your own certificate?</para>",
	Formatting::prettyID(fpr),
	uids);

	int k = KMessageBox::questionTwoActionsCancel(dialog,
	str,
	i18nc("@title:window", "Mark Own Certificate"),
	KGuiItem{i18nc("@action:button", "Yes, It's Mine")},
	KGuiItem{i18nc("@action:button", "No, It's Not Mine")});
	askedAboutFingerprints.insert(fpr);

	if (k == KMessageBox::ButtonCode::PrimaryAction) {
	// To use the ChangeOwnerTrustJob over
	// the CryptoBackendFactory
	const QGpgME::Protocol *const backend = QGpgME::openpgp();

	if (!backend) {
	qCWarning(KLEOPATRA_LOG) << "Failed to get CryptoBackend";
	return;
	}

	ChangeOwnerTrustJob *const j = backend->changeOwnerTrustJob();
	j->start(toTrustOwner, Key::Ultimate);
	} else if (k == KMessageBox::ButtonCode::Cancel) {
	// do not bother the user with further "Is this yours?" questions
	return;
	}
	}
	}
	}

	static void validateImportedCertificate(const GpgME::Import &import)
	{
	if (const auto fpr = import.fingerprint()) {
	auto key = KeyCache::instance()->findByFingerprint(fpr);
	if (!key.isNull()) {
	// this triggers a keylisting with validation for this certificate
	key.update();
	} else {
	qCWarning(KLEOPATRA_LOG) << __func__ << "Certificate with fingerprint" << fpr << "not found";
	}
	}
	}

	static void handleExternalCMSImports(const std::vector<ImportResultData> &results)
	{
	// For external CMS Imports we have to manually do a keylist
	// with validation to get the intermediate and root ca imported
	// automatically if trusted-certs and extra-certs are used.
	for (const auto &r : results) {
	if (r.protocol == GpgME::CMS && r.type == ImportType::External && !importFailed(r) && !importWasCanceled(r)) {
	const auto imports = r.result.imports();
	std::for_each(std::begin(imports), std::end(imports), &validateImportedCertificate);
	}
	}
	}

	void ImportCertificatesCommand::Private::processResults()
	{
	importGroups();

	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	if (Settings{}.retrieveSignerKeysAfterImport() && !importingSignerKeys) {
	importingSignerKeys = true;
	const auto missingSignerKeys = getMissingSignerKeyIds(results);
	if (!missingSignerKeys.empty()) {
	importSignerKeys(missingSignerKeys);
	return;
	}
	}
	-#endif

	handleExternalCMSImports(results);

	// ensure that the progress dialog is closed before we show any other dialogs
	setProgressToMaximum();

	handleOwnerTrust(results, parentWidgetOrView());

	showDetails(results, importedGroups);

	auto tv = dynamic_cast<QTreeView *>(view());
	if (!tv) {
	qCDebug(KLEOPATRA_LOG) << "Failed to find treeview";
	} else {
	tv->expandAll();
	}
	finished();
	}

	void ImportCertificatesCommand::Private::tryToFinish()
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__;
	if (waitForMoreJobs) {
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "Waiting for more jobs -> keep going";
	return;
	}
	if (!runningJobs.empty()) {
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "There are unfinished jobs -> keep going";
	return;
	}
	-#if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	if (!pendingJobs.empty()) {
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "There are pending jobs -> start the next one";
	auto job = pendingJobs.front();
	pendingJobs.pop();
	job.job->startNow();
	runningJobs.push_back(job);
	return;
	}
	-#endif

	if (keyListConnection) {
	qCWarning(KLEOPATRA_LOG) << q << __func__ << "There is already a valid keyListConnection!";
	} else {
	auto keyCache = KeyCache::mutableInstance();
	keyListConnection = connect(keyCache.get(), &KeyCache::keyListingDone, q, [this]() {
	keyCacheUpdated();
	});
	keyCache->startKeyListing();
	}
	}

	void ImportCertificatesCommand::Private::keyCacheUpdated()
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__;
	if (!disconnect(keyListConnection)) {
	qCWarning(KLEOPATRA_LOG) << q << __func__ << "Failed to disconnect keyListConnection";
	}

	keyCacheAutoRefreshSuspension.reset();

	const auto allIds = std::accumulate(std::cbegin(results), std::cend(results), std::set<QString>{}, [](auto allIds, const auto &r) {
	allIds.insert(r.id);
	return allIds;
	});
	const auto canceledIds = std::accumulate(std::cbegin(results), std::cend(results), std::set<QString>{}, [](auto canceledIds, const auto &r) {
	if (importWasCanceled(r)) {
	canceledIds.insert(r.id);
	}
	return canceledIds;
	});
	const auto totalConsidered = std::accumulate(std::cbegin(results), std::cend(results), 0, [](auto totalConsidered, const auto &r) {
	return totalConsidered + r.result.numConsidered();
	});
	if (totalConsidered == 0 && canceledIds.size() == allIds.size()) {
	// nothing was considered for import and at least one import per id was
	// canceled => treat the command as canceled
	canceled();
	return;
	}

	processResults();
	}

	static ImportedGroup storeGroup(const KeyGroup &group, const QString &id)
	{
	const auto status = KeyCache::instance()->group(group.id()).isNull() ? ImportedGroup::Status::New : ImportedGroup::Status::Updated;
	if (status == ImportedGroup::Status::New) {
	KeyCache::mutableInstance()->insert(group);
	} else {
	KeyCache::mutableInstance()->update(group);
	}
	return {id, group, status};
	}

	void ImportCertificatesCommand::Private::importGroups()
	{
	for (const auto &path : filesToImportGroupsFrom) {
	const bool certificateImportSucceeded = std::any_of(std::cbegin(results), std::cend(results), [path](const auto &r) {
	return r.id == path && !importFailed(r) && !importWasCanceled(r);
	});
	if (certificateImportSucceeded) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Importing groups from file" << path;
	const auto groups = readKeyGroups(path);
	std::transform(std::begin(groups), std::end(groups), std::back_inserter(importedGroups), [path](const auto &group) {
	return storeGroup(group, path);
	});
	}
	increaseProgressValue();
	}
	filesToImportGroupsFrom.clear();
	}

	static auto accumulateNewKeys(std::vector<std::string> &fingerprints, const std::vector<GpgME::Import> &imports)
	{
	return std::accumulate(std::begin(imports), std::end(imports), fingerprints, [](auto fingerprints, const auto &import) {
	if (import.status() == Import::NewKey) {
	fingerprints.push_back(import.fingerprint());
	}
	return fingerprints;
	});
	}

	static auto accumulateNewOpenPGPKeys(const std::vector<ImportResultData> &results)
	{
	return std::accumulate(std::begin(results), std::end(results), std::vector<std::string>{}, [](auto fingerprints, const auto &r) {
	if (r.protocol == GpgME::OpenPGP) {
	fingerprints = accumulateNewKeys(fingerprints, r.result.imports());
	}
	return fingerprints;
	});
	}

	std::set<QString> ImportCertificatesCommand::Private::getMissingSignerKeyIds(const std::vector<ImportResultData> &results)
	{
	auto newOpenPGPKeys = KeyCache::instance()->findByFingerprint(accumulateNewOpenPGPKeys(results));
	// update all new OpenPGP keys to get information about certifications
	std::for_each(std::begin(newOpenPGPKeys), std::end(newOpenPGPKeys), std::mem_fn(&Key::update));
	auto missingSignerKeyIds = Kleo::getMissingSignerKeyIds(newOpenPGPKeys);
	return missingSignerKeyIds;
	}

	void ImportCertificatesCommand::Private::importSignerKeys(const std::set<QString> &keyIds)
	{
	Q_ASSERT(!keyIds.empty());

	setProgressLabelText(i18np("Fetching 1 signer key... (this can take a while)", "Fetching %1 signer keys... (this can take a while)", keyIds.size()));

	setWaitForMoreJobs(true);
	// start one import per key id to allow canceling the key retrieval without
	// losing already retrieved keys
	for (const auto &keyId : keyIds) {
	startImport(GpgME::OpenPGP, {keyId}, QStringLiteral("Retrieve Signer Keys"));
	}
	setWaitForMoreJobs(false);
	}

	static std::unique_ptr<ImportJob> get_import_job(GpgME::Protocol protocol)
	{
	Q_ASSERT(protocol != UnknownProtocol);
	if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
	return std::unique_ptr<ImportJob>(backend->importJob());
	} else {
	return std::unique_ptr<ImportJob>();
	}
	}

	void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol,
	const QByteArray &data,
	const QString &id,
	[[maybe_unused]] const ImportOptions &options)
	{
	Q_ASSERT(protocol != UnknownProtocol);

	if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
	return;
	}

	std::unique_ptr<ImportJob> job = get_import_job(protocol);
	if (!job.get()) {
	nonWorkingProtocols.push_back(protocol);
	error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.", Formatting::displayName(protocol)),
	i18n("Certificate Import Failed"));
	addImportResult({id, protocol, ImportType::Local, ImportResult{}, AuditLogEntry{}});
	return;
	}

	keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();

	std::vector<QMetaObject::Connection> connections = {
	connect(job.get(),
	&AbstractImportJob::result,
	q,
	[this](const GpgME::ImportResult &result) {
	onImportResult(result);
	}),
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &Command::progress),
	-#else
	- connect(job.get(), &QGpgME::Job::progress,
	- q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
	-#endif
	};

	-#if QGPGME_SUPPORTS_IMPORT_WITH_FILTER
	job->setImportFilter(options.importFilter);
	-#endif
	-#if QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN
	job->setKeyOrigin(options.keyOrigin, options.keyOriginUrl);
	-#endif
	-#if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	const GpgME::Error err = job->startLater(data);
	-#else
	- const GpgME::Error err = job->start(data);
	-#endif
	if (err.code()) {
	addImportResult({id, protocol, ImportType::Local, ImportResult{err}, AuditLogEntry{}});
	} else {
	increaseProgressMaximum();
	-#if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	pendingJobs.push({id, protocol, ImportType::Local, job.release(), connections});
	-#else
	- runningJobs.push_back({id, protocol, ImportType::Local, job.release(), connections});
	-#endif
	}
	}

	static std::unique_ptr<ImportFromKeyserverJob> get_import_from_keyserver_job(GpgME::Protocol protocol)
	{
	Q_ASSERT(protocol != UnknownProtocol);
	if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
	return std::unique_ptr<ImportFromKeyserverJob>(backend->importFromKeyserverJob());
	} else {
	return std::unique_ptr<ImportFromKeyserverJob>();
	}
	}

	void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const std::vector<Key> &keys, const QString &id)
	{
	Q_ASSERT(protocol != UnknownProtocol);

	if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
	return;
	}

	std::unique_ptr<ImportFromKeyserverJob> job = get_import_from_keyserver_job(protocol);
	if (!job.get()) {
	nonWorkingProtocols.push_back(protocol);
	error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.", Formatting::displayName(protocol)),
	i18n("Certificate Import Failed"));
	addImportResult({id, protocol, ImportType::External, ImportResult{}, AuditLogEntry{}});
	return;
	}

	keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();

	std::vector<QMetaObject::Connection> connections = {
	connect(job.get(),
	&AbstractImportJob::result,
	q,
	[this](const GpgME::ImportResult &result) {
	onImportResult(result);
	}),
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &Command::progress),
	-#else
	- connect(job.get(), &QGpgME::Job::progress,
	- q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
	-#endif
	};

	const GpgME::Error err = job->start(keys);
	if (err.code()) {
	addImportResult({id, protocol, ImportType::External, ImportResult{err}, AuditLogEntry{}});
	} else {
	increaseProgressMaximum();
	runningJobs.push_back({id, protocol, ImportType::External, job.release(), connections});
	}
	}

	static auto get_receive_keys_job(GpgME::Protocol protocol)
	{
	Q_ASSERT(protocol != UnknownProtocol);

	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	std::unique_ptr<ReceiveKeysJob> job{};
	if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
	job.reset(backend->receiveKeysJob());
	}
	return job;
	-#else
	- return std::unique_ptr<Job>{};
	-#endif
	}

	void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, [[maybe_unused]] const QStringList &keyIds, const QString &id)
	{
	Q_ASSERT(protocol != UnknownProtocol);

	auto job = get_receive_keys_job(protocol);
	if (!job.get()) {
	qCWarning(KLEOPATRA_LOG) << "Failed to get ReceiveKeysJob for protocol" << Formatting::displayName(protocol);
	addImportResult({id, protocol, ImportType::External, ImportResult{}, AuditLogEntry{}});
	return;
	}

	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();

	std::vector<QMetaObject::Connection> connections = {
	connect(job.get(),
	&AbstractImportJob::result,
	q,
	[this](const GpgME::ImportResult &result) {
	onImportResult(result);
	}),
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &Command::progress),
	-#else
	- connect(job.get(), &QGpgME::Job::progress,
	- q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
	-#endif
	};

	const GpgME::Error err = job->start(keyIds);
	if (err.code()) {
	addImportResult({id, protocol, ImportType::External, ImportResult{err}, AuditLogEntry{}});
	} else {
	increaseProgressMaximum();
	runningJobs.push_back({id, protocol, ImportType::External, job.release(), connections});
	}
	-#endif
	}

	void ImportCertificatesCommand::Private::importGroupsFromFile(const QString &filename)
	{
	increaseProgressMaximum();
	filesToImportGroupsFrom.push_back(filename);
	}

	void ImportCertificatesCommand::Private::setUpProgressDialog()
	{
	if (progressDialog) {
	return;
	}
	progressDialog = new QProgressDialog{parentWidgetOrView()};
	// use a non-modal progress dialog to avoid reentrancy problems (and crashes) if multiple jobs finish in the same event loop cycle
	// (cf. the warning for QProgressDialog::setValue() in the API documentation)
	progressDialog->setModal(false);
	progressDialog->setWindowTitle(progressWindowTitle);
	progressDialog->setLabelText(progressLabelText);
	progressDialog->setMinimumDuration(1000);
	progressDialog->setMaximum(1);
	progressDialog->setValue(0);
	connect(progressDialog, &QProgressDialog::canceled, q, &Command::cancel);
	connect(q, &Command::finished, progressDialog, [this]() {
	progressDialog->accept();
	});
	}

	void ImportCertificatesCommand::Private::setProgressWindowTitle(const QString &title)
	{
	if (progressDialog) {
	progressDialog->setWindowTitle(title);
	} else {
	progressWindowTitle = title;
	}
	}

	void ImportCertificatesCommand::Private::setProgressLabelText(const QString &text)
	{
	if (progressDialog) {
	progressDialog->setLabelText(text);
	} else {
	progressLabelText = text;
	}
	}

	void ImportCertificatesCommand::Private::increaseProgressMaximum()
	{
	setUpProgressDialog();
	progressDialog->setMaximum(progressDialog->maximum() + 1);
	qCDebug(KLEOPATRA_LOG) << __func__ << "progress:" << progressDialog->value() << "/" << progressDialog->maximum();
	}

	void ImportCertificatesCommand::Private::increaseProgressValue()
	{
	progressDialog->setValue(progressDialog->value() + 1);
	qCDebug(KLEOPATRA_LOG) << __func__ << "progress:" << progressDialog->value() << "/" << progressDialog->maximum();
	}

	void ImportCertificatesCommand::Private::setProgressToMaximum()
	{
	qCDebug(KLEOPATRA_LOG) << __func__;
	progressDialog->setValue(progressDialog->maximum());
	}

	void ImportCertificatesCommand::doCancel()
	{
	const auto jobsToCancel = d->runningJobs;
	std::for_each(std::begin(jobsToCancel), std::end(jobsToCancel), [this](const auto &job) {
	if (!job.connections.empty()) {
	// ignore jobs without connections; they are already completed
	qCDebug(KLEOPATRA_LOG) << "Canceling job" << job.job;
	job.job->slotCancel();
	d->onImportResult(ImportResult{Error::fromCode(GPG_ERR_CANCELED)}, job.job);
	}
	});
	}

	#undef d
	#undef q

	#include "importcertificatescommand.moc"
	#include "moc_importcertificatescommand.cpp"
	diff --git a/src/commands/importcertificatescommand_p.h b/src/commands/importcertificatescommand_p.h
	index 7099ab183..06e208466 100644
	--- a/src/commands/importcertificatescommand_p.h
	+++ b/src/commands/importcertificatescommand_p.h
	@@ -1,170 +1,166 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/importcertificatescommand_p.h

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2021, 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#pragma once

	#include "command_p.h"
	#include "importcertificatescommand.h"

	#include <Libkleo/AuditLogEntry>
	#include <Libkleo/KeyGroup>

	#include <gpgme++/global.h>
	#include <gpgme++/importresult.h>

	-#if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	-#include <queue>
	-#endif
	#include <map>
	+#include <queue>
	#include <vector>

	namespace GpgME
	{
	class Import;
	class KeyListResult;
	class Error;
	}

	namespace QGpgME
	{
	class Job;
	}

	namespace Kleo
	{
	class KeyCacheAutoRefreshSuspension;
	}

	class QByteArray;
	class QProgressDialog;

	enum class ImportType {
	Unknown,
	Local,
	External,
	};

	struct ImportJobData {
	QString id;
	GpgME::Protocol protocol = GpgME::UnknownProtocol;
	ImportType type = ImportType::Unknown;
	QGpgME::Job *job = nullptr;
	std::vector<QMetaObject::Connection> connections;
	};

	bool operator==(const ImportJobData &lhs, const ImportJobData &rhs);

	struct ImportResultData {
	QString id;
	GpgME::Protocol protocol = GpgME::UnknownProtocol;
	ImportType type = ImportType::Unknown;
	GpgME::ImportResult result;
	Kleo::AuditLogEntry auditLog;
	};

	struct ImportedGroup {
	enum class Status {
	New,
	Updated,
	};
	QString id;
	Kleo::KeyGroup group;
	Status status;
	};

	struct ImportOptions {
	QString importFilter;
	GpgME::Key::Origin keyOrigin = GpgME::Key::OriginUnknown;
	QString keyOriginUrl;
	};

	class Kleo::ImportCertificatesCommand::Private : public Command::Private
	{
	friend class ::Kleo::ImportCertificatesCommand;
	Kleo::ImportCertificatesCommand *q_func() const
	{
	return static_cast<ImportCertificatesCommand *>(q);
	}

	public:
	explicit Private(ImportCertificatesCommand qq, KeyListController c);
	~Private() override;

	void setWaitForMoreJobs(bool waiting);
	void setProgressWindowTitle(const QString &title);
	void setProgressLabelText(const QString &text);

	void startImport(GpgME::Protocol proto, const QByteArray &data, const QString &id = QString(), const ImportOptions &options = {});
	void startImport(GpgME::Protocol proto, const std::vector<GpgME::Key> &keys, const QString &id = QString());
	void startImport(GpgME::Protocol proto, const QStringList &keyIds, const QString &id = {});
	void onImportResult(const GpgME::ImportResult &, QGpgME::Job *job = nullptr);
	void addImportResult(const ImportResultData &result, const ImportJobData &job = ImportJobData{});

	void importGroupsFromFile(const QString &filename);

	void showError(const ImportResultData &result);

	void setImportResultProxyModel(const std::vector<ImportResultData> &results);

	bool showPleaseCertify(const GpgME::Import &imp);

	void keyListDone(const GpgME::KeyListResult &result, const std::vector<GpgME::Key> &keys, const QString &, const GpgME::Error &);

	private:
	void showDetails(const std::vector<ImportResultData> &results, const std::vector<ImportedGroup> &groups);
	void processResults();
	void tryToFinish();
	void keyCacheUpdated();
	void importGroups();
	std::set<QString> getMissingSignerKeyIds(const std::vector<ImportResultData> &results);
	void importSignerKeys(const std::set<QString> &keyIds);

	void setUpProgressDialog();
	void increaseProgressMaximum();
	void increaseProgressValue();
	void setProgressToMaximum();

	private:
	bool waitForMoreJobs = false;
	bool importingSignerKeys = false;
	std::vector<GpgME::Protocol> nonWorkingProtocols;
	-#if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
	std::queue<ImportJobData> pendingJobs;
	-#endif
	std::vector<ImportJobData> runningJobs;
	std::vector<QString> filesToImportGroupsFrom;
	std::vector<ImportResultData> results;
	std::vector<ImportedGroup> importedGroups;
	std::shared_ptr<KeyCacheAutoRefreshSuspension> keyCacheAutoRefreshSuspension;
	QMetaObject::Connection keyListConnection;

	QString progressWindowTitle;
	QString progressLabelText;
	QPointer<QProgressDialog> progressDialog;
	};

	inline Kleo::ImportCertificatesCommand::Private *Kleo::ImportCertificatesCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	inline const Kleo::ImportCertificatesCommand::Private *Kleo::ImportCertificatesCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	inline Kleo::ImportCertificatesCommand::ImportCertificatesCommand(Private *pp)
	: Command(pp)
	{
	}
	inline Kleo::ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView v, Private pp)
	: Command(v, pp)
	{
	}
	diff --git a/src/commands/lookupcertificatescommand.cpp b/src/commands/lookupcertificatescommand.cpp
	index 95bbc1d61..df5c21344 100644
	--- a/src/commands/lookupcertificatescommand.cpp
	+++ b/src/commands/lookupcertificatescommand.cpp
	@@ -1,609 +1,589 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/lookupcertificatescommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008, 2009 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "lookupcertificatescommand.h"

	#include "importcertificatescommand_p.h"

	#include "detailscommand.h"

	#include <settings.h>

	#include "view/tabwidget.h"

	#include <Libkleo/Compat>
	#include <Libkleo/Debug>
	#include <Libkleo/GnuPG>

	#include <dialogs/lookupcertificatesdialog.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Formatting>
	#include <Libkleo/Stl_Util>

	#include <QGpgME/Debug>
	#include <QGpgME/ImportFromKeyserverJob>
	#include <QGpgME/KeyListJob>
	#include <QGpgME/Protocol>
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	#include <QGpgME/WKDLookupJob>
	#include <QGpgME/WKDLookupResult>
	-#endif

	#include <gpgme++/data.h>
	#include <gpgme++/importresult.h>
	#include <gpgme++/key.h>
	#include <gpgme++/keylistresult.h>

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

	#include <QRegularExpression>

	#include <algorithm>
	#include <map>
	#include <set>
	#include <vector>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Dialogs;
	using namespace GpgME;
	using namespace QGpgME;

	class LookupCertificatesCommand::Private : public ImportCertificatesCommand::Private
	{
	friend class ::Kleo::Commands::LookupCertificatesCommand;
	LookupCertificatesCommand *q_func() const
	{
	return static_cast<LookupCertificatesCommand *>(q);
	}

	public:
	explicit Private(LookupCertificatesCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotSearchTextChanged(const QString &str);
	void slotNextKey(const Key &key);
	void slotKeyListResult(const KeyListResult &result);
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	void slotWKDLookupResult(const WKDLookupResult &result);
	-#endif
	void tryToFinishKeyLookup();
	void slotImportRequested(const std::vector<Key> &keys);
	void slotDetailsRequested(const Key &key);
	void slotSaveAsRequested(const std::vector<Key> &keys);
	void slotDialogRejected()
	{
	canceled();
	}

	private:
	using ImportCertificatesCommand::Private::showError;
	void showError(QWidget *parent, const KeyListResult &result);
	void showResult(QWidget *parent, const KeyListResult &result);
	void createDialog();
	KeyListJob *createKeyListJob(GpgME::Protocol proto) const
	{
	const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	return cbp ? cbp->keyListJob(true) : nullptr;
	}
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	WKDLookupJob *createWKDLookupJob() const
	{
	const auto cbp = QGpgME::openpgp();
	return cbp ? cbp->wkdLookupJob() : nullptr;
	}
	-#endif
	ImportFromKeyserverJob *createImportJob(GpgME::Protocol proto) const
	{
	const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	return cbp ? cbp->importFromKeyserverJob() : nullptr;
	}
	void startKeyListJob(GpgME::Protocol proto, const QString &str);
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	void startWKDLookupJob(const QString &str);
	-#endif
	bool checkConfig() const;

	QWidget *dialogOrParentWidgetOrView() const
	{
	if (dialog) {
	return dialog;
	} else {
	return parentWidgetOrView();
	}
	}

	private:
	GpgME::Protocol protocol = GpgME::UnknownProtocol;
	QString query;
	bool autoStartLookup = false;
	QPointer<LookupCertificatesDialog> dialog;
	struct KeyListingVariables {
	QPointer<KeyListJob> cms, openpgp;
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	QPointer<WKDLookupJob> wkdJob;
	-#endif
	QString pattern;
	KeyListResult result;
	std::vector<Key> keys;
	int numKeysWithoutUserId = 0;
	std::set<std::string> wkdKeyFingerprints;
	QByteArray wkdKeyData;
	QString wkdSource;
	bool cmsKeysHaveNoFingerprints = false;
	bool openPgpKeysHaveNoFingerprints = false;

	void reset()
	{
	*this = KeyListingVariables();
	}
	} keyListing;
	};

	LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	LookupCertificatesCommand::Private::Private(LookupCertificatesCommand qq, KeyListController c)
	: ImportCertificatesCommand::Private(qq, c)
	, dialog()
	{
	if (!Settings{}.cmsEnabled()) {
	protocol = GpgME::OpenPGP;
	}
	}

	LookupCertificatesCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	delete dialog;
	}

	LookupCertificatesCommand::LookupCertificatesCommand(KeyListController *c)
	: ImportCertificatesCommand(new Private(this, c))
	{
	d->init();
	}

	LookupCertificatesCommand::LookupCertificatesCommand(const QString &query, KeyListController *c)
	: ImportCertificatesCommand(new Private(this, c))
	{
	d->init();
	d->query = query;
	d->autoStartLookup = true;
	}

	LookupCertificatesCommand::LookupCertificatesCommand(QAbstractItemView v, KeyListController c)
	: ImportCertificatesCommand(v, new Private(this, c))
	{
	d->init();
	if (c->tabWidget()) {
	d->query = c->tabWidget()->stringFilter();
	// do not start the lookup automatically to prevent unwanted leaking
	// of information
	}
	}

	void LookupCertificatesCommand::Private::init()
	{
	}

	LookupCertificatesCommand::~LookupCertificatesCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	void LookupCertificatesCommand::setProtocol(GpgME::Protocol protocol)
	{
	d->protocol = protocol;
	}

	GpgME::Protocol LookupCertificatesCommand::protocol() const
	{
	return d->protocol;
	}

	void LookupCertificatesCommand::doStart()
	{
	if (!d->checkConfig()) {
	d->finished();
	return;
	}

	d->createDialog();
	Q_ASSERT(d->dialog);

	// if we have a prespecified query, load it into find field
	// and start the search, if auto-start is enabled
	if (!d->query.isEmpty()) {
	d->dialog->setSearchText(d->query);
	if (d->autoStartLookup) {
	d->slotSearchTextChanged(d->query);
	}
	} else {
	d->dialog->setPassive(false);
	}

	d->dialog->show();
	}

	void LookupCertificatesCommand::Private::createDialog()
	{
	if (dialog) {
	return;
	}
	dialog = new LookupCertificatesDialog;
	applyWindowID(dialog);
	dialog->setAttribute(Qt::WA_DeleteOnClose);
	connect(dialog, &LookupCertificatesDialog::searchTextChanged, q, [this](const QString &text) {
	slotSearchTextChanged(text);
	});
	using CertsVec = std::vector<GpgME::Key>;
	connect(dialog, &LookupCertificatesDialog::saveAsRequested, q, [this](const CertsVec &certs) {
	slotSaveAsRequested(certs);
	});
	connect(dialog, &LookupCertificatesDialog::importRequested, q, [this](const CertsVec &certs) {
	slotImportRequested(certs);
	});
	connect(dialog, &LookupCertificatesDialog::detailsRequested, q, [this](const GpgME::Key &gpgKey) {
	slotDetailsRequested(gpgKey);
	});
	connect(dialog, &QDialog::rejected, q, [this]() {
	slotDialogRejected();
	});
	}

	static auto searchTextToEmailAddress(const QString &s)
	{
	return QString::fromStdString(UserID::addrSpecFromString(s.toStdString().c_str()));
	}

	void LookupCertificatesCommand::Private::slotSearchTextChanged(const QString &str)
	{
	// pressing return might trigger both search and dialog destruction (search focused and default key set)
	// On Windows, the dialog is then destroyed before this slot is called
	if (dialog) { // thus test
	dialog->setPassive(true);
	dialog->setCertificates(std::vector<Key>());
	dialog->showInformation({});
	}

	query = str;

	keyListing.reset();
	keyListing.pattern = str;

	if (protocol != GpgME::OpenPGP) {
	startKeyListJob(CMS, str);
	}

	if (protocol != GpgME::CMS) {
	static const QRegularExpression rx(QRegularExpression::anchoredPattern(QLatin1String("(?:0x\|0X)?[0-9a-fA-F]{6,}")));
	if (rx.match(query).hasMatch() && !str.startsWith(QLatin1String("0x"), Qt::CaseInsensitive)) {
	qCDebug(KLEOPATRA_LOG) << "Adding 0x prefix to query";
	startKeyListJob(OpenPGP, QStringLiteral("0x") + str);
	} else {
	startKeyListJob(OpenPGP, str);
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	if (str.contains(QLatin1Char{'@'}) && !searchTextToEmailAddress(str).isEmpty()) {
	startWKDLookupJob(str);
	}
	-#endif
	}
	}
	}

	void LookupCertificatesCommand::Private::startKeyListJob(GpgME::Protocol proto, const QString &str)
	{
	KeyListJob *const klj = createKeyListJob(proto);
	if (!klj) {
	return;
	}
	connect(klj, &QGpgME::KeyListJob::result, q, [this](const GpgME::KeyListResult &result) {
	slotKeyListResult(result);
	});
	connect(klj, &QGpgME::KeyListJob::nextKey, q, [this](const GpgME::Key &key) {
	slotNextKey(key);
	});
	if (const Error err = klj->start(QStringList(str))) {
	keyListing.result.mergeWith(KeyListResult(err));
	} else if (proto == CMS) {
	keyListing.cms = klj;
	} else {
	keyListing.openpgp = klj;
	}
	}

	-#if QGPGME_SUPPORTS_WKDLOOKUP
	void LookupCertificatesCommand::Private::startWKDLookupJob(const QString &str)
	{
	const auto job = createWKDLookupJob();
	if (!job) {
	qCDebug(KLEOPATRA_LOG) << "Failed to create WKDLookupJob";
	return;
	}
	connect(job, &WKDLookupJob::result, q, [this](const WKDLookupResult &result) {
	slotWKDLookupResult(result);
	});
	if (const Error err = job->start(str)) {
	keyListing.result.mergeWith(KeyListResult{err});
	} else {
	keyListing.wkdJob = job;
	}
	}
	-#endif

	void LookupCertificatesCommand::Private::slotNextKey(const Key &key)
	{
	if (!key.primaryFingerprint()) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "ignoring key without fingerprint" << key;
	if (q->sender() == keyListing.cms) {
	keyListing.cmsKeysHaveNoFingerprints = true;
	} else if (q->sender() == keyListing.openpgp) {
	keyListing.openPgpKeysHaveNoFingerprints = true;
	}
	} else if (key.numUserIDs() == 0) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "ignoring key without user IDs" << key;
	keyListing.numKeysWithoutUserId++;
	} else {
	qCDebug(KLEOPATRA_LOG) << __func__ << "got key" << key;
	keyListing.keys.push_back(key);
	}
	}

	void LookupCertificatesCommand::Private::slotKeyListResult(const KeyListResult &r)
	{
	if (q->sender() == keyListing.cms) {
	keyListing.cms = nullptr;
	} else if (q->sender() == keyListing.openpgp) {
	keyListing.openpgp = nullptr;
	} else {
	qCDebug(KLEOPATRA_LOG) << "unknown sender()" << q->sender();
	}

	keyListing.result.mergeWith(r);

	tryToFinishKeyLookup();
	}

	-#if QGPGME_SUPPORTS_WKDLOOKUP
	static auto removeKeysNotMatchingEmail(const std::vector<Key> &keys, const std::string &email)
	{
	std::vector<Key> filteredKeys;

	const auto addrSpec = UserID::addrSpecFromString(email.c_str());
	std::copy_if(std::begin(keys), std::end(keys), std::back_inserter(filteredKeys), [addrSpec](const auto &key) {
	const auto uids = key.userIDs();
	return std::any_of(std::begin(uids), std::end(uids), [addrSpec](const auto &uid) {
	return uid.addrSpec() == addrSpec;
	});
	});

	return filteredKeys;
	}

	void LookupCertificatesCommand::Private::slotWKDLookupResult(const WKDLookupResult &result)
	{
	if (q->sender() == keyListing.wkdJob) {
	keyListing.wkdJob = nullptr;
	} else {
	qCDebug(KLEOPATRA_LOG) << __func__ << "unknown sender()" << q->sender();
	}

	// we do not want to bother the user with errors during the WKD lookup;
	// therefore, we log the result, but we do not merge it into keyListing.result
	qCDebug(KLEOPATRA_LOG) << "Result of WKD lookup:" << result.error();

	const auto keys = removeKeysNotMatchingEmail(result.keyData().toKeys(GpgME::OpenPGP), result.pattern());
	if (!keys.empty()) {
	keyListing.wkdKeyData = QByteArray::fromStdString(result.keyData().toString());
	keyListing.wkdSource = QString::fromStdString(result.source());
	std::copy(std::begin(keys), std::end(keys), std::back_inserter(keyListing.keys));
	// remember the keys retrieved via WKD for import
	std::transform(std::begin(keys),
	std::end(keys),
	std::inserter(keyListing.wkdKeyFingerprints, std::begin(keyListing.wkdKeyFingerprints)),
	[](const auto &k) {
	return k.primaryFingerprint();
	});
	}

	tryToFinishKeyLookup();
	}
	-#endif

	namespace
	{
	void showKeysWithoutFingerprintsNotification(QWidget *parent, GpgME::Protocol protocol)
	{
	if (protocol != GpgME::CMS && protocol != GpgME::OpenPGP) {
	return;
	}

	QString message;
	if (protocol == GpgME::CMS) {
	message = xi18nc("@info",
	"<para>One of the X.509 directory services returned certificates without "
	"fingerprints. Those certificates are ignored because fingerprints "
	"are required as unique identifiers for certificates.</para>"
	"<para>You may want to configure a different X.509 directory service "
	"in the configuration dialog.</para>");
	} else {
	message = xi18nc("@info",
	"<para>The OpenPGP keyserver returned certificates without "
	"fingerprints. Those certificates are ignored because fingerprints "
	"are required as unique identifiers for certificates.</para>"
	"<para>You may want to configure a different OpenPGP keyserver "
	"in the configuration dialog.</para>");
	}
	KMessageBox::information(parent, message, i18nc("@title", "Invalid Server Reply"), QStringLiteral("certificates-lookup-missing-fingerprints"));
	}
	}

	void LookupCertificatesCommand::Private::tryToFinishKeyLookup()
	{
	- if (keyListing.cms \|\| keyListing.openpgp
	-#if QGPGME_SUPPORTS_WKDLOOKUP
	- \|\| keyListing.wkdJob
	-#endif
	- ) {
	+ if (keyListing.cms \|\| keyListing.openpgp \|\| keyListing.wkdJob) {
	// still waiting for jobs to complete
	return;
	}

	if (keyListing.result.error() && !keyListing.result.error().isCanceled()) {
	showError(dialog, keyListing.result);
	}

	if (keyListing.result.isTruncated()) {
	showResult(dialog, keyListing.result);
	}

	if (keyListing.cmsKeysHaveNoFingerprints) {
	showKeysWithoutFingerprintsNotification(dialog, GpgME::CMS);
	}
	if (keyListing.openPgpKeysHaveNoFingerprints) {
	showKeysWithoutFingerprintsNotification(dialog, GpgME::OpenPGP);
	}

	if (dialog) {
	dialog->setPassive(false);
	dialog->setCertificates(keyListing.keys);
	if (keyListing.numKeysWithoutUserId > 0) {
	dialog->showInformation(i18ncp("@info",
	"One certificate without name and email address was ignored.",
	"%1 certificates without name and email address were ignored.",
	keyListing.numKeysWithoutUserId));
	}
	} else {
	finished();
	}
	}

	void LookupCertificatesCommand::Private::slotImportRequested(const std::vector<Key> &keys)
	{
	dialog = nullptr;

	Q_ASSERT(!keys.empty());
	Q_ASSERT(std::none_of(keys.cbegin(), keys.cend(), [](const Key &key) {
	return key.isNull();
	}));

	std::vector<Key> wkdKeys, otherKeys;
	otherKeys.reserve(keys.size());
	kdtools::separate_if(std::begin(keys), std::end(keys), std::back_inserter(wkdKeys), std::back_inserter(otherKeys), [this](const auto &key) {
	return key.primaryFingerprint() && keyListing.wkdKeyFingerprints.find(key.primaryFingerprint()) != std::end(keyListing.wkdKeyFingerprints);
	});

	std::vector<Key> pgp, cms;
	pgp.reserve(otherKeys.size());
	cms.reserve(otherKeys.size());
	kdtools::separate_if(otherKeys.begin(), otherKeys.end(), std::back_inserter(pgp), std::back_inserter(cms), [](const Key &key) {
	return key.protocol() == GpgME::OpenPGP;
	});

	setWaitForMoreJobs(true);
	if (!wkdKeys.empty()) {
	// set an import filter, so that only user IDs matching the email address used for the WKD lookup are imported
	const QString importFilter = QLatin1String{"keep-uid=mbox = "} + searchTextToEmailAddress(keyListing.pattern);
	startImport(OpenPGP, keyListing.wkdKeyData, keyListing.wkdSource, {importFilter, Key::OriginWKD, keyListing.wkdSource});
	}
	if (!pgp.empty()) {
	startImport(OpenPGP, pgp, i18nc(R"(@title %1:"OpenPGP" or "S/MIME")", "%1 Certificate Server", Formatting::displayName(OpenPGP)));
	}
	if (!cms.empty()) {
	startImport(CMS, cms, i18nc(R"(@title %1:"OpenPGP" or "S/MIME")", "%1 Certificate Server", Formatting::displayName(CMS)));
	}
	setWaitForMoreJobs(false);
	}

	void LookupCertificatesCommand::Private::slotSaveAsRequested(const std::vector<Key> &keys)
	{
	Q_UNUSED(keys)
	qCDebug(KLEOPATRA_LOG) << "not implemented";
	}

	void LookupCertificatesCommand::Private::slotDetailsRequested(const Key &key)
	{
	Command *const cmd = new DetailsCommand(key);
	cmd->setParentWidget(dialogOrParentWidgetOrView());
	cmd->start();
	}

	void LookupCertificatesCommand::doCancel()
	{
	ImportCertificatesCommand::doCancel();
	if (QDialog *const dlg = d->dialog) {
	d->dialog = nullptr;
	dlg->close();
	}
	}

	void LookupCertificatesCommand::Private::showError(QWidget *parent, const KeyListResult &result)
	{
	if (!result.error()) {
	return;
	}
	KMessageBox::information(parent,
	i18nc("@info", "Failed to search on certificate server. The error returned was:\n%1", Formatting::errorAsString(result.error())));
	}

	void LookupCertificatesCommand::Private::showResult(QWidget *parent, const KeyListResult &result)
	{
	if (result.isTruncated())
	KMessageBox::information(parent,
	xi18nc("@info",
	"<para>The query result has been truncated.</para>"
	"<para>Either the local or a remote limit on "
	"the maximum number of returned hits has "
	"been exceeded.</para>"
	"<para>You can try to increase the local limit "
	"in the configuration dialog, but if one "
	"of the configured servers is the limiting "
	"factor, you have to refine your search.</para>"),
	i18nc("@title", "Result Truncated"),
	QStringLiteral("lookup-certificates-truncated-result"));
	}

	bool LookupCertificatesCommand::Private::checkConfig() const
	{
	const bool haveOrDontNeedOpenPGPServer = haveKeyserverConfigured() \|\| (protocol == GpgME::CMS);
	const bool haveOrDontNeedCMSServer = haveX509DirectoryServerConfigured() \|\| (protocol == GpgME::OpenPGP);
	const bool ok = haveOrDontNeedOpenPGPServer \|\| haveOrDontNeedCMSServer;
	if (!ok)
	information(xi18nc("@info",
	"<para>You do not have any directory servers configured.</para>"
	"<para>You need to configure at least one directory server to "
	"search on one.</para>"
	"<para>You can configure directory servers here: "
	"<interface>Settings->Configure Kleopatra</interface>.</para>"),
	i18nc("@title", "No Directory Servers Configured"));
	return ok;
	}

	#undef d
	#undef q

	#include "moc_lookupcertificatescommand.cpp"
	diff --git a/src/commands/refreshcertificatecommand.cpp b/src/commands/refreshcertificatecommand.cpp
	index 2ebf4d5ce..46af5f0eb 100644
	--- a/src/commands/refreshcertificatecommand.cpp
	+++ b/src/commands/refreshcertificatecommand.cpp
	@@ -1,416 +1,389 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/refreshcertificatecommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "command_p.h"
	#include "refreshcertificatecommand.h"
	#include <settings.h>

	#include <Libkleo/Formatting>

	#include <KLocalizedString>
	#include <KMessageBox>

	#include <QGpgME/Protocol>
	-#if QGPGME_SUPPORTS_KEY_REFRESH
	#include <QGpgME/ReceiveKeysJob>
	#include <QGpgME/RefreshKeysJob>
	-#endif
	#if QGPGME_SUPPORTS_WKD_REFRESH_JOB
	#include <QGpgME/WKDRefreshJob>
	#endif

	#include <gpgme++/importresult.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace GpgME;

	class RefreshCertificateCommand::Private : public Command::Private
	{
	friend class ::RefreshCertificateCommand;
	RefreshCertificateCommand *q_func() const
	{
	return static_cast<RefreshCertificateCommand *>(q);
	}

	public:
	explicit Private(RefreshCertificateCommand *qq);
	~Private() override;

	void start();
	void cancel();

	-#if QGPGME_SUPPORTS_KEY_REFRESH
	std::unique_ptr<QGpgME::ReceiveKeysJob> startReceiveKeysJob();
	std::unique_ptr<QGpgME::RefreshKeysJob> startSMIMEJob();
	-#endif
	#if QGPGME_SUPPORTS_WKD_REFRESH_JOB
	std::unique_ptr<QGpgME::WKDRefreshJob> startWKDRefreshJob();
	#endif
	void onReceiveKeysJobResult(const ImportResult &result);
	void onWKDRefreshJobResult(const ImportResult &result);
	void onSMIMEJobResult(const Error &err);
	void showOpenPGPResult();
	void showError(const Error &err);

	private:
	Key key;
	-#if QGPGME_SUPPORTS_KEY_REFRESH
	QPointer<QGpgME::Job> job;
	-#endif
	ImportResult receiveKeysResult;
	ImportResult wkdRefreshResult;
	};

	RefreshCertificateCommand::Private *RefreshCertificateCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const RefreshCertificateCommand::Private *RefreshCertificateCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	RefreshCertificateCommand::Private::Private(RefreshCertificateCommand *qq)
	: Command::Private{qq}
	{
	}

	RefreshCertificateCommand::Private::~Private() = default;

	namespace
	{
	Key getKey(const std::vector<Key> &keys)
	{
	if (keys.size() != 1) {
	qCWarning(KLEOPATRA_LOG) << "Expected exactly one key, but got" << keys.size();
	return {};
	}
	const Key key = keys.front();
	if (key.protocol() == GpgME::UnknownProtocol) {
	qCWarning(KLEOPATRA_LOG) << "Key has unknown protocol";
	return {};
	}
	return key;
	}
	}

	void RefreshCertificateCommand::Private::start()
	{
	key = getKey(keys());
	if (key.isNull()) {
	finished();
	return;
	}

	-#if QGPGME_SUPPORTS_KEY_REFRESH
	std::unique_ptr<QGpgME::Job> refreshJob;
	switch (key.protocol()) {
	case GpgME::OpenPGP:
	refreshJob = startReceiveKeysJob();
	break;
	case GpgME::CMS:
	refreshJob = startSMIMEJob();
	break;
	default:; // cannot happen ;-)
	}
	if (!refreshJob) {
	finished();
	return;
	}
	job = refreshJob.release();
	-#else
	- error(i18n("The backend does not support updating individual certificates."));
	- finished();
	-#endif
	}

	void RefreshCertificateCommand::Private::cancel()
	{
	-#if QGPGME_SUPPORTS_KEY_REFRESH
	if (job) {
	job->slotCancel();
	}
	job.clear();
	-#endif
	}

	-#if QGPGME_SUPPORTS_KEY_REFRESH
	std::unique_ptr<QGpgME::ReceiveKeysJob> RefreshCertificateCommand::Private::startReceiveKeysJob()
	{
	std::unique_ptr<QGpgME::ReceiveKeysJob> refreshJob{QGpgME::openpgp()->receiveKeysJob()};
	Q_ASSERT(refreshJob);

	connect(refreshJob.get(), &QGpgME::ReceiveKeysJob::result, q, [this](const GpgME::ImportResult &result) {
	onReceiveKeysJobResult(result);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(refreshJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(refreshJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const GpgME::Error err = refreshJob->start({QString::fromLatin1(key.primaryFingerprint())});
	if (err) {
	showError(err);
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Updating key..."));

	return refreshJob;
	}

	std::unique_ptr<QGpgME::RefreshKeysJob> RefreshCertificateCommand::Private::startSMIMEJob()
	{
	std::unique_ptr<QGpgME::RefreshKeysJob> refreshJob{QGpgME::smime()->refreshKeysJob()};
	Q_ASSERT(refreshJob);

	connect(refreshJob.get(), &QGpgME::RefreshKeysJob::result, q, [this](const GpgME::Error &err) {
	onSMIMEJobResult(err);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(refreshJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(refreshJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const GpgME::Error err = refreshJob->start({key});
	if (err) {
	showError(err);
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Updating certificate..."));

	return refreshJob;
	}
	-#endif

	#if QGPGME_SUPPORTS_WKD_REFRESH_JOB
	std::unique_ptr<QGpgME::WKDRefreshJob> RefreshCertificateCommand::Private::startWKDRefreshJob()
	{
	if (!Settings{}.queryWKDsForAllUserIDs()) {
	// check if key is eligible for WKD refresh, i.e. if any user ID has WKD as origin
	const auto userIds = key.userIDs();
	const auto eligibleForWKDRefresh = std::any_of(userIds.begin(), userIds.end(), [](const auto &userId) {
	return !userId.isRevoked() && !userId.addrSpec().empty() && userId.origin() == Key::OriginWKD;
	});
	if (!eligibleForWKDRefresh) {
	wkdRefreshResult = ImportResult{Error::fromCode(GPG_ERR_USER_1)};
	return {};
	}
	}

	std::unique_ptr<QGpgME::WKDRefreshJob> refreshJob{QGpgME::openpgp()->wkdRefreshJob()};
	Q_ASSERT(refreshJob);

	connect(refreshJob.get(), &QGpgME::WKDRefreshJob::result, q, [this](const GpgME::ImportResult &result) {
	onWKDRefreshJobResult(result);
	});
	connect(refreshJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);

	Error err;
	if (Settings{}.queryWKDsForAllUserIDs()) {
	err = refreshJob->start(key.userIDs());
	} else {
	err = refreshJob->start({key});
	}
	if (err) {
	wkdRefreshResult = ImportResult{err};
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Updating key..."));

	return refreshJob;
	}
	#endif

	namespace
	{
	static auto informationOnChanges(const ImportResult &result)
	{
	QString text;

	// if additional keys have been retrieved via WKD, then most of the below
	// details are just a guess and may concern the additional keys instead of
	// the refresh keys; this could only be clarified by a thorough comparison of
	// unrefreshed and refreshed key

	if (result.numUnchanged() == result.numConsidered()) {
	// if numUnchanged < numConsidered, then it is not clear whether the refreshed key
	// hasn't changed or whether another key retrieved via WKD hasn't changed
	text = i18n("The key hasn't changed.");
	} else if (result.newRevocations() > 0) {
	// it is possible that a revoked key has been newly imported via WKD,
	// but it is much more likely that the refreshed key was revoked
	text = i18n("The key has been revoked.");
	} else {
	// it doesn't make much sense to list below details if the key has been revoked
	text = i18n("The key has been updated.");

	QStringList details;
	if (result.newUserIDs() > 0) {
	details.push_back(i18n("New user IDs: %1", result.newUserIDs()));
	}
	if (result.newSubkeys() > 0) {
	details.push_back(i18n("New subkeys: %1", result.newSubkeys()));
	}
	if (result.newSignatures() > 0) {
	details.push_back(i18n("New signatures: %1", result.newSignatures()));
	}
	if (!details.empty()) {
	text += QLatin1String{"<br><br>"} + details.join(QLatin1String{"<br>"});
	}
	}

	text = QLatin1String{"<p>"} + text + QLatin1String{"</p>"};
	if (result.numImported() > 0) {
	text += QLatin1String{"<p>"}
	+ i18np("Additionally, one new key has been retrieved.", "Additionally, %1 new keys have been retrieved.", result.numImported())
	+ QLatin1String{"</p>"};
	}

	return text;
	}

	}

	void RefreshCertificateCommand::Private::onReceiveKeysJobResult(const ImportResult &result)
	{
	receiveKeysResult = result;

	if (result.error().isCanceled()) {
	finished();
	return;
	}

	#if QGPGME_SUPPORTS_WKD_REFRESH_JOB
	std::unique_ptr<QGpgME::Job> refreshJob = startWKDRefreshJob();
	if (!refreshJob) {
	showOpenPGPResult();
	return;
	}
	job = refreshJob.release();
	#else
	if (result.error()) {
	showError(result.error());
	} else {
	information(informationOnChanges(result), i18nc("@title:window", "Key Updated"));
	}

	finished();
	#endif
	}

	void RefreshCertificateCommand::Private::onWKDRefreshJobResult(const ImportResult &result)
	{
	wkdRefreshResult = result;

	showOpenPGPResult();
	}

	void RefreshCertificateCommand::Private::onSMIMEJobResult(const Error &err)
	{
	if (err) {
	showError(err);
	finished();
	return;
	}

	if (!err.isCanceled()) {
	information(i18nc("@info", "The certificate has been updated."), i18nc("@title:window", "Certificate Updated"));
	}
	finished();
	}

	void RefreshCertificateCommand::Private::showOpenPGPResult()
	{
	if (wkdRefreshResult.error().code() == GPG_ERR_USER_1 \|\| wkdRefreshResult.error().isCanceled()) {
	if (receiveKeysResult.error()) {
	showError(receiveKeysResult.error());
	} else {
	information(informationOnChanges(receiveKeysResult), i18nc("@title:window", "Key Updated"));
	}
	finished();
	return;
	}

	if (receiveKeysResult.error() && wkdRefreshResult.error()) {
	error(xi18nc("@info",
	"<para>Updating the certificate from a keyserver, an LDAP server, or Active Directory failed:</para>"
	"<para><message>%1</message></para>"
	"<para>Updating the certificate via Web Key Directory failed:</para>"
	"<para><message>%2</message></para>",
	Formatting::errorAsString(receiveKeysResult.error()),
	Formatting::errorAsString(wkdRefreshResult.error())),
	i18nc("@title:window", "Update Failed"));
	finished();
	return;
	}

	QString text;
	text += QLatin1String{"<p><strong>"} + i18nc("@info", "Result of update from keyserver, LDAP server, or Active Directory") + QLatin1String{"</strong></p>"};
	if (receiveKeysResult.error()) {
	text += xi18nc("@info", "<para>The update failed: <message>%1</message></para>", Formatting::errorAsString(receiveKeysResult.error()));
	} else {
	text += informationOnChanges(receiveKeysResult);
	}

	text += QLatin1String{"<p><strong>"} + i18nc("@info", "Result of update via Web Key Directory") + QLatin1String{"</strong></p>"};
	if (wkdRefreshResult.error()) {
	text += xi18nc("@info", "<para>The update failed: <message>%1</message></para>", Formatting::errorAsString(wkdRefreshResult.error()));
	} else {
	text += informationOnChanges(wkdRefreshResult);
	}

	information(text, i18nc("@title:window", "Key Updated"));

	finished();
	}

	void RefreshCertificateCommand::Private::showError(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred while updating the certificate:</para>"
	"<para><message>%1</message></para>",
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Update Failed"));
	}

	RefreshCertificateCommand::RefreshCertificateCommand(const GpgME::Key &key)
	: Command{key, new Private{this}}
	{
	}

	RefreshCertificateCommand::~RefreshCertificateCommand() = default;

	void RefreshCertificateCommand::doStart()
	{
	d->start();
	}

	void RefreshCertificateCommand::doCancel()
	{
	d->cancel();
	}

	#undef d
	#undef q

	#include "moc_refreshcertificatecommand.cpp"
	diff --git a/src/commands/revokecertificationcommand.cpp b/src/commands/revokecertificationcommand.cpp
	index fd94024cf..4b341663d 100644
	--- a/src/commands/revokecertificationcommand.cpp
	+++ b/src/commands/revokecertificationcommand.cpp
	@@ -1,366 +1,360 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/revokecertificationcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2020, 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "revokecertificationcommand.h"

	#include "command_p.h"

	#include "exportopenpgpcertstoservercommand.h"

	#include <kleopatra_debug.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyHelpers>

	#include <KGuiItem>
	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KStandardGuiItem>

	#include <QGpgME/Protocol>
	#include <QGpgME/QuickJob>

	#include <gpgme++/engineinfo.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;
	using namespace QGpgME;

	namespace
	{

	enum class InputType {
	Key,
	UserIDs,
	Certifications,
	};

	struct CertificationData {
	UserID userId;
	Key certificationKey;
	};

	static std::vector<Key> getCertificationKeys(const GpgME::UserID &userId)
	{
	std::vector<Key> keys;
	if (userId.numSignatures() == 0) {
	qCWarning(KLEOPATRA_LOG) << __func__ << "- Error: Signatures of user ID" << QString::fromUtf8(userId.id()) << "not available";
	return keys;
	}
	std::vector<GpgME::UserID::Signature> revokableCertifications;
	Kleo::copy_if(userId.signatures(), std::back_inserter(revokableCertifications), [](const auto &certification) {
	return userCanRevokeCertification(certification) == CertificationCanBeRevoked;
	});
	Kleo::transform(revokableCertifications, std::back_inserter(keys), [](const auto &certification) {
	return KeyCache::instance()->findByKeyIDOrFingerprint(certification.signerKeyID());
	});
	return keys;
	}

	static bool confirmRevocations(QWidget *parent, const std::vector<CertificationData> &certifications)
	{
	KMessageBox::ButtonCode answer;
	if (certifications.size() == 1) {
	const auto [userId, certificationKey] = certifications.front();
	const auto message = xi18nc("@info",
	"<para>You are about to revoke the certification of user ID<nl/>%1<nl/>made with the key<nl/>%2.</para>",
	QString::fromUtf8(userId.id()),
	Formatting::formatForComboBox(certificationKey));
	answer = KMessageBox::questionTwoActions(parent,
	message,
	i18nc("@title:window", "Confirm Revocation"),
	KGuiItem{i18n("Revoke Certification")},
	KStandardGuiItem::cancel());
	} else {
	QStringList l;
	Kleo::transform(certifications, std::back_inserter(l), [](const auto &c) {
	return i18n("User ID '%1' certified with key %2", QString::fromUtf8(c.userId.id()), Formatting::formatForComboBox(c.certificationKey));
	});
	const auto message = i18np("You are about to revoke the following certification:", //
	"You are about to revoke the following %1 certifications:",
	certifications.size());
	answer = KMessageBox::questionTwoActionsList(parent,
	message,
	l,
	i18nc("@title:window", "Confirm Revocation"),
	KGuiItem{i18n("Revoke Certifications")},
	KStandardGuiItem::cancel());
	}
	return answer == KMessageBox::ButtonCode::PrimaryAction;
	}

	}

	class RevokeCertificationCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::RevokeCertificationCommand;
	RevokeCertificationCommand *q_func() const
	{
	return static_cast<RevokeCertificationCommand *>(q);
	}

	public:
	Private(InputType i, RevokeCertificationCommand qq, KeyListController c = nullptr);

	void init();

	private:
	std::vector<CertificationData> getCertificationsToRevoke();
	void scheduleNextRevocation();
	QGpgME::QuickJob *createJob();
	void slotResult(const Error &err);

	private:
	InputType inputType = InputType::Key;
	Key certificationTarget;
	std::vector<UserID> uids;
	std::vector<CertificationData> certificationsToRevoke;
	std::vector<CertificationData> completedRevocations;
	QPointer<QGpgME::QuickJob> job;
	};

	RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	RevokeCertificationCommand::Private::Private(InputType i, RevokeCertificationCommand qq, KeyListController c)
	: Command::Private{qq, c}
	, inputType{i}
	{
	}

	void RevokeCertificationCommand::Private::init()
	{
	const std::vector<Key> keys_ = keys();
	if (keys_.size() != 1) {
	qCWarning(KLEOPATRA_LOG) << q << "Expected exactly one key, but got" << keys_.size();
	return;
	}
	if (keys_.front().protocol() != GpgME::OpenPGP) {
	qCWarning(KLEOPATRA_LOG) << q << "Expected OpenPGP key, but got" << keys_.front().protocolAsString();
	return;
	}
	certificationTarget = keys_.front();
	}

	std::vector<CertificationData> RevokeCertificationCommand::Private::getCertificationsToRevoke()
	{
	if (inputType != InputType::Certifications) {
	// ensure that the certifications of the key have been loaded
	if (certificationTarget.userID(0).numSignatures() == 0) {
	certificationTarget.update();
	}

	// build list of user IDs and revokable certifications
	const auto userIDsToConsider = (inputType == InputType::Key) ? certificationTarget.userIDs() : uids;
	for (const auto &userId : userIDsToConsider) {
	Kleo::transform(getCertificationKeys(userId), std::back_inserter(certificationsToRevoke), [userId](const auto &k) {
	return CertificationData{userId, k};
	});
	}
	}

	Kleo::erase_if(certificationsToRevoke, [](const auto &c) {
	return c.certificationKey.isNull();
	});

	return certificationsToRevoke;
	}

	void RevokeCertificationCommand::Private::scheduleNextRevocation()
	{
	if (!certificationsToRevoke.empty()) {
	const auto nextCertification = certificationsToRevoke.back();
	job = createJob();
	if (!job) {
	qCWarning(KLEOPATRA_LOG) << q << "Failed to create job";
	finished();
	return;
	}
	job->startRevokeSignature(certificationTarget, nextCertification.certificationKey, {nextCertification.userId});
	} else {
	const auto message = xi18ncp("@info",
	"<para>The certification has been revoked successfully.</para>"
	"<para>Do you want to publish the revocation?</para>",
	"<para>%1 certifications have been revoked successfully.</para>"
	"<para>Do you want to publish the revocations?</para>",
	completedRevocations.size());
	const auto yesButton = KGuiItem{i18ncp("@action:button", "Publish Revocation", "Publish Revocations", completedRevocations.size()),
	QIcon::fromTheme(QStringLiteral("view-certificate-export-server"))};
	const auto answer = KMessageBox::questionTwoActions(parentWidgetOrView(),
	message,
	i18nc("@title:window", "Confirm Publication"),
	yesButton,
	KStandardGuiItem::cancel(),
	{},
	KMessageBox::Notify \| KMessageBox::Dangerous);
	if (answer == KMessageBox::ButtonCode::PrimaryAction) {
	const auto cmd = new ExportOpenPGPCertsToServerCommand{certificationTarget};
	cmd->start();
	}
	finished();
	}
	}

	void RevokeCertificationCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled()) {
	canceled();
	return;
	}

	if (err) {
	const auto failedRevocation = certificationsToRevoke.back();
	error(xi18nc("@info",
	"<para>The revocation of the certification of user ID<nl/>%1<nl/>made with key<nl/>%2<nl/>failed:</para>"
	"<para><message>%3</message></para>",
	Formatting::prettyNameAndEMail(failedRevocation.userId),
	Formatting::formatForComboBox(failedRevocation.certificationKey),
	Formatting::errorAsString(err)));
	finished();
	return;
	}

	completedRevocations.push_back(certificationsToRevoke.back());
	certificationsToRevoke.pop_back();
	scheduleNextRevocation();
	}

	QGpgME::QuickJob *RevokeCertificationCommand::Private::createJob()
	{
	const auto j = QGpgME::openpgp()->quickJob();
	if (j) {
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &QGpgME::QuickJob::result, q, [this](const GpgME::Error &error) {
	slotResult(error);
	});
	}

	return j;
	}

	RevokeCertificationCommand::RevokeCertificationCommand(QAbstractItemView v, KeyListController c)
	: Command{v, new Private{InputType::Key, this, c}}
	{
	d->init();
	}

	RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::Key &key)
	: Command{key, new Private{InputType::Key, this}}
	{
	d->init();
	}

	RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID &uid)
	: Command{uid.parent(), new Private{InputType::UserIDs, this}}
	{
	std::vector<UserID>(1, uid).swap(d->uids);
	d->init();
	}

	RevokeCertificationCommand::RevokeCertificationCommand(const std::vector<GpgME::UserID> &uids)
	: Command{uids.empty() ? Key{} : uids.front().parent(), new Private{InputType::UserIDs, this}}
	{
	d->uids = uids;
	d->init();
	}

	RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID::Signature &signature)
	: Command{signature.parent().parent(), new Private{InputType::Certifications, this}}
	{
	if (!signature.isNull()) {
	const Key certificationKey = KeyCache::instance()->findByKeyIDOrFingerprint(signature.signerKeyID());
	d->certificationsToRevoke = {{signature.parent(), certificationKey}};
	}
	d->init();
	}

	RevokeCertificationCommand::~RevokeCertificationCommand()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	}

	// static
	bool RevokeCertificationCommand::isSupported()
	{
	return engineInfo(GpgEngine).engineVersion() >= "2.2.24";
	}

	void RevokeCertificationCommand::doStart()
	{
	if (d->certificationTarget.isNull()) {
	d->finished();
	return;
	}

	if (!Kleo::all_of(d->uids, userIDBelongsToKey(d->certificationTarget))) {
	qCWarning(KLEOPATRA_LOG) << this << "User ID <-> Key mismatch!";
	d->finished();
	return;
	}

	const auto certificationsToRevoke = d->getCertificationsToRevoke();
	if (certificationsToRevoke.empty()) {
	switch (d->inputType) {
	case InputType::Key:
	d->information(i18n("You cannot revoke any certifications of this key."));
	break;
	case InputType::UserIDs:
	d->information(i18np("You cannot revoke any certifications of this user ID.", //
	"You cannot revoke any certifications of these user IDs.",
	d->uids.size()));
	break;
	case InputType::Certifications:
	d->information(i18n("You cannot revoke this certification."));
	break;
	}
	d->finished();
	return;
	}

	if (!confirmRevocations(d->parentWidgetOrView(), certificationsToRevoke)) {
	d->canceled();
	return;
	}

	d->scheduleNextRevocation();
	}

	void RevokeCertificationCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	if (d->job) {
	d->job->slotCancel();
	}
	}

	#undef d
	#undef q

	#include "moc_revokecertificationcommand.cpp"
	diff --git a/src/commands/revokekeycommand.cpp b/src/commands/revokekeycommand.cpp
	index d6645a17c..09ab3b0f6 100644
	--- a/src/commands/revokekeycommand.cpp
	+++ b/src/commands/revokekeycommand.cpp
	@@ -1,264 +1,246 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/revokekeycommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "command_p.h"
	#include "dialogs/revokekeydialog.h"
	#include "revokekeycommand.h"

	#include <Libkleo/Formatting>

	#include <KLocalizedString>

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	#include <QGpgME/RevokeKeyJob>
	-#endif

	#include "kleopatra_debug.h"
	#include <QGpgME/Protocol>

	using namespace Kleo;
	using namespace GpgME;

	class RevokeKeyCommand::Private : public Command::Private
	{
	friend class ::RevokeKeyCommand;
	RevokeKeyCommand *q_func() const
	{
	return static_cast<RevokeKeyCommand *>(q);
	}

	public:
	explicit Private(RevokeKeyCommand qq, KeyListController c = nullptr);
	~Private() override;

	void start();
	void cancel();

	private:
	void ensureDialogCreated();
	void onDialogAccepted();
	void onDialogRejected();

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	std::unique_ptr<QGpgME::RevokeKeyJob> startJob();
	-#endif
	void onJobResult(const Error &err);
	void showError(const Error &err);

	private:
	Key key;
	QPointer<RevokeKeyDialog> dialog;
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	QPointer<QGpgME::RevokeKeyJob> job;
	-#endif
	};

	RevokeKeyCommand::Private *RevokeKeyCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const RevokeKeyCommand::Private *RevokeKeyCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	RevokeKeyCommand::Private::Private(RevokeKeyCommand qq, KeyListController c)
	: Command::Private{qq, c}
	{
	}

	RevokeKeyCommand::Private::~Private() = default;

	namespace
	{
	Key getKey(const std::vector<Key> &keys)
	{
	if (keys.size() != 1) {
	qCWarning(KLEOPATRA_LOG) << "Expected exactly one key, but got" << keys.size();
	return {};
	}
	const Key key = keys.front();
	if (key.protocol() != GpgME::OpenPGP) {
	qCWarning(KLEOPATRA_LOG) << "Expected OpenPGP key, but got" << Formatting::displayName(key.protocol()) << "key";
	return {};
	}
	return key;
	}
	}

	void RevokeKeyCommand::Private::start()
	{
	key = getKey(keys());
	if (key.isNull()) {
	finished();
	return;
	}

	if (key.isRevoked()) {
	information(i18nc("@info", "This key has already been revoked."));
	finished();
	return;
	}

	ensureDialogCreated();
	Q_ASSERT(dialog);

	dialog->setKey(key);
	dialog->show();
	}

	void RevokeKeyCommand::Private::cancel()
	{
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	if (job) {
	job->slotCancel();
	}
	job.clear();
	-#endif
	}

	void RevokeKeyCommand::Private::ensureDialogCreated()
	{
	if (dialog) {
	return;
	}

	dialog = new RevokeKeyDialog;
	applyWindowID(dialog);
	dialog->setAttribute(Qt::WA_DeleteOnClose);

	connect(dialog, &QDialog::accepted, q, [this]() {
	onDialogAccepted();
	});
	connect(dialog, &QDialog::rejected, q, [this]() {
	onDialogRejected();
	});
	}

	void RevokeKeyCommand::Private::onDialogAccepted()
	{
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	auto revokeJob = startJob();
	if (!revokeJob) {
	finished();
	return;
	}
	job = revokeJob.release();
	-#endif
	}

	void RevokeKeyCommand::Private::onDialogRejected()
	{
	canceled();
	}

	namespace
	{
	std::vector<std::string> toStdStrings(const QStringList &l)
	{
	std::vector<std::string> v;
	v.reserve(l.size());
	std::transform(std::begin(l), std::end(l), std::back_inserter(v), std::mem_fn(&QString::toStdString));
	return v;
	}

	auto descriptionToLines(const QString &description)
	{
	std::vector<std::string> lines;
	if (!description.isEmpty()) {
	lines = toStdStrings(description.split(QLatin1Char('\n')));
	}
	return lines;
	}
	}

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	std::unique_ptr<QGpgME::RevokeKeyJob> RevokeKeyCommand::Private::startJob()
	{
	std::unique_ptr<QGpgME::RevokeKeyJob> revokeJob{QGpgME::openpgp()->revokeKeyJob()};
	Q_ASSERT(revokeJob);

	connect(revokeJob.get(), &QGpgME::RevokeKeyJob::result, q, [this](const GpgME::Error &err) {
	onJobResult(err);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(revokeJob.get(), &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(revokeJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif

	const auto description = descriptionToLines(dialog->description());
	const GpgME::Error err = revokeJob->start(key, dialog->reason(), description);
	if (err) {
	showError(err);
	return {};
	}
	Q_EMIT q->info(i18nc("@info:status", "Revoking key..."));

	return revokeJob;
	}
	-#endif

	void RevokeKeyCommand::Private::onJobResult(const Error &err)
	{
	if (err) {
	showError(err);
	finished();
	return;
	}

	if (!err.isCanceled()) {
	information(i18nc("@info", "The key was revoked successfully."), i18nc("@title:window", "Key Revoked"));
	}
	finished();
	}

	void RevokeKeyCommand::Private::showError(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred during the revocation:</para>"
	"<para><message>%1</message></para>",
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Revocation Failed"));
	}

	RevokeKeyCommand::RevokeKeyCommand(QAbstractItemView v, KeyListController c)
	: Command{v, new Private{this, c}}
	{
	}

	RevokeKeyCommand::RevokeKeyCommand(const GpgME::Key &key)
	: Command{key, new Private{this}}
	{
	}

	RevokeKeyCommand::~RevokeKeyCommand() = default;

	void RevokeKeyCommand::doStart()
	{
	d->start();
	}

	void RevokeKeyCommand::doCancel()
	{
	d->cancel();
	}

	#undef d
	#undef q

	#include "moc_revokekeycommand.cpp"
	diff --git a/src/commands/revokeuseridcommand.cpp b/src/commands/revokeuseridcommand.cpp
	index 99c8f2df6..760a43a52 100644
	--- a/src/commands/revokeuseridcommand.cpp
	+++ b/src/commands/revokeuseridcommand.cpp
	@@ -1,179 +1,173 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/revokeuseridcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "revokeuseridcommand.h"

	#include "command_p.h"

	#include <Libkleo/Formatting>
	#include <Libkleo/GnuPG>

	#include <KLocalizedString>

	#include <QGpgME/Protocol>
	#include <QGpgME/QuickJob>

	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;

	class RevokeUserIDCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::RevokeUserIDCommand;
	RevokeUserIDCommand *q_func() const
	{
	return static_cast<RevokeUserIDCommand *>(q);
	}

	public:
	explicit Private(RevokeUserIDCommand *qq, const UserID &userId);
	~Private() override;

	void startJob();

	private:
	void createJob();
	void slotResult(const Error &err);
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	GpgME::UserID userId;
	QPointer<QGpgME::QuickJob> job;
	};

	RevokeUserIDCommand::Private *RevokeUserIDCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const RevokeUserIDCommand::Private *RevokeUserIDCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	RevokeUserIDCommand::Private::Private(RevokeUserIDCommand *qq, const UserID &userId)
	: Command::Private{qq}
	, userId{userId}
	{
	}

	RevokeUserIDCommand::Private::~Private() = default;

	void Commands::RevokeUserIDCommand::Private::startJob()
	{
	createJob();
	if (!job) {
	finished();
	return;
	}
	const QString uidToRevoke = QString::fromUtf8(engineIsVersion(2, 3, 7) ? userId.uidhash() : userId.id());
	job->startRevUid(userId.parent(), uidToRevoke);
	}

	void RevokeUserIDCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	const auto backend = QGpgME::openpgp();
	if (!backend) {
	return;
	}

	const auto j = backend->quickJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &QGpgME::QuickJob::result, q, [this](const GpgME::Error &err) {
	slotResult(err);
	});

	job = j;
	}

	void RevokeUserIDCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled()) {
	} else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void RevokeUserIDCommand::Private::showErrorDialog(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred while trying to revoke the user ID<nl/><emphasis>%1</emphasis>.</para>"
	"<para><message>%2</message></para>",
	QString::fromUtf8(userId.id()),
	Formatting::errorAsString(err)),
	i18nc("@title:window", "Revocation Failed"));
	}

	void RevokeUserIDCommand::Private::showSuccessDialog()
	{
	information(xi18nc("@info", "<para>The user ID<nl/><emphasis>%1</emphasis><nl/>has been revoked successfully.</para>", QString::fromUtf8(userId.id())),
	i18nc("@title:window", "Revocation Succeeded"));
	}

	RevokeUserIDCommand::RevokeUserIDCommand(const GpgME::UserID &userId)
	: Command{new Private{this, userId}}
	{
	}

	RevokeUserIDCommand::~RevokeUserIDCommand()
	{
	}

	void RevokeUserIDCommand::doStart()
	{
	if (d->userId.isNull()) {
	d->finished();
	return;
	}

	const auto key = d->userId.parent();
	if (key.protocol() != GpgME::OpenPGP \|\| !key.hasSecret()) {
	d->finished();
	return;
	}

	d->startJob();
	}

	void RevokeUserIDCommand::doCancel()
	{
	if (d->job) {
	d->job->slotCancel();
	}
	}

	#undef d
	#undef q

	#include "moc_revokeuseridcommand.cpp"
	diff --git a/src/commands/setprimaryuseridcommand.cpp b/src/commands/setprimaryuseridcommand.cpp
	index df10a3431..c0abd2dea 100644
	--- a/src/commands/setprimaryuseridcommand.cpp
	+++ b/src/commands/setprimaryuseridcommand.cpp
	@@ -1,189 +1,171 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/setprimaryuseridcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "setprimaryuseridcommand.h"

	#include "command_p.h"

	#include <Libkleo/Formatting>

	#include <KLocalizedString>

	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	#include <QGpgME/SetPrimaryUserIDJob>
	-#endif

	#include <QGpgME/Protocol>
	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;

	class SetPrimaryUserIDCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::SetPrimaryUserIDCommand;
	SetPrimaryUserIDCommand *q_func() const
	{
	return static_cast<SetPrimaryUserIDCommand *>(q);
	}

	public:
	explicit Private(SetPrimaryUserIDCommand *qq, const UserID &userId);
	~Private() override;

	void startJob();

	private:
	void createJob();
	void slotResult(const Error &err);
	void showErrorDialog(const Error &error);
	void showSuccessDialog();

	private:
	GpgME::UserID userId;
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	QPointer<QGpgME::SetPrimaryUserIDJob> job;
	-#endif
	};

	SetPrimaryUserIDCommand::Private *SetPrimaryUserIDCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const SetPrimaryUserIDCommand::Private *SetPrimaryUserIDCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	SetPrimaryUserIDCommand::Private::Private(SetPrimaryUserIDCommand *qq, const UserID &userId)
	: Command::Private{qq}
	, userId{userId}
	{
	}

	SetPrimaryUserIDCommand::Private::~Private() = default;

	void Commands::SetPrimaryUserIDCommand::Private::startJob()
	{
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	createJob();
	if (!job) {
	finished();
	return;
	}
	job->start(userId);
	-#else
	- error(i18nc("@info", "The backend does not support this operation."));
	-#endif
	}

	void SetPrimaryUserIDCommand::Private::createJob()
	{
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	Q_ASSERT(!job);

	const auto backend = QGpgME::openpgp();
	if (!backend) {
	return;
	}

	const auto j = backend->setPrimaryUserIDJob();
	if (!j) {
	return;
	}

	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
	-#else
	- connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
	- Q_EMIT q->progress(current, total);
	- });
	-#endif
	connect(j, &QGpgME::SetPrimaryUserIDJob::result, q, [this](const GpgME::Error &err) {
	slotResult(err);
	});

	job = j;
	-#endif
	}

	void SetPrimaryUserIDCommand::Private::slotResult(const Error &err)
	{
	if (err.isCanceled()) {
	} else if (err) {
	showErrorDialog(err);
	} else {
	showSuccessDialog();
	}
	finished();
	}

	void SetPrimaryUserIDCommand::Private::showErrorDialog(const Error &err)
	{
	error(xi18nc("@info",
	"<para>An error occurred while trying to flag the user ID<nl/><emphasis>%1</emphasis><nl/>as the primary user ID.</para>"
	"<para><message>%2</message></para>",
	QString::fromUtf8(userId.id()),
	Formatting::errorAsString(err)));
	}

	void SetPrimaryUserIDCommand::Private::showSuccessDialog()
	{
	success(xi18nc("@info",
	"<para>The user ID<nl/><emphasis>%1</emphasis><nl/>has been flagged successfully as the primary user ID.</para>",
	QString::fromUtf8(userId.id())));
	}

	SetPrimaryUserIDCommand::SetPrimaryUserIDCommand(const GpgME::UserID &userId)
	: Command{new Private{this, userId}}
	{
	}

	SetPrimaryUserIDCommand::~SetPrimaryUserIDCommand()
	{
	qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
	}

	void SetPrimaryUserIDCommand::doStart()
	{
	if (d->userId.isNull()) {
	d->finished();
	return;
	}

	const auto key = d->userId.parent();
	if (key.protocol() != GpgME::OpenPGP \|\| !key.hasSecret()) {
	d->finished();
	return;
	}

	d->startJob();
	}

	void SetPrimaryUserIDCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	if (d->job) {
	d->job->slotCancel();
	}
	-#endif
	}

	#undef d
	#undef q
	diff --git a/src/conf/dirservconfigpage.cpp b/src/conf/dirservconfigpage.cpp
	index f95d168d2..723c2e348 100644
	--- a/src/conf/dirservconfigpage.cpp
	+++ b/src/conf/dirservconfigpage.cpp
	@@ -1,526 +1,517 @@
	/* -- mode: c++; c-basic-offset:4 --
	conf/dirservconfigpage.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2004, 2008 Klarälvdalens Datakonsult AB

	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "dirservconfigpage.h"

	#include "labelledwidget.h"

	#include <settings.h>

	#include <Libkleo/Compat>
	#include <Libkleo/DirectoryServicesWidget>
	#include <Libkleo/KeyserverConfig>

	#include <QGpgME/CryptoConfig>
	#include <QGpgME/Protocol>

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

	#include <QCheckBox>
	#include <QGroupBox>
	#include <QLabel>
	#include <QLayout>
	#include <QLineEdit>
	#include <QTimeEdit>
	#include <QVBoxLayout>

	#include <gpgme++/engineinfo.h>
	#include <gpgme.h>

	using namespace Kleo;
	using namespace QGpgME;

	// Option for configuring X.509 servers (available via gpgconf since GnuPG 2.3.5 and 2.2.34)
	static const char s_x509services_componentName[] = "dirmngr";
	static const char s_x509services_entryName[] = "ldapserver";

	// Legacy option for configuring X.509 servers (deprecated with GnuPG 2.2.28 and 2.3.2)
	static const char s_x509services_legacy_componentName[] = "gpgsm";
	static const char s_x509services_legacy_entryName[] = "keyserver";

	static const char s_pgpservice_componentName[] = "dirmngr";
	static const char s_pgpservice_entryName[] = "keyserver";

	// legacy config entry used until GnuPG 2.2
	static const char s_pgpservice_legacy_componentName[] = "gpg";
	static const char s_pgpservice_legacy_entryName[] = "keyserver";

	static const char s_timeout_componentName[] = "dirmngr";
	static const char s_timeout_entryName[] = "ldaptimeout";

	static const char s_maxitems_componentName[] = "dirmngr";
	static const char s_maxitems_entryName[] = "max-replies";

	class DirectoryServicesConfigurationPage::Private
	{
	DirectoryServicesConfigurationPage *q = nullptr;

	public:
	Private(DirectoryServicesConfigurationPage *q);

	void load();
	void save();
	void defaults();

	private:
	enum EntryMultiplicity {
	SingleValue,
	ListValue,
	};
	enum ShowError {
	DoNotShowError,
	DoShowError,
	};

	void setX509ServerEntry(const std::vector<KeyserverConfig> &servers);
	void load(const Kleo::Settings &settings);

	QGpgME::CryptoConfigEntry configEntry(const char componentName,
	const char *entryName,
	QGpgME::CryptoConfigEntry::ArgType argType,
	EntryMultiplicity multiplicity,
	ShowError showError);

	Kleo::LabelledWidget<QLineEdit> mOpenPGPKeyserverEdit;
	Kleo::DirectoryServicesWidget *mDirectoryServices = nullptr;
	Kleo::LabelledWidget<QTimeEdit> mTimeout;
	Kleo::LabelledWidget<QSpinBox> mMaxItems;
	QCheckBox *mFetchMissingSignerKeysCB = nullptr;
	QCheckBox *mQueryWKDsForAllUserIDsCB = nullptr;

	QGpgME::CryptoConfigEntry *mOpenPGPServiceEntry = nullptr;
	QGpgME::CryptoConfigEntry *mTimeoutConfigEntry = nullptr;
	QGpgME::CryptoConfigEntry *mMaxItemsConfigEntry = nullptr;

	QGpgME::CryptoConfig *mConfig = nullptr;
	};

	DirectoryServicesConfigurationPage::Private::Private(DirectoryServicesConfigurationPage *q)
	{
	mConfig = QGpgME::cryptoConfig();
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	auto glay = new QGridLayout(q);
	#else
	auto glay = new QGridLayout(q->widget());
	#endif
	glay->setContentsMargins(0, 0, 0, 0);

	// OpenPGP keyserver
	int row = 0;
	{
	auto l = new QHBoxLayout{};
	l->setContentsMargins(0, 0, 0, 0);

	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	mOpenPGPKeyserverEdit.createWidgets(q);
	#else
	mOpenPGPKeyserverEdit.createWidgets(q->widget());
	#endif
	mOpenPGPKeyserverEdit.label()->setText(i18n("OpenPGP keyserver:"));
	l->addWidget(mOpenPGPKeyserverEdit.label());
	l->addWidget(mOpenPGPKeyserverEdit.widget());

	glay->addLayout(l, row, 0, 1, 3);
	connect(mOpenPGPKeyserverEdit.widget(), &QLineEdit::textEdited, q, &DirectoryServicesConfigurationPage::markAsChanged);
	}

	// X.509 servers
	if (Settings{}.cmsEnabled()) {
	++row;
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	auto groupBox = new QGroupBox{i18n("X.509 Directory Services"), q};
	#else
	auto groupBox = new QGroupBox{i18n("X.509 Directory Services"), q->widget()};
	#endif
	auto groupBoxLayout = new QVBoxLayout{groupBox};

	if (gpgme_check_version("1.16.0")) {
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	mDirectoryServices = new Kleo::DirectoryServicesWidget(q);
	#else
	mDirectoryServices = new Kleo::DirectoryServicesWidget(q->widget());
	#endif
	if (QLayout *l = mDirectoryServices->layout()) {
	l->setContentsMargins(0, 0, 0, 0);
	}
	groupBoxLayout->addWidget(mDirectoryServices);
	connect(mDirectoryServices, &DirectoryServicesWidget::changed, q, &DirectoryServicesConfigurationPage::markAsChanged);
	} else {
	// QGpgME does not properly support keyserver flags for X.509 keyservers (added in GnuPG 2.2.28);
	// disable the configuration to prevent the configuration from being corrupted
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	groupBoxLayout->addWidget(new QLabel{i18n("Configuration of directory services is not possible "
	"because the used gpgme libraries are too old."),
	q});
	#else
	groupBoxLayout->addWidget(new QLabel{i18n("Configuration of directory services is not possible "
	"because the used gpgme libraries are too old."),
	q->widget()});

	#endif
	}

	glay->addWidget(groupBox, row, 0, 1, 3);
	}

	// LDAP timeout
	++row;
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	mTimeout.createWidgets(q);
	#else
	mTimeout.createWidgets(q->widget());
	#endif
	mTimeout.label()->setText(i18n("LDAP &timeout (minutes:seconds):"));
	mTimeout.widget()->setDisplayFormat(QStringLiteral("mm:ss"));
	connect(mTimeout.widget(), &QTimeEdit::timeChanged, q, &DirectoryServicesConfigurationPage::markAsChanged);
	glay->addWidget(mTimeout.label(), row, 0);
	glay->addWidget(mTimeout.widget(), row, 1);

	// Max number of items returned by queries
	++row;
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	mMaxItems.createWidgets(q);
	#else
	mMaxItems.createWidgets(q->widget());
	#endif
	mMaxItems.label()->setText(i18n("&Maximum number of items returned by query:"));
	mMaxItems.widget()->setMinimum(0);
	#if QT_DEPRECATED_SINCE(5, 14)
	connect(mMaxItems.widget(), qOverload<int>(&QSpinBox::valueChanged), q, &DirectoryServicesConfigurationPage::markAsChanged);
	#else
	connect(mMaxItems.widget(), &QSpinBox::valueChanged, q, &DirectoryServicesConfigurationPage::markAsChanged);
	#endif
	glay->addWidget(mMaxItems.label(), row, 0);
	glay->addWidget(mMaxItems.widget(), row, 1);

	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	++row;
	mFetchMissingSignerKeysCB = new QCheckBox{q};
	mFetchMissingSignerKeysCB->setText(i18nc("@option:check", "Retrieve missing certification keys when importing new keys"));
	mFetchMissingSignerKeysCB->setToolTip(xi18nc("@info:tooltip",
	"If enabled, then Kleopatra will automatically try to retrieve the keys "
	"that were used to certify the user IDs of newly imported OpenPGP keys."));
	connect(mFetchMissingSignerKeysCB, &QCheckBox::toggled, q, &DirectoryServicesConfigurationPage::markAsChanged);
	glay->addWidget(mFetchMissingSignerKeysCB, row, 0, 1, 3);
	-#endif

	++row;
	mQueryWKDsForAllUserIDsCB = new QCheckBox{q};
	mQueryWKDsForAllUserIDsCB->setText(i18nc("@option:check", "Query certificate directories of providers for all user IDs"));
	mQueryWKDsForAllUserIDsCB->setToolTip(xi18nc("@info:tooltip",
	"By default, Kleopatra only queries the certificate directories of providers (WKD) "
	"for user IDs that were originally retrieved from a WKD when you update an OpenPGP "
	"certificate. If this option is enabled, then Kleopatra will query WKDs for all user IDs."));
	connect(mQueryWKDsForAllUserIDsCB, &QCheckBox::toggled, q, &DirectoryServicesConfigurationPage::markAsChanged);
	glay->addWidget(mQueryWKDsForAllUserIDsCB, row, 0, 1, 3);

	glay->setRowStretch(++row, 1);
	glay->setColumnStretch(2, 1);
	}

	static auto readKeyserverConfigs(const CryptoConfigEntry *configEntry)
	{
	std::vector<KeyserverConfig> servers;
	if (configEntry) {
	const auto urls = configEntry->urlValueList();
	servers.reserve(urls.size());
	std::transform(std::begin(urls), std::end(urls), std::back_inserter(servers), &KeyserverConfig::fromUrl);
	}
	return servers;
	}

	void DirectoryServicesConfigurationPage::Private::load(const Kleo::Settings &settings)
	{
	if (mDirectoryServices) {
	mDirectoryServices->clear();

	// gpgsm uses the deprecated keyserver option in gpgsm.conf additionally to the ldapserver option in dirmngr.conf;
	// we (try to) read servers from both entries, but always write to the newest existing entry
	const auto *const newEntry =
	configEntry(s_x509services_componentName, s_x509services_entryName, CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoNotShowError);
	const auto *const legacyEntry =
	configEntry(s_x509services_legacy_componentName, s_x509services_legacy_entryName, CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoNotShowError);
	auto entry = newEntry ? newEntry : legacyEntry;
	if (entry) {
	const auto additionalServers = readKeyserverConfigs(legacyEntry);
	auto servers = readKeyserverConfigs(newEntry);
	std::copy(std::begin(additionalServers), std::end(additionalServers), std::back_inserter(servers));
	mDirectoryServices->setKeyservers(servers);
	mDirectoryServices->setReadOnly(entry->isReadOnly());
	} else {
	qCWarning(KLEOPATRA_LOG) << "Unknown or wrong typed config entries" << s_x509services_componentName << "/" << s_x509services_entryName << "and"
	<< s_x509services_legacy_componentName << "/" << s_x509services_legacy_entryName;

	mDirectoryServices->setDisabled(true);
	}
	}

	{
	// gpg prefers the deprecated keyserver option in gpg.conf over the keyserver option in dirmngr.conf;
	// therefore, we use the deprecated keyserver option if it is set or if the new option doesn't exist (gpg < 2.1.9)
	auto const newEntry = configEntry(s_pgpservice_componentName, s_pgpservice_entryName, CryptoConfigEntry::ArgType_String, SingleValue, DoNotShowError);
	auto const legacyEntry =
	configEntry(s_pgpservice_legacy_componentName, s_pgpservice_legacy_entryName, CryptoConfigEntry::ArgType_String, SingleValue, DoNotShowError);
	mOpenPGPServiceEntry = ((legacyEntry && legacyEntry->isSet()) \|\| !newEntry) ? legacyEntry : newEntry;

	if (!mOpenPGPServiceEntry) {
	qCWarning(KLEOPATRA_LOG) << "Unknown or wrong typed config entries" << s_pgpservice_componentName << "/" << s_pgpservice_entryName << "and"
	<< s_pgpservice_legacy_componentName << "/" << s_pgpservice_legacy_entryName;
	} else if (mOpenPGPServiceEntry == legacyEntry) {
	qCDebug(KLEOPATRA_LOG) << "Using config entry" << s_pgpservice_legacy_componentName << "/" << s_pgpservice_legacy_entryName;
	} else {
	qCDebug(KLEOPATRA_LOG) << "Using config entry" << s_pgpservice_componentName << "/" << s_pgpservice_entryName;
	}

	mOpenPGPKeyserverEdit.widget()->setText(mOpenPGPServiceEntry && mOpenPGPServiceEntry->isSet() ? mOpenPGPServiceEntry->stringValue() : QString());
	mOpenPGPKeyserverEdit.setEnabled(mOpenPGPServiceEntry && !mOpenPGPServiceEntry->isReadOnly());
	-#if QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE
	if (newEntry && !newEntry->defaultValue().isNull()) {
	mOpenPGPKeyserverEdit.widget()->setPlaceholderText(newEntry->defaultValue().toString());
	- } else
	-#endif
	- {
	+ } else {
	if (GpgME::engineInfo(GpgME::GpgEngine).engineVersion() < "2.1.16") {
	mOpenPGPKeyserverEdit.widget()->setPlaceholderText(QStringLiteral("hkp://keys.gnupg.net"));
	} else {
	mOpenPGPKeyserverEdit.widget()->setPlaceholderText(QStringLiteral("hkps://hkps.pool.sks-keyservers.net"));
	}
	}
	}

	// read LDAP timeout
	// first try to read the config entry as int (GnuPG 2.3)
	mTimeoutConfigEntry = configEntry(s_timeout_componentName, s_timeout_entryName, CryptoConfigEntry::ArgType_Int, SingleValue, DoNotShowError);
	if (!mTimeoutConfigEntry) {
	// if this fails, then try to read the config entry as unsigned int (GnuPG <= 2.2)
	mTimeoutConfigEntry = configEntry(s_timeout_componentName, s_timeout_entryName, CryptoConfigEntry::ArgType_UInt, SingleValue, DoShowError);
	}
	if (mTimeoutConfigEntry) {
	const int ldapTimeout = mTimeoutConfigEntry->argType() == CryptoConfigEntry::ArgType_Int ? mTimeoutConfigEntry->intValue()
	: static_cast<int>(mTimeoutConfigEntry->uintValue());
	const QTime time = QTime(0, 0, 0, 0).addSecs(ldapTimeout);
	// qCDebug(KLEOPATRA_LOG) <<"timeout:" << mTimeoutConfigEntry->uintValue() <<" ->" << time;
	mTimeout.widget()->setTime(time);
	}
	mTimeout.setEnabled(mTimeoutConfigEntry && !mTimeoutConfigEntry->isReadOnly());

	// read max-replies config entry
	// first try to read the config entry as int (GnuPG 2.3)
	mMaxItemsConfigEntry = configEntry(s_maxitems_componentName, s_maxitems_entryName, CryptoConfigEntry::ArgType_Int, SingleValue, DoNotShowError);
	if (!mMaxItemsConfigEntry) {
	// if this fails, then try to read the config entry as unsigned int (GnuPG <= 2.2)
	mMaxItemsConfigEntry = configEntry(s_maxitems_componentName, s_maxitems_entryName, CryptoConfigEntry::ArgType_UInt, SingleValue, DoShowError);
	}
	if (mMaxItemsConfigEntry) {
	const int value = mMaxItemsConfigEntry->argType() == CryptoConfigEntry::ArgType_Int ? mMaxItemsConfigEntry->intValue()
	: static_cast<int>(mMaxItemsConfigEntry->uintValue());
	mMaxItems.widget()->blockSignals(true); // KNumInput emits valueChanged from setValue!
	mMaxItems.widget()->setValue(value);
	mMaxItems.widget()->blockSignals(false);
	}
	mMaxItems.setEnabled(mMaxItemsConfigEntry && !mMaxItemsConfigEntry->isReadOnly());

	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	mFetchMissingSignerKeysCB->setChecked(settings.retrieveSignerKeysAfterImport());
	mFetchMissingSignerKeysCB->setEnabled(!settings.isImmutable(QStringLiteral("RetrieveSignerKeysAfterImport")));
	-#endif
	mQueryWKDsForAllUserIDsCB->setChecked(settings.queryWKDsForAllUserIDs());
	mQueryWKDsForAllUserIDsCB->setEnabled(!settings.isImmutable(QStringLiteral("QueryWKDsForAllUserIDs")));
	}

	void DirectoryServicesConfigurationPage::Private::load()
	{
	load(Settings{});
	}

	namespace
	{
	void updateIntegerConfigEntry(QGpgME::CryptoConfigEntry *configEntry, int value)
	{
	if (!configEntry) {
	return;
	}
	if (configEntry->argType() == CryptoConfigEntry::ArgType_Int) {
	if (configEntry->intValue() != value) {
	configEntry->setIntValue(value);
	}
	} else {
	const auto newValue = static_cast<unsigned>(value);
	if (configEntry->uintValue() != newValue) {
	configEntry->setUIntValue(newValue);
	}
	}
	}
	}

	void DirectoryServicesConfigurationPage::Private::setX509ServerEntry(const std::vector<KeyserverConfig> &servers)
	{
	const auto newEntry = configEntry(s_x509services_componentName, s_x509services_entryName, CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoNotShowError);
	const auto legacyEntry =
	configEntry(s_x509services_legacy_componentName, s_x509services_legacy_entryName, CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoNotShowError);

	if ((newEntry && newEntry->isReadOnly()) \|\| (legacyEntry && legacyEntry->isReadOnly())) {
	// do not change the config entries if either config entry is read-only
	return;
	}
	QList<QUrl> urls;
	urls.reserve(servers.size());
	std::transform(std::begin(servers), std::end(servers), std::back_inserter(urls), std::mem_fn(&KeyserverConfig::toUrl));
	if (newEntry) {
	// write all servers to the new config entry
	newEntry->setURLValueList(urls);
	// and clear the legacy config entry
	if (legacyEntry) {
	legacyEntry->setURLValueList({});
	}
	} else if (legacyEntry) {
	// write all servers to the legacy config entry if the new entry is not available
	legacyEntry->setURLValueList(urls);
	} else {
	qCWarning(KLEOPATRA_LOG) << "Could not store the X.509 servers. Unknown or wrong typed config entries" << s_x509services_componentName << "/"
	<< s_x509services_entryName << "and" << s_x509services_legacy_componentName << "/" << s_x509services_legacy_entryName;
	}
	}

	void DirectoryServicesConfigurationPage::Private::save()
	{
	if (mDirectoryServices && mDirectoryServices->isEnabled()) {
	setX509ServerEntry(mDirectoryServices->keyservers());
	}

	if (mOpenPGPServiceEntry) {
	const auto keyserver = mOpenPGPKeyserverEdit.widget()->text().trimmed();
	if (keyserver.isEmpty()) {
	mOpenPGPServiceEntry->resetToDefault();
	} else {
	const auto keyserverUrl = keyserver.contains(QLatin1String{"://"}) ? keyserver : (QLatin1String{"hkps://"} + keyserver);
	mOpenPGPServiceEntry->setStringValue(keyserverUrl);
	}
	}

	const QTime time{mTimeout.widget()->time()};
	updateIntegerConfigEntry(mTimeoutConfigEntry, time.minute() * 60 + time.second());

	updateIntegerConfigEntry(mMaxItemsConfigEntry, mMaxItems.widget()->value());

	mConfig->sync(true);

	Settings settings;
	-#if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	settings.setRetrieveSignerKeysAfterImport(mFetchMissingSignerKeysCB->isChecked());
	-#endif
	settings.setQueryWKDsForAllUserIDs(mQueryWKDsForAllUserIDsCB->isChecked());
	settings.save();
	}

	void DirectoryServicesConfigurationPage::Private::defaults()
	{
	// these guys don't have a default, to clear them:
	if (mDirectoryServices && mDirectoryServices->isEnabled()) {
	setX509ServerEntry({});
	}
	if (mOpenPGPServiceEntry && !mOpenPGPServiceEntry->isReadOnly()) {
	mOpenPGPServiceEntry->setStringValue(QString());
	}
	// these presumably have a default, use that one:
	if (mTimeoutConfigEntry && !mTimeoutConfigEntry->isReadOnly()) {
	mTimeoutConfigEntry->resetToDefault();
	}
	if (mMaxItemsConfigEntry && !mMaxItemsConfigEntry->isReadOnly()) {
	mMaxItemsConfigEntry->resetToDefault();
	}

	Settings settings;
	settings.setRetrieveSignerKeysAfterImport(settings.findItem(QStringLiteral("RetrieveSignerKeysAfterImport"))->getDefault().toBool());
	settings.setQueryWKDsForAllUserIDs(settings.findItem(QStringLiteral("QueryWKDsForAllUserIDs"))->getDefault().toBool());

	load(settings);
	}

	// Find config entry for ldap servers. Implements runtime checks on the configuration option.
	CryptoConfigEntry DirectoryServicesConfigurationPage::Private::configEntry(const char componentName,
	const char *entryName,
	CryptoConfigEntry::ArgType argType,
	EntryMultiplicity multiplicity,
	ShowError showError)
	{
	CryptoConfigEntry *const entry = Kleo::getCryptoConfigEntry(mConfig, componentName, entryName);
	if (!entry) {
	if (showError == DoShowError) {
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	KMessageBox::error(
	q,
	i18n("Backend error: gpgconf does not seem to know the entry for %1/%2", QLatin1String(componentName), QLatin1String(entryName)));
	#else
	KMessageBox::error(
	q->widget(),
	i18n("Backend error: gpgconf does not seem to know the entry for %1/%2", QLatin1String(componentName), QLatin1String(entryName)));
	#endif
	}
	return nullptr;
	}
	if (entry->argType() != argType \|\| entry->isList() != bool(multiplicity)) {
	if (showError == DoShowError) {
	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	KMessageBox::error(q,
	i18n("Backend error: gpgconf has wrong type for %1/%2: %3 %4",
	QLatin1String(componentName),
	QLatin1String(entryName),
	entry->argType(),
	entry->isList()));
	#else
	KMessageBox::error(q->widget(),
	i18n("Backend error: gpgconf has wrong type for %1/%2: %3 %4",
	QLatin1String(componentName),
	QLatin1String(entryName),
	entry->argType(),
	entry->isList()));
	#endif
	}
	return nullptr;
	}
	return entry;
	}

	#if KCMUTILS_VERSION < QT_VERSION_CHECK(5, 240, 0)
	DirectoryServicesConfigurationPage::DirectoryServicesConfigurationPage(QWidget *parent, const QVariantList &args)
	: KCModule{parent, args}
	#else
	DirectoryServicesConfigurationPage::DirectoryServicesConfigurationPage(QObject *parent, const KPluginMetaData &data, const QVariantList &args)
	: KCModule(parent, data, args)
	#endif
	, d{new Private{this}}
	{
	}

	DirectoryServicesConfigurationPage::~DirectoryServicesConfigurationPage() = default;

	void DirectoryServicesConfigurationPage::load()
	{
	d->load();
	}

	void DirectoryServicesConfigurationPage::save()
	{
	d->save();
	}

	void DirectoryServicesConfigurationPage::defaults()
	{
	d->defaults();
	}
	diff --git a/src/crypto/autodecryptverifyfilescontroller.cpp b/src/crypto/autodecryptverifyfilescontroller.cpp
	index cd95a4023..9ce806b1d 100644
	--- a/src/crypto/autodecryptverifyfilescontroller.cpp
	+++ b/src/crypto/autodecryptverifyfilescontroller.cpp
	@@ -1,621 +1,615 @@
	/* -- mode: c++; c-basic-offset:4 --
	autodecryptverifyfilescontroller.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB

	SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "autodecryptverifyfilescontroller.h"

	#include "fileoperationspreferences.h"

	#include <crypto/decryptverifytask.h>
	#include <crypto/gui/decryptverifyfilesdialog.h>
	#include <crypto/gui/decryptverifyoperationwidget.h>
	#include <crypto/taskcollection.h>

	#include "commands/decryptverifyfilescommand.h"

	#include <Libkleo/GnuPG>
	#include <utils/archivedefinition.h>
	#include <utils/input.h>
	#include <utils/kleo_assert.h>
	#include <utils/output.h>
	#include <utils/path-helper.h>

	#include <Libkleo/Classify>

	#ifndef Q_OS_WIN
	#include <KIO/CopyJob>
	#include <KIO/Global>
	#endif
	#include "kleopatra_debug.h"
	#include <KLocalizedString>
	#include <KMessageBox>

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	#include <QGpgME/DecryptVerifyArchiveJob>
	-#endif

	#include <QDir>
	#include <QFile>
	#include <QFileDialog>
	#include <QFileInfo>
	#include <QTemporaryDir>
	#include <QTimer>

	#include <gpgme++/decryptionresult.h>

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

	class AutoDecryptVerifyFilesController::Private
	{
	AutoDecryptVerifyFilesController *const q;

	public:
	explicit Private(AutoDecryptVerifyFilesController *qq);

	void schedule();

	QString getEmbeddedFileName(const QString &fileName) const;
	void exec();
	std::vector<std::shared_ptr<Task>> buildTasks(const QStringList &, QStringList &);

	struct CryptoFile {
	QString baseName;
	QString fileName;
	GpgME::Protocol protocol = GpgME::UnknownProtocol;
	int classification = 0;
	std::shared_ptr<Output> output;
	};
	QVector<CryptoFile> classifyAndSortFiles(const QStringList &files);

	void reportError(int err, const QString &details)
	{
	q->setLastError(err, details);
	q->emitDoneOrError();
	}
	void cancelAllTasks();

	QStringList m_passedFiles, m_filesAfterPreparation;
	std::vector<std::shared_ptr<const DecryptVerifyResult>> m_results;
	std::vector<std::shared_ptr<Task>> m_runnableTasks, m_completedTasks;
	std::shared_ptr<Task> m_runningTask;
	bool m_errorDetected = false;
	DecryptVerifyOperation m_operation = DecryptVerify;
	QPointer<DecryptVerifyFilesDialog> m_dialog;
	std::unique_ptr<QTemporaryDir> m_workDir;
	};

	AutoDecryptVerifyFilesController::Private::Private(AutoDecryptVerifyFilesController *qq)
	: q(qq)
	{
	qRegisterMetaType<VerificationResult>();
	}

	void AutoDecryptVerifyFilesController::Private::schedule()
	{
	if (!m_runningTask && !m_runnableTasks.empty()) {
	const std::shared_ptr<Task> t = m_runnableTasks.back();
	m_runnableTasks.pop_back();
	t->start();
	m_runningTask = t;
	}
	if (!m_runningTask) {
	kleo_assert(m_runnableTasks.empty());
	for (const std::shared_ptr<const DecryptVerifyResult> &i : std::as_const(m_results)) {
	Q_EMIT q->verificationResult(i->verificationResult());
	}
	}
	}

	QString AutoDecryptVerifyFilesController::Private::getEmbeddedFileName(const QString &fileName) const
	{
	auto it = std::find_if(m_results.cbegin(), m_results.cend(), [fileName](const auto &r) {
	return r->fileName() == fileName;
	});
	if (it != m_results.cend()) {
	const auto embeddedFilePath = QString::fromUtf8((*it)->decryptionResult().fileName());
	if (embeddedFilePath.contains(QLatin1Char{'\\'})) {
	// ignore embedded file names containing '\'
	return {};
	}
	// strip the path from the embedded file name
	return QFileInfo{embeddedFilePath}.fileName();
	} else {
	return {};
	}
	}

	void AutoDecryptVerifyFilesController::Private::exec()
	{
	Q_ASSERT(!m_dialog);

	QStringList undetected;
	std::vector<std::shared_ptr<Task>> tasks = buildTasks(m_passedFiles, undetected);

	if (!undetected.isEmpty()) {
	// Since GpgME 1.7.0 Classification is supposed to be reliable
	// so we really can't do anything with this data.
	reportError(makeGnuPGError(GPG_ERR_GENERAL),
	xi18n("Failed to find encrypted or signed data in one or more files.<nl/>"
	"You can manually select what to do with the files now.<nl/>"
	"If they contain signed or encrypted data please report a bug (see Help->Report Bug)."));
	auto cmd = new Commands::DecryptVerifyFilesCommand(undetected, nullptr, true);
	cmd->start();
	}
	if (tasks.empty()) {
	q->emitDoneOrError();
	return;
	}
	Q_ASSERT(m_runnableTasks.empty());
	m_runnableTasks.swap(tasks);

	std::shared_ptr<TaskCollection> coll(new TaskCollection);
	for (const std::shared_ptr<Task> &i : std::as_const(m_runnableTasks)) {
	q->connectTask(i);
	}
	coll->setTasks(m_runnableTasks);
	DecryptVerifyFilesDialog dialog{coll};
	m_dialog = &dialog;
	m_dialog->setOutputLocation(heuristicBaseDirectory(m_passedFiles));

	QTimer::singleShot(0, q, SLOT(schedule()));
	const auto result = m_dialog->exec();
	if (result == QDialog::Rejected) {
	q->cancel();
	} else if (result == QDialog::Accepted && m_workDir) {
	// Without workdir there is nothing to move.
	const QDir workdir(m_workDir->path());
	const QDir outDir(m_dialog->outputLocation());
	bool overWriteAll = false;
	qCDebug(KLEOPATRA_LOG) << workdir.entryList(QDir::Files \| QDir::Dirs \| QDir::NoDotAndDotDot);
	for (const QFileInfo &fi : workdir.entryInfoList(QDir::Files \| QDir::Dirs \| QDir::NoDotAndDotDot)) {
	const auto inpath = fi.absoluteFilePath();

	if (fi.isDir()) {
	// A directory. Assume that the input was an archive
	// and avoid directory merges by trying to find a non
	// existing directory.
	auto candidate = fi.fileName();
	if (candidate.startsWith(QLatin1Char('-'))) {
	// Bug in GpgTar Extracts stdout passed archives to a dir named -
	candidate = QFileInfo(m_passedFiles.first()).baseName();
	}

	QString suffix;
	QFileInfo ofi;
	int i = 0;
	do {
	ofi = QFileInfo(outDir.absoluteFilePath(candidate + suffix));
	if (!ofi.exists()) {
	break;
	}
	suffix = QStringLiteral("_%1").arg(++i);
	} while (i < 1000);

	const auto destPath = ofi.absoluteFilePath();
	#ifndef Q_OS_WIN
	auto job = KIO::moveAs(QUrl::fromLocalFile(inpath), QUrl::fromLocalFile(destPath));
	qCDebug(KLEOPATRA_LOG) << "Moving" << job->srcUrls().front().toLocalFile() << "to" << job->destUrl().toLocalFile();
	if (!job->exec()) {
	if (job->error() == KIO::ERR_USER_CANCELED) {
	break;
	}
	reportError(makeGnuPGError(GPG_ERR_GENERAL),
	xi18nc("@info",
	"<para>Failed to move <filename>%1</filename> to <filename>%2</filename>.</para>"
	"<para><message>%3</message></para>",
	inpath,
	destPath,
	job->errorString()));
	}
	#else
	// On Windows, KIO::move does not work for folders when crossing partition boundaries
	if (!moveDir(inpath, destPath)) {
	reportError(makeGnuPGError(GPG_ERR_GENERAL),
	xi18nc("@info", "<para>Failed to move <filename>%1</filename> to <filename>%2</filename>.</para>", inpath, destPath));
	}
	#endif
	continue;
	}

	const auto embeddedFileName = getEmbeddedFileName(inpath);
	QString outFileName = fi.fileName();
	if (!embeddedFileName.isEmpty() && embeddedFileName != fi.fileName()) {
	// we switch "Yes" and "No" because Yes is default, but saving with embedded file name could be dangerous
	const auto answer = KMessageBox::questionTwoActionsCancel(
	m_dialog,
	xi18n("Shall the file be saved with the original file name <filename>%1</filename>?", embeddedFileName),
	i18n("Use Original File Name?"),
	KGuiItem(xi18n("No, Save As <filename>%1</filename>", fi.fileName())),
	KGuiItem(xi18n("Yes, Save As <filename>%1</filename>", embeddedFileName)));
	if (answer == KMessageBox::Cancel) {
	qCDebug(KLEOPATRA_LOG) << "Saving canceled for:" << inpath;
	continue;
	} else if (answer == KMessageBox::ButtonCode::SecondaryAction) {
	outFileName = embeddedFileName;
	}
	}
	const auto outpath = outDir.absoluteFilePath(outFileName);
	qCDebug(KLEOPATRA_LOG) << "Moving " << inpath << " to " << outpath;
	const QFileInfo ofi(outpath);
	if (ofi.exists()) {
	int sel = KMessageBox::Cancel;
	if (!overWriteAll) {
	sel = KMessageBox::questionTwoActionsCancel(m_dialog,
	i18n("The file <b>%1</b> already exists.\n"
	"Overwrite?",
	outpath),
	i18n("Overwrite Existing File?"),
	KStandardGuiItem::overwrite(),
	KGuiItem(i18n("Overwrite All")),
	KStandardGuiItem::cancel());
	}
	if (sel == KMessageBox::Cancel) {
	qCDebug(KLEOPATRA_LOG) << "Overwriting canceled for: " << outpath;
	continue;
	}
	if (sel == KMessageBox::ButtonCode::SecondaryAction) { // Overwrite All
	overWriteAll = true;
	}
	if (!QFile::remove(outpath)) {
	reportError(makeGnuPGError(GPG_ERR_GENERAL), xi18n("Failed to delete <filename>%1</filename>.", outpath));
	continue;
	}
	}
	if (!QFile::rename(inpath, outpath)) {
	reportError(makeGnuPGError(GPG_ERR_GENERAL), xi18n("Failed to move <filename>%1</filename> to <filename>%2</filename>.", inpath, outpath));
	}
	}
	}
	q->emitDoneOrError();
	}

	QVector<AutoDecryptVerifyFilesController::Private::CryptoFile> AutoDecryptVerifyFilesController::Private::classifyAndSortFiles(const QStringList &files)
	{
	const auto isSignature = [](int classification) -> bool {
	return mayBeDetachedSignature(classification) //
	\|\| mayBeOpaqueSignature(classification) //
	\|\| (classification & Class::TypeMask) == Class::ClearsignedMessage;
	};

	QVector<CryptoFile> out;
	for (const auto &file : files) {
	CryptoFile cFile;
	cFile.fileName = file;
	cFile.baseName = stripSuffix(file);
	cFile.classification = classify(file);
	cFile.protocol = findProtocol(cFile.classification);

	auto it = std::find_if(out.begin(), out.end(), [&cFile](const CryptoFile &other) {
	return other.protocol == cFile.protocol && other.baseName == cFile.baseName;
	});
	if (it != out.end()) {
	// If we found a file with the same basename, make sure that encrypted
	// file is before the signature file, so that we first decrypt and then
	// verify
	if (isSignature(cFile.classification) && isCipherText(it->classification)) {
	out.insert(it + 1, cFile);
	} else if (isCipherText(cFile.classification) && isSignature(it->classification)) {
	out.insert(it, cFile);
	} else {
	// both are signatures or both are encrypted files, in which
	// case order does not matter
	out.insert(it, cFile);
	}
	} else {
	out.push_back(cFile);
	}
	}

	return out;
	}

	static bool archiveJobsCanBeUsed([[maybe_unused]] GpgME::Protocol protocol)
	{
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	return (protocol == GpgME::OpenPGP) && QGpgME::DecryptVerifyArchiveJob::isSupported();
	-#else
	- return false;
	-#endif
	}

	std::vector<std::shared_ptr<Task>> AutoDecryptVerifyFilesController::Private::buildTasks(const QStringList &fileNames, QStringList &undetected)
	{
	// sort files so that we make sure we first decrypt and then verify
	QVector<CryptoFile> cryptoFiles = classifyAndSortFiles(fileNames);

	std::vector<std::shared_ptr<Task>> tasks;
	for (auto it = cryptoFiles.begin(), end = cryptoFiles.end(); it != end; ++it) {
	auto &cFile = (*it);
	QFileInfo fi(cFile.fileName);
	qCDebug(KLEOPATRA_LOG) << "classified" << cFile.fileName << "as" << printableClassification(cFile.classification);

	if (!fi.isReadable()) {
	reportError(makeGnuPGError(GPG_ERR_ASS_NO_INPUT), xi18n("Cannot open <filename>%1</filename> for reading.", cFile.fileName));
	continue;
	}

	if (mayBeAnyCertStoreType(cFile.classification)) {
	// Trying to verify a certificate. Possible because extensions are often similar
	// for PGP Keys.
	reportError(makeGnuPGError(GPG_ERR_ASS_NO_INPUT),
	xi18n("The file <filename>%1</filename> contains certificates and can't be decrypted or verified.", cFile.fileName));
	qCDebug(KLEOPATRA_LOG) << "reported error";
	continue;
	}

	// We can't reliably detect CMS detached signatures, so we will try to do
	// our best to use the current file as a detached signature and fallback to
	// opaque signature otherwise.
	if (cFile.protocol == GpgME::CMS && mayBeDetachedSignature(cFile.classification)) {
	// First, see if previous task was a decryption task for the same file
	// and "pipe" it's output into our input
	std::shared_ptr<Input> input;
	bool prepend = false;
	if (it != cryptoFiles.begin()) {
	const auto prev = it - 1;
	if (prev->protocol == cFile.protocol && prev->baseName == cFile.baseName) {
	input = Input::createFromOutput(prev->output);
	prepend = true;
	}
	}

	if (!input) {
	if (QFile::exists(cFile.baseName)) {
	input = Input::createFromFile(cFile.baseName);
	}
	}

	if (input) {
	qCDebug(KLEOPATRA_LOG) << "Detached CMS verify: " << cFile.fileName;
	std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
	t->setInput(Input::createFromFile(cFile.fileName));
	t->setSignedData(input);
	t->setProtocol(cFile.protocol);
	if (prepend) {
	// Put the verify task BEFORE the decrypt task in the tasks queue,
	// because the tasks are executed in reverse order!
	tasks.insert(tasks.end() - 1, t);
	} else {
	tasks.push_back(t);
	}
	continue;
	} else {
	// No signed data, maybe not a detached signature
	}
	}

	if (isDetachedSignature(cFile.classification)) {
	// Detached signature, try to find data or ask the user.
	QString signedDataFileName = cFile.baseName;
	if (!QFile::exists(signedDataFileName)) {
	signedDataFileName = QFileDialog::getOpenFileName(nullptr,
	xi18n("Select the file to verify with the signature <filename>%1</filename>", fi.fileName()),
	fi.path());
	}
	if (signedDataFileName.isEmpty()) {
	qCDebug(KLEOPATRA_LOG) << "No signed data selected. Verify aborted.";
	} else {
	qCDebug(KLEOPATRA_LOG) << "Detached verify: " << cFile.fileName << " Data: " << signedDataFileName;
	std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
	t->setInput(Input::createFromFile(cFile.fileName));
	t->setSignedData(Input::createFromFile(signedDataFileName));
	t->setProtocol(cFile.protocol);
	tasks.push_back(t);
	}
	continue;
	}

	if (!mayBeAnyMessageType(cFile.classification)) {
	// Not a Message? Maybe there is a signature for this file?
	const auto signatures = findSignatures(cFile.fileName);
	bool foundSig = false;
	if (!signatures.empty()) {
	for (const QString &sig : signatures) {
	const auto classification = classify(sig);
	qCDebug(KLEOPATRA_LOG) << "Guessing: " << sig << " is a signature for: " << cFile.fileName << "Classification: " << classification;
	const auto proto = findProtocol(classification);
	if (proto == GpgME::UnknownProtocol) {
	qCDebug(KLEOPATRA_LOG) << "Could not determine protocol. Skipping guess.";
	continue;
	}
	foundSig = true;
	std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
	t->setInput(Input::createFromFile(sig));
	t->setSignedData(Input::createFromFile(cFile.fileName));
	t->setProtocol(proto);
	tasks.push_back(t);
	}
	}
	if (!foundSig) {
	undetected << cFile.fileName;
	qCDebug(KLEOPATRA_LOG) << "Failed detection for: " << cFile.fileName << " adding to undetected.";
	}
	} else {
	const FileOperationsPreferences fileOpSettings;
	// Any Message type so we have input and output.
	const auto input = Input::createFromFile(cFile.fileName);

	std::shared_ptr<ArchiveDefinition> ad;
	if (fileOpSettings.autoExtractArchives()) {
	const auto archiveDefinitions = ArchiveDefinition::getArchiveDefinitions();
	ad = q->pick_archive_definition(cFile.protocol, archiveDefinitions, cFile.fileName);
	}

	if (fileOpSettings.dontUseTmpDir()) {
	if (!m_workDir) {
	m_workDir = std::make_unique<QTemporaryDir>(heuristicBaseDirectory(fileNames) + QStringLiteral("/kleopatra-XXXXXX"));
	}
	if (!m_workDir->isValid()) {
	qCDebug(KLEOPATRA_LOG) << heuristicBaseDirectory(fileNames) << "not a valid temporary directory.";
	m_workDir.reset();
	}
	}
	if (!m_workDir) {
	m_workDir = std::make_unique<QTemporaryDir>();
	}
	qCDebug(KLEOPATRA_LOG) << "Using:" << m_workDir->path() << "as temporary directory.";

	const auto wd = QDir(m_workDir->path());

	std::shared_ptr<Output> output;
	if (ad) {
	if ((ad->id() == QLatin1String{"tar"}) && archiveJobsCanBeUsed(cFile.protocol)) {
	// we don't need an output
	} else {
	output = ad->createOutputFromUnpackCommand(cFile.protocol, ad->stripExtension(cFile.protocol, cFile.baseName), wd);
	}
	} else {
	output = Output::createFromFile(wd.absoluteFilePath(outputFileName(fi.fileName())), false);
	}

	// If this might be opaque CMS signature, then try that. We already handled
	// detached CMS signature above
	const auto isCMSOpaqueSignature = cFile.protocol == GpgME::CMS && mayBeOpaqueSignature(cFile.classification);

	if (isOpaqueSignature(cFile.classification) \|\| isCMSOpaqueSignature) {
	qCDebug(KLEOPATRA_LOG) << "creating a VerifyOpaqueTask";
	std::shared_ptr<VerifyOpaqueTask> t(new VerifyOpaqueTask);
	t->setInput(input);
	if (output) {
	t->setOutput(output);
	}
	t->setProtocol(cFile.protocol);
	if (ad) {
	t->setExtractArchive(true);
	t->setInputFile(cFile.fileName);
	if (output) {
	t->setOutputDirectory(m_workDir->path());
	} else {
	// make gpgtar extract to a subfolder of the work directory based on the input file name
	const auto baseFileName = QFileInfo{ad->stripExtension(cFile.protocol, cFile.baseName)}.fileName();
	t->setOutputDirectory(QDir{m_workDir->path()}.filePath(baseFileName));
	}
	}
	tasks.push_back(t);
	} else {
	// Any message. That is not an opaque signature needs to be
	// decrypted. Verify we always do because we can't know if
	// an encrypted message is also signed.
	qCDebug(KLEOPATRA_LOG) << "creating a DecryptVerifyTask";
	std::shared_ptr<DecryptVerifyTask> t(new DecryptVerifyTask);
	t->setInput(input);
	if (output) {
	t->setOutput(output);
	}
	t->setProtocol(cFile.protocol);
	if (ad) {
	t->setExtractArchive(true);
	t->setInputFile(cFile.fileName);
	if (output) {
	t->setOutputDirectory(m_workDir->path());
	} else {
	// make gpgtar extract to a subfolder of the work directory based on the input file name
	const auto baseFileName = QFileInfo{ad->stripExtension(cFile.protocol, cFile.baseName)}.fileName();
	t->setOutputDirectory(QDir{m_workDir->path()}.filePath(baseFileName));
	}
	}
	cFile.output = output;
	tasks.push_back(t);
	}
	}
	}

	return tasks;
	}

	void AutoDecryptVerifyFilesController::setFiles(const QStringList &files)
	{
	d->m_passedFiles = files;
	}

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

	AutoDecryptVerifyFilesController::AutoDecryptVerifyFilesController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *parent)
	: DecryptVerifyFilesController(ctx, parent)
	, d(new Private(this))
	{
	}

	AutoDecryptVerifyFilesController::~AutoDecryptVerifyFilesController()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	void AutoDecryptVerifyFilesController::start()
	{
	d->exec();
	}

	void AutoDecryptVerifyFilesController::setOperation(DecryptVerifyOperation op)
	{
	d->m_operation = op;
	}

	DecryptVerifyOperation AutoDecryptVerifyFilesController::operation() const
	{
	return d->m_operation;
	}

	void AutoDecryptVerifyFilesController::Private::cancelAllTasks()
	{
	// we just kill all runnable tasks - this will not result in
	// signal emissions.
	m_runnableTasks.clear();

	// a cancel() will result in a call to
	if (m_runningTask) {
	m_runningTask->cancel();
	}
	}

	void AutoDecryptVerifyFilesController::cancel()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	try {
	d->m_errorDetected = true;
	if (d->m_dialog) {
	d->m_dialog->close();
	}
	d->cancelAllTasks();
	} catch (const std::exception &e) {
	qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
	}
	}

	void AutoDecryptVerifyFilesController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
	{
	Q_ASSERT(task);
	Q_UNUSED(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

	d->m_completedTasks.push_back(d->m_runningTask);
	d->m_runningTask.reset();

	if (const std::shared_ptr<const DecryptVerifyResult> &dvr = std::dynamic_pointer_cast<const DecryptVerifyResult>(result)) {
	d->m_results.push_back(dvr);
	}

	QTimer::singleShot(0, this, SLOT(schedule()));
	}
	#include "moc_autodecryptverifyfilescontroller.cpp"
	diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
	index 50f3d2a3b..bc501f5b4 100644
	--- a/src/crypto/decryptverifytask.cpp
	+++ b/src/crypto/decryptverifytask.cpp
	@@ -1,1870 +1,1822 @@
	/* -- 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/DecryptJob>
	+#include <QGpgME/DecryptVerifyArchiveJob>
	#include <QGpgME/DecryptVerifyJob>
	#include <QGpgME/Protocol>
	#include <QGpgME/VerifyDetachedJob>
	#include <QGpgME/VerifyOpaqueJob>
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	-#include <QGpgME/DecryptVerifyArchiveJob>
	-#endif

	#include <Libkleo/AuditLogEntry>
	#include <Libkleo/Classify>
	#include <Libkleo/Compliance>
	#include <Libkleo/Dn>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KleoException>
	#include <Libkleo/Predicates>
	#include <Libkleo/Stl_Util>

	#include <Libkleo/GnuPG>
	#include <utils/detail_p.h>
	#include <utils/input.h>
	#include <utils/kleo_assert.h>
	#include <utils/output.h>

	#include <KMime/HeaderParsing>

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

	#include <gpg-error.h>

	#include "kleopatra_debug.h"

	#include <KFileUtils>
	#include <KLocalizedString>

	#include <QByteArray>
	#include <QDateTime>
	#include <QDir>
	#include <QFileInfo>
	#include <QIODevice>
	#include <QLocale>
	#include <QMimeDatabase>
	#include <QStringList>
	#include <QTextDocument> // Qt::escape

	#include <algorithm>
	#include <sstream>

	using namespace Kleo::Crypto;
	using namespace Kleo;
	using namespace GpgME;
	using namespace KMime::Types;

	namespace
	{

	static AuditLogEntry auditLogFromSender(QObject *sender)
	{
	return AuditLogEntry::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;
	const auto userIDs{key.userIDs()};
	for (const UserID &id : 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(quint32(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 (DeVSCompliance::isCompliant()) {
	text += (QStringLiteral("<br/>")
	+ (sig.isDeVs() ? 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",
	DeVSCompliance::name(true))
	: 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.",
	DeVSCompliance::name(true))));
	}

	return text;
	}

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

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

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

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

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

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

	static UserID findUserIDByMailbox(const Key &key, const Mailbox &mbox)
	{
	const auto userIDs{key.userIDs()};
	for (const UserID &id : 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);
	}
	}

	static QString ensureUniqueDirectory(const QString &path)
	{
	// make sure that we don't use an existing directory
	QString uniquePath = path;
	const QFileInfo outputInfo{path};
	if (outputInfo.exists()) {
	const auto uniqueName = KFileUtils::suggestName(QUrl::fromLocalFile(outputInfo.absolutePath()), outputInfo.fileName());
	uniquePath = outputInfo.dir().filePath(uniqueName);
	}
	if (!QDir{}.mkpath(uniquePath)) {
	return {};
	}
	return uniquePath;
	}

	static bool mimeTypeInherits(const QMimeType &mimeType, const QString &mimeTypeName)
	{
	// inherits is expensive on an invalid mimeType
	return mimeType.isValid() && mimeType.inherits(mimeTypeName);
	}

	}

	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>", Formatting::errorAsString(err).toHtmlEscaped());
	}

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

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

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

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

	return text;
	}

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

	if (err.isCanceled()) {
	return i18n("<b>Decryption canceled.</b>");
	} else if (result.isLegacyCipherNoMDC()) {
	return i18n("<b>Decryption failed: %1.</b>", i18n("No integrity protection (MDC)."));
	} else if (!errorString.isEmpty()) {
	return i18n("<b>Decryption failed: %1.</b>", errorString.toHtmlEscaped());
	} else if (err) {
	return i18n("<b>Decryption failed: %1.</b>", Formatting::errorAsString(err).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(Formatting::errorAsString(sig.status()));
	}
	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(Formatting::errorAsString(sig.status()));
	}
	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 formatRecipientsDetails(const std::vector<Key> &knownRecipients, unsigned int numRecipients)
	{
	if (numRecipients == 0) {
	return {};
	}

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

	QString details = i18np("Recipient:", "Recipients:", numRecipients);

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

	return details;
	}

	static QString formatDecryptionResultDetails(const DecryptionResult &res,
	const std::vector<Key> &recipients,
	const QString &errorString,
	bool isSigned,
	const QPointer<Task> &task)
	{
	if ((res.error().code() == GPG_ERR_EIO \|\| res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
	return i18n("Input error: %1", errorString);
	}

	if (res.isNull() \|\| res.error() \|\| res.error().isCanceled()) {
	return formatRecipientsDetails(recipients, res.numRecipients());
	}

	QString details;

	if (DeVSCompliance::isCompliant()) {
	details += ((res.isDeVs() ? 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.",
	DeVSCompliance::name(true))
	: 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.",
	DeVSCompliance::name(true)))
	+ 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 (!isSigned) {
	details += i18n("<b>Note:</b> You cannot be sure who encrypted this message as it is not signed.") + QLatin1String("<br/>");
	}

	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/>");
	}

	details += formatRecipientsDetails(recipients, res.numRecipients());

	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,
	const QString &fileName,
	const GpgME::Error &error,
	const QString &errString,
	const QString &input,
	const QString &output,
	const AuditLogEntry &auditLog,
	Task *parentTask,
	const Mailbox &informativeSender,
	DecryptVerifyResult *qq)
	: q(qq)
	, m_type(type)
	, m_verificationResult(vr)
	, m_decryptionResult(dr)
	, m_stuff(stuff)
	, m_fileName(fileName)
	, m_error(error)
	, 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;
	QString m_fileName;
	GpgME::Error m_error;
	QString m_errorString;
	QString m_inputLabel;
	QString m_outputLabel;
	const AuditLogEntry 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 AuditLogEntry &auditLog)
	{
	return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(Decrypt, //
	VerificationResult(),
	dr,
	plaintext,
	{},
	{},
	QString(),
	inputLabel(),
	outputLabel(),
	auditLog,
	this,
	informativeSender()));
	}

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

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

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

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

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

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

	Task::Result::ContentType DecryptVerifyResult::viewableContentType() const
	{
	#if QGPGME_SUPPORTS_IS_MIME
	if (decryptionResult().isMime()) {
	return Task::Result::ContentType::Mime;
	}
	#endif

	if (fileName().endsWith(QStringLiteral("openpgp-encrypted-message"))) {
	return Task::Result::ContentType::Mime;
	}

	QMimeDatabase mimeDatabase;
	const auto mimeType = mimeDatabase.mimeTypeForFile(fileName());
	if (mimeTypeInherits(mimeType, QStringLiteral("message/rfc822"))) {
	return Task::Result::ContentType::Mime;
	}

	if (mimeTypeInherits(mimeType, QStringLiteral("application/mbox"))) {
	return Task::Result::ContentType::Mbox;
	}

	return Task::Result::ContentType::None;
	}

	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);
	}

	GpgME::Error DecryptVerifyResult::error() const
	{
	return d->m_error;
	}

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

	AuditLogEntry 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;
	}

	QString DecryptVerifyResult::fileName() const
	{
	return d->m_fileName;
	}

	class AbstractDecryptVerifyTask::Private
	{
	public:
	Mailbox informativeSender;
	QPointer<QGpgME::Job> job;
	};

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

	AbstractDecryptVerifyTask::~AbstractDecryptVerifyTask()
	{
	}

	void AbstractDecryptVerifyTask::cancel()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	if (d->job) {
	d->job->slotCancel();
	}
	}

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

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

	QGpgME::Job *AbstractDecryptVerifyTask::job() const
	{
	return d->job;
	}

	void AbstractDecryptVerifyTask::setJob(QGpgME::Job *job)
	{
	d->job = job;
	}

	class DecryptVerifyTask::Private
	{
	DecryptVerifyTask *const q;

	public:
	explicit Private(DecryptVerifyTask *qq)
	: q{qq}
	{
	}

	void startDecryptVerifyJob();
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void startDecryptVerifyArchiveJob();
	-#endif

	void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray & = {});

	std::shared_ptr<Input> m_input;
	std::shared_ptr<Output> m_output;
	const QGpgME::Protocol *m_backend = nullptr;
	Protocol m_protocol = UnknownProtocol;
	bool m_ignoreMDCError = false;
	bool m_extractArchive = false;
	QString m_inputFilePath;
	QString m_outputDirectory;
	};

	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 AuditLogEntry auditLog = auditLogFromSender(q->sender());
	if (m_output) {
	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) {
	q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	q->emitResult(
	q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	return;
	}
	}
	}
	const int drErr = dr.error().code();
	const QString errorString = m_output ? m_output->errorString() : QString{};
	if (((drErr == GPG_ERR_EIO \|\| drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) \|\| (m_output && m_output->failed())) {
	q->emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO), errorString, auditLog));
	return;
	}

	q->emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, m_output ? m_output->fileName() : QString{}, 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() : d->m_outputDirectory;
	}

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

	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::setExtractArchive(bool extract)
	{
	d->m_extractArchive = extract;
	}

	void DecryptVerifyTask::setInputFile(const QString &path)
	{
	d->m_inputFilePath = path;
	}

	void DecryptVerifyTask::setOutputDirectory(const QString &directory)
	{
	d->m_outputDirectory = directory;
	}

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
	{
	return (protocol == GpgME::OpenPGP) && QGpgME::DecryptVerifyArchiveJob::isSupported();
	}
	-#endif

	void DecryptVerifyTask::doStart()
	{
	kleo_assert(d->m_backend);
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
	d->startDecryptVerifyArchiveJob();
	- } else
	-#endif
	- {
	+ } else {
	d->startDecryptVerifyJob();
	}
	}

	static void setIgnoreMDCErrorFlag(QGpgME::Job *job, bool ignoreMDCError)
	{
	if (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" << Formatting::errorAsString(err);
	}
	}
	}
	}

	void DecryptVerifyTask::Private::startDecryptVerifyJob()
	{
	try {
	std::unique_ptr<QGpgME::DecryptVerifyJob> job{m_backend->decryptVerifyJob()};
	kleo_assert(job);
	setIgnoreMDCErrorFlag(job.get(), m_ignoreMDCError);
	QObject::connect(job.get(),
	&QGpgME::DecryptVerifyJob::result,
	q,
	[this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult, const QByteArray &plainText) {
	slotResult(decryptResult, verifyResult, plainText);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &DecryptVerifyTask::setProgress);
	-#else
	- QObject::connect(job.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	ensureIOOpen(m_input->ioDevice().get(), m_output->ioDevice().get());
	job->start(m_input->ioDevice(), m_output->ioDevice());
	q->setJob(job.release());
	} catch (const GpgME::Exception &e) {
	q->emitResult(q->fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
	} catch (const std::exception &e) {
	q->emitResult(
	q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
	} catch (...) {
	q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
	}
	}

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void DecryptVerifyTask::Private::startDecryptVerifyArchiveJob()
	{
	std::unique_ptr<QGpgME::DecryptVerifyArchiveJob> job{m_backend->decryptVerifyArchiveJob()};
	kleo_assert(job);
	setIgnoreMDCErrorFlag(job.get(), m_ignoreMDCError);
	connect(job.get(),
	&QGpgME::DecryptVerifyArchiveJob::result,
	q,
	[this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult) {
	slotResult(decryptResult, verifyResult);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &DecryptVerifyTask::setProgress);
	-#else
	- connect(job.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	#if QGPGME_ARCHIVE_JOBS_SUPPORT_INPUT_FILENAME
	// make sure that we don't use an existing output directory
	const auto outputDirectory = ensureUniqueDirectory(m_outputDirectory);
	if (outputDirectory.isEmpty()) {
	q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_GENERAL), {}, {}));
	return;
	}
	m_outputDirectory = outputDirectory;
	job->setInputFile(m_inputFilePath);
	job->setOutputDirectory(m_outputDirectory);
	const auto err = job->startIt();
	#else
	ensureIOOpen(m_input->ioDevice().get(), nullptr);
	job->setOutputDirectory(m_outputDirectory);
	const auto err = job->start(m_input->ioDevice());
	#endif
	q->setJob(job.release());
	if (err) {
	q->emitResult(q->fromDecryptVerifyResult(err, {}, {}));
	}
	}
	-#endif

	class DecryptTask::Private
	{
	DecryptTask *const q;

	public:
	explicit Private(DecryptTask *qq)
	: q{qq}
	{
	}

	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)));
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	q->connect(job, &QGpgME::Job::jobProgress, q, &DecryptTask::setProgress);
	-#else
	- q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	}

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

	void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
	{
	{
	std::stringstream ss;
	ss << result;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLogEntry 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) {
	q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	q->emitResult(q->fromDecryptResult(Error::fromCode(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()) {
	q->emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO), errorString, auditLog));
	return;
	}

	q->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::doStart()
	{
	kleo_assert(d->m_backend);

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

	class VerifyOpaqueTask::Private
	{
	VerifyOpaqueTask *const q;

	public:
	explicit Private(VerifyOpaqueTask *qq)
	: q{qq}
	{
	}

	void startVerifyOpaqueJob();
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void startDecryptVerifyArchiveJob();
	-#endif

	void slotResult(const VerificationResult &, const QByteArray & = {});

	std::shared_ptr<Input> m_input;
	std::shared_ptr<Output> m_output;
	const QGpgME::Protocol *m_backend = nullptr;
	Protocol m_protocol = UnknownProtocol;
	bool m_extractArchive = false;
	QString m_inputFilePath;
	QString m_outputDirectory;
	};

	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 AuditLogEntry auditLog = auditLogFromSender(q->sender());
	if (m_output) {
	if (result.error().code()) {
	m_output->cancel();
	} else {
	try {
	kleo_assert(!result.isNull());
	m_output->finalize();
	} catch (const GpgME::Exception &e) {
	q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	} catch (const std::exception &e) {
	q->emitResult(
	q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	return;
	} catch (...) {
	q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
	return;
	}
	}
	}

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

	q->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() : d->m_outputDirectory;
	}

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

	void VerifyOpaqueTask::setExtractArchive(bool extract)
	{
	d->m_extractArchive = extract;
	}

	void VerifyOpaqueTask::setInputFile(const QString &path)
	{
	d->m_inputFilePath = path;
	}

	void VerifyOpaqueTask::setOutputDirectory(const QString &directory)
	{
	d->m_outputDirectory = directory;
	}

	void VerifyOpaqueTask::doStart()
	{
	kleo_assert(d->m_backend);
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
	d->startDecryptVerifyArchiveJob();
	- } else
	-#endif
	- {
	+ } else {
	d->startVerifyOpaqueJob();
	}
	}

	void VerifyOpaqueTask::Private::startVerifyOpaqueJob()
	{
	try {
	std::unique_ptr<QGpgME::VerifyOpaqueJob> job{m_backend->verifyOpaqueJob()};
	kleo_assert(job);
	connect(job.get(), &QGpgME::VerifyOpaqueJob::result, q, [this](const GpgME::VerificationResult &result, const QByteArray &plainText) {
	slotResult(result, plainText);
	});
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(job.get(), &QGpgME::Job::jobProgress, q, &VerifyOpaqueTask::setProgress);
	-#else
	- connect(job.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	ensureIOOpen(m_input->ioDevice().get(), m_output ? m_output->ioDevice().get() : nullptr);
	job->start(m_input->ioDevice(), m_output ? m_output->ioDevice() : std::shared_ptr<QIODevice>());
	q->setJob(job.release());
	} catch (const GpgME::Exception &e) {
	q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
	} catch (const std::exception &e) {
	q->emitResult(
	q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
	} catch (...) {
	q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
	}
	}

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void VerifyOpaqueTask::Private::startDecryptVerifyArchiveJob()
	{
	std::unique_ptr<QGpgME::DecryptVerifyArchiveJob> job{m_backend->decryptVerifyArchiveJob()};
	kleo_assert(job);
	connect(job.get(), &QGpgME::DecryptVerifyArchiveJob::result, q, [this](const DecryptionResult &, const VerificationResult &verifyResult) {
	slotResult(verifyResult);
	});
	connect(job.get(), &QGpgME::DecryptVerifyArchiveJob::dataProgress, q, &VerifyOpaqueTask::setProgress);
	#if QGPGME_ARCHIVE_JOBS_SUPPORT_INPUT_FILENAME
	// make sure that we don't use an existing output directory
	const auto outputDirectory = ensureUniqueDirectory(m_outputDirectory);
	if (outputDirectory.isEmpty()) {
	q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_GENERAL), {}, {}));
	return;
	}
	m_outputDirectory = outputDirectory;
	job->setInputFile(m_inputFilePath);
	job->setOutputDirectory(m_outputDirectory);
	const auto err = job->startIt();
	#else
	ensureIOOpen(m_input->ioDevice().get(), nullptr);
	job->setOutputDirectory(m_outputDirectory);
	const auto err = job->start(m_input->ioDevice());
	#endif
	q->setJob(job.release());
	if (err) {
	q->emitResult(q->fromVerifyOpaqueResult(err, {}, {}));
	}
	}
	-#endif

	class VerifyDetachedTask::Private
	{
	VerifyDetachedTask *const q;

	public:
	explicit Private(VerifyDetachedTask *qq)
	: q{qq}
	{
	}

	void slotResult(const VerificationResult &);

	void registerJob(QGpgME::VerifyDetachedJob *job)
	{
	q->connect(job, SIGNAL(result(GpgME::VerificationResult)), q, SLOT(slotResult(GpgME::VerificationResult)));
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	q->connect(job, &QGpgME::Job::jobProgress, q, &VerifyDetachedTask::setProgress);
	-#else
	- q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	}

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

	void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
	{
	updateKeys(result);
	{
	std::stringstream ss;
	ss << result;
	qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
	}
	const AuditLogEntry auditLog = auditLogFromSender(q->sender());
	try {
	kleo_assert(!result.isNull());
	q->emitResult(q->fromVerifyDetachedResult(result, auditLog));
	} catch (const GpgME::Exception &e) {
	q->emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	} catch (const std::exception &e) {
	q->emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
	} catch (...) {
	q->emitResult(q->fromVerifyDetachedResult(Error::fromCode(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::doStart()
	{
	kleo_assert(d->m_backend);
	try {
	std::unique_ptr<QGpgME::VerifyDetachedJob> job{d->m_backend->verifyDetachedJob()};
	kleo_assert(job);
	d->registerJob(job.get());
	ensureIOOpen(d->m_input->ioDevice().get(), nullptr);
	ensureIOOpen(d->m_signedData->ioDevice().get(), nullptr);
	job->start(d->m_input->ioDevice(), d->m_signedData->ioDevice());
	setJob(job.release());
	} catch (const GpgME::Exception &e) {
	emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
	} catch (const std::exception &e) {
	emitResult(
	fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
	} catch (...) {
	emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
	}
	}

	#include "moc_decryptverifytask.cpp"
	diff --git a/src/crypto/encryptemailtask.cpp b/src/crypto/encryptemailtask.cpp
	index e9fb85cb0..dda1e3224 100644
	--- a/src/crypto/encryptemailtask.cpp
	+++ b/src/crypto/encryptemailtask.cpp
	@@ -1,245 +1,239 @@
	/* -- mode: c++; c-basic-offset:4 --
	crypto/encryptemailtask.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 "encryptemailtask.h"

	#include <utils/input.h>
	#include <utils/kleo_assert.h>
	#include <utils/output.h>

	#include <Libkleo/AuditLogEntry>
	#include <Libkleo/Formatting>
	#include <Libkleo/Stl_Util>

	#include <QGpgME/EncryptJob>
	#include <QGpgME/Protocol>

	#include <gpgme++/encryptionresult.h>
	#include <gpgme++/key.h>

	#include <KLocalizedString>

	#include <QPointer>
	#include <QTextDocument> // for Qt::escape

	using namespace Kleo;
	using namespace Kleo::Crypto;
	using namespace GpgME;

	namespace
	{

	class EncryptEMailResult : public Task::Result
	{
	const EncryptionResult m_result;
	const AuditLogEntry m_auditLog;

	public:
	EncryptEMailResult(const EncryptionResult &r, const AuditLogEntry &auditLog)
	: Task::Result()
	, m_result(r)
	, m_auditLog(auditLog)
	{
	}

	QString overview() const override;
	QString details() const override;
	GpgME::Error error() const override;
	QString errorString() const override;
	VisualCode code() const override;
	AuditLogEntry auditLog() const override;
	};

	QString makeResultString(const EncryptionResult &res)
	{
	const Error err = res.error();

	if (err.isCanceled()) {
	return i18n("Encryption canceled.");
	}

	if (err) {
	return i18n("Encryption failed: %1", Formatting::errorAsString(err).toHtmlEscaped());
	}

	return i18n("Encryption succeeded.");
	}

	}

	class EncryptEMailTask::Private
	{
	friend class ::Kleo::Crypto::EncryptEMailTask;
	EncryptEMailTask *const q;

	public:
	explicit Private(EncryptEMailTask *qq);

	private:
	std::unique_ptr<QGpgME::EncryptJob> createJob(GpgME::Protocol proto);

	private:
	void slotResult(const EncryptionResult &);

	private:
	std::shared_ptr<Input> input;
	std::shared_ptr<Output> output;
	std::vector<Key> recipients;

	QPointer<QGpgME::EncryptJob> job;
	};

	EncryptEMailTask::Private::Private(EncryptEMailTask *qq)
	: q(qq)
	, input()
	, output()
	, job(nullptr)
	{
	}

	EncryptEMailTask::EncryptEMailTask(QObject *p)
	: Task(p)
	, d(new Private(this))
	{
	}

	EncryptEMailTask::~EncryptEMailTask()
	{
	}

	void EncryptEMailTask::setInput(const std::shared_ptr<Input> &input)
	{
	kleo_assert(!d->job);
	kleo_assert(input);
	d->input = input;
	}

	void EncryptEMailTask::setOutput(const std::shared_ptr<Output> &output)
	{
	kleo_assert(!d->job);
	kleo_assert(output);
	d->output = output;
	}

	void EncryptEMailTask::setRecipients(const std::vector<Key> &recipients)
	{
	kleo_assert(!d->job);
	kleo_assert(!recipients.empty());
	d->recipients = recipients;
	}

	Protocol EncryptEMailTask::protocol() const
	{
	kleo_assert(!d->recipients.empty());
	return d->recipients.front().protocol();
	}

	QString EncryptEMailTask::label() const
	{
	return d->input ? d->input->label() : QString();
	}

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

	void EncryptEMailTask::doStart()
	{
	kleo_assert(!d->job);
	kleo_assert(d->input);
	kleo_assert(d->output);
	kleo_assert(!d->recipients.empty());

	std::unique_ptr<QGpgME::EncryptJob> job = d->createJob(protocol());
	kleo_assert(job.get());

	job->start(d->recipients,
	d->input->ioDevice(),
	d->output->ioDevice(),
	/alwaysTrust=/true);

	d->job = job.release();
	}

	void EncryptEMailTask::cancel()
	{
	if (d->job) {
	d->job->slotCancel();
	}
	}

	std::unique_ptr<QGpgME::EncryptJob> EncryptEMailTask::Private::createJob(GpgME::Protocol proto)
	{
	const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(backend);
	bool shouldArmor = (proto == OpenPGP \|\| q->asciiArmor()) && !output->binaryOpt();
	std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(shouldArmor, /textmode=/false));
	kleo_assert(encryptJob.get());
	if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
	encryptJob->setOutputIsBase64Encoded(true);
	}
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(encryptJob.get(), &QGpgME::Job::jobProgress, q, &EncryptEMailTask::setProgress);
	-#else
	- connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult, QByteArray)), q, SLOT(slotResult(GpgME::EncryptionResult)));
	return encryptJob;
	}

	void EncryptEMailTask::Private::slotResult(const EncryptionResult &result)
	{
	const auto const job = qobject_cast<const QGpgME::Job >(q->sender());
	if (result.error().code()) {
	output->cancel();
	} else {
	output->finalize();
	}
	q->emitResult(std::shared_ptr<Result>(new EncryptEMailResult(result, AuditLogEntry::fromJob(job))));
	}

	QString EncryptEMailResult::overview() const
	{
	return makeOverview(makeResultString(m_result));
	}

	QString EncryptEMailResult::details() const
	{
	return QString();
	}

	GpgME::Error EncryptEMailResult::error() const
	{
	return m_result.error();
	}

	QString EncryptEMailResult::errorString() const
	{
	return hasError() ? makeResultString(m_result) : QString();
	}

	AuditLogEntry EncryptEMailResult::auditLog() const
	{
	return m_auditLog;
	}

	Task::Result::VisualCode EncryptEMailResult::code() const
	{
	if (m_result.error().isCanceled()) {
	return Warning;
	}
	return m_result.error().code() ? NeutralError : NeutralSuccess;
	}

	#include "moc_encryptemailtask.cpp"
	diff --git a/src/crypto/gui/signingcertificateselectionwidget.cpp b/src/crypto/gui/signingcertificateselectionwidget.cpp
	index ec06a72f4..bf2bff2a1 100644
	--- a/src/crypto/gui/signingcertificateselectionwidget.cpp
	+++ b/src/crypto/gui/signingcertificateselectionwidget.cpp
	@@ -1,164 +1,158 @@
	/* -- mode: c++; c-basic-offset:4 --
	crypto/gui/signingcertificateselectionwidget.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007, 2009 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "signingcertificateselectionwidget.h"

	#include "ui_signingcertificateselectionwidget.h"

	#include "utils/certificatepair.h"

	#include <Libkleo/Compat>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/Stl_Util>

	#include <QByteArray>

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

	class SigningCertificateSelectionWidget::Private
	{
	friend class ::SigningCertificateSelectionWidget;
	SigningCertificateSelectionWidget *const q;

	public:
	explicit Private(SigningCertificateSelectionWidget *qq);
	~Private();
	static std::vector<GpgME::Key> candidates(GpgME::Protocol prot);
	static void addCandidates(GpgME::Protocol prot, QComboBox *combo);

	private:
	Ui::SigningCertificateSelectionWidget ui;
	};

	static GpgME::Key current_cert(const QComboBox &cb)
	{
	const QByteArray fpr = cb.itemData(cb.currentIndex()).toByteArray();
	return KeyCache::instance()->findByFingerprint(fpr.constData());
	}

	static void select_cert(QComboBox &cb, const GpgME::Key &key)
	{
	const QByteArray fpr = key.primaryFingerprint();
	if (!fpr.isEmpty()) {
	cb.setCurrentIndex(cb.findData(fpr));
	}
	}

	static void add_cert(QComboBox &cb, const GpgME::Key &key)
	{
	cb.addItem(Formatting::formatForComboBox(key), QVariant(QByteArray(key.primaryFingerprint())));
	}

	SigningCertificateSelectionWidget::Private::Private(SigningCertificateSelectionWidget *qq)
	: q(qq)
	, ui()
	{
	ui.setupUi(q);
	addCandidates(GpgME::CMS, ui.cmsCombo);
	addCandidates(GpgME::OpenPGP, ui.pgpCombo);
	ui.rememberCO->setChecked(true);
	}

	SigningCertificateSelectionWidget::Private::~Private()
	{
	}

	SigningCertificateSelectionWidget::SigningCertificateSelectionWidget(QWidget *parent, Qt::WindowFlags f)
	: QWidget(parent, f)
	, d(new Private(this))
	{
	}

	SigningCertificateSelectionWidget::~SigningCertificateSelectionWidget()
	{
	}

	void SigningCertificateSelectionWidget::setSelectedCertificates(const CertificatePair &certificates)
	{
	setSelectedCertificates(certificates.openpgp, certificates.cms);
	}

	void SigningCertificateSelectionWidget::setSelectedCertificates(const GpgME::Key &pgp, const GpgME::Key &cms)
	{
	select_cert(*d->ui.pgpCombo, pgp);
	select_cert(*d->ui.cmsCombo, cms);
	}

	std::vector<GpgME::Key> SigningCertificateSelectionWidget::Private::candidates(GpgME::Protocol prot)
	{
	Q_ASSERT(prot != GpgME::UnknownProtocol);
	std::vector<GpgME::Key> keys = KeyCache::instance()->keys();
	auto end = keys.end();

	end = std::remove_if(keys.begin(), end, [prot](const GpgME::Key &key) {
	return key.protocol() != prot;
	});
	end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) {
	return !key.hasSecret();
	});
	Q_ASSERT(std::all_of(keys.begin(), end, [](const GpgME::Key &key) {
	return key.hasSecret();
	}));
	-#if GPGMEPP_KEY_CANSIGN_IS_FIXED
	end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) {
	return !Kleo::keyHasSign(key);
	});
	-#else
	- end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) {
	- return !key.canReallySign();
	- });
	-#endif
	end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) {
	return key.isExpired();
	});
	end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) {
	return key.isRevoked();
	});
	keys.erase(end, keys.end());
	return keys;
	}

	void SigningCertificateSelectionWidget::Private::addCandidates(GpgME::Protocol prot, QComboBox *combo)
	{
	const std::vector<GpgME::Key> keys = candidates(prot);
	for (const GpgME::Key &i : keys) {
	add_cert(*combo, i);
	}
	}

	CertificatePair SigningCertificateSelectionWidget::selectedCertificates() const
	{
	return {
	current_cert(*d->ui.pgpCombo),
	current_cert(*d->ui.cmsCombo),
	};
	}

	bool SigningCertificateSelectionWidget::rememberAsDefault() const
	{
	return d->ui.rememberCO->isChecked();
	}

	void SigningCertificateSelectionWidget::setAllowedProtocols(const std::set<GpgME::Protocol> &allowedProtocols)
	{
	setAllowedProtocols(allowedProtocols.find(GpgME::OpenPGP) != allowedProtocols.end(), allowedProtocols.find(GpgME::CMS) != allowedProtocols.end());
	}

	void SigningCertificateSelectionWidget::setAllowedProtocols(bool pgp, bool cms)
	{
	d->ui.pgpLabel->setVisible(pgp);
	d->ui.pgpCombo->setVisible(pgp);

	d->ui.cmsLabel->setVisible(cms);
	d->ui.cmsCombo->setVisible(cms);
	}
	diff --git a/src/crypto/signemailtask.cpp b/src/crypto/signemailtask.cpp
	index 2131fd069..55e38169f 100644
	--- a/src/crypto/signemailtask.cpp
	+++ b/src/crypto/signemailtask.cpp
	@@ -1,296 +1,290 @@
	/* -- mode: c++; c-basic-offset:4 --
	crypto/signemailtask.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 "signemailtask.h"

	#include <utils/input.h>
	#include <utils/kleo_assert.h>
	#include <utils/output.h>

	#include <Libkleo/AuditLogEntry>
	#include <Libkleo/Formatting>
	#include <Libkleo/Stl_Util>

	#include <QGpgME/Protocol>
	#include <QGpgME/SignJob>

	#include <gpgme++/key.h>
	#include <gpgme++/signingresult.h>

	#include <KLocalizedString>

	#include <QPointer>
	#include <QTextDocument> // for Qt::escape

	#include <algorithm>
	#include <functional>

	using namespace Kleo;
	using namespace Kleo::Crypto;
	using namespace GpgME;

	namespace
	{

	class SignEMailResult : public Task::Result
	{
	const SigningResult m_result;
	const AuditLogEntry m_auditLog;

	public:
	explicit SignEMailResult(const SigningResult &r, const AuditLogEntry &auditLog)
	: Task::Result()
	, m_result(r)
	, m_auditLog(auditLog)
	{
	}

	QString overview() const override;
	QString details() const override;
	GpgME::Error error() const override;
	QString errorString() const override;
	VisualCode code() const override;
	AuditLogEntry auditLog() const override;
	};

	QString makeResultString(const SigningResult &res)
	{
	const Error err = res.error();

	if (err.isCanceled()) {
	return i18n("Signing canceled.");
	}

	if (err) {
	return i18n("Signing failed: %1", Formatting::errorAsString(err).toHtmlEscaped());
	}

	return i18n("Signing succeeded.");
	}
	}

	class SignEMailTask::Private
	{
	friend class ::Kleo::Crypto::SignEMailTask;
	SignEMailTask *const q;

	public:
	explicit Private(SignEMailTask *qq);

	private:
	std::unique_ptr<QGpgME::SignJob> createJob(GpgME::Protocol proto);

	private:
	void slotResult(const SigningResult &);

	private:
	std::shared_ptr<Input> input;
	std::shared_ptr<Output> output;
	std::vector<Key> signers;
	bool detached;
	bool clearsign;

	QString micAlg;

	QPointer<QGpgME::SignJob> job;
	};

	SignEMailTask::Private::Private(SignEMailTask *qq)
	: q(qq)
	, input()
	, output()
	, signers()
	, detached(false)
	, clearsign(false)
	, micAlg()
	, job(nullptr)
	{
	}

	SignEMailTask::SignEMailTask(QObject *p)
	: Task(p)
	, d(new Private(this))
	{
	}

	SignEMailTask::~SignEMailTask()
	{
	}

	void SignEMailTask::setInput(const std::shared_ptr<Input> &input)
	{
	kleo_assert(!d->job);
	kleo_assert(input);
	d->input = input;
	}

	void SignEMailTask::setOutput(const std::shared_ptr<Output> &output)
	{
	kleo_assert(!d->job);
	kleo_assert(output);
	d->output = output;
	}

	void SignEMailTask::setSigners(const std::vector<Key> &signers)
	{
	kleo_assert(!d->job);
	kleo_assert(!signers.empty());
	kleo_assert(std::none_of(signers.cbegin(), signers.cend(), std::mem_fn(&Key::isNull)));
	d->signers = signers;
	}

	void SignEMailTask::setDetachedSignature(bool detached)
	{
	kleo_assert(!d->job);
	d->detached = detached;
	d->clearsign = false;
	}

	void SignEMailTask::setClearsign(bool clear)
	{
	kleo_assert(!d->job);
	d->clearsign = clear;
	d->detached = false;
	}

	Protocol SignEMailTask::protocol() const
	{
	kleo_assert(!d->signers.empty());
	return d->signers.front().protocol();
	}

	QString SignEMailTask::label() const
	{
	return d->input ? d->input->label() : QString();
	}

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

	void SignEMailTask::doStart()
	{
	kleo_assert(!d->job);
	kleo_assert(d->input);
	kleo_assert(d->output);
	kleo_assert(!d->signers.empty());

	d->micAlg.clear();

	std::unique_ptr<QGpgME::SignJob> job = d->createJob(protocol());
	kleo_assert(job.get());

	job->start(d->signers,
	d->input->ioDevice(),
	d->output->ioDevice(),
	d->clearsign ? GpgME::Clearsigned
	: d->detached ? GpgME::Detached
	: GpgME::NormalSignatureMode);

	d->job = job.release();
	}

	void SignEMailTask::cancel()
	{
	if (d->job) {
	d->job->slotCancel();
	}
	}

	std::unique_ptr<QGpgME::SignJob> SignEMailTask::Private::createJob(GpgME::Protocol proto)
	{
	const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(backend);
	bool shouldArmor = (proto == OpenPGP \|\| q->asciiArmor()) && !output->binaryOpt();
	std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(/armor=/shouldArmor, /textmode=/false));
	kleo_assert(signJob.get());
	if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
	signJob->setOutputIsBase64Encoded(true);
	}
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(signJob.get(), &QGpgME::Job::jobProgress, q, &SignEMailTask::setProgress);
	-#else
	- connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	connect(signJob.get(), SIGNAL(result(GpgME::SigningResult, QByteArray)), q, SLOT(slotResult(GpgME::SigningResult)));
	return signJob;
	}

	static QString collect_micalgs(const GpgME::SigningResult &result, GpgME::Protocol proto)
	{
	const std::vector<GpgME::CreatedSignature> css = result.createdSignatures();
	QStringList micalgs;
	std::transform(css.begin(), css.end(), std::back_inserter(micalgs), [](const GpgME::CreatedSignature &sig) {
	return QString::fromLatin1(sig.hashAlgorithmAsString()).toLower();
	});
	if (proto == GpgME::OpenPGP)
	for (QStringList::iterator it = micalgs.begin(), end = micalgs.end(); it != end; ++it) {
	it->prepend(QLatin1String("pgp-"));
	}
	micalgs.sort();
	micalgs.erase(std::unique(micalgs.begin(), micalgs.end()), micalgs.end());
	return micalgs.join(QLatin1Char(','));
	}

	void SignEMailTask::Private::slotResult(const SigningResult &result)
	{
	const auto const job = qobject_cast<const QGpgME::Job >(q->sender());
	if (result.error().code()) {
	output->cancel();
	} else {
	output->finalize();
	micAlg = collect_micalgs(result, q->protocol());
	}
	q->emitResult(std::shared_ptr<Result>(new SignEMailResult(result, AuditLogEntry::fromJob(job))));
	}

	QString SignEMailTask::micAlg() const
	{
	return d->micAlg;
	}

	QString SignEMailResult::overview() const
	{
	return makeOverview(makeResultString(m_result));
	}

	QString SignEMailResult::details() const
	{
	return QString();
	}

	GpgME::Error SignEMailResult::error() const
	{
	return m_result.error();
	}

	QString SignEMailResult::errorString() const
	{
	return hasError() ? makeResultString(m_result) : QString();
	}

	Task::Result::VisualCode SignEMailResult::code() const
	{
	if (m_result.error().isCanceled()) {
	return Warning;
	}
	return m_result.error().code() ? NeutralError : NeutralSuccess;
	}

	AuditLogEntry SignEMailResult::auditLog() const
	{
	return m_auditLog;
	}

	#include "moc_signemailtask.cpp"
	diff --git a/src/crypto/signencryptfilescontroller.cpp b/src/crypto/signencryptfilescontroller.cpp
	index abb5f9787..55431be43 100644
	--- a/src/crypto/signencryptfilescontroller.cpp
	+++ b/src/crypto/signencryptfilescontroller.cpp
	@@ -1,789 +1,783 @@
	/* -- 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 "crypto/gui/signencryptfileswizard.h"
	#include "crypto/taskcollection.h"

	#include "fileoperationspreferences.h"

	#include "utils/archivedefinition.h"
	#include "utils/input.h"
	#include "utils/kleo_assert.h"
	#include "utils/output.h"
	#include "utils/path-helper.h"

	#include <Libkleo/Classify>
	#include <Libkleo/KleoException>

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

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	#include <QGpgME/SignEncryptArchiveJob>
	-#endif

	#include <QDir>
	#include <QFileInfo>
	#include <QPointer>
	#include <QTimer>

	using namespace Kleo;
	using namespace Kleo::Crypto;
	using namespace GpgME;

	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) << q << __func__;
	}

	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) << this << __func__;
	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(encrOp == EncryptSelected);
	}

	wizard->setArchiveForced(archOp == ArchiveForced);
	wizard->setArchiveMutable(archOp == ArchiveAllowed);
	}

	unsigned int SignEncryptFilesController::operationMode() const
	{
	return d->operation;
	}

	static QString 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();
	const auto ext = outputFileExtension(cls, usePGPFileExt);
	if (!ext.isEmpty()) {
	return ext;
	} else {
	return QStringLiteral("out");
	}
	}

	static std::shared_ptr<ArchiveDefinition> getDefaultAd()
	{
	const std::vector<std::shared_ptr<ArchiveDefinition>> ads = ArchiveDefinition::getArchiveDefinitions();
	Q_ASSERT(!ads.empty());
	std::shared_ptr<ArchiveDefinition> ad = ads.front();
	const FileOperationsPreferences prefs;
	const QString archiveCmd = prefs.archiveCommand();
	auto it = std::find_if(ads.cbegin(), ads.cend(), [&archiveCmd](const std::shared_ptr<ArchiveDefinition> &toCheck) {
	return toCheck->id() == archiveCmd;
	});
	if (it != ads.cend()) {
	ad = *it;
	}
	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 = files.size() > 1 ? i18nc("base name of an archive file, e.g. archive.zip or archive.tar.gz", "archive") : firstFile.baseName();
	baseName = QDir(heuristicBaseDirectory(files)).absoluteFilePath(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 + extension(false, true, false, ascii, true));
	nameMap.insert(SignEncryptFilesWizard::EncryptedCMS, baseNameCms + extension(false, false, true, ascii, false));
	nameMap.insert(SignEncryptFilesWizard::CombinedPGP, baseNamePgp + extension(true, true, true, ascii, false));
	nameMap.insert(SignEncryptFilesWizard::EncryptedPGP, baseNamePgp + extension(true, false, true, ascii, false));
	nameMap.insert(SignEncryptFilesWizard::SignaturePGP, baseNamePgp + 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 + extension(false, true, false, ascii, true));
	ret.insert(SignEncryptFilesWizard::EncryptedCMS, baseName + extension(false, false, true, ascii, false));
	ret.insert(SignEncryptFilesWizard::CombinedPGP, baseName + extension(true, true, true, ascii, false));
	ret.insert(SignEncryptFilesWizard::EncryptedPGP, baseName + extension(true, false, true, ascii, false));
	ret.insert(SignEncryptFilesWizard::SignaturePGP, baseName + extension(true, true, false, ascii, true));
	return ret;
	}

	// strips all trailing slashes from the filename, but keeps filename "/"
	static QString stripTrailingSlashes(const QString &fileName)
	{
	if (fileName.size() < 2 \|\| !fileName.endsWith(QLatin1Char('/'))) {
	return fileName;
	}
	auto tmp = QStringView{fileName}.chopped(1);
	while (tmp.size() > 1 && tmp.endsWith(QLatin1Char('/'))) {
	tmp.chop(1);
	}
	return tmp.toString();
	}

	static QStringList stripTrailingSlashesForAll(const QStringList &fileNames)
	{
	QStringList result;
	result.reserve(fileNames.size());
	std::transform(fileNames.begin(), fileNames.end(), std::back_inserter(result), &stripTrailingSlashes);
	return result;
	}

	void SignEncryptFilesController::setFiles(const QStringList &files)
	{
	kleo_assert(!files.empty());
	d->files = stripTrailingSlashesForAll(files);
	bool archive = false;

	if (d->files.size() > 1) {
	setOperationMode((operationMode() & ~ArchiveMask) \| ArchiveAllowed);
	archive = true;
	}
	for (const auto &file : d->files) {
	if (QFileInfo(file).isDir()) {
	setOperationMode((operationMode() & ~ArchiveMask) \| ArchiveForced);
	archive = true;
	break;
	}
	}
	d->ensureWizardCreated();
	d->wizard->setSingleFile(!archive);
	d->wizard->setOutputNames(buildOutputNames(d->files, archive));
	}

	void SignEncryptFilesController::Private::slotWizardCanceled()
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__;
	q->cancel();
	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 bool archiveJobsCanBeUsed([[maybe_unused]] GpgME::Protocol protocol)
	{
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	return (protocol == GpgME::OpenPGP) && QGpgME::SignEncryptArchiveJob::isSupported();
	-#else
	- return false;
	-#endif
	}

	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->setCreateArchive(true);
	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);
	}

	const Protocol proto = pgp ? OpenPGP : CMS;

	task->setInputFileNames(files);
	if (!archiveJobsCanBeUsed(proto)) {
	// use legacy archive creation
	kleo_assert(ad);
	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;
	}

	namespace
	{
	static auto resolveFileNameConflicts(const std::vector<std::shared_ptr<SignEncryptTask>> &tasks, QWidget *parent)
	{
	std::vector<std::shared_ptr<SignEncryptTask>> resolvedTasks;

	OverwritePolicy overwritePolicy{parent, tasks.size() > 1 ? OverwritePolicy::MultipleFiles : OverwritePolicy::Options{}};
	for (auto &task : tasks) {
	// by default, do not overwrite existing files
	task->setOverwritePolicy(std::make_shared<OverwritePolicy>(OverwritePolicy::Skip));
	const auto outputFileName = task->outputFileName();
	if (QFile::exists(outputFileName)) {
	const auto newFileName = overwritePolicy.obtainOverwritePermission(outputFileName);
	if (newFileName.isEmpty()) {
	if (overwritePolicy.policy() == OverwritePolicy::Cancel) {
	resolvedTasks.clear();
	break;
	}
	// else Skip -> do not add task to the final task list
	continue;
	} else if (newFileName != outputFileName) {
	task->setOutputFileName(newFileName);
	} else {
	task->setOverwritePolicy(std::make_shared<OverwritePolicy>(OverwritePolicy::Overwrite));
	}
	}
	resolvedTasks.push_back(task);
	}

	return resolvedTasks;
	}
	}

	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 std::vector<Key> recipients = wizard->resolvedRecipients();
	const std::vector<Key> signers = wizard->resolvedSigners();

	const FileOperationsPreferences prefs;
	const bool ascii = prefs.addASCIIArmor();

	std::vector<Key> pgpRecipients, cmsRecipients, pgpSigners, cmsSigners;
	for (const Key &k : recipients) {
	if (k.protocol() == GpgME::OpenPGP) {
	pgpRecipients.push_back(k);
	} else {
	cmsRecipients.push_back(k);
	}
	}

	for (const Key &k : signers) {
	if (k.protocol() == GpgME::OpenPGP) {
	pgpSigners.push_back(k);
	} else {
	cmsSigners.push_back(k);
	}
	}

	std::vector<std::shared_ptr<SignEncryptTask>> tasks;
	if (!archive) {
	tasks.reserve(files.size());
	}

	if (archive) {
	tasks = createArchiveSignEncryptTasksForFiles(files,
	getDefaultAd(),
	ascii,
	pgpRecipients,
	pgpSigners,
	cmsRecipients,
	cmsSigners,
	wizard->outputNames(),
	wizard->encryptSymmetric());
	} else {
	for (const QString &file : std::as_const(files)) {
	const std::vector<std::shared_ptr<SignEncryptTask>> created =
	createSignEncryptTasksForFileInfo(QFileInfo(file),
	ascii,
	pgpRecipients,
	pgpSigners,
	cmsRecipients,
	cmsSigners,
	buildOutputNamesForDir(file, wizard->outputNames()),
	wizard->encryptSymmetric());
	tasks.insert(tasks.end(), created.begin(), created.end());
	}
	}

	tasks = resolveFileNameConflicts(tasks, wizard);
	if (tasks.empty()) {
	q->cancel();
	return;
	}

	kleo_assert(runnable.empty());

	runnable.swap(tasks);

	for (const auto &task : std::as_const(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) << this << __func__;
	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 d609fe75f..9358f6594 100644
	--- a/src/crypto/signencrypttask.cpp
	+++ b/src/crypto/signencrypttask.cpp
	@@ -1,942 +1,909 @@
	/* -- 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/gpgme-compat.h>
	#include <utils/input.h>
	#include <utils/kleo_assert.h>
	#include <utils/output.h>
	#include <utils/path-helper.h>
	#include <utils/qt-cxx20-compat.h>

	#include <Libkleo/AuditLogEntry>
	#include <Libkleo/Formatting>
	#include <Libkleo/KleoException>
	#include <Libkleo/Stl_Util>

	+#include <QGpgME/EncryptArchiveJob>
	#include <QGpgME/EncryptJob>
	#include <QGpgME/Protocol>
	-#include <QGpgME/SignEncryptJob>
	-#include <QGpgME/SignJob>
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	-#include <QGpgME/EncryptArchiveJob>
	#include <QGpgME/SignArchiveJob>
	#include <QGpgME/SignEncryptArchiveJob>
	-#endif
	+#include <QGpgME/SignEncryptJob>
	+#include <QGpgME/SignJob>

	#include <gpgme++/encryptionresult.h>
	#include <gpgme++/key.h>
	#include <gpgme++/signingresult.h>

	#include <KLocalizedString>

	#include "kleopatra_debug.h"
	#include <QFileInfo>
	#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 → %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 AuditLogEntry &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;
	GpgME::Error error() const override
	{
	return m_error;
	}
	QString errorString() const override
	{
	return m_errString;
	}
	VisualCode code() const override
	{
	return NeutralError;
	}
	AuditLogEntry 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 AuditLogEntry m_auditLog;
	};

	namespace
	{
	struct LabelAndError {
	QString label;
	QString errorString;
	};
	}

	class SignEncryptFilesResult : public Task::Result
	{
	public:
	SignEncryptFilesResult(const SigningResult &sr, const LabelAndError &input, const LabelAndError &output, bool outputCreated, const AuditLogEntry &auditLog)
	: Task::Result()
	, m_sresult(sr)
	, m_input{input}
	, m_output{output}
	, m_outputCreated(outputCreated)
	, m_auditLog(auditLog)
	{
	qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString << "\noutputError:" << m_output.errorString;
	Q_ASSERT(!m_sresult.isNull());
	}
	SignEncryptFilesResult(const EncryptionResult &er,
	const LabelAndError &input,
	const LabelAndError &output,
	bool outputCreated,
	const AuditLogEntry &auditLog)
	: Task::Result()
	, m_eresult(er)
	, m_input{input}
	, m_output{output}
	, m_outputCreated(outputCreated)
	, m_auditLog(auditLog)
	{
	qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString << "\noutputError:" << m_output.errorString;
	Q_ASSERT(!m_eresult.isNull());
	}
	SignEncryptFilesResult(const SigningResult &sr,
	const EncryptionResult &er,
	const LabelAndError &input,
	const LabelAndError &output,
	bool outputCreated,
	const AuditLogEntry &auditLog)
	: Task::Result()
	, m_sresult(sr)
	, m_eresult(er)
	, m_input{input}
	, m_output{output}
	, m_outputCreated(outputCreated)
	, m_auditLog(auditLog)
	{
	qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString << "\noutputError:" << m_output.errorString;
	Q_ASSERT(!m_sresult.isNull() \|\| !m_eresult.isNull());
	}

	QString overview() const override;
	QString details() const override;
	GpgME::Error error() const override;
	QString errorString() const override;
	VisualCode code() const override;
	AuditLogEntry auditLog() const override;

	private:
	const SigningResult m_sresult;
	const EncryptionResult m_eresult;
	const LabelAndError m_input;
	const LabelAndError m_output;
	const bool m_outputCreated;
	const AuditLogEntry 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 \|\| err.isCanceled()) {
	return Formatting::errorAsString(err).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 \|\| err.isCanceled()) {
	return Formatting::errorAsString(err).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:
	QString inputLabel() const;
	QString outputLabel() const;

	bool removeExistingOutputFile();

	void startSignEncryptJob(GpgME::Protocol proto);
	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);

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void startSignEncryptArchiveJob(GpgME::Protocol proto);
	std::unique_ptr<QGpgME::SignArchiveJob> createSignArchiveJob(GpgME::Protocol proto);
	std::unique_ptr<QGpgME::SignEncryptArchiveJob> createSignEncryptArchiveJob(GpgME::Protocol proto);
	std::unique_ptr<QGpgME::EncryptArchiveJob> createEncryptArchiveJob(GpgME::Protocol proto);
	-#endif

	std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog);

	private:
	void slotResult(const SigningResult &);
	void slotResult(const SigningResult &, const EncryptionResult &);
	void slotResult(const EncryptionResult &);

	void slotResult(const QGpgME::Job *, const SigningResult &, 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;
	bool archive : 1;

	QPointer<QGpgME::Job> job;
	QString labelText;
	std::shared_ptr<OverwritePolicy> m_overwritePolicy;
	};

	SignEncryptTask::Private::Private(SignEncryptTask *qq)
	: q{qq}
	, sign{true}
	, encrypt{true}
	, detached{false}
	, clearsign{false}
	, archive{false}
	, m_overwritePolicy{new OverwritePolicy{OverwritePolicy::Ask}}
	{
	q->setAsciiArmor(true);
	}

	std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog)
	{
	return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, inputLabel(), outputLabel(), 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;
	}

	QString SignEncryptTask::outputFileName() const
	{
	return d->outputFileName;
	}

	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;
	}

	void SignEncryptTask::setCreateArchive(bool archive)
	{
	kleo_assert(!d->job);
	d->archive = archive;
	}

	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
	{
	if (!d->labelText.isEmpty()) {
	return d->labelText;
	}
	return d->inputLabel();
	}

	QString SignEncryptTask::tag() const
	{
	return Formatting::displayName(protocol());
	}

	unsigned long long SignEncryptTask::inputSize() const
	{
	return d->input ? d->input->size() : 0U;
	}

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
	{
	return (protocol == GpgME::OpenPGP) && QGpgME::SignEncryptArchiveJob::isSupported();
	}
	-#endif

	void SignEncryptTask::doStart()
	{
	kleo_assert(!d->job);
	if (d->sign) {
	kleo_assert(!d->signers.empty());
	if (d->archive) {
	kleo_assert(!d->detached && !d->clearsign);
	}
	}

	const auto proto = protocol();
	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	if (d->archive && archiveJobsCanBeUsed(proto)) {
	d->startSignEncryptArchiveJob(proto);
	- } else
	-#endif
	- {
	+ } else {
	if (!d->output) {
	d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
	}
	d->startSignEncryptJob(proto);
	}
	}

	QString SignEncryptTask::Private::inputLabel() const
	{
	if (input) {
	return input->label();
	}
	if (!inputFileNames.empty()) {
	const auto firstFile = QFileInfo{inputFileNames.front()}.fileName();
	return inputFileNames.size() == 1 ? firstFile : i18nc("<name of first file>, ...", "%1, ...", firstFile);
	}
	return {};
	}

	QString SignEncryptTask::Private::outputLabel() const
	{
	return output ? output->label() : QFileInfo{outputFileName}.fileName();
	}

	bool SignEncryptTask::Private::removeExistingOutputFile()
	{
	if (QFile::exists(outputFileName)) {
	bool fileRemoved = false;
	// we should already have asked the user for overwrite permission
	if (m_overwritePolicy && (m_overwritePolicy->policy() == OverwritePolicy::Overwrite)) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "going to remove file for overwriting" << outputFileName;
	fileRemoved = QFile::remove(outputFileName);
	if (!fileRemoved) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "removing file to overwrite failed";
	}
	} else {
	qCDebug(KLEOPATRA_LOG) << __func__ << "we have no permission to overwrite" << outputFileName;
	}
	if (!fileRemoved) {
	QMetaObject::invokeMethod(
	q,
	[this]() {
	slotResult(nullptr, SigningResult{}, EncryptionResult{Error::fromCode(GPG_ERR_EEXIST)});
	},
	Qt::QueuedConnection);
	return false;
	}
	}

	return true;
	}

	void SignEncryptTask::Private::startSignEncryptJob(GpgME::Protocol proto)
	{
	kleo_assert(input);

	if (encrypt \|\| symmetric) {
	Context::EncryptionFlags flags{Context::None};
	if (proto == GpgME::OpenPGP) {
	flags = static_cast<Context::EncryptionFlags>(flags \| Context::AlwaysTrust);
	}
	if (symmetric) {
	flags = static_cast<Context::EncryptionFlags>(flags \| Context::Symmetric);
	qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
	}
	if (sign) {
	std::unique_ptr<QGpgME::SignEncryptJob> job = createSignEncryptJob(proto);
	kleo_assert(job.get());
	-#if QGPGME_SUPPORTS_SET_FILENAME
	if (inputFileNames.size() == 1) {
	job->setFileName(inputFileNames.front());
	}
	-#endif

	job->start(signers, recipients, input->ioDevice(), output->ioDevice(), flags);

	this->job = job.release();
	} else {
	std::unique_ptr<QGpgME::EncryptJob> job = createEncryptJob(proto);
	kleo_assert(job.get());
	-#if QGPGME_SUPPORTS_SET_FILENAME
	if (inputFileNames.size() == 1) {
	job->setFileName(inputFileNames.front());
	}
	-#endif

	job->start(recipients, input->ioDevice(), output->ioDevice(), flags);

	this->job = job.release();
	}
	} else if (sign) {
	std::unique_ptr<QGpgME::SignJob> job = createSignJob(proto);
	kleo_assert(job.get());
	kleo_assert(!(detached && clearsign));

	job->start(signers, input->ioDevice(), output->ioDevice(), detached ? GpgME::Detached : clearsign ? GpgME::Clearsigned : GpgME::NormalSignatureMode);

	this->job = job.release();
	} else {
	kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
	}
	}

	void SignEncryptTask::cancel()
	{
	qCDebug(KLEOPATRA_LOG) << this << __func__;
	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());
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(signJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
	-#else
	- connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	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());
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(signEncryptJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
	-#else
	- connect(signEncryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	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());
	-#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
	connect(encryptJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
	-#else
	- connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
	- q->setProgress(processed, total);
	- });
	-#endif
	connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult, QByteArray)), q, SLOT(slotResult(GpgME::EncryptionResult)));
	return encryptJob;
	}

	-#if QGPGME_SUPPORTS_ARCHIVE_JOBS
	void SignEncryptTask::Private::startSignEncryptArchiveJob(GpgME::Protocol proto)
	{
	kleo_assert(!input);
	kleo_assert(!output);

	#if !QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME
	output = Output::createFromFile(outputFileName, m_overwritePolicy);
	#endif

	const auto baseDirectory = heuristicBaseDirectory(inputFileNames);
	if (baseDirectory.isEmpty()) {
	throw Kleo::Exception(GPG_ERR_CONFLICT, i18n("Cannot find common base directory for these files:\n%1", inputFileNames.join(QLatin1Char('\n'))));
	}
	qCDebug(KLEOPATRA_LOG) << "heuristicBaseDirectory(" << inputFileNames << ") ->" << baseDirectory;
	const auto tempPaths = makeRelativeTo(baseDirectory, inputFileNames);
	const auto relativePaths = std::vector<QString>{tempPaths.begin(), tempPaths.end()};
	qCDebug(KLEOPATRA_LOG) << "relative paths:" << relativePaths;

	if (encrypt \|\| symmetric) {
	Context::EncryptionFlags flags{Context::None};
	if (proto == GpgME::OpenPGP) {
	flags = static_cast<Context::EncryptionFlags>(flags \| Context::AlwaysTrust);
	}
	if (symmetric) {
	flags = static_cast<Context::EncryptionFlags>(flags \| Context::Symmetric);
	qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
	}
	if (sign) {
	labelText = i18nc("@info", "Creating signed and encrypted archive ...");
	std::unique_ptr<QGpgME::SignEncryptArchiveJob> job = createSignEncryptArchiveJob(proto);
	kleo_assert(job.get());
	job->setBaseDirectory(baseDirectory);
	#if QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME
	job->setSigners(signers);
	job->setRecipients(recipients);
	job->setInputPaths(relativePaths);
	job->setOutputFile(outputFileName);
	job->setEncryptionFlags(flags);
	if (!removeExistingOutputFile()) {
	return;
	}
	job->startIt();
	#else
	job->start(signers, recipients, relativePaths, output->ioDevice(), flags);
	#endif

	this->job = job.release();
	} else {
	labelText = i18nc("@info", "Creating encrypted archive ...");
	std::unique_ptr<QGpgME::EncryptArchiveJob> job = createEncryptArchiveJob(proto);
	kleo_assert(job.get());
	job->setBaseDirectory(baseDirectory);
	#if QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME
	job->setRecipients(recipients);
	job->setInputPaths(relativePaths);
	job->setOutputFile(outputFileName);
	job->setEncryptionFlags(flags);
	if (!removeExistingOutputFile()) {
	return;
	}
	job->startIt();
	#else
	job->start(recipients, relativePaths, output->ioDevice(), flags);
	#endif

	this->job = job.release();
	}
	} else if (sign) {
	labelText = i18nc("@info", "Creating signed archive ...");
	std::unique_ptr<QGpgME::SignArchiveJob> job = createSignArchiveJob(proto);
	kleo_assert(job.get());
	job->setBaseDirectory(baseDirectory);
	#if QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME
	job->setSigners(signers);
	job->setInputPaths(relativePaths);
	job->setOutputFile(outputFileName);
	if (!removeExistingOutputFile()) {
	return;
	}
	job->startIt();
	#else
	job->start(signers, relativePaths, output->ioDevice());
	#endif

	this->job = job.release();
	} else {
	kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
	}
	}

	std::unique_ptr<QGpgME::SignArchiveJob> SignEncryptTask::Private::createSignArchiveJob(GpgME::Protocol proto)
	{
	const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(backend);
	std::unique_ptr<QGpgME::SignArchiveJob> signJob(backend->signArchiveJob(q->asciiArmor()));
	auto job = signJob.get();
	kleo_assert(job);
	connect(job, &QGpgME::SignArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
	connect(job, &QGpgME::SignArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult) {
	slotResult(job, signResult, EncryptionResult{});
	});
	return signJob;
	}

	std::unique_ptr<QGpgME::SignEncryptArchiveJob> SignEncryptTask::Private::createSignEncryptArchiveJob(GpgME::Protocol proto)
	{
	const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(backend);
	std::unique_ptr<QGpgME::SignEncryptArchiveJob> signEncryptJob(backend->signEncryptArchiveJob(q->asciiArmor()));
	auto job = signEncryptJob.get();
	kleo_assert(job);
	connect(job, &QGpgME::SignEncryptArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
	connect(job, &QGpgME::SignEncryptArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult, const GpgME::EncryptionResult &encryptResult) {
	slotResult(job, signResult, encryptResult);
	});
	return signEncryptJob;
	}

	std::unique_ptr<QGpgME::EncryptArchiveJob> SignEncryptTask::Private::createEncryptArchiveJob(GpgME::Protocol proto)
	{
	const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
	kleo_assert(backend);
	std::unique_ptr<QGpgME::EncryptArchiveJob> encryptJob(backend->encryptArchiveJob(q->asciiArmor()));
	auto job = encryptJob.get();
	kleo_assert(job);
	connect(job, &QGpgME::EncryptArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
	connect(job, &QGpgME::EncryptArchiveJob::result, q, [this, job](const GpgME::EncryptionResult &encryptResult) {
	slotResult(job, SigningResult{}, encryptResult);
	});
	return encryptJob;
	}
	-#endif

	void SignEncryptTask::Private::slotResult(const SigningResult &result)
	{
	slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), result, EncryptionResult{});
	}

	void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
	{
	slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), sresult, eresult);
	}

	void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
	{
	slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), SigningResult{}, result);
	}

	void SignEncryptTask::Private::slotResult(const QGpgME::Job *job, const SigningResult &sresult, const EncryptionResult &eresult)
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__ << "job:" << job << "signing result:" << QGpgME::toLogString(sresult)
	<< "encryption result:" << QGpgME::toLogString(eresult);
	const AuditLogEntry auditLog = AuditLogEntry::fromJob(job);
	bool outputCreated = false;
	if (input && input->failed()) {
	if (output) {
	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()) {
	if (output) {
	output->cancel();
	}
	if (!outputFileName.isEmpty() && eresult.error().code() != GPG_ERR_EEXIST) {
	// ensure that the output file is removed if the task was canceled or an error occurred;
	// unless a "file exists" error occurred because this means that the file with the name
	// of outputFileName wasn't created as result of this task
	if (QFile::exists(outputFileName)) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Removing output file" << outputFileName << "after error or cancel";
	if (!QFile::remove(outputFileName)) {
	qCDebug(KLEOPATRA_LOG) << __func__ << "Removing output file" << outputFileName << "failed";
	}
	}
	}
	} else {
	try {
	kleo_assert(!sresult.isNull() \|\| !eresult.isNull());
	if (output) {
	output->finalize();
	}
	outputCreated = true;
	if (input) {
	input->finalize();
	}
	} catch (const GpgME::Exception &e) {
	q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
	return;
	}
	}

	const LabelAndError inputInfo{inputLabel(), input ? input->errorString() : QString{}};
	const LabelAndError outputInfo{outputLabel(), output ? output->errorString() : QString{}};
	q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, inputInfo, outputInfo, outputCreated, auditLog)));
	}

	QString SignEncryptFilesResult::overview() const
	{
	const QString files = formatInputOutputLabel(m_input.label, m_output.label, !m_outputCreated);
	return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
	}

	QString SignEncryptFilesResult::details() const
	{
	return errorString();
	}

	GpgME::Error SignEncryptFilesResult::error() const
	{
	if (m_sresult.error().code()) {
	return m_sresult.error();
	}
	if (m_eresult.error().code()) {
	return m_eresult.error();
	}
	return {};
	}

	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_input.errorString, m_output.errorString)
	: m_eresult.error().code() ? makeResultDetails(m_eresult, m_input.errorString, m_output.errorString)
	: QString();
	}

	return sign ? makeResultDetails(m_sresult, m_input.errorString, m_output.errorString) //
	: makeResultDetails(m_eresult, m_input.errorString, m_output.errorString);
	}

	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;
	}

	AuditLogEntry SignEncryptFilesResult::auditLog() const
	{
	return m_auditLog;
	}

	#include "moc_signencrypttask.cpp"
	diff --git a/src/dialogs/certificatedetailswidget.cpp b/src/dialogs/certificatedetailswidget.cpp
	index 67f4b7ea9..1eac494ad 100644
	--- a/src/dialogs/certificatedetailswidget.cpp
	+++ b/src/dialogs/certificatedetailswidget.cpp
	@@ -1,1143 +1,1132 @@
	/*
	dialogs/certificatedetailswidget.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2017 Intevation GmbH
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
	SPDX-FileCopyrightText: 2022 Felix Tiede

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "certificatedetailswidget.h"

	#include "exportdialog.h"
	#include "kleopatra_debug.h"
	#include "subkeyswidget.h"
	#include "trustchainwidget.h"
	#include "weboftrustdialog.h"

	#include "commands/certifycertificatecommand.h"
	#include "commands/changeexpirycommand.h"
	#include "commands/changepassphrasecommand.h"
	#ifdef MAILAKONADI_ENABLED
	#include "commands/exportopenpgpcerttoprovidercommand.h"
	#endif // MAILAKONADI_ENABLED
	#include "commands/adduseridcommand.h"
	#include "commands/detailscommand.h"
	#include "commands/dumpcertificatecommand.h"
	#include "commands/genrevokecommand.h"
	#include "commands/refreshcertificatecommand.h"
	#include "commands/revokecertificationcommand.h"
	#include "commands/revokeuseridcommand.h"
	#include "commands/setprimaryuseridcommand.h"
	#include "utils/accessibility.h"
	#include "utils/tags.h"
	#include "view/infofield.h"

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compliance>
	#include <Libkleo/Dn>
	#include <Libkleo/Formatting>
	#include <Libkleo/GnuPG>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyHelpers>
	#include <Libkleo/NavigatableTreeWidget>

	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KSeparator>

	#include <gpgme++/context.h>
	#include <gpgme++/key.h>
	#include <gpgme++/keylistresult.h>
	#include <gpgme++/tofuinfo.h>

	#include <QGpgME/Debug>
	#include <QGpgME/KeyListJob>
	#include <QGpgME/Protocol>

	#include <QClipboard>
	#include <QDateTime>
	#include <QGridLayout>
	#include <QGuiApplication>
	#include <QHBoxLayout>
	#include <QLabel>
	#include <QListWidget>
	#include <QLocale>
	#include <QMenu>
	#include <QPushButton>
	#include <QStringBuilder>
	#include <QTreeWidget>
	#include <QVBoxLayout>

	#include <map>
	#if __has_include(<ranges>)
	#include <ranges>
	#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
	#define USE_RANGES
	#endif
	#endif
	#include <set>

	Q_DECLARE_METATYPE(GpgME::UserID)

	using namespace Kleo;

	namespace
	{
	std::vector<GpgME::UserID> selectedUserIDs(const QTreeWidget *treeWidget)
	{
	if (!treeWidget) {
	return {};
	}

	std::vector<GpgME::UserID> userIDs;
	const auto selected = treeWidget->selectedItems();
	std::transform(selected.begin(), selected.end(), std::back_inserter(userIDs), [](const QTreeWidgetItem *item) {
	return item->data(0, Qt::UserRole).value<GpgME::UserID>();
	});
	return userIDs;
	}
	}

	class CertificateDetailsWidget::Private
	{
	public:
	Private(CertificateDetailsWidget *qq);

	void setupCommonProperties();
	void updateUserIDActions();
	void setUpUserIDTable();
	void setUpSMIMEAdressList();
	void setupPGPProperties();
	void setupSMIMEProperties();

	void revokeUserID(const GpgME::UserID &uid);
	void revokeSelectedUserID();
	void genRevokeCert();
	void refreshCertificate();
	void certifyUserIDs();
	void revokeCertifications();
	void webOfTrustClicked();
	void exportClicked();
	void addUserID();
	void setPrimaryUserID(const GpgME::UserID &uid = {});
	void changePassphrase();
	void changeExpiration();
	void keysMayHaveChanged();
	void showTrustChainDialog();
	void showMoreDetails();
	void userIDTableContextMenuRequested(const QPoint &p);

	QString tofuTooltipString(const GpgME::UserID &uid) const;
	QIcon trustLevelIcon(const GpgME::UserID &uid) const;
	QString trustLevelText(const GpgME::UserID &uid) const;

	void showIssuerCertificate();

	void updateKey();
	void setUpdatedKey(const GpgME::Key &key);
	void keyListDone(const GpgME::KeyListResult &, const std::vector<GpgME::Key> &, const QString &, const GpgME::Error &);
	void copyFingerprintToClipboard();

	private:
	CertificateDetailsWidget *const q;

	public:
	GpgME::Key key;
	bool updateInProgress = false;

	private:
	InfoField *attributeField(const QString &attributeName)
	{
	const auto keyValuePairIt = ui.smimeAttributeFields.find(attributeName);
	if (keyValuePairIt != ui.smimeAttributeFields.end()) {
	return (*keyValuePairIt).second.get();
	}
	return nullptr;
	}

	private:
	struct UI {
	QWidget *userIDs = nullptr;
	QLabel *userIDTableLabel = nullptr;
	NavigatableTreeWidget *userIDTable = nullptr;
	QPushButton *addUserIDBtn = nullptr;
	QPushButton *setPrimaryUserIDBtn = nullptr;
	QPushButton *certifyBtn = nullptr;
	QPushButton *revokeCertificationsBtn = nullptr;
	QPushButton *revokeUserIDBtn = nullptr;
	QPushButton *webOfTrustBtn = nullptr;

	std::map<QString, std::unique_ptr<InfoField>> smimeAttributeFields;
	std::unique_ptr<InfoField> smimeTrustLevelField;
	std::unique_ptr<InfoField> validFromField;
	std::unique_ptr<InfoField> expiresField;
	QAction *changeExpirationAction = nullptr;
	std::unique_ptr<InfoField> fingerprintField;
	QAction *copyFingerprintAction = nullptr;
	std::unique_ptr<InfoField> smimeIssuerField;
	QAction *showIssuerCertificateAction = nullptr;
	std::unique_ptr<InfoField> complianceField;
	std::unique_ptr<InfoField> trustedIntroducerField;

	QLabel *smimeRelatedAddresses = nullptr;
	QListWidget *smimeAddressList = nullptr;

	QPushButton *moreDetailsBtn = nullptr;
	QPushButton *trustChainDetailsBtn = nullptr;
	QPushButton *refreshBtn = nullptr;
	QPushButton *changePassphraseBtn = nullptr;
	QPushButton *exportBtn = nullptr;
	QPushButton *genRevokeBtn = nullptr;

	void setupUi(QWidget *parent)
	{
	auto mainLayout = new QVBoxLayout{parent};

	userIDs = new QWidget{parent};
	{
	auto userIDsLayout = new QVBoxLayout{userIDs};
	userIDsLayout->setContentsMargins({});

	userIDTableLabel = new QLabel(i18n("User IDs:"), parent);
	userIDsLayout->addWidget(userIDTableLabel);

	userIDTable = new NavigatableTreeWidget{parent};
	userIDTableLabel->setBuddy(userIDTable);
	userIDTable->setAccessibleName(i18n("User IDs"));
	QTreeWidgetItem *__qtreewidgetitem = new QTreeWidgetItem();
	__qtreewidgetitem->setText(0, QString::fromUtf8("1"));
	userIDTable->setHeaderItem(__qtreewidgetitem);
	userIDTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
	userIDTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
	userIDTable->setRootIsDecorated(false);
	userIDTable->setUniformRowHeights(true);
	userIDTable->setAllColumnsShowFocus(false);

	userIDsLayout->addWidget(userIDTable);

	{
	auto buttonRow = new QHBoxLayout;

	addUserIDBtn = new QPushButton(i18nc("@action:button", "Add User ID"), parent);
	buttonRow->addWidget(addUserIDBtn);

	setPrimaryUserIDBtn = new QPushButton{i18nc("@action:button", "Flag as Primary"), parent};
	setPrimaryUserIDBtn->setToolTip(i18nc("@info:tooltip", "Flag the selected user ID as the primary user ID of this key."));
	buttonRow->addWidget(setPrimaryUserIDBtn);

	certifyBtn = new QPushButton(i18nc("@action:button", "Certify User IDs"), parent);
	buttonRow->addWidget(certifyBtn);

	webOfTrustBtn = new QPushButton(i18nc("@action:button", "Show Certifications"), parent);
	buttonRow->addWidget(webOfTrustBtn);

	revokeCertificationsBtn = new QPushButton(i18nc("@action:button", "Revoke Certifications"), parent);
	buttonRow->addWidget(revokeCertificationsBtn);

	revokeUserIDBtn = new QPushButton(i18nc("@action:button", "Revoke User ID"), parent);
	buttonRow->addWidget(revokeUserIDBtn);

	buttonRow->addStretch(1);

	userIDsLayout->addLayout(buttonRow);
	}

	userIDsLayout->addWidget(new KSeparator{Qt::Horizontal, parent});
	}

	mainLayout->addWidget(userIDs);

	{
	auto gridLayout = new QGridLayout;
	gridLayout->setColumnStretch(1, 1);

	int row = -1;
	for (const auto &attribute : DN::attributeOrder()) {
	const auto attributeLabel = DN::attributeNameToLabel(attribute);
	if (attributeLabel.isEmpty()) {
	continue;
	}
	const auto labelWithColon = i18nc("interpunctation for labels", "%1:", attributeLabel);
	const auto &[it, inserted] = smimeAttributeFields.try_emplace(attribute, std::make_unique<InfoField>(labelWithColon, parent));
	if (inserted) {
	row++;
	const auto &field = it->second;
	gridLayout->addWidget(field->label(), row, 0);
	gridLayout->addLayout(field->layout(), row, 1);
	}
	}

	row++;
	smimeTrustLevelField = std::make_unique<InfoField>(i18n("Trust level:"), parent);
	gridLayout->addWidget(smimeTrustLevelField->label(), row, 0);
	gridLayout->addLayout(smimeTrustLevelField->layout(), row, 1);

	row++;
	validFromField = std::make_unique<InfoField>(i18n("Valid from:"), parent);
	gridLayout->addWidget(validFromField->label(), row, 0);
	gridLayout->addLayout(validFromField->layout(), row, 1);

	row++;
	expiresField = std::make_unique<InfoField>(i18n("Valid until:"), parent);
	changeExpirationAction = new QAction{parent};
	changeExpirationAction->setIcon(QIcon::fromTheme(QStringLiteral("editor")));
	changeExpirationAction->setToolTip(i18nc("@info:tooltip", "Change the end of the validity period"));
	Kleo::setAccessibleName(changeExpirationAction, i18nc("@action:button", "Change Validity"));
	expiresField->setAction(changeExpirationAction);
	gridLayout->addWidget(expiresField->label(), row, 0);
	gridLayout->addLayout(expiresField->layout(), row, 1);

	row++;
	fingerprintField = std::make_unique<InfoField>(i18n("Fingerprint:"), parent);
	if (QGuiApplication::clipboard()) {
	copyFingerprintAction = new QAction{parent};
	copyFingerprintAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
	copyFingerprintAction->setToolTip(i18nc("@info:tooltip", "Copy the fingerprint to the clipboard"));
	Kleo::setAccessibleName(copyFingerprintAction, i18nc("@action:button", "Copy fingerprint"));
	fingerprintField->setAction(copyFingerprintAction);
	}
	gridLayout->addWidget(fingerprintField->label(), row, 0);
	gridLayout->addLayout(fingerprintField->layout(), row, 1);

	row++;
	smimeIssuerField = std::make_unique<InfoField>(i18n("Issuer:"), parent);
	showIssuerCertificateAction = new QAction{parent};
	showIssuerCertificateAction->setIcon(QIcon::fromTheme(QStringLiteral("dialog-information")));
	showIssuerCertificateAction->setToolTip(i18nc("@info:tooltip", "Show the issuer certificate"));
	Kleo::setAccessibleName(showIssuerCertificateAction, i18nc("@action:button", "Show certificate"));
	smimeIssuerField->setAction(showIssuerCertificateAction);
	gridLayout->addWidget(smimeIssuerField->label(), row, 0);
	gridLayout->addLayout(smimeIssuerField->layout(), row, 1);

	row++;
	complianceField = std::make_unique<InfoField>(i18n("Compliance:"), parent);
	gridLayout->addWidget(complianceField->label(), row, 0);
	gridLayout->addLayout(complianceField->layout(), row, 1);

	row++;
	trustedIntroducerField = std::make_unique<InfoField>(i18n("Trusted introducer for:"), parent);
	gridLayout->addWidget(trustedIntroducerField->label(), row, 0);
	trustedIntroducerField->setToolTip(i18n("See certifications for details."));
	gridLayout->addLayout(trustedIntroducerField->layout(), row, 1);

	mainLayout->addLayout(gridLayout);
	}

	smimeRelatedAddresses = new QLabel(i18n("Related addresses:"), parent);
	mainLayout->addWidget(smimeRelatedAddresses);

	smimeAddressList = new QListWidget{parent};
	smimeRelatedAddresses->setBuddy(smimeAddressList);
	smimeAddressList->setAccessibleName(i18n("Related addresses"));
	smimeAddressList->setEditTriggers(QAbstractItemView::NoEditTriggers);
	smimeAddressList->setSelectionMode(QAbstractItemView::SingleSelection);

	mainLayout->addWidget(smimeAddressList);

	mainLayout->addStretch();

	{
	auto buttonRow = new QHBoxLayout;

	moreDetailsBtn = new QPushButton(i18nc("@action:button", "More Details..."), parent);
	buttonRow->addWidget(moreDetailsBtn);

	trustChainDetailsBtn = new QPushButton(i18nc("@action:button", "Trust Chain Details"), parent);
	buttonRow->addWidget(trustChainDetailsBtn);

	refreshBtn = new QPushButton{i18nc("@action:button", "Update"), parent};
	-#if !QGPGME_SUPPORTS_KEY_REFRESH
	- refreshBtn->setVisible(false);
	-#endif
	buttonRow->addWidget(refreshBtn);

	exportBtn = new QPushButton(i18nc("@action:button", "Export"), parent);
	buttonRow->addWidget(exportBtn);

	changePassphraseBtn = new QPushButton(i18nc("@action:button", "Change Passphrase"), parent);
	buttonRow->addWidget(changePassphraseBtn);

	genRevokeBtn = new QPushButton(i18nc("@action:button", "Generate Revocation Certificate"), parent);
	genRevokeBtn->setToolTip(u"<html>"
	% i18n("A revocation certificate is a file that serves as a \"kill switch\" to publicly "
	"declare that a key shall not anymore be used. It is not possible "
	"to retract such a revocation certificate once it has been published.")
	% u"</html>");
	buttonRow->addWidget(genRevokeBtn);

	buttonRow->addStretch(1);

	mainLayout->addLayout(buttonRow);
	}
	}
	} ui;
	};

	CertificateDetailsWidget::Private::Private(CertificateDetailsWidget *qq)
	: q{qq}
	{
	ui.setupUi(q);

	ui.userIDTable->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui.userIDTable, &QAbstractItemView::customContextMenuRequested, q, [this](const QPoint &p) {
	userIDTableContextMenuRequested(p);
	});
	connect(ui.userIDTable, &QTreeWidget::itemSelectionChanged, q, [this]() {
	updateUserIDActions();
	});
	connect(ui.addUserIDBtn, &QPushButton::clicked, q, [this]() {
	addUserID();
	});
	connect(ui.setPrimaryUserIDBtn, &QPushButton::clicked, q, [this]() {
	setPrimaryUserID();
	});
	connect(ui.revokeUserIDBtn, &QPushButton::clicked, q, [this]() {
	revokeSelectedUserID();
	});
	connect(ui.changePassphraseBtn, &QPushButton::clicked, q, [this]() {
	changePassphrase();
	});
	connect(ui.genRevokeBtn, &QPushButton::clicked, q, [this]() {
	genRevokeCert();
	});
	connect(ui.changeExpirationAction, &QAction::triggered, q, [this]() {
	changeExpiration();
	});
	connect(ui.showIssuerCertificateAction, &QAction::triggered, q, [this]() {
	showIssuerCertificate();
	});
	connect(ui.trustChainDetailsBtn, &QPushButton::pressed, q, [this]() {
	showTrustChainDialog();
	});
	connect(ui.moreDetailsBtn, &QPushButton::pressed, q, [this]() {
	showMoreDetails();
	});
	connect(ui.refreshBtn, &QPushButton::clicked, q, [this]() {
	refreshCertificate();
	});
	connect(ui.certifyBtn, &QPushButton::clicked, q, [this]() {
	certifyUserIDs();
	});
	connect(ui.revokeCertificationsBtn, &QPushButton::clicked, q, [this]() {
	revokeCertifications();
	});
	connect(ui.webOfTrustBtn, &QPushButton::clicked, q, [this]() {
	webOfTrustClicked();
	});
	connect(ui.exportBtn, &QPushButton::clicked, q, [this]() {
	exportClicked();
	});
	if (ui.copyFingerprintAction) {
	connect(ui.copyFingerprintAction, &QAction::triggered, q, [this]() {
	copyFingerprintToClipboard();
	});
	}

	connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged, q, [this]() {
	keysMayHaveChanged();
	});
	}

	void CertificateDetailsWidget::Private::setupCommonProperties()
	{
	const bool isOpenPGP = key.protocol() == GpgME::OpenPGP;
	const bool isSMIME = key.protocol() == GpgME::CMS;
	const bool isOwnKey = key.hasSecret();
	const auto isLocalKey = !isRemoteKey(key);
	const auto keyCanBeCertified = Kleo::canBeCertified(key);

	// update visibility of UI elements
	ui.userIDs->setVisible(isOpenPGP);
	ui.addUserIDBtn->setVisible(isOwnKey);
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	ui.setPrimaryUserIDBtn->setVisible(isOwnKey);
	-#else
	- ui.setPrimaryUserIDBtn->setVisible(false);
	-#endif
	// ui.certifyBtn->setVisible(true); // always visible (for OpenPGP keys)
	// ui.webOfTrustBtn->setVisible(true); // always visible (for OpenPGP keys)
	ui.revokeCertificationsBtn->setVisible(Kleo::Commands::RevokeCertificationCommand::isSupported());
	ui.revokeUserIDBtn->setVisible(isOwnKey);

	for (const auto &[_, field] : ui.smimeAttributeFields) {
	field->setVisible(isSMIME);
	}
	ui.smimeTrustLevelField->setVisible(isSMIME);
	// ui.validFromField->setVisible(true); // always visible
	// ui.expiresField->setVisible(true); // always visible
	if (isOpenPGP && isOwnKey) {
	ui.expiresField->setAction(ui.changeExpirationAction);
	} else {
	ui.expiresField->setAction(nullptr);
	}
	// ui.fingerprintField->setVisible(true); // always visible
	ui.smimeIssuerField->setVisible(isSMIME);
	ui.complianceField->setVisible(DeVSCompliance::isCompliant());
	ui.trustedIntroducerField->setVisible(isOpenPGP); // may be hidden again by setupPGPProperties()

	ui.smimeRelatedAddresses->setVisible(isSMIME);
	ui.smimeAddressList->setVisible(isSMIME);

	ui.moreDetailsBtn->setVisible(isLocalKey);
	ui.trustChainDetailsBtn->setVisible(isSMIME);
	ui.refreshBtn->setVisible(isLocalKey);
	ui.changePassphraseBtn->setVisible(isSecretKeyStoredInKeyRing(key));
	ui.exportBtn->setVisible(isLocalKey);
	ui.genRevokeBtn->setVisible(isOpenPGP && isOwnKey);

	// update availability of buttons
	const auto userCanSignUserIDs = userHasCertificationKey();
	ui.addUserIDBtn->setEnabled(canBeUsedForSecretKeyOperations(key));
	ui.setPrimaryUserIDBtn->setEnabled(false); // requires a selected user ID
	ui.certifyBtn->setEnabled(isLocalKey && keyCanBeCertified && userCanSignUserIDs);
	ui.webOfTrustBtn->setEnabled(isLocalKey);
	ui.revokeCertificationsBtn->setEnabled(userCanSignUserIDs && isLocalKey);
	ui.revokeUserIDBtn->setEnabled(false); // requires a selected user ID
	ui.changeExpirationAction->setEnabled(canBeUsedForSecretKeyOperations(key));
	ui.changePassphraseBtn->setEnabled(isSecretKeyStoredInKeyRing(key));
	ui.genRevokeBtn->setEnabled(canBeUsedForSecretKeyOperations(key));

	// update values of protocol-independent UI elements
	ui.validFromField->setValue(Formatting::creationDateString(key), Formatting::accessibleCreationDate(key));
	ui.expiresField->setValue(Formatting::expirationDateString(key, i18nc("Valid until:", "unlimited")), Formatting::accessibleExpirationDate(key));
	ui.fingerprintField->setValue(Formatting::prettyID(key.primaryFingerprint()), Formatting::accessibleHexID(key.primaryFingerprint()));
	if (DeVSCompliance::isCompliant()) {
	ui.complianceField->setValue(Kleo::Formatting::complianceStringForKey(key));
	}
	}

	void CertificateDetailsWidget::Private::updateUserIDActions()
	{
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	const auto singleUserID = userIDs.size() == 1 ? userIDs.front() : GpgME::UserID{};
	const bool isPrimaryUserID = !singleUserID.isNull() && (ui.userIDTable->selectedItems().front() == ui.userIDTable->topLevelItem(0));
	ui.setPrimaryUserIDBtn->setEnabled(!singleUserID.isNull() //
	&& !isPrimaryUserID //
	&& !Kleo::isRevokedOrExpired(singleUserID) //
	&& canBeUsedForSecretKeyOperations(key));
	ui.revokeUserIDBtn->setEnabled(!singleUserID.isNull() && canCreateCertifications(key) && canRevokeUserID(singleUserID));
	}

	void CertificateDetailsWidget::Private::setUpUserIDTable()
	{
	ui.userIDTable->clear();

	QStringList headers = {i18n("Email"), i18n("Name"), i18n("Trust Level"), i18n("Tags")};
	ui.userIDTable->setColumnCount(headers.count());
	ui.userIDTable->setColumnWidth(0, 200);
	ui.userIDTable->setColumnWidth(1, 200);
	ui.userIDTable->setHeaderLabels(headers);

	const auto uids = key.userIDs();
	for (unsigned int i = 0; i < uids.size(); ++i) {
	const auto &uid = uids[i];
	auto item = new QTreeWidgetItem;
	const QString toolTip = tofuTooltipString(uid);
	item->setData(0, Qt::UserRole, QVariant::fromValue(uid));

	auto pMail = Kleo::Formatting::prettyEMail(uid);
	auto pName = Kleo::Formatting::prettyName(uid);

	item->setData(0, Qt::DisplayRole, pMail);
	item->setData(0, Qt::ToolTipRole, toolTip);
	item->setData(0, Qt::AccessibleTextRole, pMail.isEmpty() ? i18nc("text for screen readers for an empty email address", "no email") : pMail);
	item->setData(1, Qt::DisplayRole, pName);
	item->setData(1, Qt::ToolTipRole, toolTip);

	item->setData(2, Qt::DecorationRole, trustLevelIcon(uid));
	item->setData(2, Qt::DisplayRole, trustLevelText(uid));
	item->setData(2, Qt::ToolTipRole, toolTip);

	GpgME::Error err;
	QStringList tagList;
	for (const auto &tag : uid.remarks(Tags::tagKeys(), err)) {
	if (err) {
	qCWarning(KLEOPATRA_LOG) << "Getting remarks for user ID" << uid.id() << "failed:" << err;
	}
	tagList << QString::fromStdString(tag);
	}
	qCDebug(KLEOPATRA_LOG) << "tagList:" << tagList;
	const auto tags = tagList.join(QStringLiteral("; "));
	item->setData(3, Qt::DisplayRole, tags);
	item->setData(3, Qt::ToolTipRole, toolTip);

	ui.userIDTable->addTopLevelItem(item);
	}
	if (!Tags::tagsEnabled()) {
	ui.userIDTable->hideColumn(3);
	}
	}

	void CertificateDetailsWidget::Private::setUpSMIMEAdressList()
	{
	ui.smimeAddressList->clear();

	const auto *const emailField = attributeField(QStringLiteral("EMAIL"));

	// add email address from primary user ID if not listed already as attribute field
	if (!emailField) {
	const auto ownerId = key.userID(0);
	const Kleo::DN dn(ownerId.id());
	const QString dnEmail = dn[QStringLiteral("EMAIL")];
	if (!dnEmail.isEmpty()) {
	ui.smimeAddressList->addItem(dnEmail);
	}
	}

	if (key.numUserIDs() > 1) {
	// iterate over the secondary user IDs
	#ifdef USE_RANGES
	for (const auto uids = key.userIDs(); const auto &uid : std::ranges::subrange(std::next(uids.begin()), uids.end())) {
	#else
	const auto uids = key.userIDs();
	for (auto it = std::next(uids.begin()); it != uids.end(); ++it) {
	const auto &uid = *it;
	#endif
	const auto name = Kleo::Formatting::prettyName(uid);
	const auto email = Kleo::Formatting::prettyEMail(uid);
	QString itemText;
	if (name.isEmpty() && !email.isEmpty()) {
	// skip email addresses already listed in email attribute field
	if (emailField && email == emailField->value()) {
	continue;
	}
	itemText = email;
	} else {
	// S/MIME certificates sometimes contain urls where both
	// name and mail is empty. In that case we print whatever
	// the uid is as name.
	//
	// Can be ugly like (3:uri24:http://ca.intevation.org), but
	// this is better then showing an empty entry.
	itemText = QString::fromUtf8(uid.id());
	}
	// avoid duplicate entries in the list
	if (ui.smimeAddressList->findItems(itemText, Qt::MatchExactly).empty()) {
	ui.smimeAddressList->addItem(itemText);
	}
	}
	}

	if (ui.smimeAddressList->count() == 0) {
	ui.smimeRelatedAddresses->setVisible(false);
	ui.smimeAddressList->setVisible(false);
	}
	}

	void CertificateDetailsWidget::Private::revokeUserID(const GpgME::UserID &userId)
	{
	const QString message =
	xi18nc("@info", "<para>Do you really want to revoke the user ID<nl/><emphasis>%1</emphasis> ?</para>", QString::fromUtf8(userId.id()));
	auto confirmButton = KStandardGuiItem::ok();
	confirmButton.setText(i18nc("@action:button", "Revoke User ID"));
	confirmButton.setToolTip({});
	const auto choice = KMessageBox::questionTwoActions(q->window(),
	message,
	i18nc("@title:window", "Confirm Revocation"),
	confirmButton,
	KStandardGuiItem::cancel(),
	{},
	KMessageBox::Notify \| KMessageBox::WindowModal);
	if (choice != KMessageBox::ButtonCode::PrimaryAction) {
	return;
	}

	auto cmd = new Commands::RevokeUserIDCommand(userId);
	cmd->setParentWidget(q);
	connect(cmd, &Command::finished, q, [this]() {
	ui.userIDTable->setEnabled(true);
	// the Revoke User ID button will be updated by the key update
	updateKey();
	});
	ui.userIDTable->setEnabled(false);
	ui.revokeUserIDBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::revokeSelectedUserID()
	{
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	if (userIDs.size() != 1) {
	return;
	}
	revokeUserID(userIDs.front());
	}

	void CertificateDetailsWidget::Private::changeExpiration()
	{
	auto cmd = new Kleo::Commands::ChangeExpiryCommand(key);
	QObject::connect(cmd, &Kleo::Commands::ChangeExpiryCommand::finished, q, [this]() {
	ui.changeExpirationAction->setEnabled(true);
	});
	ui.changeExpirationAction->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::changePassphrase()
	{
	auto cmd = new Kleo::Commands::ChangePassphraseCommand(key);
	QObject::connect(cmd, &Kleo::Commands::ChangePassphraseCommand::finished, q, [this]() {
	ui.changePassphraseBtn->setEnabled(true);
	});
	ui.changePassphraseBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::genRevokeCert()
	{
	auto cmd = new Kleo::Commands::GenRevokeCommand(key);
	QObject::connect(cmd, &Kleo::Commands::GenRevokeCommand::finished, q, [this]() {
	ui.genRevokeBtn->setEnabled(true);
	});
	ui.genRevokeBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::refreshCertificate()
	{
	auto cmd = new Kleo::RefreshCertificateCommand{key};
	QObject::connect(cmd, &Kleo::RefreshCertificateCommand::finished, q, [this]() {
	ui.refreshBtn->setEnabled(true);
	});
	ui.refreshBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::certifyUserIDs()
	{
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	auto cmd = userIDs.empty() ? new Kleo::Commands::CertifyCertificateCommand{key} //
	: new Kleo::Commands::CertifyCertificateCommand{userIDs};
	QObject::connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished, q, [this]() {
	updateKey();
	ui.certifyBtn->setEnabled(true);
	});
	ui.certifyBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::revokeCertifications()
	{
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	auto cmd = userIDs.empty() ? new Kleo::Commands::RevokeCertificationCommand{key} //
	: new Kleo::Commands::RevokeCertificationCommand{userIDs};
	QObject::connect(cmd, &Kleo::Command::finished, q, [this]() {
	updateKey();
	ui.revokeCertificationsBtn->setEnabled(true);
	});
	ui.revokeCertificationsBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::webOfTrustClicked()
	{
	QScopedPointer<WebOfTrustDialog> dlg(new WebOfTrustDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::exportClicked()
	{
	QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::addUserID()
	{
	auto cmd = new Kleo::Commands::AddUserIDCommand(key);
	QObject::connect(cmd, &Kleo::Commands::AddUserIDCommand::finished, q, [this]() {
	ui.addUserIDBtn->setEnabled(true);
	updateKey();
	});
	ui.addUserIDBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::setPrimaryUserID(const GpgME::UserID &uid)
	{
	auto userId = uid;
	if (userId.isNull()) {
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	if (userIDs.size() != 1) {
	return;
	}
	userId = userIDs.front();
	}

	auto cmd = new Kleo::Commands::SetPrimaryUserIDCommand(userId);
	QObject::connect(cmd, &Kleo::Commands::SetPrimaryUserIDCommand::finished, q, [this]() {
	ui.userIDTable->setEnabled(true);
	// the Flag As Primary button will be updated by the key update
	updateKey();
	});
	ui.userIDTable->setEnabled(false);
	ui.setPrimaryUserIDBtn->setEnabled(false);
	cmd->start();
	}

	namespace
	{
	void ensureThatKeyDetailsAreLoaded(GpgME::Key &key)
	{
	if (key.userID(0).numSignatures() == 0) {
	key.update();
	}
	}
	}

	void CertificateDetailsWidget::Private::keysMayHaveChanged()
	{
	auto newKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
	if (!newKey.isNull()) {
	ensureThatKeyDetailsAreLoaded(newKey);
	setUpdatedKey(newKey);
	}
	}

	void CertificateDetailsWidget::Private::showTrustChainDialog()
	{
	QScopedPointer<TrustChainDialog> dlg(new TrustChainDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::userIDTableContextMenuRequested(const QPoint &p)
	{
	const auto userIDs = selectedUserIDs(ui.userIDTable);
	const auto singleUserID = (userIDs.size() == 1) ? userIDs.front() : GpgME::UserID{};
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	const bool isPrimaryUserID = !singleUserID.isNull() && (ui.userIDTable->selectedItems().front() == ui.userIDTable->topLevelItem(0));
	-#endif
	const bool canSignUserIDs = userHasCertificationKey();
	const auto isLocalKey = !isRemoteKey(key);
	const auto keyCanBeCertified = Kleo::canBeCertified(key);

	auto menu = new QMenu(q);
	-#if QGPGME_SUPPORTS_SET_PRIMARY_UID
	if (key.hasSecret()) {
	auto action =
	menu->addAction(QIcon::fromTheme(QStringLiteral("favorite")), i18nc("@action:inmenu", "Flag as Primary User ID"), q, [this, singleUserID]() {
	setPrimaryUserID(singleUserID);
	});
	action->setEnabled(!singleUserID.isNull() //
	&& !isPrimaryUserID //
	&& !Kleo::isRevokedOrExpired(singleUserID) //
	&& canBeUsedForSecretKeyOperations(key));
	}
	-#endif
	{
	const auto actionText = userIDs.empty() ? i18nc("@action:inmenu", "Certify User IDs...")
	: i18ncp("@action:inmenu", "Certify User ID...", "Certify User IDs...", userIDs.size());
	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")), actionText, q, [this]() {
	certifyUserIDs();
	});
	action->setEnabled(isLocalKey && keyCanBeCertified && canSignUserIDs);
	}
	if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
	const auto actionText = userIDs.empty() ? i18nc("@action:inmenu", "Revoke Certifications...")
	: i18ncp("@action:inmenu", "Revoke Certification...", "Revoke Certifications...", userIDs.size());
	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")), actionText, q, [this]() {
	revokeCertifications();
	});
	action->setEnabled(isLocalKey && canSignUserIDs);
	}
	#ifdef MAILAKONADI_ENABLED
	if (key.hasSecret()) {
	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-export")),
	i18nc("@action:inmenu", "Publish at Mail Provider ..."),
	q,
	[this, singleUserID]() {
	auto cmd = new Kleo::Commands::ExportOpenPGPCertToProviderCommand(singleUserID);
	ui.userIDTable->setEnabled(false);
	connect(cmd, &Kleo::Commands::ExportOpenPGPCertToProviderCommand::finished, q, [this]() {
	ui.userIDTable->setEnabled(true);
	});
	cmd->start();
	});
	action->setEnabled(!singleUserID.isNull());
	}
	#endif // MAILAKONADI_ENABLED
	{
	auto action =
	menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")), i18nc("@action:inmenu", "Revoke User ID"), q, [this, singleUserID]() {
	revokeUserID(singleUserID);
	});
	action->setEnabled(!singleUserID.isNull() && canCreateCertifications(key) && canRevokeUserID(singleUserID));
	}
	connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
	menu->popup(ui.userIDTable->viewport()->mapToGlobal(p));
	}

	void CertificateDetailsWidget::Private::showMoreDetails()
	{
	if (key.protocol() == GpgME::CMS) {
	auto cmd = new Kleo::Commands::DumpCertificateCommand(key);
	cmd->setParentWidget(q);
	cmd->setUseDialog(true);
	cmd->start();
	} else {
	auto dlg = new SubKeysDialog{q};
	dlg->setAttribute(Qt::WA_DeleteOnClose);
	dlg->setKey(key);
	dlg->open();
	}
	}

	QString CertificateDetailsWidget::Private::tofuTooltipString(const GpgME::UserID &uid) const
	{
	const auto tofu = uid.tofuInfo();
	if (tofu.isNull()) {
	return QString();
	}

	QString html = QStringLiteral("<table border=\"0\" cell-padding=\"5\">");
	const auto appendRow = [&html](const QString &lbl, const QString &val) {
	html += QStringLiteral(
	"<tr>"
	"<th style=\"text-align: right; padding-right: 5px; white-space: nowrap;\">%1:</th>"
	"<td style=\"white-space: nowrap;\">%2</td>"
	"</tr>")
	.arg(lbl, val);
	};
	const auto appendHeader = [this, &html](const QString &hdr) {
	html += QStringLiteral("<tr><th colspan=\"2\" style=\"background-color: %1; color: %2\">%3</th></tr>")
	.arg(q->palette().highlight().color().name(), q->palette().highlightedText().color().name(), hdr);
	};
	const auto dateTime = [](long ts) {
	QLocale l;
	return ts == 0 ? i18n("never") : l.toString(QDateTime::fromSecsSinceEpoch(ts), QLocale::ShortFormat);
	};
	appendHeader(i18n("Signing"));
	appendRow(i18n("First message"), dateTime(tofu.signFirst()));
	appendRow(i18n("Last message"), dateTime(tofu.signLast()));
	appendRow(i18n("Message count"), QString::number(tofu.signCount()));
	appendHeader(i18n("Encryption"));
	appendRow(i18n("First message"), dateTime(tofu.encrFirst()));
	appendRow(i18n("Last message"), dateTime(tofu.encrLast()));
	appendRow(i18n("Message count"), QString::number(tofu.encrCount()));

	html += QStringLiteral("</table>");
	// Make sure the tooltip string is different for each UserID, even if the
	// data are the same, otherwise the tooltip is not updated and moved when
	// user moves mouse from one row to another.
	html += QStringLiteral("<!-- %1 //-->").arg(QString::fromUtf8(uid.id()));
	return html;
	}

	QIcon CertificateDetailsWidget::Private::trustLevelIcon(const GpgME::UserID &uid) const
	{
	if (updateInProgress) {
	return QIcon::fromTheme(QStringLiteral("emblem-question"));
	}
	switch (uid.validity()) {
	case GpgME::UserID::Unknown:
	case GpgME::UserID::Undefined:
	return QIcon::fromTheme(QStringLiteral("emblem-question"));
	case GpgME::UserID::Never:
	return QIcon::fromTheme(QStringLiteral("emblem-error"));
	case GpgME::UserID::Marginal:
	return QIcon::fromTheme(QStringLiteral("emblem-warning"));
	case GpgME::UserID::Full:
	case GpgME::UserID::Ultimate:
	return QIcon::fromTheme(QStringLiteral("emblem-success"));
	}
	return {};
	}

	QString CertificateDetailsWidget::Private::trustLevelText(const GpgME::UserID &uid) const
	{
	return updateInProgress ? i18n("Updating...") : Formatting::validityShort(uid);
	}

	namespace
	{
	auto isGood(const GpgME::UserID::Signature &signature)
	{
	return signature.status() == GpgME::UserID::Signature::NoError //
	&& !signature.isInvalid() //
	&& 0x10 <= signature.certClass() && signature.certClass() <= 0x13;
	}

	auto accumulateTrustDomains(const std::vector<GpgME::UserID::Signature> &signatures)
	{
	return std::accumulate(std::begin(signatures), std::end(signatures), std::set<QString>(), [](auto domains, const auto &signature) {
	if (isGood(signature) && signature.isTrustSignature()) {
	domains.insert(Formatting::trustSignatureDomain(signature));
	}
	return domains;
	});
	}

	auto accumulateTrustDomains(const std::vector<GpgME::UserID> &userIds)
	{
	return std::accumulate(std::begin(userIds), std::end(userIds), std::set<QString>(), [](auto domains, const auto &userID) {
	const auto newDomains = accumulateTrustDomains(userID.signatures());
	std::copy(std::begin(newDomains), std::end(newDomains), std::inserter(domains, std::end(domains)));
	return domains;
	});
	}
	}

	void CertificateDetailsWidget::Private::setupPGPProperties()
	{
	setUpUserIDTable();

	const auto trustDomains = accumulateTrustDomains(key.userIDs());
	ui.trustedIntroducerField->setVisible(!trustDomains.empty());
	ui.trustedIntroducerField->setValue(QStringList(std::begin(trustDomains), std::end(trustDomains)).join(u", "));

	ui.refreshBtn->setToolTip(i18nc("@info:tooltip", "Update the key from external sources."));
	}

	static QString formatDNToolTip(const Kleo::DN &dn)
	{
	QString html = QStringLiteral("<table border=\"0\" cell-spacing=15>");

	const auto appendRow = [&html, dn](const QString &lbl, const QString &attr) {
	const QString val = dn[attr];
	if (!val.isEmpty()) {
	html += QStringLiteral(
	"<tr><th style=\"text-align: left; white-space: nowrap\">%1:</th>"
	"<td style=\"white-space: nowrap\">%2</td>"
	"</tr>")
	.arg(lbl, val);
	}
	};
	appendRow(i18n("Common Name"), QStringLiteral("CN"));
	appendRow(i18n("Organization"), QStringLiteral("O"));
	appendRow(i18n("Street"), QStringLiteral("STREET"));
	appendRow(i18n("City"), QStringLiteral("L"));
	appendRow(i18n("State"), QStringLiteral("ST"));
	appendRow(i18n("Country"), QStringLiteral("C"));
	html += QStringLiteral("</table>");

	return html;
	}

	void CertificateDetailsWidget::Private::setupSMIMEProperties()
	{
	const auto ownerId = key.userID(0);
	const Kleo::DN dn(ownerId.id());

	for (const auto &[attributeName, field] : ui.smimeAttributeFields) {
	const QString attributeValue = dn[attributeName];
	field->setValue(attributeValue);
	field->setVisible(!attributeValue.isEmpty());
	}
	ui.smimeTrustLevelField->setIcon(trustLevelIcon(ownerId));
	ui.smimeTrustLevelField->setValue(trustLevelText(ownerId));

	const Kleo::DN issuerDN(key.issuerName());
	const QString issuerCN = issuerDN[QStringLiteral("CN")];
	const QString issuer = issuerCN.isEmpty() ? QString::fromUtf8(key.issuerName()) : issuerCN;
	ui.smimeIssuerField->setValue(issuer);
	ui.smimeIssuerField->setToolTip(formatDNToolTip(issuerDN));
	ui.showIssuerCertificateAction->setEnabled(!key.isRoot());

	setUpSMIMEAdressList();

	ui.refreshBtn->setToolTip(i18nc("@info:tooltip", "Update the CRLs and do a full validation check of the certificate."));
	}

	void CertificateDetailsWidget::Private::showIssuerCertificate()
	{
	// there is either one or no parent key
	const auto parentKeys = KeyCache::instance()->findIssuers(key, KeyCache::NoOption);

	if (parentKeys.empty()) {
	KMessageBox::error(q, i18n("The issuer certificate could not be found locally."));
	return;
	}
	auto cmd = new Kleo::Commands::DetailsCommand(parentKeys.front());
	cmd->setParentWidget(q);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::copyFingerprintToClipboard()
	{
	if (auto clipboard = QGuiApplication::clipboard()) {
	clipboard->setText(QString::fromLatin1(key.primaryFingerprint()));
	}
	}

	CertificateDetailsWidget::CertificateDetailsWidget(QWidget *parent)
	: QWidget{parent}
	, d{std::make_unique<Private>(this)}
	{
	}

	CertificateDetailsWidget::~CertificateDetailsWidget() = default;

	void CertificateDetailsWidget::Private::keyListDone(const GpgME::KeyListResult &, const std::vector<GpgME::Key> &keys, const QString &, const GpgME::Error &)
	{
	updateInProgress = false;
	if (keys.size() != 1) {
	qCWarning(KLEOPATRA_LOG) << "Invalid keylist result in update.";
	return;
	}
	// As we listen for keysmayhavechanged we get the update
	// after updating the keycache.
	KeyCache::mutableInstance()->insert(keys);
	}

	void CertificateDetailsWidget::Private::updateKey()
	{
	key.update();
	setUpdatedKey(key);
	}

	void CertificateDetailsWidget::Private::setUpdatedKey(const GpgME::Key &k)
	{
	key = k;

	setupCommonProperties();
	if (key.protocol() == GpgME::OpenPGP) {
	setupPGPProperties();
	} else {
	setupSMIMEProperties();
	}
	}

	void CertificateDetailsWidget::setKey(const GpgME::Key &key)
	{
	if (key.protocol() == GpgME::CMS) {
	// For everything but S/MIME this should be quick
	// and we don't need to show another status.
	d->updateInProgress = true;
	}
	d->setUpdatedKey(key);

	// Run a keylistjob with full details (TOFU / Validate)
	QGpgME::KeyListJob *job =
	key.protocol() == GpgME::OpenPGP ? QGpgME::openpgp()->keyListJob(false, true, true) : QGpgME::smime()->keyListJob(false, true, true);

	auto ctx = QGpgME::Job::context(job);
	ctx->addKeyListMode(GpgME::WithTofu);
	ctx->addKeyListMode(GpgME::SignatureNotations);
	if (key.hasSecret()) {
	ctx->addKeyListMode(GpgME::WithSecret);
	}

	// Windows QGpgME new style connect problem makes this necessary.
	connect(job,
	SIGNAL(result(GpgME::KeyListResult, std::vector<GpgME::Key>, QString, GpgME::Error)),
	this,
	SLOT(keyListDone(GpgME::KeyListResult, std::vector<GpgME::Key>, QString, GpgME::Error)));

	job->start(QStringList() << QLatin1String(key.primaryFingerprint()));
	}

	GpgME::Key CertificateDetailsWidget::key() const
	{
	return d->key;
	}

	#include "moc_certificatedetailswidget.cpp"
	diff --git a/src/dialogs/certificateselectiondialog.cpp b/src/dialogs/certificateselectiondialog.cpp
	index e09104a81..a97cbfd1c 100644
	--- a/src/dialogs/certificateselectiondialog.cpp
	+++ b/src/dialogs/certificateselectiondialog.cpp
	@@ -1,520 +1,514 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/certificateselectiondialog.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 "certificateselectiondialog.h"

	#include "settings.h"

	#include "conf/groupsconfigdialog.h"

	#include <view/keytreeview.h>
	#include <view/searchbar.h>
	#include <view/tabwidget.h>

	#include "utils/tags.h"

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compat>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyGroup>
	#include <Libkleo/KeyListModel>

	#include <commands/importcertificatefromfilecommand.h>
	#include <commands/lookupcertificatescommand.h>
	#include <commands/newopenpgpcertificatecommand.h>
	#include <commands/reloadkeyscommand.h>

	#include <gpgme++/key.h>

	#include <KConfigDialog>
	#include <KConfigGroup>
	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <QAbstractItemView>
	#include <QDialogButtonBox>
	#include <QItemSelectionModel>
	#include <QLabel>
	#include <QPushButton>
	#include <QVBoxLayout>

	#include <algorithm>

	using namespace Kleo;
	using namespace Kleo::Dialogs;
	using namespace Kleo::Commands;
	using namespace GpgME;

	CertificateSelectionDialog::Option CertificateSelectionDialog::optionsFromProtocol(Protocol proto)
	{
	switch (proto) {
	case OpenPGP:
	return CertificateSelectionDialog::OpenPGPFormat;
	case CMS:
	return CertificateSelectionDialog::CMSFormat;
	default:
	return CertificateSelectionDialog::AnyFormat;
	}
	}

	namespace
	{
	auto protocolFromOptions(CertificateSelectionDialog::Options options)
	{
	switch (options & CertificateSelectionDialog::AnyFormat) {
	case CertificateSelectionDialog::OpenPGPFormat:
	return GpgME::OpenPGP;
	case CertificateSelectionDialog::CMSFormat:
	return GpgME::CMS;
	default:
	return GpgME::UnknownProtocol;
	}
	}
	}

	class CertificateSelectionDialog::Private
	{
	friend class ::Kleo::Dialogs::CertificateSelectionDialog;
	CertificateSelectionDialog *const q;

	public:
	explicit Private(CertificateSelectionDialog *qq);

	private:
	void reload()
	{
	Command *const cmd = new ReloadKeysCommand(nullptr);
	cmd->setParentWidget(q);
	cmd->start();
	}
	void create()
	{
	auto cmd = new NewOpenPGPCertificateCommand;
	cmd->setParentWidget(q);
	cmd->start();
	}
	void lookup()
	{
	const auto cmd = new LookupCertificatesCommand(nullptr);
	cmd->setParentWidget(q);
	cmd->setProtocol(protocolFromOptions(options));
	cmd->start();
	}
	void manageGroups()
	{
	KConfigDialog *dialog = KConfigDialog::exists(GroupsConfigDialog::dialogName());
	if (dialog) {
	// reparent the dialog to ensure it's shown on top of the modal CertificateSelectionDialog
	dialog->setParent(q, Qt::Dialog);
	} else {
	dialog = new GroupsConfigDialog(q);
	}
	dialog->show();
	}
	void slotKeysMayHaveChanged();
	void slotCurrentViewChanged(QAbstractItemView *newView);
	void slotSelectionChanged();
	void slotDoubleClicked(const QModelIndex &idx);

	private:
	bool acceptable(const std::vector<Key> &keys, const std::vector<KeyGroup> &groups)
	{
	return !keys.empty() \|\| !groups.empty();
	}
	void updateLabelText()
	{
	ui.label.setText(!customLabelText.isEmpty() ? customLabelText
	: (options & MultiSelection) ? i18n("Please select one or more of the following certificates:")
	: i18n("Please select one of the following certificates:"));
	}

	private:
	std::vector<QAbstractItemView *> connectedViews;
	QString customLabelText;
	Options options = AnyCertificate \| AnyFormat;

	struct UI {
	QLabel label;
	SearchBar searchBar;
	TabWidget tabWidget;
	QDialogButtonBox buttonBox;
	QPushButton *createButton = nullptr;
	} ui;

	void setUpUI(CertificateSelectionDialog *q)
	{
	KDAB_SET_OBJECT_NAME(ui.label);
	KDAB_SET_OBJECT_NAME(ui.searchBar);
	KDAB_SET_OBJECT_NAME(ui.tabWidget);
	KDAB_SET_OBJECT_NAME(ui.buttonBox);

	auto vlay = new QVBoxLayout(q);
	vlay->addWidget(&ui.label);
	vlay->addWidget(&ui.searchBar);
	vlay->addWidget(&ui.tabWidget, 1);
	vlay->addWidget(&ui.buttonBox);

	QPushButton *const okButton = ui.buttonBox.addButton(QDialogButtonBox::Ok);
	okButton->setEnabled(false);
	ui.buttonBox.addButton(QDialogButtonBox::Close);
	QPushButton *const reloadButton = ui.buttonBox.addButton(i18n("Reload"), QDialogButtonBox::ActionRole);
	reloadButton->setToolTip(i18nc("@info:tooltip", "Refresh certificate list"));
	QPushButton *const importButton = ui.buttonBox.addButton(i18n("Import..."), QDialogButtonBox::ActionRole);
	importButton->setToolTip(i18nc("@info:tooltip", "Import certificate from file"));
	importButton->setAccessibleName(i18n("Import certificate"));
	QPushButton *const lookupButton = ui.buttonBox.addButton(i18n("Lookup..."), QDialogButtonBox::ActionRole);
	lookupButton->setToolTip(i18nc("@info:tooltip", "Look up certificate on server"));
	lookupButton->setAccessibleName(i18n("Look up certificate"));
	ui.createButton = ui.buttonBox.addButton(i18n("New..."), QDialogButtonBox::ActionRole);
	ui.createButton->setToolTip(i18nc("@info:tooltip", "Create a new OpenPGP certificate"));
	ui.createButton->setAccessibleName(i18n("Create certificate"));
	QPushButton *const groupsButton = ui.buttonBox.addButton(i18n("Groups..."), QDialogButtonBox::ActionRole);
	groupsButton->setToolTip(i18nc("@info:tooltip", "Manage certificate groups"));
	groupsButton->setAccessibleName(i18n("Manage groups"));
	groupsButton->setVisible(Settings().groupsEnabled());

	connect(&ui.buttonBox, &QDialogButtonBox::accepted, q, &CertificateSelectionDialog::accept);
	connect(&ui.buttonBox, &QDialogButtonBox::rejected, q, &CertificateSelectionDialog::reject);
	connect(reloadButton, &QPushButton::clicked, q, [this]() {
	reload();
	});
	connect(lookupButton, &QPushButton::clicked, q, [this]() {
	lookup();
	});
	connect(ui.createButton, &QPushButton::clicked, q, [this]() {
	create();
	});
	connect(groupsButton, &QPushButton::clicked, q, [this]() {
	manageGroups();
	});
	connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged, q, [this]() {
	slotKeysMayHaveChanged();
	});

	connect(importButton, &QPushButton::clicked, q, [importButton, q]() {
	importButton->setEnabled(false);
	auto cmd = new Kleo::ImportCertificateFromFileCommand();
	connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished, q, [importButton]() {
	importButton->setEnabled(true);
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	}
	};

	CertificateSelectionDialog::Private::Private(CertificateSelectionDialog *qq)
	: q(qq)
	{
	setUpUI(q);
	ui.tabWidget.setFlatModel(AbstractKeyListModel::createFlatKeyListModel(q));
	ui.tabWidget.setHierarchicalModel(AbstractKeyListModel::createHierarchicalKeyListModel(q));
	const auto tagKeys = Tags::tagKeys();
	ui.tabWidget.flatModel()->setRemarkKeys(tagKeys);
	ui.tabWidget.hierarchicalModel()->setRemarkKeys(tagKeys);
	ui.tabWidget.connectSearchBar(&ui.searchBar);

	connect(&ui.tabWidget, &TabWidget::currentViewChanged, q, [this](QAbstractItemView *view) {
	slotCurrentViewChanged(view);
	});

	updateLabelText();
	q->setWindowTitle(i18nc("@title:window", "Certificate Selection"));
	}

	CertificateSelectionDialog::CertificateSelectionDialog(QWidget *parent)
	: QDialog(parent)
	, d(new Private(this))
	{
	const KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
	d->ui.tabWidget.loadViews(config.data());
	const KConfigGroup geometry(config, "Geometry");
	resize(geometry.readEntry("size", size()));
	d->slotKeysMayHaveChanged();
	}

	CertificateSelectionDialog::~CertificateSelectionDialog()
	{
	}

	void CertificateSelectionDialog::setCustomLabelText(const QString &txt)
	{
	if (txt == d->customLabelText) {
	return;
	}
	d->customLabelText = txt;
	d->updateLabelText();
	}

	QString CertificateSelectionDialog::customLabelText() const
	{
	return d->customLabelText;
	}

	void CertificateSelectionDialog::setOptions(Options options)
	{
	Q_ASSERT((options & CertificateSelectionDialog::AnyCertificate) != 0);
	Q_ASSERT((options & CertificateSelectionDialog::AnyFormat) != 0);
	if (d->options == options) {
	return;
	}
	d->options = options;

	d->ui.tabWidget.setMultiSelection(options & MultiSelection);

	d->slotKeysMayHaveChanged();
	d->updateLabelText();
	d->ui.createButton->setVisible(options & OpenPGPFormat);
	}

	CertificateSelectionDialog::Options CertificateSelectionDialog::options() const
	{
	return d->options;
	}

	void CertificateSelectionDialog::setStringFilter(const QString &filter)
	{
	d->ui.tabWidget.setStringFilter(filter);
	}

	void CertificateSelectionDialog::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
	{
	d->ui.tabWidget.setKeyFilter(filter);
	}

	namespace
	{

	void selectRows(const QAbstractItemView *view, const QModelIndexList &indexes)
	{
	if (!view) {
	return;
	}
	QItemSelectionModel *const sm = view->selectionModel();
	Q_ASSERT(sm);

	for (const QModelIndex &idx : std::as_const(indexes)) {
	if (idx.isValid()) {
	sm->select(idx, QItemSelectionModel::Select \| QItemSelectionModel::Rows);
	}
	}
	}

	QModelIndexList getGroupIndexes(const KeyListModelInterface *model, const std::vector<KeyGroup> &groups)
	{
	QModelIndexList indexes;
	indexes.reserve(groups.size());
	std::transform(groups.begin(), groups.end(), std::back_inserter(indexes), [model](const KeyGroup &group) {
	return model->index(group);
	});
	indexes.erase(std::remove_if(indexes.begin(),
	indexes.end(),
	[](const QModelIndex &index) {
	return !index.isValid();
	}),
	indexes.end());
	return indexes;
	}

	}

	void CertificateSelectionDialog::selectCertificates(const std::vector<Key> &keys)
	{
	const auto *const model = d->ui.tabWidget.currentModel();
	Q_ASSERT(model);
	selectRows(d->ui.tabWidget.currentView(), model->indexes(keys));
	}

	void CertificateSelectionDialog::selectCertificate(const Key &key)
	{
	selectCertificates(std::vector<Key>(1, key));
	}

	void CertificateSelectionDialog::selectGroups(const std::vector<KeyGroup> &groups)
	{
	const auto *const model = d->ui.tabWidget.currentModel();
	Q_ASSERT(model);
	selectRows(d->ui.tabWidget.currentView(), getGroupIndexes(model, groups));
	}

	namespace
	{

	QModelIndexList getSelectedRows(const QAbstractItemView *view)
	{
	if (!view) {
	return {};
	}
	const QItemSelectionModel *const sm = view->selectionModel();
	Q_ASSERT(sm);
	return sm->selectedRows();
	}

	std::vector<KeyGroup> getGroups(const KeyListModelInterface *model, const QModelIndexList &indexes)
	{
	std::vector<KeyGroup> groups;
	groups.reserve(indexes.size());
	std::transform(indexes.begin(), indexes.end(), std::back_inserter(groups), [model](const QModelIndex &idx) {
	return model->group(idx);
	});
	groups.erase(std::remove_if(groups.begin(), groups.end(), std::mem_fn(&Kleo::KeyGroup::isNull)), groups.end());
	return groups;
	}

	}

	std::vector<Key> CertificateSelectionDialog::selectedCertificates() const
	{
	const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
	Q_ASSERT(model);
	return model->keys(getSelectedRows(d->ui.tabWidget.currentView()));
	}

	Key CertificateSelectionDialog::selectedCertificate() const
	{
	const std::vector<Key> keys = selectedCertificates();
	return keys.empty() ? Key() : keys.front();
	}

	std::vector<KeyGroup> CertificateSelectionDialog::selectedGroups() const
	{
	const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
	Q_ASSERT(model);
	return getGroups(model, getSelectedRows(d->ui.tabWidget.currentView()));
	}

	void CertificateSelectionDialog::hideEvent(QHideEvent *e)
	{
	KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
	d->ui.tabWidget.saveViews(config.data());
	KConfigGroup geometry(config, "Geometry");
	geometry.writeEntry("size", size());
	QDialog::hideEvent(e);
	}

	void CertificateSelectionDialog::Private::slotKeysMayHaveChanged()
	{
	q->setEnabled(true);
	std::vector<Key> keys = (options & SecretKeys) ? KeyCache::instance()->secretKeys() : KeyCache::instance()->keys();
	q->filterAllowedKeys(keys, options);
	const std::vector<KeyGroup> groups = (options & IncludeGroups) ? KeyCache::instance()->groups() : std::vector<KeyGroup>();

	const std::vector<Key> selectedKeys = q->selectedCertificates();
	const std::vector<KeyGroup> selectedGroups = q->selectedGroups();
	if (AbstractKeyListModel *const model = ui.tabWidget.flatModel()) {
	model->setKeys(keys);
	model->setGroups(groups);
	}
	if (AbstractKeyListModel *const model = ui.tabWidget.hierarchicalModel()) {
	model->setKeys(keys);
	model->setGroups(groups);
	}
	q->selectCertificates(selectedKeys);
	q->selectGroups(selectedGroups);
	}

	void CertificateSelectionDialog::filterAllowedKeys(std::vector<Key> &keys, int options)
	{
	auto end = keys.end();

	switch (options & AnyFormat) {
	case OpenPGPFormat:
	end = std::remove_if(keys.begin(), end, [](const Key &key) {
	return key.protocol() != OpenPGP;
	});
	break;
	case CMSFormat:
	end = std::remove_if(keys.begin(), end, [](const Key &key) {
	return key.protocol() != CMS;
	});
	break;
	default:
	case AnyFormat:;
	}

	switch (options & AnyCertificate) {
	case SignOnly:
	-#if GPGMEPP_KEY_CANSIGN_IS_FIXED
	end = std::remove_if(keys.begin(), end, [](const Key &key) {
	return !Kleo::keyHasSign(key);
	});
	-#else
	- end = std::remove_if(keys.begin(), end, [](const Key &key) {
	- return !key.canReallySign();
	- });
	-#endif
	break;
	case EncryptOnly:
	end = std::remove_if(keys.begin(), end, [](const Key &key) {
	return !Kleo::keyHasEncrypt(key);
	});
	break;
	default:
	case AnyCertificate:;
	}

	if (options & SecretKeys) {
	end = std::remove_if(keys.begin(), end, [](const Key &key) {
	return !key.hasSecret();
	});
	}

	keys.erase(end, keys.end());
	}

	void CertificateSelectionDialog::Private::slotCurrentViewChanged(QAbstractItemView *newView)
	{
	if (!Kleo::contains(connectedViews, newView)) {
	connectedViews.push_back(newView);
	connect(newView, &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) {
	slotDoubleClicked(index);
	});
	Q_ASSERT(newView->selectionModel());
	connect(newView->selectionModel(), &QItemSelectionModel::selectionChanged, q, [this](const QItemSelection &, const QItemSelection &) {
	slotSelectionChanged();
	});
	}
	slotSelectionChanged();
	}

	void CertificateSelectionDialog::Private::slotSelectionChanged()
	{
	if (QPushButton *const pb = ui.buttonBox.button(QDialogButtonBox::Ok)) {
	pb->setEnabled(acceptable(q->selectedCertificates(), q->selectedGroups()));
	}
	}

	void CertificateSelectionDialog::Private::slotDoubleClicked(const QModelIndex &idx)
	{
	QAbstractItemView *const view = ui.tabWidget.currentView();
	Q_ASSERT(view);
	const auto *const model = ui.tabWidget.currentModel();
	Q_ASSERT(model);
	Q_UNUSED(model)
	QItemSelectionModel *const sm = view->selectionModel();
	Q_ASSERT(sm);
	sm->select(idx, QItemSelectionModel::ClearAndSelect \| QItemSelectionModel::Rows);
	QMetaObject::invokeMethod(
	q,
	[this]() {
	q->accept();
	},
	Qt::QueuedConnection);
	}

	void CertificateSelectionDialog::accept()
	{
	if (d->acceptable(selectedCertificates(), selectedGroups())) {
	QDialog::accept();
	}
	}

	#include "moc_certificateselectiondialog.cpp"
	diff --git a/src/dialogs/expirydialog.cpp b/src/dialogs/expirydialog.cpp
	index 1a1636fdb..4b03cbe31 100644
	--- a/src/dialogs/expirydialog.cpp
	+++ b/src/dialogs/expirydialog.cpp
	@@ -1,229 +1,225 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/expirydialog.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2021 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "expirydialog.h"

	#include "utils/expiration.h"
	#include "utils/gui-helper.h"
	#include "utils/qt-cxx20-compat.h"

	#include <Libkleo/Formatting>

	#include <KDateComboBox>
	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KStandardGuiItem>

	#include <QCheckBox>
	#include <QDate>
	#include <QDialogButtonBox>
	#include <QHBoxLayout>
	#include <QLabel>
	#include <QPushButton>
	#include <QRadioButton>
	#include <QVBoxLayout>

	using namespace Kleo;
	using namespace Kleo::Dialogs;

	class ExpiryDialog::Private
	{
	friend class ::Kleo::Dialogs::ExpiryDialog;
	ExpiryDialog *const q;

	public:
	Private(Mode mode, ExpiryDialog *qq)
	: q{qq}
	, ui{mode, qq}
	{
	ui.neverRB->setEnabled(unlimitedValidityAllowed());
	ui.onRB->setEnabled(!fixedExpirationDate());

	connect(ui.onCB, &KDateComboBox::dateChanged, q, [this]() {
	slotOnDateChanged();
	});
	}

	private:
	void slotOnDateChanged();

	private:
	bool unlimitedValidityAllowed() const;
	bool fixedExpirationDate() const;
	void setInitialFocus();

	private:
	bool initialFocusWasSet = false;

	struct UI {
	QRadioButton *neverRB;
	QRadioButton *onRB;
	KDateComboBox *onCB;
	QCheckBox *updateSubkeysCheckBox;

	explicit UI(Mode mode, Dialogs::ExpiryDialog *qq)
	{
	auto mainLayout = new QVBoxLayout{qq};

	auto mainWidget = new QWidget{qq};

	auto vboxLayout = new QVBoxLayout{mainWidget};
	vboxLayout->setContentsMargins(0, 0, 0, 0);

	{
	auto label = new QLabel{qq};
	label->setText(mode == Mode::UpdateIndividualSubkey ? i18n("Please select until when the subkey should be valid:")
	: i18n("Please select until when the certificate should be valid:"));
	vboxLayout->addWidget(label);
	}

	neverRB = new QRadioButton(i18n("Unlimited validity"), mainWidget);
	neverRB->setChecked(false);

	vboxLayout->addWidget(neverRB);

	{
	auto hboxLayout = new QHBoxLayout;

	onRB = new QRadioButton{i18n("Valid until:"), mainWidget};
	onRB->setChecked(true);

	hboxLayout->addWidget(onRB);

	onCB = new KDateComboBox{mainWidget};
	setUpExpirationDateComboBox(onCB);

	hboxLayout->addWidget(onCB);

	hboxLayout->addStretch(1);

	vboxLayout->addLayout(hboxLayout);
	}

	{
	updateSubkeysCheckBox = new QCheckBox{i18n("Also update the validity period of the subkeys"), qq};
	-#if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
	updateSubkeysCheckBox->setVisible(mode == Mode::UpdateCertificateWithSubkeys);
	-#else
	- updateSubkeysCheckBox->setVisible(false);
	-#endif
	vboxLayout->addWidget(updateSubkeysCheckBox);
	}

	vboxLayout->addStretch(1);

	mainLayout->addWidget(mainWidget);

	auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok \| QDialogButtonBox::Cancel, qq};
	auto okButton = buttonBox->button(QDialogButtonBox::Ok);
	KGuiItem::assign(okButton, KStandardGuiItem::ok());
	okButton->setDefault(true);
	okButton->setShortcut(static_cast<int>(Qt::CTRL) \| static_cast<int>(Qt::Key_Return));
	KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
	qq->connect(buttonBox, &QDialogButtonBox::accepted, qq, &ExpiryDialog::accept);
	qq->connect(buttonBox, &QDialogButtonBox::rejected, qq, &QDialog::reject);

	mainLayout->addWidget(buttonBox);

	connect(onRB, &QRadioButton::toggled, onCB, &QWidget::setEnabled);
	}
	} ui;
	};

	void ExpiryDialog::Private::slotOnDateChanged()
	{
	ui.onRB->setAccessibleName(i18nc("Valid until DATE", "Valid until %1", Formatting::accessibleDate(ui.onCB->date())));
	}

	bool Kleo::Dialogs::ExpiryDialog::Private::unlimitedValidityAllowed() const
	{
	return !Kleo::maximumExpirationDate().isValid();
	}

	bool Kleo::Dialogs::ExpiryDialog::Private::fixedExpirationDate() const
	{
	return ui.onCB->minimumDate() == ui.onCB->maximumDate();
	}

	void ExpiryDialog::Private::setInitialFocus()
	{
	if (initialFocusWasSet) {
	return;
	}
	// give focus to the checked radio button
	(void)focusFirstCheckedButton({ui.neverRB, ui.onRB});
	initialFocusWasSet = true;
	}

	ExpiryDialog::ExpiryDialog(Mode mode, QWidget *p)
	: QDialog{p}
	, d{new Private{mode, this}}
	{
	setWindowTitle(i18nc("@title:window", "Change Validity Period"));
	}

	ExpiryDialog::~ExpiryDialog() = default;

	void ExpiryDialog::setDateOfExpiry(const QDate &date)
	{
	const QDate current = QDate::currentDate();
	if (date.isValid()) {
	d->ui.onRB->setChecked(true);
	if (date <= current) {
	d->ui.onCB->setDate(defaultExpirationDate(ExpirationOnUnlimitedValidity::InternalDefaultExpiration));
	} else {
	d->ui.onCB->setDate(date);
	}
	} else {
	if (d->unlimitedValidityAllowed()) {
	d->ui.neverRB->setChecked(true);
	} else {
	d->ui.onRB->setChecked(true);
	}
	d->ui.onCB->setDate(defaultExpirationDate(ExpirationOnUnlimitedValidity::InternalDefaultExpiration));
	}
	}

	QDate ExpiryDialog::dateOfExpiry() const
	{
	return d->ui.onRB->isChecked() ? d->ui.onCB->date() : QDate{};
	}

	void ExpiryDialog::setUpdateExpirationOfAllSubkeys(bool update)
	{
	d->ui.updateSubkeysCheckBox->setChecked(update);
	}

	bool ExpiryDialog::updateExpirationOfAllSubkeys() const
	{
	return d->ui.updateSubkeysCheckBox->isChecked();
	}

	void ExpiryDialog::accept()
	{
	const auto date = dateOfExpiry();
	if (!Kleo::isValidExpirationDate(date)) {
	KMessageBox::error(this, i18nc("@info", "Error: %1", Kleo::validityPeriodHint()));
	return;
	}

	QDialog::accept();
	}

	void ExpiryDialog::showEvent(QShowEvent *event)
	{
	d->setInitialFocus();
	QDialog::showEvent(event);
	}

	#include "moc_expirydialog.cpp"
	diff --git a/src/dialogs/revokekeydialog.cpp b/src/dialogs/revokekeydialog.cpp
	index 68bc90ee2..df305b855 100644
	--- a/src/dialogs/revokekeydialog.cpp
	+++ b/src/dialogs/revokekeydialog.cpp
	@@ -1,292 +1,286 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/revokekeydialog.h

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include "revokekeydialog.h"

	#include "utils/accessibility.h"
	#include "view/errorlabel.h"

	#include <Libkleo/Formatting>

	#include <KConfigGroup>
	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KSharedConfig>

	#include <QApplication>
	#include <QButtonGroup>
	#include <QDialogButtonBox>
	#include <QFocusEvent>
	#include <QGroupBox>
	#include <QLabel>
	#include <QPushButton>
	#include <QRadioButton>
	#include <QRegularExpression>
	#include <QTextEdit>
	#include <QVBoxLayout>

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	#include <gpgme++/global.h>
	-#endif
	#include <gpgme++/key.h>

	#include <kleopatra_debug.h>

	using namespace Kleo;
	using namespace GpgME;

	namespace
	{
	class TextEdit : public QTextEdit
	{
	Q_OBJECT
	public:
	using QTextEdit::QTextEdit;

	Q_SIGNALS:
	void editingFinished();

	protected:
	void focusOutEvent(QFocusEvent *event) override
	{
	Qt::FocusReason reason = event->reason();
	if (reason != Qt::PopupFocusReason \|\| !(QApplication::activePopupWidget() && QApplication::activePopupWidget()->parentWidget() == this)) {
	Q_EMIT editingFinished();
	}

	QTextEdit::focusOutEvent(event);
	}
	};
	}

	class RevokeKeyDialog::Private
	{
	friend class ::Kleo::RevokeKeyDialog;
	RevokeKeyDialog *const q;

	struct {
	QLabel *infoLabel = nullptr;
	QLabel *descriptionLabel = nullptr;
	TextEdit *description = nullptr;
	ErrorLabel *descriptionError = nullptr;
	QDialogButtonBox *buttonBox = nullptr;
	} ui;

	Key key;
	QButtonGroup reasonGroup;
	bool descriptionEditingInProgress = false;
	QString descriptionAccessibleName;

	public:
	Private(RevokeKeyDialog *qq)
	: q(qq)
	{
	q->setWindowTitle(i18nc("title:window", "Revoke Key"));

	auto mainLayout = new QVBoxLayout{q};

	ui.infoLabel = new QLabel{q};
	mainLayout->addWidget(ui.infoLabel);

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	auto groupBox = new QGroupBox{i18nc("@title:group", "Reason for revocation"), q};

	reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "No reason specified"), q}, static_cast<int>(RevocationReason::Unspecified));
	reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key has been compromised"), q}, static_cast<int>(RevocationReason::Compromised));
	reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key is superseded"), q}, static_cast<int>(RevocationReason::Superseded));
	reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key is no longer used"), q}, static_cast<int>(RevocationReason::NoLongerUsed));
	reasonGroup.button(static_cast<int>(RevocationReason::Unspecified))->setChecked(true);

	{
	auto boxLayout = new QVBoxLayout{groupBox};
	for (auto radio : reasonGroup.buttons()) {
	boxLayout->addWidget(radio);
	}
	}

	mainLayout->addWidget(groupBox);
	-#endif

	{
	ui.descriptionLabel = new QLabel{i18nc("@label:textbox", "Description (optional):"), q};
	ui.description = new TextEdit{q};
	ui.description->setAcceptRichText(false);
	// do not accept Tab as input; this is better for accessibility and
	// tabulators are not really that useful in the description
	ui.description->setTabChangesFocus(true);
	ui.descriptionLabel->setBuddy(ui.description);
	ui.descriptionError = new ErrorLabel{q};
	ui.descriptionError->setVisible(false);

	mainLayout->addWidget(ui.descriptionLabel);
	mainLayout->addWidget(ui.description);
	mainLayout->addWidget(ui.descriptionError);
	}

	connect(ui.description, &TextEdit::editingFinished, q, [this]() {
	onDescriptionEditingFinished();
	});
	connect(ui.description, &TextEdit::textChanged, q, [this]() {
	onDescriptionTextChanged();
	});

	ui.buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok \| QDialogButtonBox::Cancel);
	auto okButton = ui.buttonBox->button(QDialogButtonBox::Ok);
	okButton->setText(i18nc("@action:button", "Revoke Key"));
	okButton->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete-remove")));

	mainLayout->addWidget(ui.buttonBox);

	connect(ui.buttonBox, &QDialogButtonBox::accepted, q, [this]() {
	checkAccept();
	});
	connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);

	restoreGeometry();
	}

	~Private()
	{
	saveGeometry();
	}

	private:
	void saveGeometry()
	{
	KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeKeyDialog");
	cfgGroup.writeEntry("Size", q->size());
	cfgGroup.sync();
	}

	void restoreGeometry(const QSize &defaultSize = {})
	{
	KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeKeyDialog");
	const QSize size = cfgGroup.readEntry("Size", defaultSize);
	if (size.isValid()) {
	q->resize(size);
	}
	}

	void checkAccept()
	{
	if (!descriptionHasAcceptableInput()) {
	KMessageBox::error(q, descriptionErrorMessage());
	} else {
	q->accept();
	}
	}

	bool descriptionHasAcceptableInput() const
	{
	return !q->description().contains(QLatin1String{"\n\n"});
	}

	QString descriptionErrorMessage() const
	{
	QString message;

	if (!descriptionHasAcceptableInput()) {
	message = i18n("Error: The description must not contain empty lines.");
	}
	return message;
	}

	void updateDescriptionError()
	{
	const auto currentErrorMessage = ui.descriptionError->text();
	const auto newErrorMessage = descriptionErrorMessage();
	if (newErrorMessage == currentErrorMessage) {
	return;
	}
	if (currentErrorMessage.isEmpty() && descriptionEditingInProgress) {
	// delay showing the error message until editing is finished, so that we
	// do not annoy the user with an error message while they are still
	// entering the recipient;
	// on the other hand, we clear the error message immediately if it does
	// not apply anymore and we update the error message immediately if it
	// changed
	return;
	}
	ui.descriptionError->setVisible(!newErrorMessage.isEmpty());
	ui.descriptionError->setText(newErrorMessage);
	updateAccessibleNameAndDescription();
	}

	void updateAccessibleNameAndDescription()
	{
	// fall back to default accessible name if accessible name wasn't set explicitly
	if (descriptionAccessibleName.isEmpty()) {
	descriptionAccessibleName = getAccessibleName(ui.description);
	}
	const bool errorShown = ui.descriptionError->isVisible();

	// Qt does not support "described-by" relations (like WCAG's "aria-describedby" relationship attribute);
	// emulate this by setting the error message as accessible description of the input field
	const auto description = errorShown ? ui.descriptionError->text() : QString{};
	if (ui.description->accessibleDescription() != description) {
	ui.description->setAccessibleDescription(description);
	}

	// Qt does not support IA2's "invalid entry" state (like WCAG's "aria-invalid" state attribute);
	// screen readers say something like "invalid entry" if this state is set;
	// emulate this by adding "invalid entry" to the accessible name of the input field
	// and its label
	const auto name = errorShown ? descriptionAccessibleName + QLatin1String{", "} + invalidEntryText() //
	: descriptionAccessibleName;
	if (ui.descriptionLabel->accessibleName() != name) {
	ui.descriptionLabel->setAccessibleName(name);
	}
	if (ui.description->accessibleName() != name) {
	ui.description->setAccessibleName(name);
	}
	}

	void onDescriptionTextChanged()
	{
	descriptionEditingInProgress = true;
	updateDescriptionError();
	}

	void onDescriptionEditingFinished()
	{
	descriptionEditingInProgress = false;
	updateDescriptionError();
	}
	};

	RevokeKeyDialog::RevokeKeyDialog(QWidget *parent, Qt::WindowFlags f)
	: QDialog{parent, f}
	, d{new Private{this}}
	{
	}

	RevokeKeyDialog::~RevokeKeyDialog() = default;

	void RevokeKeyDialog::setKey(const GpgME::Key &key)
	{
	d->key = key;
	d->ui.infoLabel->setText(xi18n("<para>You are about to revoke the following key:<nl/>%1</para>").arg(Formatting::summaryLine(key)));
	}

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	GpgME::RevocationReason RevokeKeyDialog::reason() const
	{
	return static_cast<RevocationReason>(d->reasonGroup.checkedId());
	}
	-#endif

	QString RevokeKeyDialog::description() const
	{
	static const QRegularExpression whitespaceAtEndOfLine{QStringLiteral(R"([ \t\r]+\n)")};
	static const QRegularExpression trailingWhitespace{QStringLiteral(R"(\s*$)")};
	return d->ui.description->toPlainText().remove(whitespaceAtEndOfLine).remove(trailingWhitespace);
	}

	#include "revokekeydialog.moc"
	diff --git a/src/dialogs/revokekeydialog.h b/src/dialogs/revokekeydialog.h
	index 4050f698e..876198e09 100644
	--- a/src/dialogs/revokekeydialog.h
	+++ b/src/dialogs/revokekeydialog.h
	@@ -1,49 +1,45 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/revokekeydialog.h

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#pragma once

	#include <config-kleopatra.h>

	#include <QDialog>

	#include <memory>

	namespace GpgME
	{
	class Key;
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	enum class RevocationReason;
	-#endif
	}

	namespace Kleo
	{

	class RevokeKeyDialog : public QDialog
	{
	Q_OBJECT
	public:
	explicit RevokeKeyDialog(QWidget *parent = nullptr, Qt::WindowFlags f = {});
	~RevokeKeyDialog() override;

	void setKey(const GpgME::Key &key);

	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	GpgME::RevocationReason reason() const;
	-#endif
	QString description() const;

	private:
	class Private;
	const std::unique_ptr<Private> d;
	};

	} // namespace Kleo
	diff --git a/src/dialogs/subkeyswidget.cpp b/src/dialogs/subkeyswidget.cpp
	index 0196ee5eb..e7bfe42b1 100644
	--- a/src/dialogs/subkeyswidget.cpp
	+++ b/src/dialogs/subkeyswidget.cpp
	@@ -1,321 +1,317 @@
	/*
	dialogs/subkeyswidget.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "subkeyswidget.h"

	#include "commands/changeexpirycommand.h"
	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	#include "commands/exportsecretsubkeycommand.h"
	-#endif
	#include "commands/importpaperkeycommand.h"
	#include "commands/keytocardcommand.h"
	#include "exportdialog.h"

	#include <kleopatra_debug.h>

	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyHelpers>
	#include <Libkleo/NavigatableTreeWidget>

	#include <KConfigGroup>
	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <QDialogButtonBox>
	#include <QHeaderView>
	#include <QLabel>
	#include <QMenu>
	#include <QPushButton>
	#include <QTreeWidgetItem>
	#include <QVBoxLayout>

	#include <gpgme++/context.h>
	#include <gpgme++/key.h>

	Q_DECLARE_METATYPE(GpgME::Subkey)

	using namespace Kleo;
	using namespace Kleo::Commands;

	class SubKeysWidget::Private
	{
	SubKeysWidget *const q;

	public:
	Private(SubKeysWidget *qq)
	: q{qq}
	, ui{qq}
	{
	ui.subkeysTree->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui.subkeysTree, &QAbstractItemView::customContextMenuRequested, q, [this](const QPoint &p) {
	tableContextMenuRequested(p);
	});
	connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged, q, [this]() {
	keysMayHaveChanged();
	});
	}

	private:
	void tableContextMenuRequested(const QPoint &p);
	void keysMayHaveChanged();

	public:
	GpgME::Key key;

	public:
	struct UI {
	QVBoxLayout *mainLayout;
	NavigatableTreeWidget *subkeysTree;

	UI(QWidget *widget)
	{
	mainLayout = new QVBoxLayout{widget};
	mainLayout->setContentsMargins(0, 0, 0, 0);

	auto subkeysTreeLabel = new QLabel{i18nc("@label", "Subkeys:"), widget};
	mainLayout->addWidget(subkeysTreeLabel);

	subkeysTree = new NavigatableTreeWidget{widget};
	subkeysTreeLabel->setBuddy(subkeysTree);
	subkeysTree->setAccessibleName(i18nc("@label", "Subkeys"));
	subkeysTree->setRootIsDecorated(false);
	subkeysTree->setHeaderLabels({
	i18nc("@title:column", "ID"),
	i18nc("@title:column", "Type"),
	i18nc("@title:column", "Valid From"),
	i18nc("@title:column", "Valid Until"),
	i18nc("@title:column", "Status"),
	i18nc("@title:column", "Strength"),
	i18nc("@title:column", "Usage"),
	i18nc("@title:column", "Primary"),
	i18nc("@title:column", "Storage"),
	});
	mainLayout->addWidget(subkeysTree);
	}
	} ui;
	};

	void SubKeysWidget::Private::tableContextMenuRequested(const QPoint &p)
	{
	auto item = ui.subkeysTree->itemAt(p);
	if (!item) {
	return;
	}
	const auto subkey = item->data(0, Qt::UserRole).value<GpgME::Subkey>();
	const bool isOwnKey = subkey.parent().hasSecret();
	const bool secretSubkeyStoredInKeyRing = subkey.isSecret() && !subkey.isCardKey();

	auto menu = new QMenu(q);
	connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);

	if (isOwnKey) {
	auto action = menu->addAction(i18n("Change End of Validity Period..."), q, [this, subkey]() {
	auto cmd = new ChangeExpiryCommand(subkey.parent());
	cmd->setSubkey(subkey);
	ui.subkeysTree->setEnabled(false);
	connect(cmd, &ChangeExpiryCommand::finished, q, [this]() {
	ui.subkeysTree->setEnabled(true);
	key.update();
	q->setKey(key);
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	action->setEnabled(canBeUsedForSecretKeyOperations(subkey.parent()));
	}

	if (subkey.canAuthenticate()) {
	menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-export")), i18n("Export OpenSSH key"), q, [this, subkey]() {
	QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
	dlg->setKey(subkey, static_cast<unsigned int>(GpgME::Context::ExportSSH));
	dlg->exec();
	});
	}

	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-import")), i18n("Restore printed backup"), q, [this, subkey]() {
	auto cmd = new ImportPaperKeyCommand(subkey.parent());
	ui.subkeysTree->setEnabled(false);
	connect(cmd, &ImportPaperKeyCommand::finished, q, [this]() {
	ui.subkeysTree->setEnabled(true);
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	action->setEnabled(!secretSubkeyStoredInKeyRing);

	if (isOwnKey) {
	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("send-to-symbolic")), i18n("Transfer to smartcard"), q, [this, subkey]() {
	auto cmd = new KeyToCardCommand(subkey);
	ui.subkeysTree->setEnabled(false);
	connect(cmd, &KeyToCardCommand::finished, q, [this]() {
	ui.subkeysTree->setEnabled(true);
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	action->setEnabled(secretSubkeyStoredInKeyRing && !KeyToCardCommand::getSuitableCards(subkey).empty());
	}

	-#if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
	const bool isPrimarySubkey = subkey.keyID() == key.keyID();
	if (isOwnKey && !isPrimarySubkey) {
	auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-export")), i18n("Export secret subkey"), q, [this, subkey]() {
	auto cmd = new ExportSecretSubkeyCommand{{subkey}};
	ui.subkeysTree->setEnabled(false);
	connect(cmd, &ExportSecretSubkeyCommand::finished, q, [this]() {
	ui.subkeysTree->setEnabled(true);
	});
	cmd->setParentWidget(q);
	cmd->start();
	});
	action->setEnabled(secretSubkeyStoredInKeyRing);
	}
	-#endif

	menu->popup(ui.subkeysTree->viewport()->mapToGlobal(p));
	}

	void SubKeysWidget::Private::keysMayHaveChanged()
	{
	qCDebug(KLEOPATRA_LOG) << q << __func__;
	const auto updatedKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
	if (!updatedKey.isNull()) {
	q->setKey(updatedKey);
	}
	}

	SubKeysWidget::SubKeysWidget(QWidget *parent)
	: QWidget(parent)
	, d(new Private(this))
	{
	}

	SubKeysWidget::~SubKeysWidget() = default;

	void SubKeysWidget::setKey(const GpgME::Key &key)
	{
	if (key.protocol() != GpgME::OpenPGP) {
	return;
	}
	d->key = key;

	const auto currentItem = d->ui.subkeysTree->currentItem();
	const QByteArray selectedKeyFingerprint = currentItem ? QByteArray(currentItem->data(0, Qt::UserRole).value<GpgME::Subkey>().fingerprint()) : QByteArray();
	d->ui.subkeysTree->clear();

	const auto subkeys = key.subkeys();
	for (const auto &subkey : subkeys) {
	auto item = new QTreeWidgetItem;
	item->setData(0, Qt::DisplayRole, Formatting::prettyID(subkey.keyID()));
	item->setData(0, Qt::AccessibleTextRole, Formatting::accessibleHexID(subkey.keyID()));
	item->setData(0, Qt::UserRole, QVariant::fromValue(subkey));
	item->setData(1, Qt::DisplayRole, Kleo::Formatting::type(subkey));
	item->setData(2, Qt::DisplayRole, Kleo::Formatting::creationDateString(subkey));
	item->setData(2, Qt::AccessibleTextRole, Formatting::accessibleCreationDate(subkey));
	item->setData(3, Qt::DisplayRole, Kleo::Formatting::expirationDateString(subkey));
	item->setData(3, Qt::AccessibleTextRole, Formatting::accessibleExpirationDate(subkey));
	item->setData(4, Qt::DisplayRole, Kleo::Formatting::validityShort(subkey));
	switch (subkey.publicKeyAlgorithm()) {
	case GpgME::Subkey::AlgoECDSA:
	case GpgME::Subkey::AlgoEDDSA:
	case GpgME::Subkey::AlgoECDH:
	item->setData(5, Qt::DisplayRole, QString::fromStdString(subkey.algoName()));
	break;
	default:
	item->setData(5, Qt::DisplayRole, QString::number(subkey.length()));
	}
	item->setData(6, Qt::DisplayRole, Kleo::Formatting::usageString(subkey));
	const auto isPrimary = subkey.keyID() == key.keyID();
	item->setData(7, Qt::DisplayRole, isPrimary ? QStringLiteral("✓") : QString());
	item->setData(7, Qt::AccessibleTextRole, isPrimary ? i18nc("yes, is primary key", "yes") : i18nc("no, is not primary key", "no"));
	if (subkey.isCardKey()) {
	if (const char *serialNo = subkey.cardSerialNumber()) {
	item->setData(8, Qt::DisplayRole, i18nc("smart card <serial number>", "smart card %1", QString::fromUtf8(serialNo)));
	} else {
	item->setData(8, Qt::DisplayRole, i18n("smart card"));
	}
	} else if (isPrimary && key.hasSecret() && !subkey.isSecret()) {
	item->setData(8, Qt::DisplayRole, i18nc("key is 'offline key', i.e. secret key is not stored on this computer", "offline"));
	} else if (subkey.isSecret()) {
	item->setData(8, Qt::DisplayRole, i18n("on this computer"));
	} else {
	item->setData(8, Qt::DisplayRole, i18nc("unknown storage location", "unknown"));
	}
	d->ui.subkeysTree->addTopLevelItem(item);
	if (subkey.fingerprint() == selectedKeyFingerprint) {
	d->ui.subkeysTree->setCurrentItem(item);
	}
	}
	if (!key.hasSecret()) {
	// hide information about storage location for keys of other people
	d->ui.subkeysTree->hideColumn(8);
	}
	d->ui.subkeysTree->header()->resizeSections(QHeaderView::ResizeToContents);
	}

	GpgME::Key SubKeysWidget::key() const
	{
	return d->key;
	}

	SubKeysDialog::SubKeysDialog(QWidget *parent)
	: QDialog(parent)
	{
	setWindowTitle(i18nc("@title:window", "Subkeys Details"));
	auto l = new QVBoxLayout(this);
	l->addWidget(new SubKeysWidget(this));

	auto bbox = new QDialogButtonBox(this);
	auto btn = bbox->addButton(QDialogButtonBox::Close);
	connect(btn, &QPushButton::clicked, this, &QDialog::accept);
	l->addWidget(bbox);
	readConfig();
	}

	SubKeysDialog::~SubKeysDialog()
	{
	writeConfig();
	}

	void SubKeysDialog::readConfig()
	{
	KConfigGroup dialog(KSharedConfig::openStateConfig(), "SubKeysDialog");
	const QSize size = dialog.readEntry("Size", QSize(820, 280));
	if (size.isValid()) {
	resize(size);
	}
	}

	void SubKeysDialog::writeConfig()
	{
	KConfigGroup dialog(KSharedConfig::openStateConfig(), "SubKeysDialog");
	dialog.writeEntry("Size", size());
	dialog.sync();
	}

	void SubKeysDialog::setKey(const GpgME::Key &key)
	{
	auto w = findChild<SubKeysWidget *>();
	Q_ASSERT(w);
	w->setKey(key);
	}

	GpgME::Key SubKeysDialog::key() const
	{
	auto w = findChild<SubKeysWidget *>();
	Q_ASSERT(w);
	return w->key();
	}
	diff --git a/src/dialogs/weboftrustdialog.cpp b/src/dialogs/weboftrustdialog.cpp
	index 614499ab5..ef08d4112 100644
	--- a/src/dialogs/weboftrustdialog.cpp
	+++ b/src/dialogs/weboftrustdialog.cpp
	@@ -1,121 +1,118 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/weboftrustdialog.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2017 Intevation GmbH
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "weboftrustdialog.h"

	#include "weboftrustwidget.h"

	#include "commands/importcertificatefromkeyservercommand.h"

	#include <Libkleo/KeyHelpers>

	#include <QAction>
	#include <QDialogButtonBox>
	#include <QPushButton>
	#include <QVBoxLayout>

	#include <gpgme++/key.h>

	#include <KConfigGroup>
	#include <KLocalizedString>
	#include <KSharedConfig>

	#include <algorithm>
	#include <set>

	using namespace Kleo;

	namespace
	{
	void addActionButton(QDialogButtonBox buttonBox, QAction action)
	{
	if (!action) {
	return;
	}
	auto button = buttonBox->addButton(action->text(), QDialogButtonBox::ActionRole);
	button->setEnabled(action->isEnabled());
	QObject::connect(action, &QAction::changed, button, [action, button]() {
	button->setEnabled(action->isEnabled());
	});
	QObject::connect(button, &QPushButton::clicked, action, &QAction::trigger);
	}
	}

	WebOfTrustDialog::WebOfTrustDialog(QWidget *parent)
	: QDialog(parent)
	{
	KConfigGroup dialog(KSharedConfig::openStateConfig(), "WebOfTrustDialog");
	const QSize size = dialog.readEntry("Size", QSize(900, 400));
	if (size.isValid()) {
	resize(size);
	}
	setWindowTitle(i18nc("@title:window", "Certifications"));

	mWidget = new WebOfTrustWidget(this);
	auto l = new QVBoxLayout(this);
	l->addWidget(mWidget);

	auto bbox = new QDialogButtonBox(this);

	auto btn = bbox->addButton(QDialogButtonBox::Close);
	connect(btn, &QPushButton::pressed, this, &QDialog::accept);

	addActionButton(bbox, mWidget->detailsAction());
	addActionButton(bbox, mWidget->certifyAction());
	addActionButton(bbox, mWidget->revokeAction());

	mFetchKeysBtn = bbox->addButton(i18nc("@action:button", "Fetch Missing Keys"), QDialogButtonBox::ActionRole);
	mFetchKeysBtn->setToolTip(i18nc("@info:tooltip", "Look up and import all keys that were used to certify the user IDs of this key"));
	connect(mFetchKeysBtn, &QPushButton::pressed, this, &WebOfTrustDialog::fetchMissingKeys);
	-#if !QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
	- mFetchKeysBtn->setVisible(false);
	-#endif

	l->addWidget(bbox);
	}

	void WebOfTrustDialog::setKey(const GpgME::Key &key)
	{
	mWidget->setKey(key);
	mFetchKeysBtn->setEnabled(!key.isBad());
	}

	GpgME::Key WebOfTrustDialog::key() const
	{
	return mWidget->key();
	}

	WebOfTrustDialog::~WebOfTrustDialog()
	{
	KConfigGroup dialog(KSharedConfig::openStateConfig(), "WebOfTrustDialog");
	dialog.writeEntry("Size", size());
	dialog.sync();
	}

	void WebOfTrustDialog::fetchMissingKeys()
	{
	if (key().isNull()) {
	return;
	}
	const auto missingSignerKeyIds = Kleo::getMissingSignerKeyIds(key().userIDs());

	auto cmd = new Kleo::ImportCertificateFromKeyserverCommand{QStringList{std::begin(missingSignerKeyIds), std::end(missingSignerKeyIds)}};
	cmd->setParentWidget(this);
	mFetchKeysBtn->setEnabled(false);
	connect(cmd, &Kleo::ImportCertificateFromKeyserverCommand::finished, this, [this]() {
	// Trigger an update when done
	setKey(key());
	mFetchKeysBtn->setEnabled(true);
	});
	cmd->start();
	}
	diff --git a/src/newcertificatewizard/resultpage.cpp b/src/newcertificatewizard/resultpage.cpp
	index feaf1256e..7128bf182 100644
	--- a/src/newcertificatewizard/resultpage.cpp
	+++ b/src/newcertificatewizard/resultpage.cpp
	@@ -1,374 +1,367 @@
	/* -- mode: c++; c-basic-offset:4 --
	newcertificatewizard/resultpage.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2016, 2017 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH
	SPDX-FileCopyrightText: 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "resultpage_p.h"

	#include "commands/exportcertificatecommand.h"
	#include "commands/exportopenpgpcertstoservercommand.h"
	-#if QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	#include "commands/exportsecretkeycommand.h"
	-#else
	-#include "commands/exportsecretkeycommand_old.h"
	-#endif
	#include "utils/dragqueen.h"
	#include "utils/email.h"
	#include "utils/filedialog.h"
	#include "utils/scrollarea.h"

	#include <Libkleo/KeyCache>

	#include <KConfigGroup>
	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KSharedConfig>

	#include <QGroupBox>
	#include <QHBoxLayout>
	#include <QLineEdit>
	#include <QPushButton>
	#include <QTextBrowser>
	#include <QVBoxLayout>

	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::NewCertificateUi;
	using namespace GpgME;
	-#if !QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	-using Kleo::Commands::Compat::ExportSecretKeyCommand;
	-#endif

	struct ResultPage::UI {
	QTextBrowser *resultTB = nullptr;
	QTextBrowser *errorTB = nullptr;
	DragQueen *dragQueen = nullptr;
	QPushButton *restartWizardPB = nullptr;
	QGroupBox *nextStepsGB = nullptr;
	QPushButton *saveRequestToFilePB = nullptr;
	QPushButton *sendRequestByEMailPB = nullptr;
	QPushButton *makeBackupPB = nullptr;
	QPushButton *sendCertificateByEMailPB = nullptr;
	QPushButton *uploadToKeyserverPB = nullptr;
	QPushButton *createRevocationRequestPB = nullptr;
	QPushButton *createSigningCertificatePB = nullptr;
	QPushButton *createEncryptionCertificatePB = nullptr;

	UI(QWizardPage *parent)
	{
	auto mainLayout = new QVBoxLayout{parent};
	const auto margins = mainLayout->contentsMargins();
	mainLayout->setContentsMargins(margins.left(), 0, margins.right(), 0);

	auto scrollArea = new ScrollArea{parent};
	scrollArea->setFocusPolicy(Qt::NoFocus);
	scrollArea->setFrameStyle(QFrame::NoFrame);
	scrollArea->setBackgroundRole(parent->backgroundRole());
	scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	scrollArea->setSizeAdjustPolicy(QScrollArea::AdjustToContents);
	auto scrollAreaLayout = qobject_cast<QBoxLayout *>(scrollArea->widget()->layout());
	scrollAreaLayout->setContentsMargins(0, margins.top(), 0, margins.bottom());

	auto resultGB = new QGroupBox{i18nc("@title:group", "Result"), parent};
	auto resultGBLayout = new QHBoxLayout{resultGB};

	resultTB = new QTextBrowser{resultGB};
	resultGBLayout->addWidget(resultTB);

	errorTB = new QTextBrowser{resultGB};
	resultGBLayout->addWidget(errorTB);

	dragQueen = new Kleo::DragQueen{resultGB};
	dragQueen->setToolTip(i18n("Drag this icon to your mail application's composer to attach the request to a mail."));
	dragQueen->setAlignment(Qt::AlignCenter);
	resultGBLayout->addWidget(dragQueen);

	scrollAreaLayout->addWidget(resultGB);

	restartWizardPB = new QPushButton{i18n("Restart This Wizard (Keeps Your Parameters)"), parent};

	scrollAreaLayout->addWidget(restartWizardPB);

	nextStepsGB = new QGroupBox{i18nc("@title:group", "Next Steps"), parent};
	auto nextStepsGBLayout = new QVBoxLayout{nextStepsGB};

	saveRequestToFilePB = new QPushButton{i18n("Save Certificate Request To File..."), nextStepsGB};
	nextStepsGBLayout->addWidget(saveRequestToFilePB);

	sendRequestByEMailPB = new QPushButton{i18n("Send Certificate Request By EMail..."), nextStepsGB};
	nextStepsGBLayout->addWidget(sendRequestByEMailPB);

	makeBackupPB = new QPushButton{i18n("Make a Backup Of Your Key Pair..."), nextStepsGB};
	nextStepsGBLayout->addWidget(makeBackupPB);

	sendCertificateByEMailPB = new QPushButton{i18n("Send Public Key By EMail..."), nextStepsGB};
	nextStepsGBLayout->addWidget(sendCertificateByEMailPB);

	uploadToKeyserverPB = new QPushButton{i18n("Upload Public Key To Directory Service..."), nextStepsGB};
	nextStepsGBLayout->addWidget(uploadToKeyserverPB);

	createRevocationRequestPB = new QPushButton{i18n("Create Revocation Request..."), nextStepsGB};
	nextStepsGBLayout->addWidget(createRevocationRequestPB);

	createSigningCertificatePB = new QPushButton{i18n("Create Signing Certificate With Same Parameters"), nextStepsGB};
	nextStepsGBLayout->addWidget(createSigningCertificatePB);

	createEncryptionCertificatePB = new QPushButton{i18n("Create Encryption Certificate With Same Parameters"), nextStepsGB};
	nextStepsGBLayout->addWidget(createEncryptionCertificatePB);

	scrollAreaLayout->addWidget(nextStepsGB);

	mainLayout->addWidget(scrollArea);
	}
	};

	ResultPage::ResultPage(QWidget *p)
	: WizardPage{p}
	, ui{new UI{this}}
	, initialized{false}
	, successfullyCreatedSigningCertificate{false}
	, successfullyCreatedEncryptionCertificate{false}
	{
	setObjectName(QString::fromUtf8("Kleo__NewCertificateUi__ResultPage"));

	connect(ui->saveRequestToFilePB, &QPushButton::clicked, this, &ResultPage::slotSaveRequestToFile);
	connect(ui->sendRequestByEMailPB, &QPushButton::clicked, this, &ResultPage::slotSendRequestByEMail);
	connect(ui->sendCertificateByEMailPB, &QPushButton::clicked, this, &ResultPage::slotSendCertificateByEMail);
	connect(ui->uploadToKeyserverPB, &QPushButton::clicked, this, &ResultPage::slotUploadCertificateToDirectoryServer);
	connect(ui->makeBackupPB, &QPushButton::clicked, this, &ResultPage::slotBackupCertificate);
	connect(ui->createRevocationRequestPB, &QPushButton::clicked, this, &ResultPage::slotCreateRevocationRequest);
	connect(ui->createSigningCertificatePB, &QPushButton::clicked, this, &ResultPage::slotCreateSigningCertificate);
	connect(ui->createEncryptionCertificatePB, &QPushButton::clicked, this, &ResultPage::slotCreateEncryptionCertificate);

	ui->dragQueen->setPixmap(QIcon::fromTheme(QStringLiteral("kleopatra")).pixmap(64, 64));
	registerField(QStringLiteral("error"), ui->errorTB, "plainText");
	registerField(QStringLiteral("result"), ui->resultTB, "plainText");
	registerField(QStringLiteral("url"), ui->dragQueen, "url");
	// hidden field, since QWizard can't deal with non-widget-backed fields...
	auto le = new QLineEdit(this);
	le->hide();
	registerField(QStringLiteral("fingerprint"), le);
	}

	ResultPage::~ResultPage() = default;

	void ResultPage::initializePage()
	{
	const bool error = isError();

	if (error) {
	setTitle(i18nc("@title", "Key Creation Failed"));
	setSubTitle(i18n("Key pair creation failed. Please find details about the failure below."));
	} else {
	setTitle(i18nc("@title", "Key Pair Successfully Created"));
	setSubTitle(i18n("Your new key pair was created successfully. Please find details on the result and some suggested next steps below."));
	}

	ui->resultTB->setVisible(!error);
	ui->errorTB->setVisible(error);
	ui->dragQueen->setVisible(!error && !pgp());
	ui->restartWizardPB->setVisible(error);
	ui->nextStepsGB->setVisible(!error);
	ui->saveRequestToFilePB->setVisible(!pgp());
	ui->makeBackupPB->setVisible(pgp());
	ui->createRevocationRequestPB->setVisible(pgp() && false); // not implemented

	ui->sendCertificateByEMailPB->setVisible(pgp());
	ui->sendRequestByEMailPB->setVisible(!pgp());
	ui->uploadToKeyserverPB->setVisible(pgp());

	if (!error && !pgp()) {
	if (signingAllowed() && !encryptionAllowed()) {
	successfullyCreatedSigningCertificate = true;
	} else if (!signingAllowed() && encryptionAllowed()) {
	successfullyCreatedEncryptionCertificate = true;
	} else {
	successfullyCreatedEncryptionCertificate = successfullyCreatedSigningCertificate = true;
	}
	}

	ui->createSigningCertificatePB->setVisible(successfullyCreatedEncryptionCertificate && !successfullyCreatedSigningCertificate);
	ui->createEncryptionCertificatePB->setVisible(successfullyCreatedSigningCertificate && !successfullyCreatedEncryptionCertificate);

	if (error) {
	wizard()->setOptions(wizard()->options() & ~QWizard::NoCancelButtonOnLastPage);
	} else {
	wizard()->setOptions(wizard()->options() \| QWizard::NoCancelButtonOnLastPage);
	}

	if (!initialized) {
	connect(ui->restartWizardPB, &QAbstractButton::clicked, this, [this]() {
	restartAtEnterDetailsPage();
	});
	}
	initialized = true;
	}

	bool ResultPage::isError() const
	{
	return !ui->errorTB->document()->isEmpty();
	}

	bool ResultPage::isComplete() const
	{
	return !isError();
	}

	Key ResultPage::key() const
	{
	return KeyCache::instance()->findByFingerprint(fingerprint().toLatin1().constData());
	}

	void ResultPage::slotSaveRequestToFile()
	{
	QString fileName = FileDialog::getSaveFileName(this, i18nc("@title", "Save Request"), QStringLiteral("imp"), i18n("PKCS#10 Requests (*.p10)"));
	if (fileName.isEmpty()) {
	return;
	}
	if (!fileName.endsWith(QLatin1String(".p10"), Qt::CaseInsensitive)) {
	fileName += QLatin1String(".p10");
	}
	QFile src(QUrl(url()).toLocalFile());
	if (!src.copy(fileName))
	KMessageBox::error(this,
	xi18nc("@info",
	"Could not copy temporary file <filename>%1</filename> "
	"to file <filename>%2</filename>: <message>%3</message>",
	src.fileName(),
	fileName,
	src.errorString()),
	i18nc("@title", "Error Saving Request"));
	else
	KMessageBox::information(this,
	xi18nc("@info",
	"<para>Successfully wrote request to <filename>%1</filename>.</para>"
	"<para>You should now send the request to the Certification Authority (CA).</para>",
	fileName),
	i18nc("@title", "Request Saved"));
	}

	void ResultPage::slotSendRequestByEMail()
	{
	if (pgp()) {
	return;
	}
	const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
	invokeMailer(config.readEntry("CAEmailAddress"), // to
	i18n("Please process this certificate."), // subject
	i18n("Please process this certificate and inform the sender about the location to fetch the resulting certificate.\n\nThanks,\n"), // body
	QFileInfo{QUrl(url()).toLocalFile()}); // attachment
	KMessageBox::information(this,
	xi18nc("@info",
	"<para><application>Kleopatra</application> tried to send a mail via your default mail client.</para>"
	"<para>Some mail clients are known not to support attachments when invoked this way.</para>"
	"<para>If your mail client does not have an attachment, then drag the <application>Kleopatra</application> icon and drop "
	"it on the message compose window of your mail client.</para>"
	"<para>If that does not work, either, save the request to a file, and then attach that.</para>"),
	i18nc("@title", "Sending Mail"),
	QStringLiteral("newcertificatewizard-mailto-troubles"));
	}

	void ResultPage::slotSendCertificateByEMail()
	{
	if (!pgp() \|\| exportCertificateCommand) {
	return;
	}
	auto cmd = new ExportCertificateCommand(key());
	connect(cmd, &ExportCertificateCommand::finished, this, &ResultPage::slotSendCertificateByEMailContinuation);
	cmd->setOpenPGPFileName(tmpDir().absoluteFilePath(fingerprint() + QLatin1String(".asc")));
	cmd->start();
	exportCertificateCommand = cmd;
	}

	void ResultPage::slotSendCertificateByEMailContinuation()
	{
	if (!exportCertificateCommand) {
	return;
	}
	// ### better error handling?
	const QString fileName = exportCertificateCommand->openPGPFileName();
	qCDebug(KLEOPATRA_LOG) << "fileName" << fileName;
	exportCertificateCommand = nullptr;
	if (fileName.isEmpty()) {
	return;
	}
	invokeMailer(i18n("My new public OpenPGP key"), // subject
	i18n("Please find attached my new public OpenPGP key."), // body
	QFileInfo{fileName});
	KMessageBox::information(this,
	xi18nc("@info",
	"<para><application>Kleopatra</application> tried to send a mail via your default mail client.</para>"
	"<para>Some mail clients are known not to support attachments when invoked this way.</para>"
	"<para>If your mail client does not have an attachment, then attach the file <filename>%1</filename> manually.</para>",
	fileName),
	i18nc("@title", "Sending Mail"),
	QStringLiteral("newcertificatewizard-openpgp-mailto-troubles"));
	}

	void ResultPage::slotUploadCertificateToDirectoryServer()
	{
	if (pgp()) {
	(new ExportOpenPGPCertsToServerCommand(key()))->start();
	}
	}

	void ResultPage::slotBackupCertificate()
	{
	if (pgp()) {
	(new ExportSecretKeyCommand(key()))->start();
	}
	}

	void ResultPage::slotCreateRevocationRequest()
	{
	}

	void ResultPage::slotCreateSigningCertificate()
	{
	if (successfullyCreatedSigningCertificate) {
	return;
	}
	toggleSignEncryptAndRestart();
	}

	void ResultPage::slotCreateEncryptionCertificate()
	{
	if (successfullyCreatedEncryptionCertificate) {
	return;
	}
	toggleSignEncryptAndRestart();
	}

	void ResultPage::toggleSignEncryptAndRestart()
	{
	if (!wizard()) {
	return;
	}
	if (KMessageBox::warningContinueCancel(this,
	i18nc("@info",
	"This operation will delete the certification request. "
	"Please make sure that you have sent or saved it before proceeding."),
	i18nc("@title", "Certification Request About To Be Deleted"))
	!= KMessageBox::Continue) {
	return;
	}
	const bool sign = signingAllowed();
	const bool encr = encryptionAllowed();
	setField(QStringLiteral("signingAllowed"), !sign);
	setField(QStringLiteral("encryptionAllowed"), !encr);
	restartAtEnterDetailsPage();
	}
	diff --git a/src/utils/clipboardmenu.cpp b/src/utils/clipboardmenu.cpp
	index 6b9e671c5..ef2b69238 100644
	--- a/src/utils/clipboardmenu.cpp
	+++ b/src/utils/clipboardmenu.cpp
	@@ -1,151 +1,147 @@
	/*
	SPDX-FileCopyrightText: 2014-2021 Laurent Montel <montel@kde.org>

	SPDX-License-Identifier: GPL-2.0-only
	*/

	#include <config-kleopatra.h>

	#include "clipboardmenu.h"

	#include "kdtoolsglobal.h"
	#include "mainwindow.h"

	#include <settings.h>

	#include <commands/decryptverifyclipboardcommand.h>
	#include <commands/encryptclipboardcommand.h>
	#include <commands/importcertificatefromclipboardcommand.h>
	#include <commands/signclipboardcommand.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compat>
	#include <Libkleo/KeyCache>

	#include <KActionMenu>
	#include <KLocalizedString>

	#include <QAction>
	#include <QApplication>
	#include <QClipboard>
	#include <QSignalBlocker>

	#include <gpgme++/key.h>

	using namespace Kleo;

	using namespace Kleo::Commands;

	ClipboardMenu::ClipboardMenu(QObject *parent)
	: QObject{parent}
	{
	mClipboardMenu = new KActionMenu(i18n("Clipboard"), this);
	mImportClipboardAction = new QAction(i18n("Certificate Import"), this);
	mEncryptClipboardAction = new QAction(i18n("Encrypt..."), this);
	const Kleo::Settings settings{};
	if (settings.cmsEnabled() && settings.cmsSigningAllowed()) {
	mSmimeSignClipboardAction = new QAction(i18n("S/MIME-Sign..."), this);
	}
	mOpenPGPSignClipboardAction = new QAction(i18n("OpenPGP-Sign..."), this);
	mDecryptVerifyClipboardAction = new QAction(i18n("Decrypt/Verify..."), this);

	KDAB_SET_OBJECT_NAME(mClipboardMenu);
	KDAB_SET_OBJECT_NAME(mImportClipboardAction);
	KDAB_SET_OBJECT_NAME(mEncryptClipboardAction);
	KDAB_SET_OBJECT_NAME(mSmimeSignClipboardAction);
	KDAB_SET_OBJECT_NAME(mOpenPGPSignClipboardAction);
	KDAB_SET_OBJECT_NAME(mDecryptVerifyClipboardAction);

	connect(mImportClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotImportClipboard);
	connect(mEncryptClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotEncryptClipboard);
	if (mSmimeSignClipboardAction) {
	connect(mSmimeSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotSMIMESignClipboard);
	}
	connect(mOpenPGPSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotOpenPGPSignClipboard);
	connect(mDecryptVerifyClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotDecryptVerifyClipboard);
	mClipboardMenu->addAction(mImportClipboardAction);
	mClipboardMenu->addAction(mEncryptClipboardAction);
	if (mSmimeSignClipboardAction) {
	mClipboardMenu->addAction(mSmimeSignClipboardAction);
	}
	mClipboardMenu->addAction(mOpenPGPSignClipboardAction);
	mClipboardMenu->addAction(mDecryptVerifyClipboardAction);
	connect(QApplication::clipboard(), &QClipboard::changed, this, &ClipboardMenu::slotEnableDisableActions);
	connect(KeyCache::instance().get(), &KeyCache::keyListingDone, this, &ClipboardMenu::slotEnableDisableActions);
	slotEnableDisableActions();
	}

	ClipboardMenu::~ClipboardMenu() = default;

	void ClipboardMenu::setMainWindow(MainWindow *window)
	{
	mWindow = window;
	}

	KActionMenu *ClipboardMenu::clipboardMenu() const
	{
	return mClipboardMenu;
	}

	void ClipboardMenu::startCommand(Command *cmd)
	{
	Q_ASSERT(cmd);
	cmd->setParent(mWindow);
	cmd->start();
	}

	void ClipboardMenu::slotImportClipboard()
	{
	startCommand(new ImportCertificateFromClipboardCommand(nullptr));
	}

	void ClipboardMenu::slotEncryptClipboard()
	{
	startCommand(new EncryptClipboardCommand(nullptr));
	}

	void ClipboardMenu::slotOpenPGPSignClipboard()
	{
	startCommand(new SignClipboardCommand(GpgME::OpenPGP, nullptr));
	}

	void ClipboardMenu::slotSMIMESignClipboard()
	{
	startCommand(new SignClipboardCommand(GpgME::CMS, nullptr));
	}

	void ClipboardMenu::slotDecryptVerifyClipboard()
	{
	startCommand(new DecryptVerifyClipboardCommand(nullptr));
	}

	namespace
	{

	bool hasSigningKeys(GpgME::Protocol protocol)
	{
	if (!KeyCache::instance()->initialized()) {
	return false;
	}
	return Kleo::any_of(KeyCache::instance()->keys(), [protocol](const auto &k) {
	-#if GPGMEPP_KEY_CANSIGN_IS_FIXED
	return k.hasSecret() && Kleo::keyHasSign(k) && (k.protocol() == protocol);
	-#else
	- return k.hasSecret() && k.canReallySign() && (k.protocol() == protocol);
	-#endif
	});
	}

	}

	void ClipboardMenu::slotEnableDisableActions()
	{
	const QSignalBlocker blocker(QApplication::clipboard());
	mImportClipboardAction->setEnabled(ImportCertificateFromClipboardCommand::canImportCurrentClipboard());
	mEncryptClipboardAction->setEnabled(EncryptClipboardCommand::canEncryptCurrentClipboard());
	mOpenPGPSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::OpenPGP));
	if (mSmimeSignClipboardAction) {
	mSmimeSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::CMS));
	}
	mDecryptVerifyClipboardAction->setEnabled(DecryptVerifyClipboardCommand::canDecryptVerifyCurrentClipboard());
	}
	diff --git a/src/view/keylistcontroller.cpp b/src/view/keylistcontroller.cpp
	index 54ec2bcf9..1bbc682b9 100644
	--- a/src/view/keylistcontroller.cpp
	+++ b/src/view/keylistcontroller.cpp
	@@ -1,1060 +1,1049 @@
	/* -- mode: c++; c-basic-offset:4 --
	controllers/keylistcontroller.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2022 Felix Tiede

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "keylistcontroller.h"
	#include "tabwidget.h"

	#include <smartcard/readerstatus.h>

	#include <utils/action_data.h>

	#include "commands/exportcertificatecommand.h"
	#include "commands/exportopenpgpcertstoservercommand.h"
	#include "kleopatra_debug.h"
	#include "tooltippreferences.h"
	#include <settings.h>
	#ifdef MAILAKONADI_ENABLED
	#include "commands/exportopenpgpcerttoprovidercommand.h"
	#endif // MAILAKONADI_ENABLED
	-#if QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	-#include "commands/exportsecretkeycommand.h"
	-#else
	-#include "commands/exportsecretkeycommand_old.h"
	-#endif
	#include "commands/adduseridcommand.h"
	#include "commands/certifycertificatecommand.h"
	#include "commands/changeexpirycommand.h"
	#include "commands/changeownertrustcommand.h"
	#include "commands/changepassphrasecommand.h"
	#include "commands/changeroottrustcommand.h"
	#include "commands/checksumcreatefilescommand.h"
	#include "commands/checksumverifyfilescommand.h"
	#include "commands/clearcrlcachecommand.h"
	#include "commands/decryptverifyfilescommand.h"
	#include "commands/deletecertificatescommand.h"
	#include "commands/detailscommand.h"
	#include "commands/dumpcertificatecommand.h"
	#include "commands/dumpcrlcachecommand.h"
	#include "commands/exportpaperkeycommand.h"
	+#include "commands/exportsecretkeycommand.h"
	#include "commands/importcertificatefromfilecommand.h"
	#include "commands/importcrlcommand.h"
	#include "commands/lookupcertificatescommand.h"
	#include "commands/newcertificatesigningrequestcommand.h"
	#include "commands/newopenpgpcertificatecommand.h"
	#include "commands/refreshopenpgpcertscommand.h"
	#include "commands/refreshx509certscommand.h"
	#include "commands/reloadkeyscommand.h"
	#include "commands/revokecertificationcommand.h"
	#include "commands/revokekeycommand.h"
	#include "commands/signencryptfilescommand.h"
	#include "commands/signencryptfoldercommand.h"

	#include <Libkleo/Algorithm>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyListModel>

	#include <gpgme++/key.h>

	#include <KActionCollection>
	#include <KLocalizedString>

	#include <QAbstractItemView>
	#include <QAction>
	#include <QItemSelectionModel>
	#include <QPointer>

	#include <algorithm>
	#include <iterator>

	// needed for GPGME_VERSION_NUMBER
	#include <gpgme.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::SmartCard;
	using namespace GpgME;
	-#if !QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	-using Kleo::Commands::Compat::ExportSecretKeyCommand;
	-#endif

	class KeyListController::Private
	{
	friend class ::Kleo::KeyListController;
	KeyListController *const q;

	public:
	explicit Private(KeyListController *qq);
	~Private();

	void connectView(QAbstractItemView *view);
	void connectCommand(Command *cmd);

	void connectTabWidget();
	void disconnectTabWidget();

	void addCommand(Command *cmd)
	{
	connectCommand(cmd);
	commands.insert(std::lower_bound(commands.begin(), commands.end(), cmd), cmd);
	}
	void addView(QAbstractItemView *view)
	{
	connectView(view);
	views.insert(std::lower_bound(views.begin(), views.end(), view), view);
	}
	void removeView(QAbstractItemView *view)
	{
	view->disconnect(q);
	view->selectionModel()->disconnect(q);
	views.erase(std::remove(views.begin(), views.end(), view), views.end());
	}

	public:
	void slotDestroyed(QObject *o)
	{
	qCDebug(KLEOPATRA_LOG) << (void *)o;
	views.erase(std::remove(views.begin(), views.end(), o), views.end());
	commands.erase(std::remove(commands.begin(), commands.end(), o), commands.end());
	}
	void slotDoubleClicked(const QModelIndex &idx);
	void slotActivated(const QModelIndex &idx);
	void slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_);
	void slotContextMenu(const QPoint &pos);
	void slotCommandFinished();
	void slotAddKey(const Key &key);
	void slotAboutToRemoveKey(const Key &key);
	void slotActionTriggered(QAction *action);
	void slotCurrentViewChanged(QAbstractItemView *view)
	{
	if (view && !std::binary_search(views.cbegin(), views.cend(), view)) {
	qCDebug(KLEOPATRA_LOG) << "you need to register view" << view << "before trying to set it as the current view!";
	addView(view);
	}
	currentView = view;
	q->enableDisableActions(view ? view->selectionModel() : nullptr);
	}

	private:
	int toolTipOptions() const;

	private:
	static Command::Restrictions calculateRestrictionsMask(const QItemSelectionModel *sm);

	private:
	struct action_item {
	QPointer<QAction> action;
	Command::Restrictions restrictions;
	Command (createCommand)(QAbstractItemView , KeyListController );
	};
	std::vector<action_item> actions;
	std::vector<QAbstractItemView *> views;
	std::vector<Command *> commands;
	QPointer<QWidget> parentWidget;
	QPointer<TabWidget> tabWidget;
	QPointer<QAbstractItemView> currentView;
	QPointer<AbstractKeyListModel> flatModel, hierarchicalModel;
	std::vector<QMetaObject::Connection> m_connections;
	};

	KeyListController::Private::Private(KeyListController *qq)
	: q(qq)
	, actions()
	, views()
	, commands()
	, parentWidget()
	, tabWidget()
	, flatModel()
	, hierarchicalModel()
	{
	connect(KeyCache::instance().get(), &KeyCache::added, q, [this](const GpgME::Key &key) {
	slotAddKey(key);
	});
	connect(KeyCache::instance().get(), &KeyCache::aboutToRemove, q, [this](const GpgME::Key &key) {
	slotAboutToRemoveKey(key);
	});
	}

	KeyListController::Private::~Private()
	{
	}

	KeyListController::KeyListController(QObject *p)
	: QObject(p)
	, d(new Private(this))
	{
	}

	KeyListController::~KeyListController()
	{
	}

	void KeyListController::Private::slotAddKey(const Key &key)
	{
	// ### make model act on keycache directly...
	if (flatModel) {
	flatModel->addKey(key);
	}
	if (hierarchicalModel) {
	hierarchicalModel->addKey(key);
	}
	}

	void KeyListController::Private::slotAboutToRemoveKey(const Key &key)
	{
	// ### make model act on keycache directly...
	if (flatModel) {
	flatModel->removeKey(key);
	}
	if (hierarchicalModel) {
	hierarchicalModel->removeKey(key);
	}
	}

	void KeyListController::addView(QAbstractItemView *view)
	{
	if (!view \|\| std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
	return;
	}
	d->addView(view);
	}

	void KeyListController::removeView(QAbstractItemView *view)
	{
	if (!view \|\| !std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
	return;
	}
	d->removeView(view);
	}

	void KeyListController::setCurrentView(QAbstractItemView *view)
	{
	d->slotCurrentViewChanged(view);
	}

	std::vector<QAbstractItemView *> KeyListController::views() const
	{
	return d->views;
	}

	void KeyListController::setFlatModel(AbstractKeyListModel *model)
	{
	if (model == d->flatModel) {
	return;
	}

	d->flatModel = model;

	if (model) {
	model->clear();
	if (KeyCache::instance()->initialized()) {
	model->addKeys(KeyCache::instance()->keys());
	}
	model->setToolTipOptions(d->toolTipOptions());
	}
	}

	void KeyListController::setHierarchicalModel(AbstractKeyListModel *model)
	{
	if (model == d->hierarchicalModel) {
	return;
	}

	d->hierarchicalModel = model;

	if (model) {
	model->clear();
	if (KeyCache::instance()->initialized()) {
	model->addKeys(KeyCache::instance()->keys());
	}
	model->setToolTipOptions(d->toolTipOptions());
	}
	}

	void KeyListController::setTabWidget(TabWidget *tabWidget)
	{
	if (tabWidget == d->tabWidget) {
	return;
	}

	d->disconnectTabWidget();

	d->tabWidget = tabWidget;

	d->connectTabWidget();

	d->slotCurrentViewChanged(tabWidget ? tabWidget->currentView() : nullptr);
	}

	void KeyListController::setParentWidget(QWidget *parent)
	{
	d->parentWidget = parent;
	}

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

	void KeyListController::Private::connectTabWidget()
	{
	if (!tabWidget) {
	return;
	}
	const auto views = tabWidget->views();
	std::for_each(views.cbegin(), views.cend(), [this](QAbstractItemView *view) {
	addView(view);
	});

	m_connections.reserve(3);
	m_connections.push_back(connect(tabWidget, &TabWidget::viewAdded, q, &KeyListController::addView));
	m_connections.push_back(connect(tabWidget, &TabWidget::viewAboutToBeRemoved, q, &KeyListController::removeView));
	m_connections.push_back(connect(tabWidget, &TabWidget::currentViewChanged, q, [this](QAbstractItemView *view) {
	slotCurrentViewChanged(view);
	}));
	}

	void KeyListController::Private::disconnectTabWidget()
	{
	if (!tabWidget) {
	return;
	}
	for (const auto &connection : m_connections) {
	disconnect(connection);
	}
	m_connections.clear();

	const auto views = tabWidget->views();
	std::for_each(views.cbegin(), views.cend(), [this](QAbstractItemView *view) {
	removeView(view);
	});
	}

	AbstractKeyListModel *KeyListController::flatModel() const
	{
	return d->flatModel;
	}

	AbstractKeyListModel *KeyListController::hierarchicalModel() const
	{
	return d->hierarchicalModel;
	}

	QAbstractItemView *KeyListController::currentView() const
	{
	return d->currentView;
	}

	TabWidget *KeyListController::tabWidget() const
	{
	return d->tabWidget;
	}

	void KeyListController::createActions(KActionCollection *coll)
	{
	const std::vector<action_data> common_and_openpgp_action_data = {
	// File menu
	{
	"file_new_certificate",
	i18n("New OpenPGP Key Pair..."),
	i18n("Create a new OpenPGP certificate"),
	"view-certificate-add",
	nullptr,
	nullptr,
	QStringLiteral("Ctrl+N"),
	},
	{
	"file_export_certificates",
	i18n("Export..."),
	i18n("Export the selected certificate (public key) to a file"),
	"view-certificate-export",
	nullptr,
	nullptr,
	QStringLiteral("Ctrl+E"),
	},
	{
	"file_export_certificates_to_server",
	i18n("Publish on Server..."),
	i18n("Publish the selected certificate (public key) on a public keyserver"),
	"view-certificate-export-server",
	nullptr,
	nullptr,
	QStringLiteral("Ctrl+Shift+E"),
	},
	#ifdef MAILAKONADI_ENABLED
	{
	"file_export_certificate_to_provider",
	i18n("Publish at Mail Provider..."),
	i18n("Publish the selected certificate (public key) at mail provider's Web Key Directory if offered"),
	"view-certificate-export",
	nullptr,
	nullptr,
	QString(),
	},
	#endif // MAILAKONADI_ENABLED
	{
	"file_export_secret_keys",
	i18n("Backup Secret Keys..."),
	QString(),
	"view-certificate-export-secret",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_export_paper_key",
	i18n("Print Secret Key..."),
	QString(),
	"document-print",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_lookup_certificates",
	i18n("Lookup on Server..."),
	i18n("Search for certificates online using a public keyserver"),
	"edit-find",
	nullptr,
	nullptr,
	QStringLiteral("Shift+Ctrl+I"),
	},
	{
	"file_import_certificates",
	i18n("Import..."),
	i18n("Import a certificate from a file"),
	"view-certificate-import",
	nullptr,
	nullptr,
	QStringLiteral("Ctrl+I"),
	},
	{
	"file_decrypt_verify_files",
	i18n("Decrypt/Verify..."),
	i18n("Decrypt and/or verify files"),
	"document-edit-decrypt-verify",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_sign_encrypt_files",
	i18n("Sign/Encrypt..."),
	i18n("Encrypt and/or sign files"),
	"document-edit-sign-encrypt",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_sign_encrypt_folder",
	i18n("Sign/Encrypt Folder..."),
	i18n("Encrypt and/or sign folders"),
	nullptr /"folder-edit-sign-encrypt"/,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_checksum_create_files",
	i18n("Create Checksum Files..."),
	QString(),
	nullptr /"document-checksum-create"/,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"file_checksum_verify_files",
	i18n("Verify Checksum Files..."),
	QString(),
	nullptr /"document-checksum-verify"/,
	nullptr,
	nullptr,
	QString(),
	},
	// View menu
	{
	"view_redisplay",
	i18n("Redisplay"),
	QString(),
	"view-refresh",
	nullptr,
	nullptr,
	QStringLiteral("F5"),
	},
	{
	"view_stop_operations",
	i18n("Stop Operation"),
	QString(),
	"process-stop",
	this,
	[this](bool) {
	cancelCommands();
	},
	QStringLiteral("Escape"),
	RegularQAction,
	Disabled,
	},
	{
	"view_certificate_details",
	i18n("Details"),
	QString(),
	"dialog-information",
	nullptr,
	nullptr,
	QString(),
	},
	- // Certificate menu
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	+ // Certificate menu
	{
	"certificates_revoke",
	i18n("Revoke Certificate..."),
	i18n("Revoke the selected OpenPGP certificate"),
	"view-certificate-revoke",
	nullptr,
	nullptr,
	{},
	},
	-#endif
	{
	"certificates_delete",
	i18n("Delete"),
	i18n("Delete selected certificates"),
	"edit-delete",
	nullptr,
	nullptr,
	QStringLiteral("Delete"),
	},
	{
	"certificates_certify_certificate",
	i18n("Certify..."),
	i18n("Certify the validity of the selected certificate"),
	"view-certificate-sign",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_revoke_certification",
	i18n("Revoke Certification..."),
	i18n("Revoke the certification of the selected certificate"),
	"view-certificate-revoke",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_change_expiry",
	i18n("Change End of Validity Period..."),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_change_owner_trust",
	i18nc("@action:inmenu", "Change Certification Power..."),
	i18nc("@info:tooltip", "Grant or revoke the certification power of the selected certificate"),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_change_passphrase",
	i18n("Change Passphrase..."),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_add_userid",
	i18n("Add User ID..."),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	// Tools menu
	{
	"tools_refresh_openpgp_certificates",
	i18n("Refresh OpenPGP Certificates"),
	QString(),
	"view-refresh",
	nullptr,
	nullptr,
	QString(),
	},
	// Window menu
	// (come from TabWidget)
	// Help menu
	// (come from MainWindow)
	};

	static const action_data cms_create_csr_action_data = {
	"file_new_certificate_signing_request",
	i18n("New S/MIME Certification Request..."),
	i18n("Create a new S/MIME certificate signing request (CSR)"),
	"view-certificate-add",
	nullptr,
	nullptr,
	{},
	};

	static const std::vector<action_data> cms_action_data = {
	// Certificate menu
	{
	"certificates_trust_root",
	i18n("Trust Root Certificate"),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_distrust_root",
	i18n("Distrust Root Certificate"),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"certificates_dump_certificate",
	i18n("Technical Details"),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	// Tools menu
	{
	"tools_refresh_x509_certificates",
	i18n("Refresh S/MIME Certificates"),
	QString(),
	"view-refresh",
	nullptr,
	nullptr,
	QString(),
	},
	{
	"crl_clear_crl_cache",
	i18n("Clear CRL Cache"),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"crl_dump_crl_cache",
	i18n("Dump CRL Cache"),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	{
	"crl_import_crl",
	i18n("Import CRL From File..."),
	QString(),
	nullptr,
	nullptr,
	nullptr,
	QString(),
	},
	};

	std::vector<action_data> action_data = common_and_openpgp_action_data;

	if (const Kleo::Settings settings{}; settings.cmsEnabled()) {
	if (settings.cmsCertificateCreationAllowed()) {
	action_data.push_back(cms_create_csr_action_data);
	}
	action_data.reserve(action_data.size() + cms_action_data.size());
	std::copy(std::begin(cms_action_data), std::end(cms_action_data), std::back_inserter(action_data));
	}

	make_actions_from_data(action_data, coll);

	if (QAction *action = coll->action(QStringLiteral("view_stop_operations"))) {
	connect(this, &KeyListController::commandsExecuting, action, &QAction::setEnabled);
	}

	// ### somehow make this better...
	registerActionForCommand<NewOpenPGPCertificateCommand>(coll->action(QStringLiteral("file_new_certificate")));
	registerActionForCommand<NewCertificateSigningRequestCommand>(coll->action(QStringLiteral("file_new_certificate_signing_request")));
	//---
	registerActionForCommand<LookupCertificatesCommand>(coll->action(QStringLiteral("file_lookup_certificates")));
	registerActionForCommand<ImportCertificateFromFileCommand>(coll->action(QStringLiteral("file_import_certificates")));
	//---
	registerActionForCommand<ExportCertificateCommand>(coll->action(QStringLiteral("file_export_certificates")));
	registerActionForCommand<ExportSecretKeyCommand>(coll->action(QStringLiteral("file_export_secret_keys")));
	registerActionForCommand<ExportPaperKeyCommand>(coll->action(QStringLiteral("file_export_paper_key")));
	registerActionForCommand<ExportOpenPGPCertsToServerCommand>(coll->action(QStringLiteral("file_export_certificates_to_server")));
	#ifdef MAILAKONADI_ENABLED
	registerActionForCommand<ExportOpenPGPCertToProviderCommand>(coll->action(QStringLiteral("file_export_certificate_to_provider")));
	#endif // MAILAKONADI_ENABLED
	//---
	registerActionForCommand<DecryptVerifyFilesCommand>(coll->action(QStringLiteral("file_decrypt_verify_files")));
	registerActionForCommand<SignEncryptFilesCommand>(coll->action(QStringLiteral("file_sign_encrypt_files")));
	registerActionForCommand<SignEncryptFolderCommand>(coll->action(QStringLiteral("file_sign_encrypt_folder")));
	//---
	registerActionForCommand<ChecksumCreateFilesCommand>(coll->action(QStringLiteral("file_checksum_create_files")));
	registerActionForCommand<ChecksumVerifyFilesCommand>(coll->action(QStringLiteral("file_checksum_verify_files")));

	registerActionForCommand<ReloadKeysCommand>(coll->action(QStringLiteral("view_redisplay")));
	// coll->action( "view_stop_operations" ) <-- already dealt with in make_actions_from_data()
	registerActionForCommand<DetailsCommand>(coll->action(QStringLiteral("view_certificate_details")));

	registerActionForCommand<ChangeOwnerTrustCommand>(coll->action(QStringLiteral("certificates_change_owner_trust")));
	registerActionForCommand<TrustRootCommand>(coll->action(QStringLiteral("certificates_trust_root")));
	registerActionForCommand<DistrustRootCommand>(coll->action(QStringLiteral("certificates_distrust_root")));
	//---
	registerActionForCommand<CertifyCertificateCommand>(coll->action(QStringLiteral("certificates_certify_certificate")));
	if (RevokeCertificationCommand::isSupported()) {
	registerActionForCommand<RevokeCertificationCommand>(coll->action(QStringLiteral("certificates_revoke_certification")));
	}
	//---
	registerActionForCommand<ChangeExpiryCommand>(coll->action(QStringLiteral("certificates_change_expiry")));
	registerActionForCommand<ChangePassphraseCommand>(coll->action(QStringLiteral("certificates_change_passphrase")));
	registerActionForCommand<AddUserIDCommand>(coll->action(QStringLiteral("certificates_add_userid")));
	//---
	-#if QGPGME_SUPPORTS_KEY_REVOCATION
	registerActionForCommand<RevokeKeyCommand>(coll->action(QStringLiteral("certificates_revoke")));
	-#endif
	registerActionForCommand<DeleteCertificatesCommand>(coll->action(QStringLiteral("certificates_delete")));
	//---
	registerActionForCommand<DumpCertificateCommand>(coll->action(QStringLiteral("certificates_dump_certificate")));

	registerActionForCommand<RefreshX509CertsCommand>(coll->action(QStringLiteral("tools_refresh_x509_certificates")));
	registerActionForCommand<RefreshOpenPGPCertsCommand>(coll->action(QStringLiteral("tools_refresh_openpgp_certificates")));
	//---
	registerActionForCommand<ImportCrlCommand>(coll->action(QStringLiteral("crl_import_crl")));
	//---
	registerActionForCommand<ClearCrlCacheCommand>(coll->action(QStringLiteral("crl_clear_crl_cache")));
	registerActionForCommand<DumpCrlCacheCommand>(coll->action(QStringLiteral("crl_dump_crl_cache")));

	enableDisableActions(nullptr);
	}

	void KeyListController::registerAction(QAction action, Command::Restrictions restrictions, Command (create)(QAbstractItemView , KeyListController *))
	{
	if (!action) {
	return;
	}
	Q_ASSERT(!action->isCheckable()); // can be added later, for now, disallow

	const Private::action_item ai = {action, restrictions, create};
	connect(action, &QAction::triggered, this, [this, action]() {
	d->slotActionTriggered(action);
	});
	d->actions.push_back(ai);
	}

	void KeyListController::registerCommand(Command *cmd)
	{
	if (!cmd \|\| std::binary_search(d->commands.cbegin(), d->commands.cend(), cmd)) {
	return;
	}
	d->addCommand(cmd);
	qCDebug(KLEOPATRA_LOG) << (void *)cmd;
	if (d->commands.size() == 1) {
	Q_EMIT commandsExecuting(true);
	}
	}

	bool KeyListController::hasRunningCommands() const
	{
	return !d->commands.empty();
	}

	bool KeyListController::shutdownWarningRequired() const
	{
	return std::any_of(d->commands.cbegin(), d->commands.cend(), std::mem_fn(&Command::warnWhenRunningAtShutdown));
	}

	// slot
	void KeyListController::cancelCommands()
	{
	std::for_each(d->commands.begin(), d->commands.end(), std::mem_fn(&Command::cancel));
	}

	void KeyListController::Private::connectView(QAbstractItemView *view)
	{
	connect(view, &QObject::destroyed, q, [this](QObject *obj) {
	slotDestroyed(obj);
	});
	connect(view, &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) {
	slotDoubleClicked(index);
	});
	connect(view, &QAbstractItemView::activated, q, [this](const QModelIndex &index) {
	slotActivated(index);
	});
	connect(view->selectionModel(), &QItemSelectionModel::selectionChanged, q, [this](const QItemSelection &oldSel, const QItemSelection &newSel) {
	slotSelectionChanged(oldSel, newSel);
	});

	view->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(view, &QWidget::customContextMenuRequested, q, [this](const QPoint &pos) {
	slotContextMenu(pos);
	});
	}

	void KeyListController::Private::connectCommand(Command *cmd)
	{
	if (!cmd) {
	return;
	}
	connect(cmd, &QObject::destroyed, q, [this](QObject *obj) {
	slotDestroyed(obj);
	});
	connect(cmd, &Command::finished, q, [this] {
	slotCommandFinished();
	});
	// connect( cmd, SIGNAL(canceled()), q, SLOT(slotCommandCanceled()) );
	connect(cmd, &Command::progress, q, &KeyListController::progress);
	}

	void KeyListController::Private::slotDoubleClicked(const QModelIndex &idx)
	{
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (!view \|\| !std::binary_search(views.cbegin(), views.cend(), view)) {
	return;
	}

	if (const auto const keyListModel = dynamic_cast<KeyListModelInterface >(view->model())) {
	DetailsCommand *const c = new DetailsCommand{keyListModel->key(idx)};
	c->setParentWidget(parentWidget ? parentWidget : view);
	c->start();
	}
	}

	void KeyListController::Private::slotActivated(const QModelIndex &idx)
	{
	Q_UNUSED(idx)
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (!view \|\| !std::binary_search(views.cbegin(), views.cend(), view)) {
	return;
	}
	}

	void KeyListController::Private::slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_)
	{
	Q_UNUSED(old)
	Q_UNUSED(new_)

	const QItemSelectionModel const sm = qobject_cast<QItemSelectionModel >(q->sender());
	if (!sm) {
	return;
	}
	q->enableDisableActions(sm);
	}

	void KeyListController::Private::slotContextMenu(const QPoint &p)
	{
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (view && std::binary_search(views.cbegin(), views.cend(), view)) {
	Q_EMIT q->contextMenuRequested(view, view->viewport()->mapToGlobal(p));
	} else {
	qCDebug(KLEOPATRA_LOG) << "sender is not a QAbstractItemView*!";
	}
	}

	void KeyListController::Private::slotCommandFinished()
	{
	Command const cmd = qobject_cast<Command >(q->sender());
	if (!cmd \|\| !std::binary_search(commands.cbegin(), commands.cend(), cmd)) {
	return;
	}
	qCDebug(KLEOPATRA_LOG) << (void *)cmd;
	if (commands.size() == 1) {
	Q_EMIT q->commandsExecuting(false);
	}
	}

	void KeyListController::enableDisableActions(const QItemSelectionModel *sm) const
	{
	const Command::Restrictions restrictionsMask = d->calculateRestrictionsMask(sm);
	for (const Private::action_item &ai : std::as_const(d->actions))
	if (ai.action) {
	ai.action->setEnabled(ai.restrictions == (ai.restrictions & restrictionsMask));
	}
	}

	static bool all_secret_are_not_owner_trust_ultimate(const std::vector<Key> &keys)
	{
	for (const Key &key : keys)
	if (key.hasSecret() && key.ownerTrust() == Key::Ultimate) {
	return false;
	}
	return true;
	}

	Command::Restrictions find_root_restrictions(const std::vector<Key> &keys)
	{
	bool trusted = false, untrusted = false;
	for (const Key &key : keys)
	if (key.isRoot())
	if (key.userID(0).validity() == UserID::Ultimate) {
	trusted = true;
	} else {
	untrusted = true;
	}
	else {
	return Command::NoRestriction;
	}
	if (trusted)
	if (untrusted) {
	return Command::NoRestriction;
	} else {
	return Command::MustBeTrustedRoot;
	}
	else if (untrusted) {
	return Command::MustBeUntrustedRoot;
	} else {
	return Command::NoRestriction;
	}
	}

	Command::Restrictions KeyListController::Private::calculateRestrictionsMask(const QItemSelectionModel *sm)
	{
	if (!sm) {
	return Command::NoRestriction;
	}

	const KeyListModelInterface const m = dynamic_cast<const KeyListModelInterface >(sm->model());
	if (!m) {
	return Command::NoRestriction;
	}

	const std::vector<Key> keys = m->keys(sm->selectedRows());
	if (keys.empty()) {
	return Command::NoRestriction;
	}

	Command::Restrictions result = Command::NeedSelection;

	if (keys.size() == 1) {
	result \|= Command::OnlyOneKey;
	}

	#if GPGME_VERSION_NUMBER >= 0x011102 // 1.17.2
	// we need to check the primary subkey because Key::hasSecret() is also true if just the secret key stub of an offline key is available
	const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) {
	return k.subkey(0).isSecret();
	};
	#else
	// older versions of GpgME did not always set the secret flag for card keys
	const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) {
	return k.subkey(0).isSecret() \|\| k.subkey(0).isCardKey();
	};
	#endif
	if (std::all_of(keys.cbegin(), keys.cend(), primaryKeyCanBeUsedForSecretKeyOperations)) {
	result \|= Command::NeedSecretKey;
	}

	if (std::all_of(std::begin(keys), std::end(keys), [](const auto &k) {
	return k.subkey(0).isSecret() && !k.subkey(0).isCardKey();
	})) {
	result \|= Command::NeedSecretKeyData;
	}

	if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) {
	return key.protocol() == OpenPGP;
	})) {
	result \|= Command::MustBeOpenPGP;
	} else if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) {
	return key.protocol() == CMS;
	})) {
	result \|= Command::MustBeCMS;
	}

	if (Kleo::all_of(keys, [](const auto &key) {
	return !key.isBad();
	})) {
	result \|= Command::MustBeValid;
	}

	if (all_secret_are_not_owner_trust_ultimate(keys)) {
	result \|= Command::MayOnlyBeSecretKeyIfOwnerTrustIsNotYetUltimate;
	}

	result \|= find_root_restrictions(keys);

	if (const ReaderStatus *rs = ReaderStatus::instance()) {
	if (!rs->firstCardWithNullPin().empty()) {
	result \|= Command::AnyCardHasNullPin;
	}
	if (rs->anyCardCanLearnKeys()) {
	result \|= Command::AnyCardCanLearnKeys;
	}
	}

	return result;
	}

	void KeyListController::Private::slotActionTriggered(QAction *sender)
	{
	const auto it = std::find_if(actions.cbegin(), actions.cend(), [sender](const action_item &item) {
	return item.action == sender;
	});
	if (it != actions.end())
	if (Command *const c = it->createCommand(this->currentView, q)) {
	if (parentWidget) {
	c->setParentWidget(parentWidget);
	}
	c->start();
	} else
	qCDebug(KLEOPATRA_LOG) << "createCommand() == NULL for action(?) \"" << qPrintable(sender->objectName()) << "\"";
	else {
	qCDebug(KLEOPATRA_LOG) << "I don't know anything about action(?) \"%s\"", qPrintable(sender->objectName());
	}
	}

	int KeyListController::Private::toolTipOptions() const
	{
	using namespace Kleo::Formatting;
	static const int validityFlags = Validity \| Issuer \| ExpiryDates \| CertificateUsage;
	static const int ownerFlags = Subject \| UserIDs \| OwnerTrust;
	static const int detailsFlags = StorageLocation \| CertificateType \| SerialNumber \| Fingerprint;

	const TooltipPreferences prefs;

	int flags = KeyID;
	flags \|= prefs.showValidity() ? validityFlags : 0;
	flags \|= prefs.showOwnerInformation() ? ownerFlags : 0;
	flags \|= prefs.showCertificateDetails() ? detailsFlags : 0;
	return flags;
	}

	void KeyListController::updateConfig()
	{
	const int opts = d->toolTipOptions();
	if (d->flatModel) {
	d->flatModel->setToolTipOptions(opts);
	}
	if (d->hierarchicalModel) {
	d->hierarchicalModel->setToolTipOptions(opts);
	}
	}

	#include "moc_keylistcontroller.cpp"
	diff --git a/src/view/pgpcardwidget.cpp b/src/view/pgpcardwidget.cpp
	index 8c2af9391..ad9f30641 100644
	--- a/src/view/pgpcardwidget.cpp
	+++ b/src/view/pgpcardwidget.cpp
	@@ -1,575 +1,553 @@
	/* view/pgpcardwiget.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH
	SPDX-FileCopyrightText: 2020, 2022 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "pgpcardwidget.h"

	#include "openpgpkeycardwidget.h"

	#include "kleopatra_debug.h"

	#include "commands/createcsrforcardkeycommand.h"
	#include "commands/createopenpgpkeyfromcardkeyscommand.h"
	#include "commands/openpgpgeneratecardkeycommand.h"

	#include "smartcard/algorithminfo.h"
	#include "smartcard/openpgpcard.h"
	#include "smartcard/readerstatus.h"
	#include "smartcard/utils.h"

	#include "dialogs/gencardkeydialog.h"

	#include <utils/qt-cxx20-compat.h>

	#include <Libkleo/Compliance>
	#include <Libkleo/GnuPG>

	#include <QFileDialog>
	#include <QFileInfo>
	#include <QGridLayout>
	#include <QHBoxLayout>
	#include <QInputDialog>
	#include <QLabel>
	#include <QProgressDialog>
	#include <QPushButton>
	#include <QScrollArea>
	#include <QThread>
	#include <QVBoxLayout>

	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KSeparator>

	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>

	#include <gpgme++/context.h>
	#include <gpgme++/data.h>

	#include <QGpgME/DataProvider>

	#include <gpgme++/gpggencardkeyinteractor.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::SmartCard;

	namespace
	{
	class GenKeyThread : public QThread
	{
	Q_OBJECT

	public:
	explicit GenKeyThread(const GenCardKeyDialog::KeyParams &params, const std::string &serial)
	: mSerial(serial)
	, mParams(params)
	{
	}

	GpgME::Error error()
	{
	return mErr;
	}

	std::string bkpFile()
	{
	return mBkpFile;
	}

	protected:
	void run() override
	{
	// the index of the curves in this list has to match the enum values
	// minus 1 of GpgGenCardKeyInteractor::Curve
	static const std::vector<std::string> curves = {
	"curve25519",
	-#if GPGMEPP_SUPPORTS_SET_CURVE
	"curve448",
	"nistp256",
	"nistp384",
	"nistp521",
	"brainpoolP256r1",
	"brainpoolP384r1",
	"brainpoolP512r1",
	"secp256k1", // keep it, even if we don't support it in Kleopatra
	-#endif
	};

	auto ei = std::make_unique<GpgME::GpgGenCardKeyInteractor>(mSerial);
	if (mParams.algorithm.starts_with("rsa")) {
	ei->setAlgo(GpgME::GpgGenCardKeyInteractor::RSA);
	ei->setKeySize(QByteArray::fromStdString(mParams.algorithm.substr(3)).toInt());
	} else {
	ei->setAlgo(GpgME::GpgGenCardKeyInteractor::ECC);
	const auto curveIt = std::find(curves.cbegin(), curves.cend(), mParams.algorithm);
	if (curveIt != curves.end()) {
	-#if GPGMEPP_SUPPORTS_SET_CURVE
	ei->setCurve(static_cast<GpgME::GpgGenCardKeyInteractor::Curve>(curveIt - curves.cbegin() + 1));
	-#endif
	} else {
	qCWarning(KLEOPATRA_LOG) << this << __func__ << "Invalid curve name:" << mParams.algorithm;
	mErr = GpgME::Error::fromCode(GPG_ERR_INV_VALUE);
	return;
	}
	}
	ei->setNameUtf8(mParams.name.toStdString());
	ei->setEmailUtf8(mParams.email.toStdString());
	ei->setDoBackup(mParams.backup);

	const auto ctx = std::shared_ptr<GpgME::Context>(GpgME::Context::createForProtocol(GpgME::OpenPGP));
	ctx->setFlag("extended-edit", "1"); // we want to be able to select all curves
	QGpgME::QByteArrayDataProvider dp;
	GpgME::Data data(&dp);

	mErr = ctx->cardEdit(GpgME::Key(), std::move(ei), data);
	mBkpFile = static_cast<GpgME::GpgGenCardKeyInteractor *>(ctx->lastCardEditInteractor())->backupFileName();
	}

	private:
	GpgME::Error mErr;
	std::string mSerial;
	GenCardKeyDialog::KeyParams mParams;

	std::string mBkpFile;
	};

	} // Namespace

	PGPCardWidget::PGPCardWidget(QWidget *parent)
	: QWidget(parent)
	, mSerialNumber(new QLabel(this))
	, mCardHolderLabel(new QLabel(this))
	, mVersionLabel(new QLabel(this))
	, mUrlLabel(new QLabel(this))
	, mCardIsEmpty(false)
	{
	// Set up the scroll area
	auto myLayout = new QVBoxLayout(this);
	myLayout->setContentsMargins(0, 0, 0, 0);

	auto area = new QScrollArea;
	area->setFrameShape(QFrame::NoFrame);
	area->setWidgetResizable(true);
	myLayout->addWidget(area);

	auto areaWidget = new QWidget;
	area->setWidget(areaWidget);

	auto areaVLay = new QVBoxLayout(areaWidget);

	auto cardInfoGrid = new QGridLayout;
	{
	int row = 0;

	// Version and Serialnumber
	cardInfoGrid->addWidget(mVersionLabel, row, 0, 1, 2);
	mVersionLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
	row++;

	cardInfoGrid->addWidget(new QLabel(i18n("Serial number:")), row, 0);
	cardInfoGrid->addWidget(mSerialNumber, row, 1);
	mSerialNumber->setTextInteractionFlags(Qt::TextBrowserInteraction);
	row++;

	// Cardholder Row
	cardInfoGrid->addWidget(new QLabel(i18nc("The owner of a smartcard. GnuPG refers to this as cardholder.", "Cardholder:")), row, 0);
	cardInfoGrid->addWidget(mCardHolderLabel, row, 1);
	mCardHolderLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
	{
	auto button = new QPushButton;
	button->setIcon(QIcon::fromTheme(QStringLiteral("cell_edit")));
	button->setAccessibleName(i18nc("@action:button", "Edit"));
	button->setToolTip(i18n("Change"));
	cardInfoGrid->addWidget(button, row, 2);
	connect(button, &QPushButton::clicked, this, &PGPCardWidget::changeNameRequested);
	}
	row++;

	// URL Row
	cardInfoGrid->addWidget(new QLabel(i18nc("The URL under which a public key that "
	"corresponds to a smartcard can be downloaded",
	"Pubkey URL:")),
	row,
	0);
	cardInfoGrid->addWidget(mUrlLabel, row, 1);
	mUrlLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
	{
	auto button = new QPushButton;
	button->setIcon(QIcon::fromTheme(QStringLiteral("cell_edit")));
	button->setAccessibleName(i18nc("@action:button", "Edit"));
	button->setToolTip(i18n("Change"));
	cardInfoGrid->addWidget(button, row, 2);
	connect(button, &QPushButton::clicked, this, &PGPCardWidget::changeUrlRequested);
	}

	cardInfoGrid->setColumnStretch(cardInfoGrid->columnCount(), 1);
	}
	areaVLay->addLayout(cardInfoGrid);

	areaVLay->addWidget(new KSeparator(Qt::Horizontal));

	// The keys
	areaVLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Keys:"))));

	mKeysWidget = new OpenPGPKeyCardWidget{this};
	areaVLay->addWidget(mKeysWidget);
	connect(mKeysWidget, &OpenPGPKeyCardWidget::createCSRRequested, this, &PGPCardWidget::createCSR);
	connect(mKeysWidget, &OpenPGPKeyCardWidget::generateKeyRequested, this, &PGPCardWidget::generateKey);

	areaVLay->addWidget(new KSeparator(Qt::Horizontal));

	areaVLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Actions:"))));

	auto actionLayout = new QHBoxLayout;

	{
	auto generateButton = new QPushButton(i18n("Generate New Keys"));
	generateButton->setToolTip(i18n("Create a new primary key and generate subkeys on the card."));
	actionLayout->addWidget(generateButton);
	connect(generateButton, &QPushButton::clicked, this, &PGPCardWidget::genkeyRequested);
	}
	{
	auto pinButton = new QPushButton(i18n("Change PIN"));
	pinButton->setToolTip(i18n("Change the PIN required for using the keys on the smartcard."));
	actionLayout->addWidget(pinButton);
	connect(pinButton, &QPushButton::clicked, this, [this]() {
	doChangePin(OpenPGPCard::pinKeyRef());
	});
	}
	{
	auto unblockButton = new QPushButton(i18n("Unblock Card"));
	unblockButton->setToolTip(i18n("Unblock the smartcard and set a new PIN."));
	actionLayout->addWidget(unblockButton);
	connect(unblockButton, &QPushButton::clicked, this, [this]() {
	doChangePin(OpenPGPCard::resetCodeKeyRef());
	});
	}
	{
	auto pukButton = new QPushButton(i18n("Change Admin PIN"));
	pukButton->setToolTip(i18n("Change the PIN required for administrative operations."));
	actionLayout->addWidget(pukButton);
	connect(pukButton, &QPushButton::clicked, this, [this]() {
	doChangePin(OpenPGPCard::adminPinKeyRef());
	});
	}
	{
	auto resetCodeButton = new QPushButton(i18n("Change Reset Code"));
	resetCodeButton->setToolTip(i18n("Change the PIN required to unblock the smartcard and set a new PIN."));
	actionLayout->addWidget(resetCodeButton);
	connect(resetCodeButton, &QPushButton::clicked, this, [this]() {
	doChangePin(OpenPGPCard::resetCodeKeyRef(), ChangePinCommand::ResetMode);
	});
	}

	if (CreateOpenPGPKeyFromCardKeysCommand::isSupported()) {
	mKeyForCardKeysButton = new QPushButton(this);
	mKeyForCardKeysButton->setText(i18n("Create OpenPGP Key"));
	mKeyForCardKeysButton->setToolTip(i18n("Create an OpenPGP key for the keys stored on the card."));
	actionLayout->addWidget(mKeyForCardKeysButton);
	connect(mKeyForCardKeysButton, &QPushButton::clicked, this, &PGPCardWidget::createKeyFromCardKeys);
	}

	actionLayout->addStretch(-1);
	areaVLay->addLayout(actionLayout);

	areaVLay->addStretch(1);
	}

	void PGPCardWidget::setCard(const OpenPGPCard *card)
	{
	const QString version = card->displayAppVersion();

	mIs21 = card->appVersion() >= 0x0201;
	const QString manufacturer = QString::fromStdString(card->manufacturer());
	const bool manufacturerIsUnknown = manufacturer.isEmpty() \|\| manufacturer == QLatin1String("unknown");
	mVersionLabel->setText(
	manufacturerIsUnknown
	? i18nc("Placeholder is a version number", "Unknown OpenPGP v%1 card", version)
	: i18nc("First placeholder is manufacturer, second placeholder is a version number", "%1 OpenPGP v%2 card", manufacturer, version));
	mSerialNumber->setText(card->displaySerialNumber());
	mRealSerial = card->serialNumber();

	const auto holder = card->cardHolder();
	const auto url = QString::fromStdString(card->pubkeyUrl());
	mCardHolderLabel->setText(holder.isEmpty() ? i18n("not set") : holder);
	mUrl = url;
	mUrlLabel->setText(url.isEmpty() ? i18n("not set") : QStringLiteral("<a href=\"%1\">%1</a>").arg(url.toHtmlEscaped()));
	mUrlLabel->setOpenExternalLinks(true);

	mKeysWidget->update(card);

	mCardIsEmpty = card->keyFingerprint(OpenPGPCard::pgpSigKeyRef()).empty() && card->keyFingerprint(OpenPGPCard::pgpEncKeyRef()).empty()
	&& card->keyFingerprint(OpenPGPCard::pgpAuthKeyRef()).empty();

	if (mKeyForCardKeysButton) {
	mKeyForCardKeysButton->setEnabled(card->hasSigningKey() //
	&& card->hasEncryptionKey() //
	&& DeVSCompliance::algorithmIsCompliant(card->keyInfo(card->signingKeyRef()).algorithm)
	&& DeVSCompliance::algorithmIsCompliant(card->keyInfo(card->encryptionKeyRef()).algorithm));
	}
	}

	void PGPCardWidget::doChangePin(const std::string &keyRef, ChangePinCommand::ChangePinMode mode)
	{
	auto cmd = new ChangePinCommand(mRealSerial, OpenPGPCard::AppName, this);
	this->setEnabled(false);
	connect(cmd, &ChangePinCommand::finished, this, [this]() {
	this->setEnabled(true);
	});
	cmd->setKeyRef(keyRef);
	cmd->setMode(mode);
	cmd->start();
	}

	void PGPCardWidget::doGenKey(GenCardKeyDialog *dlg)
	{
	const GpgME::Error err = ReaderStatus::switchCardAndApp(mRealSerial, OpenPGPCard::AppName);
	if (err) {
	return;
	}

	const auto params = dlg->getKeyParams();

	auto progress = new QProgressDialog(this, Qt::CustomizeWindowHint \| Qt::WindowTitleHint \| Qt::Dialog);
	progress->setAutoClose(true);
	progress->setMinimumDuration(0);
	progress->setMaximum(0);
	progress->setMinimum(0);
	progress->setModal(true);
	progress->setCancelButton(nullptr);
	progress->setWindowTitle(i18nc("@title:window", "Generating Keys"));
	progress->setLabel(new QLabel(i18n("This may take several minutes...")));
	auto workerThread = new GenKeyThread(params, mRealSerial);
	connect(workerThread, &QThread::finished, this, [this, workerThread, progress] {
	progress->accept();
	progress->deleteLater();
	genKeyDone(workerThread->error(), workerThread->bkpFile());
	delete workerThread;
	});
	workerThread->start();
	progress->exec();
	}

	void PGPCardWidget::genKeyDone(const GpgME::Error &err, const std::string &backup)
	{
	if (err) {
	KMessageBox::error(this, i18nc("@info", "Failed to generate new key: %1", Formatting::errorAsString(err)));
	return;
	}
	if (err.isCanceled()) {
	return;
	}
	if (!backup.empty()) {
	const auto bkpFile = QString::fromStdString(backup);
	QFileInfo fi(bkpFile);
	const auto target =
	QFileDialog::getSaveFileName(this, i18n("Save backup of encryption key"), fi.fileName(), QStringLiteral("%1 (*.gpg)").arg(i18n("Backup Key")));
	if (!target.isEmpty() && !QFile::copy(bkpFile, target)) {
	KMessageBox::error(this, i18nc("@info", "Failed to move backup. The backup key is still stored under: %1", bkpFile));
	} else if (!target.isEmpty()) {
	QFile::remove(bkpFile);
	}
	}

	KMessageBox::information(this, i18nc("@info", "Successfully generated a new key for this card."), i18nc("@title", "Success"));
	ReaderStatus::mutableInstance()->updateStatus();
	}

	void PGPCardWidget::genkeyRequested()
	{
	const auto pgpCard = ReaderStatus::instance()->getCard<OpenPGPCard>(mRealSerial);
	if (!pgpCard) {
	KMessageBox::error(this, i18n("Failed to find the OpenPGP card with the serial number: %1", QString::fromStdString(mRealSerial)));
	return;
	}

	if (!mCardIsEmpty) {
	auto ret = KMessageBox::warningContinueCancel(this,
	i18n("The existing keys on this card will be <b>deleted</b> "
	"and replaced by new keys.")
	+ QStringLiteral("<br/><br/>")
	+ i18n("It will no longer be possible to decrypt past communication "
	"encrypted for the existing key."),
	i18n("Secret Key Deletion"),
	KStandardGuiItem::guiItem(KStandardGuiItem::Delete),
	KStandardGuiItem::cancel(),
	QString(),
	KMessageBox::Notify \| KMessageBox::Dangerous);

	if (ret != KMessageBox::Continue) {
	return;
	}
	}

	auto dlg = new GenCardKeyDialog(GenCardKeyDialog::AllKeyAttributes, this);
	-#if GPGMEPP_SUPPORTS_SET_CURVE
	const auto allowedAlgos = getAllowedAlgorithms(pgpCard->supportedAlgorithms());
	if (allowedAlgos.empty()) {
	KMessageBox::error(this, i18nc("@info", "You cannot generate keys on this smart card because it doesn't support any of the compliant algorithms."));
	return;
	}
	dlg->setSupportedAlgorithms(allowedAlgos, getPreferredAlgorithm(allowedAlgos));
	-#else
	- std::vector<AlgorithmInfo> algos = {
	- {"rsa2048", i18nc("@info", "RSA 2048")},
	- {"rsa3072", i18nc("@info", "RSA 3072")},
	- };
	- // There is probably a better way to check for capabilities
	- if (mIs21) {
	- algos.push_back({"rsa4096", i18nc("@info", "RSA 4096")});
	- }
	- const auto supportedAlgos = pgpCard->supportedAlgorithms();
	- if (std::any_of(supportedAlgos.begin(), supportedAlgos.end(), [](const auto &algo) {
	- return algo.id == "curve25519";
	- })) {
	- algos.push_back({"curve25519", i18nc("@info", "ECC (Curve25519)")});
	- }
	- dlg->setSupportedAlgorithms(algos, "rsa2048");
	-#endif
	connect(dlg, &QDialog::accepted, this, [this, dlg]() {
	doGenKey(dlg);
	dlg->deleteLater();
	});
	dlg->setModal(true);
	dlg->show();
	}

	void PGPCardWidget::changeNameRequested()
	{
	QString text = mCardHolderLabel->text();
	while (true) {
	bool ok = false;
	text = QInputDialog::getText(this, i18n("Change cardholder"), i18n("New name:"), QLineEdit::Normal, text, &ok, Qt::WindowFlags(), Qt::ImhLatinOnly);
	if (!ok) {
	return;
	}
	// Some additional restrictions imposed by gnupg
	if (text.contains(QLatin1Char('<'))) {
	KMessageBox::error(this, i18nc("@info", "The \"<\" character may not be used."));
	continue;
	}
	if (text.contains(QLatin1String(" "))) {
	KMessageBox::error(this, i18nc("@info", "Double spaces are not allowed"));
	continue;
	}
	if (text.size() > 38) {
	KMessageBox::error(this, i18nc("@info", "The size of the name may not exceed 38 characters."));
	}
	break;
	}
	auto parts = text.split(QLatin1Char(' '));
	const auto lastName = parts.takeLast();
	const QString formatted = lastName + QStringLiteral("<<") + parts.join(QLatin1Char('<'));

	const auto pgpCard = ReaderStatus::instance()->getCard<OpenPGPCard>(mRealSerial);
	if (!pgpCard) {
	KMessageBox::error(this, i18n("Failed to find the OpenPGP card with the serial number: %1", QString::fromStdString(mRealSerial)));
	return;
	}

	const QByteArray command = QByteArrayLiteral("SCD SETATTR DISP-NAME ") + formatted.toUtf8();
	ReaderStatus::mutableInstance()->startSimpleTransaction(pgpCard, command, this, [this](const GpgME::Error &err) {
	changeNameResult(err);
	});
	}

	void PGPCardWidget::changeNameResult(const GpgME::Error &err)
	{
	if (err) {
	KMessageBox::error(this, i18nc("@info", "Name change failed: %1", Formatting::errorAsString(err)));
	return;
	}
	if (!err.isCanceled()) {
	KMessageBox::information(this, i18nc("@info", "Name successfully changed."), i18nc("@title", "Success"));
	ReaderStatus::mutableInstance()->updateStatus();
	}
	}

	void PGPCardWidget::changeUrlRequested()
	{
	QString text = mUrl;
	while (true) {
	bool ok = false;
	text = QInputDialog::getText(this,
	i18n("Change the URL where the pubkey can be found"),
	i18n("New pubkey URL:"),
	QLineEdit::Normal,
	text,
	&ok,
	Qt::WindowFlags(),
	Qt::ImhLatinOnly);
	if (!ok) {
	return;
	}
	// Some additional restrictions imposed by gnupg
	if (text.size() > 254) {
	KMessageBox::error(this, i18nc("@info", "The size of the URL may not exceed 254 characters."));
	}
	break;
	}

	const auto pgpCard = ReaderStatus::instance()->getCard<OpenPGPCard>(mRealSerial);
	if (!pgpCard) {
	KMessageBox::error(this, i18n("Failed to find the OpenPGP card with the serial number: %1", QString::fromStdString(mRealSerial)));
	return;
	}

	const QByteArray command = QByteArrayLiteral("SCD SETATTR PUBKEY-URL ") + text.toUtf8();
	ReaderStatus::mutableInstance()->startSimpleTransaction(pgpCard, command, this, [this](const GpgME::Error &err) {
	changeUrlResult(err);
	});
	}

	void PGPCardWidget::changeUrlResult(const GpgME::Error &err)
	{
	if (err) {
	KMessageBox::error(this, i18nc("@info", "URL change failed: %1", Formatting::errorAsString(err)));
	return;
	}
	if (!err.isCanceled()) {
	KMessageBox::information(this, i18nc("@info", "URL successfully changed."), i18nc("@title", "Success"));
	ReaderStatus::mutableInstance()->updateStatus();
	}
	}

	void PGPCardWidget::createKeyFromCardKeys()
	{
	auto cmd = new CreateOpenPGPKeyFromCardKeysCommand(mRealSerial, OpenPGPCard::AppName, this);
	this->setEnabled(false);
	connect(cmd, &CreateOpenPGPKeyFromCardKeysCommand::finished, this, [this]() {
	this->setEnabled(true);
	});
	cmd->start();
	}

	void PGPCardWidget::createCSR(const std::string &keyref)
	{
	auto cmd = new CreateCSRForCardKeyCommand(keyref, mRealSerial, OpenPGPCard::AppName, this);
	this->setEnabled(false);
	connect(cmd, &CreateCSRForCardKeyCommand::finished, this, [this]() {
	this->setEnabled(true);
	});
	cmd->start();
	}

	void PGPCardWidget::generateKey(const std::string &keyref)
	{
	auto cmd = new OpenPGPGenerateCardKeyCommand(keyref, mRealSerial, this);
	this->setEnabled(false);
	connect(cmd, &OpenPGPGenerateCardKeyCommand::finished, this, [this]() {
	this->setEnabled(true);
	});
	cmd->start();
	}

	#include "pgpcardwidget.moc"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Dec 4, 1:05 PM (1 d, 17 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 70/50/415fc51153fb0f70b2330cedee4d

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions