diff --git a/src/crypto/checksumsutils_p.h b/src/crypto/checksumsutils_p.h
index 1e89f84a5..d3eda1b2f 100644
--- a/src/crypto/checksumsutils_p.h
+++ b/src/crypto/checksumsutils_p.h
@@ -1,55 +1,55 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/checksumsutils_p.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "kleopatra_debug.h"
 
 #include <QRegularExpression>
 
 namespace Kleo
 {
 class ChecksumDefinition;
 }
 
 namespace ChecksumsUtils {
 #ifdef Q_OS_UNIX
 // Can we use QAbstractFileEngine::caseSensitive()?
 static const Qt::CaseSensitivity fs_cs = Qt::CaseSensitive;
 
 static const QRegularExpression::PatternOption s_regex_cs = QRegularExpression::NoPatternOption;
 #else
 static const Qt::CaseSensitivity fs_cs = Qt::CaseInsensitive;
 static const QRegularExpression::PatternOption s_regex_cs = QRegularExpression::CaseInsensitiveOption;
 #endif
 
 std::vector<QRegularExpression> get_patterns(const std::vector<std::shared_ptr<Kleo::ChecksumDefinition>> &checksumDefinitions);
 
-struct matches_any : std::unary_function<QString, bool> {
+struct matches_any {
     const std::vector<QRegularExpression> m_regexps;
     explicit matches_any(const std::vector<QRegularExpression> &regexps) : m_regexps(regexps) {}
     bool operator()(const QString &s) const
     {
         return std::any_of(m_regexps.cbegin(), m_regexps.cend(),
                            [&s](const QRegularExpression &rx) { return rx.match(s).hasMatch(); });
     }
 };
 
 struct File {
     QString name;
     QByteArray checksum;
     bool binary;
 };
 
 std::vector<File> parse_sum_file(const QString &fileName);
 
 std::shared_ptr<Kleo::ChecksumDefinition> filename2definition(const QString &fileName,
         const std::vector<std::shared_ptr<Kleo::ChecksumDefinition>> &checksumDefinitions);
 
 } // namespace ChecksumsUtils
diff --git a/src/crypto/createchecksumscontroller.cpp b/src/crypto/createchecksumscontroller.cpp
index 8568581dd..16e98ec3b 100644
--- a/src/crypto/createchecksumscontroller.cpp
+++ b/src/crypto/createchecksumscontroller.cpp
@@ -1,610 +1,610 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/createchecksumscontroller.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 "createchecksumscontroller.h"
 #include "checksumsutils_p.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/ChecksumDefinition>
 #include <Libkleo/Classify>
 
 #include <KLocalizedString>
 #include <QTemporaryFile>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QListWidget>
 #include <QVBoxLayout>
 
 #include <QPointer>
 #include <QFileInfo>
 #include <QThread>
 #include <QMutex>
 #include <QProgressDialog>
 #include <QDir>
 #include <QProcess>
 
 #include <gpg-error.h>
 
 #include <deque>
 #include <map>
 #include <limits>
 #include <functional>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 namespace
 {
 
 class ResultDialog : public QDialog
 {
     Q_OBJECT
 public:
     ResultDialog(const QStringList &created, const QStringList &errors, QWidget *parent = nullptr, Qt::WindowFlags f = {})
         : QDialog(parent, f),
           createdLB(created.empty()
                     ? i18nc("@info", "No checksum files have been created.")
                     : i18nc("@info", "These checksum files have been successfully created:"), this),
           createdLW(this),
           errorsLB(errors.empty()
                    ? i18nc("@info", "There were no errors.")
                    : i18nc("@info", "The following errors were encountered:"), this),
           errorsLW(this),
           buttonBox(QDialogButtonBox::Ok, Qt::Horizontal, this),
           vlay(this)
     {
         KDAB_SET_OBJECT_NAME(createdLB);
         KDAB_SET_OBJECT_NAME(createdLW);
         KDAB_SET_OBJECT_NAME(errorsLB);
         KDAB_SET_OBJECT_NAME(errorsLW);
         KDAB_SET_OBJECT_NAME(buttonBox);
         KDAB_SET_OBJECT_NAME(vlay);
 
         createdLW.addItems(created);
         QRect r;
         for (int i = 0; i < created.size(); ++i) {
             r = r.united(createdLW.visualRect(createdLW.model()->index(0, i)));
         }
         createdLW.setMinimumWidth(qMin(1024, r.width() + 4 * createdLW.frameWidth()));
 
         errorsLW.addItems(errors);
 
         vlay.addWidget(&createdLB);
         vlay.addWidget(&createdLW, 1);
         vlay.addWidget(&errorsLB);
         vlay.addWidget(&errorsLW, 1);
         vlay.addWidget(&buttonBox);
 
         if (created.empty()) {
             createdLW.hide();
         }
         if (errors.empty()) {
             errorsLW.hide();
         }
 
         connect(&buttonBox, &QDialogButtonBox::accepted, this, &ResultDialog::accept);
         connect(&buttonBox, &QDialogButtonBox::rejected, this, &ResultDialog::reject);
         readConfig();
     }
     ~ResultDialog() override
     {
         writeConfig();
     }
 
     void readConfig()
     {
         KConfigGroup dialog(KSharedConfig::openStateConfig(), "ResultDialog");
         const QSize size = dialog.readEntry("Size", QSize(600, 400));
         if (size.isValid()) {
             resize(size);
         }
     }
     void writeConfig()
     {
         KConfigGroup dialog(KSharedConfig::openStateConfig(), "ResultDialog");
         dialog.writeEntry("Size", size());
         dialog.sync();
     }
 
 private:
     QLabel createdLB;
     QListWidget createdLW;
     QLabel errorsLB;
     QListWidget errorsLW;
     QDialogButtonBox buttonBox;
     QVBoxLayout vlay;
 };
 
 }
 
 static QStringList fs_sort(QStringList l)
 {
     std::sort(l.begin(), l.end(), [](const QString &lhs, const QString &rhs) {
                                     return QString::compare(lhs, rhs, ChecksumsUtils::fs_cs) < 0;
                                   });
     return l;
 }
 
 static QStringList fs_intersect(QStringList l1, QStringList l2)
 {
     fs_sort(l1);
     fs_sort(l2);
     QStringList result;
     std::set_intersection(l1.begin(), l1.end(),
                           l2.begin(), l2.end(),
                           std::back_inserter(result),
                           [](const QString &lhs, const QString &rhs) {
                               return QString::compare(lhs, rhs, ChecksumsUtils::fs_cs) < 0;
                           });
     return result;
 }
 
 class CreateChecksumsController::Private : public QThread
 {
     Q_OBJECT
     friend class ::Kleo::Crypto::CreateChecksumsController;
     CreateChecksumsController *const q;
 public:
     explicit Private(CreateChecksumsController *qq);
     ~Private() override;
 
 Q_SIGNALS:
     void progress(int, int, const QString &);
 
 private:
     void slotOperationFinished()
     {
 #ifndef QT_NO_PROGRESSDIALOG
         if (progressDialog) {
             progressDialog->setValue(progressDialog->maximum());
             progressDialog->close();
         }
 #endif // QT_NO_PROGRESSDIALOG
         auto const dlg = new ResultDialog(created, errors);
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         q->bringToForeground(dlg);
         if (!errors.empty())
             q->setLastError(gpg_error(GPG_ERR_GENERAL),
                             errors.join(QLatin1Char('\n')));
         q->emitDoneOrError();
     }
     void slotProgress(int current, int total, const QString &what)
     {
         qCDebug(KLEOPATRA_LOG) << "progress: " << current << "/" << total << ": " << qPrintable(what);
 #ifndef QT_NO_PROGRESSDIALOG
         if (!progressDialog) {
             return;
         }
         progressDialog->setMaximum(total);
         progressDialog->setValue(current);
         progressDialog->setLabelText(what);
 #endif // QT_NO_PROGRESSDIALOG
     }
 
 private:
     void run() override;
 
 private:
 #ifndef QT_NO_PROGRESSDIALOG
     QPointer<QProgressDialog> progressDialog;
 #endif
     mutable QMutex mutex;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
     QStringList files;
     QStringList errors, created;
     bool allowAddition;
     volatile bool canceled;
 };
 
 CreateChecksumsController::Private::Private(CreateChecksumsController *qq)
     : q(qq),
 #ifndef QT_NO_PROGRESSDIALOG
       progressDialog(),
 #endif
       mutex(),
       checksumDefinitions(ChecksumDefinition::getChecksumDefinitions()),
       checksumDefinition(ChecksumDefinition::getDefaultChecksumDefinition(checksumDefinitions)),
       files(),
       errors(),
       created(),
       allowAddition(false),
       canceled(false)
 {
     connect(this, SIGNAL(progress(int,int,QString)),
             q, SLOT(slotProgress(int,int,QString)));
     connect(this, &Private::progress,
             q, &Controller::progress);
     connect(this, SIGNAL(finished()),
             q, SLOT(slotOperationFinished()));
 }
 
 CreateChecksumsController::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 CreateChecksumsController::CreateChecksumsController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 CreateChecksumsController::CreateChecksumsController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *p)
     : Controller(ctx, p), d(new Private(this))
 {
 
 }
 
 CreateChecksumsController::~CreateChecksumsController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void CreateChecksumsController::setFiles(const QStringList &files)
 {
     kleo_assert(!d->isRunning());
     kleo_assert(!files.empty());
     const std::vector<QRegularExpression> patterns = ChecksumsUtils::get_patterns(d->checksumDefinitions);
     if (!std::all_of(files.cbegin(), files.cend(), ChecksumsUtils::matches_any(patterns)) &&
             !std::none_of(files.cbegin(), files.cend(), ChecksumsUtils::matches_any(patterns))) {
         throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Create Checksums: input files must be either all checksum files or all files to be checksummed, not a mixture of both."));
     }
     const QMutexLocker locker(&d->mutex);
     d->files = files;
 }
 
 void CreateChecksumsController::setAllowAddition(bool allow)
 {
     kleo_assert(!d->isRunning());
     const QMutexLocker locker(&d->mutex);
     d->allowAddition = allow;
 }
 
 bool CreateChecksumsController::allowAddition() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->allowAddition;
 }
 
 void CreateChecksumsController::start()
 {
 
     {
         const QMutexLocker locker(&d->mutex);
 
 #ifndef QT_NO_PROGRESSDIALOG
         d->progressDialog = new QProgressDialog(i18n("Initializing..."), i18n("Cancel"), 0, 0);
         applyWindowID(d->progressDialog);
         d->progressDialog->setAttribute(Qt::WA_DeleteOnClose);
         d->progressDialog->setMinimumDuration(1000);
         d->progressDialog->setWindowTitle(i18nc("@title:window", "Create Checksum Progress"));
         connect(d->progressDialog.data(), &QProgressDialog::canceled, this, &CreateChecksumsController::cancel);
 #endif // QT_NO_PROGRESSDIALOG
 
         d->canceled = false;
         d->errors.clear();
         d->created.clear();
     }
 
     d->start();
 
 }
 
 void CreateChecksumsController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     const QMutexLocker locker(&d->mutex);
     d->canceled = true;
 }
 
 namespace
 {
 
 struct Dir {
     QDir dir;
     QString sumFile;
     QStringList inputFiles;
     quint64 totalSize;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
 };
 
 }
 
 static QStringList remove_checksum_files(QStringList l, const std::vector<QRegularExpression> &rxs)
 {
     QStringList::iterator end = l.end();
     for (const auto &rx : rxs) {
         end = std::remove_if(l.begin(), end,
                              [rx](const QString &str) {
                                 return rx.match(str).hasMatch();
                              });
     }
     l.erase(end, l.end());
     return l;
 }
 
 static quint64 aggregate_size(const QDir &dir, const QStringList &files)
 {
     quint64 n = 0;
     for (const QString &file : files) {
         n += QFileInfo(dir.absoluteFilePath(file)).size();
     }
     return n;
 }
 
 static std::vector<Dir> find_dirs_by_sum_files(const QStringList &files, bool allowAddition,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
 
     const std::vector<QRegularExpression> patterns = ChecksumsUtils::get_patterns(checksumDefinitions);
 
     std::vector<Dir> dirs;
     dirs.reserve(files.size());
 
     int i = 0;
 
     for (const QString &file : files) {
 
         const QFileInfo fi(file);
         const QDir dir = fi.dir();
         const QStringList entries = remove_checksum_files(dir.entryList(QDir::Files), patterns);
 
         QStringList inputFiles;
         if (allowAddition) {
             inputFiles = entries;
         } else {
             const std::vector<ChecksumsUtils::File> parsed = ChecksumsUtils::parse_sum_file(fi.absoluteFilePath());
             QStringList oldInputFiles;
             oldInputFiles.reserve(parsed.size());
             std::transform(parsed.cbegin(), parsed.cend(), std::back_inserter(oldInputFiles),
                            std::mem_fn(&ChecksumsUtils::File::name));
             inputFiles = fs_intersect(oldInputFiles, entries);
         }
 
         const Dir item = {
             dir,
             fi.fileName(),
             inputFiles,
             aggregate_size(dir, inputFiles),
             ChecksumsUtils::filename2definition(fi.fileName(), checksumDefinitions)
         };
 
         dirs.push_back(item);
 
         if (progress) {
             progress(++i);
         }
 
     }
     return dirs;
 }
 
 namespace
 {
-struct less_dir : std::binary_function<QDir, QDir, bool> {
+struct less_dir {
     bool operator()(const QDir &lhs, const QDir &rhs) const
     {
         return QString::compare(lhs.absolutePath(), rhs.absolutePath(), ChecksumsUtils::fs_cs) < 0;
     }
 };
 }
 
 static std::vector<Dir> find_dirs_by_input_files(const QStringList &files, const std::shared_ptr<ChecksumDefinition> &checksumDefinition, bool allowAddition,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     Q_UNUSED(allowAddition)
     if (!checksumDefinition) {
         return std::vector<Dir>();
     }
 
     const std::vector<QRegularExpression> patterns = ChecksumsUtils::get_patterns(checksumDefinitions);
 
     std::map<QDir, QStringList, less_dir> dirs2files;
 
     // Step 1: sort files by the dir they're contained in:
 
     std::deque<QString> inputs(files.begin(), files.end());
 
     int i = 0;
     while (!inputs.empty()) {
         const QString file = inputs.front();
         inputs.pop_front();
         const QFileInfo fi(file);
         if (fi.isDir()) {
             QDir dir(file);
             dirs2files[ dir ] = remove_checksum_files(dir.entryList(QDir::Files), patterns);
             const auto entryList = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
             std::transform(entryList.cbegin(), entryList.cend(),
                            std::inserter(inputs, inputs.begin()),
                            [&dir](const QString &entry) {
                                return dir.absoluteFilePath(entry);
                            });
         } else {
             dirs2files[fi.dir()].push_back(file);
         }
         if (progress) {
             progress(++i);
         }
     }
 
     // Step 2: convert into vector<Dir>:
 
     std::vector<Dir> dirs;
     dirs.reserve(dirs2files.size());
 
     for (auto it = dirs2files.begin(), end = dirs2files.end(); it != end; ++it) {
 
         const QStringList inputFiles = remove_checksum_files(it->second, patterns);
         if (inputFiles.empty()) {
             continue;
         }
 
         const Dir dir = {
             it->first,
             checksumDefinition->outputFileName(),
             inputFiles,
             aggregate_size(it->first, inputFiles),
             checksumDefinition
         };
         dirs.push_back(dir);
 
         if (progress) {
             progress(++i);
         }
 
     }
     return dirs;
 }
 
 static QString process(const Dir &dir, bool *fatal)
 {
     const QString absFilePath = dir.dir.absoluteFilePath(dir.sumFile);
     QTemporaryFile out;
     QProcess p;
     if (!out.open()) {
         return QStringLiteral("Failed to open Temporary file.");
     }
     p.setWorkingDirectory(dir.dir.absolutePath());
     p.setStandardOutputFile(out.fileName());
     const QString program = dir.checksumDefinition->createCommand();
     dir.checksumDefinition->startCreateCommand(&p, dir.inputFiles);
     p.waitForFinished();
     qCDebug(KLEOPATRA_LOG) << "[" << &p << "] Exit code " << p.exitCode();
 
     if (p.exitStatus() != QProcess::NormalExit || p.exitCode() != 0) {
         if (fatal && p.error() == QProcess::FailedToStart) {
             *fatal = true;
         }
         if (p.error() == QProcess::UnknownError)
             return i18n("Error while running %1: %2", program,
                         QString::fromLocal8Bit(p.readAllStandardError().trimmed().constData()));
         else {
             return i18n("Failed to execute %1: %2", program, p.errorString());
         }
     }
 
     QFileInfo fi(absFilePath);
     if (!(fi.exists() && !QFile::remove(absFilePath)) && QFile::copy(out.fileName(), absFilePath)) {
         return QString();
     }
 
     return xi18n("Failed to overwrite <filename>%1</filename>.", dir.sumFile);
 }
 
 namespace
 {
 static QDebug operator<<(QDebug s, const Dir &dir)
 {
     return s << "Dir(" << dir.dir << "->" << dir.sumFile << "<-(" << dir.totalSize << ')' << dir.inputFiles << ")\n";
 }
 }
 
 void CreateChecksumsController::Private::run()
 {
 
     QMutexLocker locker(&mutex);
 
     const QStringList files = this->files;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions = this->checksumDefinitions;
     const std::shared_ptr<ChecksumDefinition> checksumDefinition = this->checksumDefinition;
     const bool allowAddition = this->allowAddition;
 
     locker.unlock();
 
     QStringList errors;
     QStringList created;
 
     if (!checksumDefinition) {
         errors.push_back(i18n("No checksum programs defined."));
         locker.relock();
         this->errors = errors;
         return;
     } else {
         qCDebug(KLEOPATRA_LOG) << "using checksum-definition" << checksumDefinition->id();
     }
 
     //
     // Step 1: build a list of work to do (no progress):
     //
 
     const QString scanning = i18n("Scanning directories...");
     Q_EMIT progress(0, 0, scanning);
 
     const bool haveSumFiles = std::all_of(files.cbegin(), files.cend(), ChecksumsUtils::matches_any(ChecksumsUtils::get_patterns(checksumDefinitions)));
     const auto progressCb = [this, &scanning](int c) { Q_EMIT progress(c, 0, scanning); };
     const std::vector<Dir> dirs = haveSumFiles
                                   ? find_dirs_by_sum_files(files, allowAddition, progressCb, checksumDefinitions)
                                   : find_dirs_by_input_files(files, checksumDefinition, allowAddition, progressCb, checksumDefinitions);
 
     for (const Dir &dir : dirs) {
         qCDebug(KLEOPATRA_LOG) << dir;
     }
 
     if (!canceled) {
 
         Q_EMIT progress(0, 0, i18n("Calculating total size..."));
 
         const quint64 total = kdtools::accumulate_transform(dirs.cbegin(), dirs.cend(),
                                                             std::mem_fn(&Dir::totalSize),
                                                             Q_UINT64_C(0));
 
         if (!canceled) {
 
             //
             // Step 2: perform work (with progress reporting):
             //
 
             // re-scale 'total' to fit into ints (wish QProgressDialog would use quint64...)
             const quint64 factor = total / std::numeric_limits<int>::max() + 1;
 
             quint64 done = 0;
             for (const Dir &dir : dirs) {
                 Q_EMIT progress(done / factor, total / factor,
                                 i18n("Checksumming (%2) in %1", dir.checksumDefinition->label(), dir.dir.path()));
                 bool fatal = false;
                 const QString error = process(dir, &fatal);
                 if (!error.isEmpty()) {
                     errors.push_back(error);
                 } else {
                     created.push_back(dir.dir.absoluteFilePath(dir.sumFile));
                 }
                 done += dir.totalSize;
                 if (fatal || canceled) {
                     break;
                 }
             }
             Q_EMIT progress(done / factor, total / factor, i18n("Done."));
 
         }
     }
 
     locker.relock();
 
     this->errors = errors;
     this->created = created;
 
     // mutex unlocked by QMutexLocker
 
 }
 
 #include "moc_createchecksumscontroller.cpp"
 #include "createchecksumscontroller.moc"
diff --git a/src/crypto/decryptverifyfilescontroller.cpp b/src/crypto/decryptverifyfilescontroller.cpp
index dc5eb08a6..b8789c4cc 100644
--- a/src/crypto/decryptverifyfilescontroller.cpp
+++ b/src/crypto/decryptverifyfilescontroller.cpp
@@ -1,443 +1,443 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifyfilescontroller.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 "decryptverifyfilescontroller.h"
 
 #include <crypto/gui/decryptverifyoperationwidget.h>
 #include <crypto/gui/decryptverifyfileswizard.h>
 #include <crypto/decryptverifytask.h>
 #include <crypto/taskcollection.h>
 
 #include <Libkleo/GnuPG>
 #include <utils/path-helper.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/archivedefinition.h>
 
 #include <Libkleo/Classify>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QPointer>
 #include <QTimer>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class DecryptVerifyFilesController::Private
 {
     DecryptVerifyFilesController *const q;
 public:
 
     static std::shared_ptr<AbstractDecryptVerifyTask> taskFromOperationWidget(const DecryptVerifyOperationWidget *w, const QString &fileName, const QDir &outDir, const std::shared_ptr<OverwritePolicy> &overwritePolicy);
 
     explicit Private(DecryptVerifyFilesController *qq);
 
     void slotWizardOperationPrepared();
     void slotWizardCanceled();
     void schedule();
 
     void prepareWizardFromPassedFiles();
     std::vector<std::shared_ptr<Task> > buildTasks(const QStringList &, const std::shared_ptr<OverwritePolicy> &);
 
     void ensureWizardCreated();
     void ensureWizardVisible();
     void reportError(int err, const QString &details)
     {
         q->setLastError(err, details);
         q->emitDoneOrError();
     }
     void cancelAllTasks();
 
     QStringList m_passedFiles, m_filesAfterPreparation;
     QPointer<DecryptVerifyFilesWizard> m_wizard;
     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;
     DecryptVerifyOperation m_operation;
 };
 
 // static
 std::shared_ptr<AbstractDecryptVerifyTask> DecryptVerifyFilesController::Private::taskFromOperationWidget(const DecryptVerifyOperationWidget *w, const QString &fileName, const QDir &outDir, const std::shared_ptr<OverwritePolicy> &overwritePolicy)
 {
 
     kleo_assert(w);
 
     std::shared_ptr<AbstractDecryptVerifyTask> task;
 
     switch (w->mode()) {
     case DecryptVerifyOperationWidget::VerifyDetachedWithSignature: {
 
         std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
         t->setInput(Input::createFromFile(fileName));
         t->setSignedData(Input::createFromFile(w->signedDataFileName()));
         task = t;
 
         kleo_assert(fileName == w->inputFileName());
     }
     break;
     case DecryptVerifyOperationWidget::VerifyDetachedWithSignedData: {
         std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
         t->setInput(Input::createFromFile(w->inputFileName()));
         t->setSignedData(Input::createFromFile(fileName));
         task = t;
 
         kleo_assert(fileName == w->signedDataFileName());
     }
     break;
     case DecryptVerifyOperationWidget::DecryptVerifyOpaque: {
         const unsigned int classification = classify(fileName);
         qCDebug(KLEOPATRA_LOG) << "classified" << fileName << "as" << printableClassification(classification);
 
         const std::shared_ptr<ArchiveDefinition> ad = w->selectedArchiveDefinition();
 
         const Protocol proto =
             isOpenPGP(classification) ? OpenPGP :
             isCMS(classification)     ? CMS :
             ad /* _needs_ the info */   ? throw Exception(gpg_error(GPG_ERR_CONFLICT), i18n("Cannot determine whether input data is OpenPGP or CMS")) :
             /* else we don't care */      UnknownProtocol;
 
         const std::shared_ptr<Input> input = Input::createFromFile(fileName);
         const std::shared_ptr<Output> output =
             ad       ? ad->createOutputFromUnpackCommand(proto, fileName, outDir) :
             /*else*/   Output::createFromFile(outDir.absoluteFilePath(outputFileName(QFileInfo(fileName).fileName())), overwritePolicy);
 
         if (mayBeCipherText(classification)) {
             qCDebug(KLEOPATRA_LOG) << "creating a DecryptVerifyTask";
             std::shared_ptr<DecryptVerifyTask> t(new DecryptVerifyTask);
             t->setInput(input);
             t->setOutput(output);
             task = t;
         } else {
             qCDebug(KLEOPATRA_LOG) << "creating a VerifyOpaqueTask";
             std::shared_ptr<VerifyOpaqueTask> t(new VerifyOpaqueTask);
             t->setInput(input);
             t->setOutput(output);
             task = t;
         }
 
         kleo_assert(fileName == w->inputFileName());
     }
     break;
     }
 
     task->autodetectProtocolFromInput();
     return task;
 }
 
 DecryptVerifyFilesController::Private::Private(DecryptVerifyFilesController *qq) : q(qq), m_errorDetected(false), m_operation(DecryptVerify)
 {
     qRegisterMetaType<VerificationResult>();
 }
 
 void DecryptVerifyFilesController::Private::slotWizardOperationPrepared()
 {
     ensureWizardCreated();
     std::vector<std::shared_ptr<Task> > tasks = buildTasks(m_filesAfterPreparation, std::shared_ptr<OverwritePolicy>(new OverwritePolicy(m_wizard)));
     if (tasks.empty()) {
         reportError(makeGnuPGError(GPG_ERR_ASS_NO_INPUT), i18n("No usable inputs found"));
     }
     kleo_assert(m_runnableTasks.empty());
     m_runnableTasks.swap(tasks);
 
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     for (const auto &i: m_runnableTasks) {
         q->connectTask(i);
     }
     coll->setTasks(m_runnableTasks);
     m_wizard->setTaskCollection(coll);
 
     QTimer::singleShot(0, q, SLOT(schedule()));
 }
 
 void DecryptVerifyFilesController::Private::slotWizardCanceled()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void DecryptVerifyFilesController::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()));
 }
 
 void DecryptVerifyFilesController::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 auto &i: m_results) {
             Q_EMIT q->verificationResult(i->verificationResult());
         }
         q->emitDoneOrError();
     }
 }
 
 void DecryptVerifyFilesController::Private::ensureWizardCreated()
 {
     if (m_wizard) {
         return;
     }
 
     std::unique_ptr<DecryptVerifyFilesWizard> w(new DecryptVerifyFilesWizard);
     w->setWindowTitle(i18nc("@title:window", "Decrypt/Verify Files"));
     w->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(w.get(), SIGNAL(operationPrepared()), q, SLOT(slotWizardOperationPrepared()), Qt::QueuedConnection);
     connect(w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
     m_wizard = w.release();
 
 }
 
 namespace
 {
-struct FindExtension : std::unary_function<std::shared_ptr<ArchiveDefinition>, bool> {
+struct FindExtension {
     const QString ext;
     const Protocol proto;
     FindExtension(const QString &ext, Protocol proto) : ext(ext), proto(proto) {}
     bool operator()(const std::shared_ptr<ArchiveDefinition> &ad) const
     {
         qCDebug(KLEOPATRA_LOG) << "   considering" << (ad ? ad->label() : QStringLiteral("<null>")) << "for" << ext;
         bool result;
         if (proto == UnknownProtocol) {
             result = ad && (ad->extensions(OpenPGP).contains(ext, Qt::CaseInsensitive) || ad->extensions(CMS).contains(ext, Qt::CaseInsensitive));
         } else {
             result = ad && ad->extensions(proto).contains(ext, Qt::CaseInsensitive);
         }
         qCDebug(KLEOPATRA_LOG) << (result ? "   -> matches" : "   -> doesn't match");
         return result;
     }
 };
 }
 
 std::shared_ptr<ArchiveDefinition> DecryptVerifyFilesController::pick_archive_definition(GpgME::Protocol proto, const std::vector< std::shared_ptr<ArchiveDefinition> > &ads, const QString &filename)
 {
     const QFileInfo fi(outputFileName(filename));
     QString extension = fi.completeSuffix();
 
     if (extension == QLatin1String("out")) { // added by outputFileName() -> useless
         return std::shared_ptr<ArchiveDefinition>();
     }
 
     if (extension.endsWith(QLatin1String(".out"))) {     // added by outputFileName() -> remove
         extension.chop(4);
     }
 
     for (;;) {
         const auto it
             = std::find_if(ads.begin(), ads.end(), FindExtension(extension, proto));
         if (it != ads.end()) {
             return *it;
         }
         const int idx = extension.indexOf(QLatin1Char('.'));
         if (idx < 0) {
             return std::shared_ptr<ArchiveDefinition>();
         }
         extension = extension.mid(idx + 1);
     }
 }
 
 void DecryptVerifyFilesController::Private::prepareWizardFromPassedFiles()
 {
     ensureWizardCreated();
     const std::vector< std::shared_ptr<ArchiveDefinition> > archiveDefinitions = ArchiveDefinition::getArchiveDefinitions();
 
     unsigned int counter = 0;
     for (const auto &fname: std::as_const(m_passedFiles)) {
         kleo_assert(!fname.isEmpty());
 
         const unsigned int classification = classify(fname);
         const Protocol proto = findProtocol(classification);
 
         if (mayBeOpaqueSignature(classification) || mayBeCipherText(classification) || mayBeDetachedSignature(classification)) {
 
             DecryptVerifyOperationWidget *const op = m_wizard->operationWidget(counter++);
             kleo_assert(op != nullptr);
 
             op->setArchiveDefinitions(archiveDefinitions);
 
             const QString signedDataFileName = findSignedData(fname);
 
             // this breaks opaque signatures whose source files still
             // happen to exist in the same directory. Until we have
             // content-based classification, this is the most unlikely
             // case, so that's the case we break. ### FIXME remove when content-classify is done
             if (mayBeDetachedSignature(classification) && !signedDataFileName.isEmpty()) {
                 op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignature);
             }
             // ### end FIXME
             else if (mayBeOpaqueSignature(classification) || mayBeCipherText(classification)) {
                 op->setMode(DecryptVerifyOperationWidget::DecryptVerifyOpaque, q->pick_archive_definition(proto, archiveDefinitions, fname));
             } else {
                 op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignature);
             }
 
             op->setInputFileName(fname);
             op->setSignedDataFileName(signedDataFileName);
 
             m_filesAfterPreparation << fname;
 
         } else {
 
             // probably the signed data file was selected:
             const QStringList signatures = findSignatures(fname);
 
             if (signatures.empty()) {
                 // We are assuming this is a detached signature file, but
                 // there were no signature files for it. Let's guess it's encrypted after all.
                 // ### FIXME once we have a proper heuristic for this, this should move into
                 // classify() and/or classifyContent()
                 DecryptVerifyOperationWidget *const op = m_wizard->operationWidget(counter++);
                 kleo_assert(op != nullptr);
                 op->setArchiveDefinitions(archiveDefinitions);
                 op->setMode(DecryptVerifyOperationWidget::DecryptVerifyOpaque, q->pick_archive_definition(proto, archiveDefinitions, fname));
                 op->setInputFileName(fname);
                 m_filesAfterPreparation << fname;
             } else {
                 for (const auto &s: signatures) {
                     DecryptVerifyOperationWidget *op = m_wizard->operationWidget(counter++);
                     kleo_assert(op != nullptr);
 
                     op->setArchiveDefinitions(archiveDefinitions);
                     op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignedData);
                     op->setInputFileName(s);
                     op->setSignedDataFileName(fname);
 
                     m_filesAfterPreparation << fname;
                 }
 
             }
         }
     }
 
     m_wizard->setOutputDirectory(heuristicBaseDirectory(m_passedFiles));
     return;
 }
 
 std::vector< std::shared_ptr<Task> > DecryptVerifyFilesController::Private::buildTasks(const QStringList &fileNames, const std::shared_ptr<OverwritePolicy> &overwritePolicy)
 {
     const bool useOutDir = m_wizard->useOutputDirectory();
     const QFileInfo outDirInfo(m_wizard->outputDirectory());
 
     kleo_assert(!useOutDir || outDirInfo.isDir());
 
     const QDir outDir(outDirInfo.absoluteFilePath());
     kleo_assert(!useOutDir || outDir.exists());
 
     std::vector<std::shared_ptr<Task> > tasks;
     for (int i = 0, end  = fileNames.size(); i != end; ++i)
         try {
             const QDir fileDir = QFileInfo(fileNames[i]).absoluteDir();
             kleo_assert(fileDir.exists());
             tasks.push_back(taskFromOperationWidget(m_wizard->operationWidget(static_cast<unsigned int>(i)), fileNames[i], useOutDir ? outDir : fileDir, overwritePolicy));
         } catch (const GpgME::Exception &e) {
             tasks.push_back(Task::makeErrorTask(e.error().code(), QString::fromLocal8Bit(e.what()), fileNames[i]));
         }
 
     return tasks;
 }
 
 void DecryptVerifyFilesController::setFiles(const QStringList &files)
 {
     d->m_passedFiles = files;
 }
 
 void DecryptVerifyFilesController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(m_wizard);
 }
 
 DecryptVerifyFilesController::DecryptVerifyFilesController(QObject *parent) : Controller(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyFilesController::DecryptVerifyFilesController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *parent) : Controller(ctx, parent), d(new Private(this))
 {
 }
 
 DecryptVerifyFilesController::~DecryptVerifyFilesController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void DecryptVerifyFilesController::start()
 {
     d->prepareWizardFromPassedFiles();
     d->ensureWizardVisible();
 }
 
 void DecryptVerifyFilesController::setOperation(DecryptVerifyOperation op)
 {
     d->m_operation = op;
 }
 
 DecryptVerifyOperation DecryptVerifyFilesController::operation() const
 {
     return d->m_operation;
 }
 
 void DecryptVerifyFilesController::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 DecryptVerifyFilesController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     try {
         d->m_errorDetected = true;
         if (d->m_wizard) {
             d->m_wizard->close();
         }
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 #include "moc_decryptverifyfilescontroller.cpp"
diff --git a/src/crypto/verifychecksumscontroller.cpp b/src/crypto/verifychecksumscontroller.cpp
index 25f8edf3a..334495939 100644
--- a/src/crypto/verifychecksumscontroller.cpp
+++ b/src/crypto/verifychecksumscontroller.cpp
@@ -1,587 +1,586 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/verifychecksumscontroller.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 "verifychecksumscontroller.h"
 #include "checksumsutils_p.h"
 
 #ifndef QT_NO_DIRMODEL
 
 #include <crypto/gui/verifychecksumsdialog.h>
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/ChecksumDefinition>
 #include <Libkleo/Classify>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QFileInfo>
 #include <QThread>
 #include <QMutex>
 #include <QProgressDialog>
 #include <QDir>
 #include <QProcess>
 
 #include <gpg-error.h>
 
 #include <deque>
 #include <limits>
 #include <set>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 static const QLatin1String CHECKSUM_DEFINITION_ID_ENTRY("checksum-definition-id");
 
 #if 0
 static QStringList fs_sort(QStringList l)
 {
     int (*QString_compare)(const QString &, const QString &, Qt::CaseSensitivity) = &QString::compare;
     std::sort(l.begin(), l.end(),
               [](const QString &lhs, const QString &rhs) {
                 return QString::compare(lhs, rhs, ChecksumsUtils::fs_cs) < 0;
               });
     return l;
 }
 
 static QStringList fs_intersect(QStringList l1, QStringList l2)
 {
     int (*QString_compare)(const QString &, const QString &, Qt::CaseSensitivity) = &QString::compare;
     fs_sort(l1);
     fs_sort(l2);
     QStringList result;
     std::set_intersection(l1.begin(), l1.end(),
                           l2.begin(), l2.end(),
                           std::back_inserter(result),
                           [](const QString &lhs, const QString &rhs) {
                             return QString::compare(lhs, rhs, ChecksumsUtils::fs_cs) < 0;
                           });
     return result;
 }
 #endif
 
 namespace {
-struct matches_none_of : std::unary_function<QString, bool> {
+struct matches_none_of {
     const std::vector<QRegularExpression> m_regexps;
     explicit matches_none_of(const std::vector<QRegularExpression> &regexps) : m_regexps(regexps) {}
     bool operator()(const QString &s) const
     {
         return std::none_of(m_regexps.cbegin(), m_regexps.cend(),
                             [&s](const QRegularExpression &rx) { return rx.match(s).hasMatch(); });
     }
 };
 }
 
 class VerifyChecksumsController::Private : public QThread
 {
     Q_OBJECT
     friend class ::Kleo::Crypto::VerifyChecksumsController;
     VerifyChecksumsController *const q;
 public:
     explicit Private(VerifyChecksumsController *qq);
     ~Private() override;
 
 Q_SIGNALS:
     void baseDirectories(const QStringList &);
     void progress(int, int, const QString &);
     void status(const QString &file, Kleo::Crypto::Gui::VerifyChecksumsDialog::Status);
 
 private:
     void slotOperationFinished()
     {
         if (dialog) {
             dialog->setProgress(100, 100);
             dialog->setErrors(errors);
         }
 
         if (!errors.empty())
             q->setLastError(gpg_error(GPG_ERR_GENERAL),
                             errors.join(QLatin1Char('\n')));
         q->emitDoneOrError();
     }
 
 private:
     void run() override;
 
 private:
     QPointer<VerifyChecksumsDialog> dialog;
     mutable QMutex mutex;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions;
     QStringList files;
     QStringList errors;
     volatile bool canceled;
 };
 
 VerifyChecksumsController::Private::Private(VerifyChecksumsController *qq)
     : q(qq),
       dialog(),
       mutex(),
       checksumDefinitions(ChecksumDefinition::getChecksumDefinitions()),
       files(),
       errors(),
       canceled(false)
 {
     connect(this, &Private::progress,
             q, &Controller::progress);
     connect(this, SIGNAL(finished()),
             q, SLOT(slotOperationFinished()));
 }
 
 VerifyChecksumsController::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 VerifyChecksumsController::VerifyChecksumsController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 VerifyChecksumsController::VerifyChecksumsController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *p)
     : Controller(ctx, p), d(new Private(this))
 {
 
 }
 
 VerifyChecksumsController::~VerifyChecksumsController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void VerifyChecksumsController::setFiles(const QStringList &files)
 {
     kleo_assert(!d->isRunning());
     kleo_assert(!files.empty());
     const QMutexLocker locker(&d->mutex);
     d->files = files;
 }
 
 void VerifyChecksumsController::start()
 {
 
     {
         const QMutexLocker locker(&d->mutex);
 
         d->dialog = new VerifyChecksumsDialog;
         d->dialog->setAttribute(Qt::WA_DeleteOnClose);
         d->dialog->setWindowTitle(i18nc("@title:window", "Verify Checksum Results"));
 
         connect(d->dialog.data(), &VerifyChecksumsDialog::canceled,
                 this, &VerifyChecksumsController::cancel);
         connect(d.get(), &Private::baseDirectories,
                 d->dialog.data(), &VerifyChecksumsDialog::setBaseDirectories);
         connect(d.get(), &Private::progress,
                 d->dialog.data(), &VerifyChecksumsDialog::setProgress);
         connect(d.get(), &Private::status,
                 d->dialog.data(), &VerifyChecksumsDialog::setStatus);
 
         d->canceled = false;
         d->errors.clear();
     }
 
     d->start();
 
     d->dialog->show();
 
 }
 
 void VerifyChecksumsController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     const QMutexLocker locker(&d->mutex);
     d->canceled = true;
 }
 
 namespace
 {
 
 struct SumFile {
     QDir dir;
     QString sumFile;
     quint64 totalSize;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
 };
 
 }
 
 static QStringList filter_checksum_files(QStringList l, const std::vector<QRegularExpression> &rxs)
 {
     l.erase(std::remove_if(l.begin(), l.end(),
                            matches_none_of(rxs)),
             l.end());
     return l;
 }
 
 static quint64 aggregate_size(const QDir &dir, const QStringList &files)
 {
     quint64 n = 0;
     for (const QString &file : files) {
         n += QFileInfo(dir.absoluteFilePath(file)).size();
     }
     return n;
 }
 
 namespace
 {
-struct less_dir : std::binary_function<QDir, QDir, bool> {
+struct less_dir {
     bool operator()(const QDir &lhs, const QDir &rhs) const
     {
         return QString::compare(lhs.absolutePath(), rhs.absolutePath(), ChecksumsUtils::fs_cs) < 0;
     }
 };
-struct less_file : std::binary_function<QString, QString, bool> {
+struct less_file {
     bool operator()(const QString &lhs, const QString &rhs) const
     {
         return QString::compare(lhs, rhs, ChecksumsUtils::fs_cs) < 0;
     }
 };
-struct sumfile_contains_file : std::unary_function<QString, bool> {
+struct sumfile_contains_file {
     const QDir dir;
     const QString fileName;
     sumfile_contains_file(const QDir &dir_, const QString &fileName_)
         : dir(dir_), fileName(fileName_) {}
     bool operator()(const QString &sumFile) const
     {
         const std::vector<ChecksumsUtils::File> files = ChecksumsUtils::parse_sum_file(dir.absoluteFilePath(sumFile));
         qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:      found " << files.size()
                                << " files listed in " << qPrintable(dir.absoluteFilePath(sumFile));
         for (const ChecksumsUtils::File &file : files) {
             const bool isSameFileName = (QString::compare(file.name, fileName, ChecksumsUtils::fs_cs) == 0);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:        "
                                    << qPrintable(file.name) << " == "
                                    << qPrintable(fileName)  << " ? "
                                    << isSameFileName;
             if (isSameFileName) {
                 return true;
             }
         }
         return false;
     }
 };
-
 }
 
 // IF is_dir(file)
 //   add all sumfiles \in dir(file)
 //   inputs.prepend( all dirs \in dir(file) )
 // ELSE IF is_sum_file(file)
 //   add
 // ELSE IF \exists sumfile in dir(file) \where sumfile \contains file
 //   add sumfile
 // ELSE
 //   error: no checksum found for "file"
 
 static QStringList find_base_directories(const QStringList &files)
 {
 
     // Step 1: find base dirs:
 
     std::set<QDir, less_dir> dirs;
     for (const QString &file : files) {
         const QFileInfo fi(file);
         const QDir dir = fi.isDir() ? QDir(file) : fi.dir();
         dirs.insert(dir);
     }
 
     // Step 1a: collapse direct child directories
 
     bool changed;
     do {
         changed = false;
         auto it = dirs.begin();
         while (it != dirs.end()) {
             QDir dir = *it;
             if (dir.cdUp() && dirs.count(dir)) {
                 dirs.erase(it++);
                 changed = true;
             } else {
                 ++it;
             }
         }
     } while (changed);
 
     QStringList rv;
     rv.reserve(dirs.size());
     std::transform(dirs.cbegin(), dirs.cend(), std::back_inserter(rv), std::mem_fn(&QDir::absolutePath));
     return rv;
 }
 
 static std::vector<SumFile> find_sums_by_input_files(const QStringList &files, QStringList &errors,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     const std::vector<QRegularExpression> patterns = ChecksumsUtils::get_patterns(checksumDefinitions);
 
     const ChecksumsUtils::matches_any is_sum_file(patterns);
 
     std::map<QDir, std::set<QString, less_file>, less_dir> dirs2sums;
 
     // Step 1: find the sumfiles we need to check:
 
     std::deque<QString> inputs(files.begin(), files.end());
 
     int i = 0;
     while (!inputs.empty()) {
         const QString file = inputs.front();
         qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files: considering " << qPrintable(file);
         inputs.pop_front();
         const QFileInfo fi(file);
         const QString fileName = fi.fileName();
         if (fi.isDir()) {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's a directory";
             QDir dir(file);
             const QStringList sumfiles = filter_checksum_files(dir.entryList(QDir::Files), patterns);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << sumfiles.size()
                                    << " sum files: " << qPrintable(sumfiles.join(QLatin1String(", ")));
             dirs2sums[ dir ].insert(sumfiles.begin(), sumfiles.end());
             const QStringList dirs = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << dirs.size()
                                    << " subdirs, prepending";
             std::transform(dirs.cbegin(), dirs.cend(),
                            std::inserter(inputs, inputs.begin()),
                            [&dir](const QString &path) {
                                return dir.absoluteFilePath(path);
                            });
         } else if (is_sum_file(fileName)) {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's a sum file";
             dirs2sums[fi.dir()].insert(fileName);
         } else {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's something else; checking whether we'll find a sumfile for it...";
             const QDir dir = fi.dir();
             const QStringList sumfiles = filter_checksum_files(dir.entryList(QDir::Files), patterns);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << sumfiles.size()
                                    << " potential sumfiles: " << qPrintable(sumfiles.join(QLatin1String(", ")));
             const auto it = std::find_if(sumfiles.cbegin(), sumfiles.cend(),
                                          sumfile_contains_file(dir, fileName));
             if (it == sumfiles.end()) {
                 errors.push_back(i18n("Cannot find checksums file for file %1", file));
             } else {
                 dirs2sums[dir].insert(*it);
             }
         }
         if (progress) {
             progress(++i);
         }
     }
 
     // Step 2: convert into vector<SumFile>:
 
     std::vector<SumFile> sumfiles;
     sumfiles.reserve(dirs2sums.size());
 
     for (auto it = dirs2sums.begin(), end = dirs2sums.end(); it != end; ++it) {
 
         if (it->second.empty()) {
             continue;
         }
 
         const QDir &dir = it->first;
 
         for (const QString &sumFileName : std::as_const(it->second)) {
 
             const std::vector<ChecksumsUtils::File> summedfiles = ChecksumsUtils::parse_sum_file(dir.absoluteFilePath(sumFileName));
             QStringList files;
             files.reserve(summedfiles.size());
             std::transform(summedfiles.cbegin(), summedfiles.cend(),
                            std::back_inserter(files), std::mem_fn(&ChecksumsUtils::File::name));
             const SumFile sumFile = {
                 it->first,
                 sumFileName,
                 aggregate_size(it->first, files),
                 ChecksumsUtils::filename2definition(sumFileName, checksumDefinitions),
             };
             sumfiles.push_back(sumFile);
 
         }
 
         if (progress) {
             progress(++i);
         }
 
     }
     return sumfiles;
 }
 
 static QStringList c_lang_environment()
 {
     static const QRegularExpression re(QRegularExpression::anchoredPattern(u"LANG=.*"), ChecksumsUtils::s_regex_cs);
     QStringList env = QProcess::systemEnvironment();
     env.erase(std::remove_if(env.begin(), env.end(),
                              [](const QString &str) {
                                  return re.match(str).hasMatch();
                              }),
               env.end());
     env.push_back(QStringLiteral("LANG=C"));
     return env;
 }
 
 static const struct {
     const char *string;
     VerifyChecksumsDialog::Status status;
 } statusStrings[] = {
     { "OK",     VerifyChecksumsDialog::OK     },
     { "FAILED", VerifyChecksumsDialog::Failed },
 };
 static const size_t numStatusStrings = sizeof statusStrings / sizeof * statusStrings;
 
 static VerifyChecksumsDialog::Status string2status(const QByteArray &str)
 {
     for (unsigned int i = 0; i < numStatusStrings; ++i)
         if (str == statusStrings[i].string) {
             return statusStrings[i].status;
         }
     return VerifyChecksumsDialog::Unknown;
 }
 
 static QString process(const SumFile &sumFile, bool *fatal, const QStringList &env,
                        const std::function<void(const QString &, VerifyChecksumsDialog::Status)> &status)
 {
     QProcess p;
     p.setEnvironment(env);
     p.setWorkingDirectory(sumFile.dir.absolutePath());
     p.setReadChannel(QProcess::StandardOutput);
 
     const QString absFilePath = sumFile.dir.absoluteFilePath(sumFile.sumFile);
 
     const QString program = sumFile.checksumDefinition->verifyCommand();
     sumFile.checksumDefinition->startVerifyCommand(&p, QStringList(absFilePath));
 
     QByteArray remainder; // used for filenames with newlines in them
     while (p.state() != QProcess::NotRunning) {
         p.waitForReadyRead();
         while (p.canReadLine()) {
             const QByteArray line = p.readLine();
             const int colonIdx = line.lastIndexOf(':');
             if (colonIdx < 0) {
                 remainder += line; // no colon -> probably filename with a newline
                 continue;
             }
             const QString file = QFile::decodeName(remainder + line.left(colonIdx));
             remainder.clear();
             const VerifyChecksumsDialog::Status result = string2status(line.mid(colonIdx + 1).trimmed());
             status(sumFile.dir.absoluteFilePath(file), result);
         }
     }
     qCDebug(KLEOPATRA_LOG) << "[" << &p << "] Exit code " << p.exitCode();
 
     if (p.exitStatus() != QProcess::NormalExit || p.exitCode() != 0) {
         if (fatal && p.error() == QProcess::FailedToStart) {
             *fatal = true;
         }
         if (p.error() == QProcess::UnknownError)
             return i18n("Error while running %1: %2", program,
                         QString::fromLocal8Bit(p.readAllStandardError().trimmed().constData()));
         else {
             return i18n("Failed to execute %1: %2", program, p.errorString());
         }
     }
 
     return QString();
 }
 
 namespace
 {
 static QDebug operator<<(QDebug s, const SumFile &sum)
 {
     return s << "SumFile(" << sum.dir << "->" << sum.sumFile << "<-(" << sum.totalSize << ')' << ")\n";
 }
 }
 
 void VerifyChecksumsController::Private::run()
 {
 
     QMutexLocker locker(&mutex);
 
     const QStringList files = this->files;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions = this->checksumDefinitions;
 
     locker.unlock();
 
     QStringList errors;
 
     //
     // Step 0: find base directories:
     //
 
     Q_EMIT baseDirectories(find_base_directories(files));
 
     //
     // Step 1: build a list of work to do (no progress):
     //
 
     const QString scanning = i18n("Scanning directories...");
     Q_EMIT progress(0, 0, scanning);
 
     const auto progressCb = [this, scanning](int arg) { Q_EMIT progress(arg, 0, scanning); };
     const auto statusCb = [this](const QString &str, VerifyChecksumsDialog::Status st) { Q_EMIT status(str, st); };
 
     const std::vector<SumFile> sumfiles = find_sums_by_input_files(files, errors, progressCb, checksumDefinitions);
 
     for (const SumFile &sumfile : sumfiles) {
         qCDebug(KLEOPATRA_LOG) << sumfile;
     }
 
     if (!canceled) {
 
         Q_EMIT progress(0, 0, i18n("Calculating total size..."));
 
         const quint64 total
             = kdtools::accumulate_transform(sumfiles.cbegin(), sumfiles.cend(),
                                             std::mem_fn(&SumFile::totalSize), Q_UINT64_C(0));
 
         if (!canceled) {
 
             //
             // Step 2: perform work (with progress reporting):
             //
 
             const QStringList env = c_lang_environment();
 
             // re-scale 'total' to fit into ints (wish QProgressDialog would use quint64...)
             const quint64 factor = total / std::numeric_limits<int>::max() + 1;
 
             quint64 done = 0;
             for (const SumFile &sumFile : sumfiles) {
                 Q_EMIT progress(done / factor, total / factor,
                                 i18n("Verifying checksums (%2) in %1", sumFile.checksumDefinition->label(), sumFile.dir.path()));
                 bool fatal = false;
                 const QString error = process(sumFile, &fatal, env, statusCb);
                 if (!error.isEmpty()) {
                     errors.push_back(error);
                 }
                 done += sumFile.totalSize;
                 if (fatal || canceled) {
                     break;
                 }
             }
             Q_EMIT progress(done / factor, total / factor, i18n("Done."));
 
         }
     }
 
     locker.relock();
 
     this->errors = errors;
 
     // mutex unlocked by QMutexLocker
 
 }
 
 #include "moc_verifychecksumscontroller.cpp"
 #include "verifychecksumscontroller.moc"
 
 #endif // QT_NO_DIRMODEL
diff --git a/src/uiserver/decryptverifycommandfilesbase.cpp b/src/uiserver/decryptverifycommandfilesbase.cpp
index 88db10a6b..a9b89cf5e 100644
--- a/src/uiserver/decryptverifycommandfilesbase.cpp
+++ b/src/uiserver/decryptverifycommandfilesbase.cpp
@@ -1,193 +1,192 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/decryptverifycommandfilesbase.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "decryptverifycommandfilesbase.h"
 #include "fileoperationspreferences.h"
 
 #include <crypto/decryptverifytask.h>
 
 #include "crypto/decryptverifyfilescontroller.h"
 #include "crypto/autodecryptverifyfilescontroller.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Hex>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <KLocalizedString>
 
 #include <QFileInfo>
 
 #include <gpg-error.h>
 
 #include <memory>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Formatting;
 using namespace GpgME;
 
 class DecryptVerifyCommandFilesBase::Private : public QObject
 {
     Q_OBJECT
     friend class ::Kleo::DecryptVerifyCommandFilesBase;
     DecryptVerifyCommandFilesBase *const q;
 public:
     explicit Private(DecryptVerifyCommandFilesBase *qq)
         : QObject(),
           q(qq),
           controller()
     {
     }
 
     ~Private() override
     {
     }
 
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotProgress(const QString &what, int current, int total);
     void verificationResult(const GpgME::VerificationResult &);
     void slotDone()
     {
         q->done();
     }
     void slotError(int err, const QString &details)
     {
         q->done(err, details);
     }
 
 public:
 
 private:
     std::shared_ptr<DecryptVerifyFilesController> controller;
 };
 
 DecryptVerifyCommandFilesBase::DecryptVerifyCommandFilesBase()
     : AssuanCommandMixin<DecryptVerifyCommandFilesBase>(), d(new Private(this))
 {
 
 }
 
 DecryptVerifyCommandFilesBase::~DecryptVerifyCommandFilesBase() {}
 
 int DecryptVerifyCommandFilesBase::doStart()
 {
 
     d->checkForErrors();
 
     FileOperationsPreferences prefs;
     if (prefs.autoDecryptVerify()) {
         d->controller.reset(new AutoDecryptVerifyFilesController());
     } else {
         d->controller.reset(new DecryptVerifyFilesController(shared_from_this()));
     }
 
     d->controller->setOperation(operation());
     d->controller->setFiles(fileNames());
 
     QObject::connect(d->controller.get(), SIGNAL(done()),
                      d.get(), SLOT(slotDone()), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), SIGNAL(error(int,QString)),
                      d.get(), SLOT(slotError(int,QString)), Qt::QueuedConnection);
     QObject::connect(d->controller.get(), &DecryptVerifyFilesController::verificationResult,
                      d.get(), &Private::verificationResult, Qt::QueuedConnection);
 
     d->controller->start();
 
     return 0;
 }
 
 namespace
 {
 
-struct is_file : std::unary_function<QString, bool> {
+struct is_file {
     bool operator()(const QString &file) const
     {
         return QFileInfo(file).isFile();
     }
 };
-
 }
 
 void DecryptVerifyCommandFilesBase::Private::checkForErrors() const
 {
     if (!q->senders().empty())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use SENDER"));
 
     if (!q->recipients().empty())
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT),
                               i18n("Cannot use RECIPIENT"));
 
     const unsigned int numInputs = q->inputs().size();
     const unsigned int numMessages = q->messages().size();
     const unsigned int numOutputs  = q->outputs().size();
 
     if (numInputs) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("INPUT present"));
     }
     if (numMessages) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("MESSAGE present"));
     }
     if (numOutputs) {
         throw Kleo::Exception(q->makeError(GPG_ERR_CONFLICT), i18n("OUTPUT present"));
     }
     const QStringList fileNames = q->fileNames();
     if (fileNames.empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one FILE must be present"));
     if (!std::all_of(fileNames.cbegin(), fileNames.cend(), is_file()))
         throw Exception(makeError(GPG_ERR_INV_ARG),
                         i18n("DECRYPT/VERIFY_FILES cannot use directories as input"));
 
 }
 
 void DecryptVerifyCommandFilesBase::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 void DecryptVerifyCommandFilesBase::Private::slotProgress(const QString &what, int current, int total)
 {
     Q_UNUSED(what)
     Q_UNUSED(current)
     Q_UNUSED(total)
     // ### FIXME report progress, via sendStatus()
 }
 
 void DecryptVerifyCommandFilesBase::Private::verificationResult(const VerificationResult &vResult)
 {
     try {
         const std::vector<Signature> sigs = vResult.signatures();
         for (const Signature &sig : sigs) {
             const QString s = signatureToString(sig, sig.key(true, true));
             const char *color = summaryToString(sig.summary());
             q->sendStatusEncoded("SIGSTATUS",
                                  color + (' ' + hexencode(s.toUtf8().constData())));
         }
     } catch (...) {}
 }
 
 #include "decryptverifycommandfilesbase.moc"