diff --git a/src/kleopatraapplication.cpp b/src/kleopatraapplication.cpp
index 43c308601..9be10fe84 100644
--- a/src/kleopatraapplication.cpp
+++ b/src/kleopatraapplication.cpp
@@ -1,646 +1,646 @@
 /*
     kleopatraapplication.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 "kleopatraapplication.h"
 
 #include "mainwindow.h"
 #include "kleopatra_options.h"
 #include "systrayicon.h"
 #include <smartcard/readerstatus.h>
 #include <conf/configuredialog.h>
 
 #include <utils/gnupg-helper.h>
 #include <utils/kdpipeiodevice.h>
 #include <utils/log.h>
 
 #include <gpgme++/key.h>
 
 #include <Libkleo/FileSystemWatcher>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Classify>
 
 #ifdef HAVE_USABLE_ASSUAN
 # include <uiserver/uiserver.h>
 #endif
 
 #include "commands/signencryptfilescommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "commands/checksumcreatefilescommand.h"
 #include "commands/checksumverifyfilescommand.h"
 #include "commands/detailscommand.h"
 #include "commands/newcertificatecommand.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 #include <KMessageBox>
 #include <KWindowSystem>
 
 #include <QFile>
 #include <QDir>
 #include <QPointer>
 
 #include <memory>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 
 static void add_resources()
 {
     KIconLoader::global()->addAppDir(QStringLiteral("libkleopatra"));
     KIconLoader::global()->addAppDir(QStringLiteral("kwatchgnupg"));
 }
 
 static QList<QByteArray> default_logging_options()
 {
     QList<QByteArray> result;
     result.push_back("io");
     return result;
 }
 
 class KleopatraApplication::Private
 {
     friend class ::KleopatraApplication;
     KleopatraApplication *const q;
 public:
     explicit Private(KleopatraApplication *qq)
         : q(qq),
           ignoreNewInstance(true),
           firstNewInstance(true),
           sysTray(nullptr)
     {
     }
     ~Private() {
 #ifndef QT_NO_SYSTEMTRAYICON
         delete sysTray;
 #endif
     }
     void init()
     {
         KDAB_SET_OBJECT_NAME(readerStatus);
 #ifndef QT_NO_SYSTEMTRAYICON
         sysTray = new SysTrayIcon();
-        sysTray->setAnyCardHasNullPin(readerStatus.anyCardHasNullPin());
+        sysTray->setFirstCardWithNullPin(readerStatus.firstCardWithNullPin());
         sysTray->setAnyCardCanLearnKeys(readerStatus.anyCardCanLearnKeys());
 
-        connect(&readerStatus, &SmartCard::ReaderStatus::anyCardHasNullPinChanged,
-                sysTray, &SysTrayIcon::setAnyCardHasNullPin);
+        connect(&readerStatus, &SmartCard::ReaderStatus::firstCardWithNullPinChanged,
+                sysTray, &SysTrayIcon::setFirstCardWithNullPin);
         connect(&readerStatus, &SmartCard::ReaderStatus::anyCardCanLearnKeysChanged,
                 sysTray, &SysTrayIcon::setAnyCardCanLearnKeys);
 #endif
     }
 
 private:
     void connectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             connect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
     void disconnectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             disconnect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
 
 public:
     bool ignoreNewInstance;
     bool firstNewInstance;
     QPointer<ConfigureDialog> configureDialog;
     QPointer<MainWindow> mainWindow;
     SmartCard::ReaderStatus readerStatus;
 #ifndef QT_NO_SYSTEMTRAYICON
     SysTrayIcon *sysTray;
 #endif
     std::shared_ptr<KeyCache> keyCache;
     std::shared_ptr<Log> log;
     std::shared_ptr<FileSystemWatcher> watcher;
 
 public:
     void setupKeyCache()
     {
         keyCache = KeyCache::mutableInstance();
         watcher.reset(new FileSystemWatcher);
 
         watcher->whitelistFiles(gnupgFileWhitelist());
         watcher->addPath(gnupgHomeDirectory());
         watcher->setDelay(1000);
         keyCache->addFileSystemWatcher(watcher);
     }
 
     void setupLogging()
     {
         log = Log::mutableInstance();
 
         const QByteArray envOptions = qgetenv("KLEOPATRA_LOGOPTIONS");
         const bool logAll = envOptions.trimmed() == "all";
         const QList<QByteArray> options = envOptions.isEmpty() ? default_logging_options() : envOptions.split(',');
 
         const QByteArray dirNative = qgetenv("KLEOPATRA_LOGDIR");
         if (dirNative.isEmpty()) {
             return;
         }
         const QString dir = QFile::decodeName(dirNative);
         const QString logFileName = QDir(dir).absoluteFilePath(QStringLiteral("kleopatra.log.%1").arg(QCoreApplication::applicationPid()));
         std::unique_ptr<QFile> logFile(new QFile(logFileName));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Append)) {
             qCDebug(KLEOPATRA_LOG) << "Could not open file for logging: " << logFileName << "\nLogging disabled";
             return;
         }
 
         log->setOutputDirectory(dir);
         if (logAll || options.contains("io")) {
             log->setIOLoggingEnabled(true);
         }
         qInstallMessageHandler(Log::messageHandler);
 
 #ifdef HAVE_USABLE_ASSUAN
         if (logAll || options.contains("pipeio")) {
             KDPipeIODevice::setDebugLevel(KDPipeIODevice::Debug);
         }
         UiServer::setLogStream(log->logFile());
 #endif
 
     }
 };
 
 KleopatraApplication::KleopatraApplication(int &argc, char *argv[])
     : QApplication(argc, argv), d(new Private(this))
 {
 }
 
 void KleopatraApplication::init()
 {
     d->init();
     add_resources();
     d->setupKeyCache();
     d->setupLogging();
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->show();
 #endif
     setQuitOnLastWindowClosed(false);
     KWindowSystem::allowExternalProcessWindowActivation();
 }
 
 KleopatraApplication::~KleopatraApplication()
 {
     // main window doesn't receive "close" signal and cannot
     // save settings before app exit
     delete d->mainWindow;
 
     // work around kdelibs bug https://bugs.kde.org/show_bug.cgi?id=162514
     KSharedConfig::openConfig()->sync();
 }
 
 namespace
 {
 typedef void (KleopatraApplication::*Func)(const QStringList &, GpgME::Protocol);
 }
 
 void KleopatraApplication::slotActivateRequested(const QStringList &arguments,
         const QString &workingDirectory)
 {
     QCommandLineParser parser;
 
     kleopatra_options(&parser);
     QString err;
     if (!arguments.isEmpty() && !parser.parse(arguments)) {
         err = parser.errorText();
     } else if (arguments.isEmpty()) {
         // KDBusServices omits the application name if no other
         // arguments are provided. In that case the parser prints
         // a warning.
         parser.parse(QStringList() << QCoreApplication::applicationFilePath());
     }
 
     if (err.isEmpty()) {
         err = newInstance(parser, workingDirectory);
     }
 
     if (!err.isEmpty()) {
         KMessageBox::sorry(nullptr, err.toHtmlEscaped(), i18n("Failed to execute command"));
         Q_EMIT setExitValue(1);
         return;
     }
     Q_EMIT setExitValue(0);
 }
 
 QString KleopatraApplication::newInstance(const QCommandLineParser &parser,
         const QString &workingDirectory)
 {
     if (d->ignoreNewInstance) {
         qCDebug(KLEOPATRA_LOG) << "New instance ignored because of ignoreNewInstance";
         return QString();
     }
 
     QStringList files;
     const QDir cwd = QDir(workingDirectory);
     bool queryMode = parser.isSet(QStringLiteral("query")) || parser.isSet(QStringLiteral("search"));
 
     // Query and Search treat positional arguments differently, see below.
     if (!queryMode) {
         Q_FOREACH (const QString &file, parser.positionalArguments()) {
             // We do not check that file exists here. Better handle
             // these errors in the UI.
             if (QFileInfo(file).isAbsolute()) {
                 files << file;
             } else {
                 files << cwd.absoluteFilePath(file);
             }
         }
     }
 
     GpgME::Protocol protocol = GpgME::UnknownProtocol;
 
     if (parser.isSet(QStringLiteral("openpgp"))) {
         qCDebug(KLEOPATRA_LOG) << "found OpenPGP";
         protocol = GpgME::OpenPGP;
     }
 
     if (parser.isSet(QStringLiteral("cms"))) {
         qCDebug(KLEOPATRA_LOG) << "found CMS";
         if (protocol == GpgME::OpenPGP) {
             return i18n("Ambiguous protocol: --openpgp and --cms");
         }
         protocol = GpgME::CMS;
     }
 
     // Check for Parent Window id
     WId parentId = 0;
     if (parser.isSet(QStringLiteral("parent-windowid"))) {
 #ifdef Q_OS_WIN
         // WId is not a portable type as it is a pointer type on Windows.
         // casting it from an integer is ok though as the values are guaranteed to
         // be compatible in the documentation.
         parentId = reinterpret_cast<WId>(parser.value(QStringLiteral("parent-windowid")).toUInt());
 #else
         parentId = parser.value(QStringLiteral("parent-windowid")).toUInt();
 #endif
     }
 
     // Handle openpgp4fpr URI scheme
     QString needle;
     if (queryMode) {
         needle = parser.positionalArguments().join(QLatin1Char(' '));
     }
     if (needle.startsWith(QLatin1String("openpgp4fpr:"))) {
         needle.remove(0, 12);
     }
 
     // Check for --search command.
     if (parser.isSet(QStringLiteral("search"))) {
         // This is an extra command instead of a combination with the
         // similar query to avoid changing the older query commands behavior
         // and query's "show details if a certificate exist or search on a
         // keyserver" logic is hard to explain and use consistently.
         if (needle.isEmpty()) {
             return i18n("No search string specified for --search");
         }
         LookupCertificatesCommand *const cmd = new LookupCertificatesCommand(needle, nullptr);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --query command
     if (parser.isSet(QStringLiteral("query"))) {
         if (needle.isEmpty()) {
             return i18n("No fingerprint argument specified for --query");
         }
         auto cmd = Command::commandForQuery(needle);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --gen-key command
     if (parser.isSet(QStringLiteral("gen-key"))) {
         auto cmd = new NewCertificateCommand(nullptr);
         cmd->setParentWId(parentId);
         cmd->setProtocol(protocol);
         cmd->start();
         return QString();
     }
 
     // Check for --config command
     if (parser.isSet(QStringLiteral("config"))) {
         openConfigDialogWithForeignParent(parentId);
         return QString();
     }
 
     static const QMap<QString, Func> funcMap {
         { QStringLiteral("import-certificate"), &KleopatraApplication::importCertificatesFromFile },
         { QStringLiteral("encrypt"), &KleopatraApplication::encryptFiles },
         { QStringLiteral("sign"), &KleopatraApplication::signFiles },
         { QStringLiteral("encrypt-sign"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("sign-encrypt"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("decrypt"), &KleopatraApplication::decryptFiles },
         { QStringLiteral("verify"), &KleopatraApplication::verifyFiles },
         { QStringLiteral("decrypt-verify"), &KleopatraApplication::decryptVerifyFiles },
         { QStringLiteral("checksum"), &KleopatraApplication::checksumFiles },
     };
 
     QString found;
     Q_FOREACH (const QString &opt, funcMap.keys()) {
         if (parser.isSet(opt) && found.isEmpty()) {
             found = opt;
         } else if (parser.isSet(opt)) {
             return i18n("Ambiguous commands \"%1\" and \"%2\"", found, opt);
         }
     }
 
     QStringList errors;
     if (!found.isEmpty()) {
         if (files.empty()) {
             return i18n("No files specified for \"%1\" command", found);
         }
         qCDebug(KLEOPATRA_LOG) << "found" << found;
         (this->*funcMap.value(found))(files, protocol);
     } else {
         if (files.empty()) {
             if (!(d->firstNewInstance && isSessionRestored())) {
                 qCDebug(KLEOPATRA_LOG) << "openOrRaiseMainWindow";
                 openOrRaiseMainWindow();
             }
         } else {
             Q_FOREACH (const QString& fileName, files) {
                 QFileInfo fi(fileName);
                 if (!fi.isReadable()) {
                     errors << i18n("Cannot read \"%1\"", fileName);
                 }
             }
             Q_FOREACH (Command *cmd, Command::commandsForFiles(files)) {
                 if (parentId) {
                     cmd->setParentWId(parentId);
                 } else {
                     MainWindow *mw = mainWindow();
                     if (!mw) {
                         mw = new MainWindow;
                         mw->setAttribute(Qt::WA_DeleteOnClose);
                         setMainWindow(mw);
                         d->connectConfigureDialog();
                     }
                     cmd->setParentWidget(mw);
                 }
                 cmd->start();
             }
         }
     }
     d->firstNewInstance = false;
 
 #ifdef Q_OS_WIN
     // On Windows we might be started from the
     // explorer in any working directory. E.g.
     // a double click on a file. To avoid preventing
     // the folder from deletion we set the
     // working directory to the users homedir.
     QDir::setCurrent(QDir::homePath());
 #endif
 
     return errors.join(QLatin1Char('\n'));
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 const SysTrayIcon *KleopatraApplication::sysTrayIcon() const
 {
     return d->sysTray;
 }
 
 SysTrayIcon *KleopatraApplication::sysTrayIcon()
 {
     return d->sysTray;
 }
 #endif
 
 const MainWindow *KleopatraApplication::mainWindow() const
 {
     return d->mainWindow;
 }
 
 MainWindow *KleopatraApplication::mainWindow()
 {
     return d->mainWindow;
 }
 
 void KleopatraApplication::setMainWindow(MainWindow *mainWindow)
 {
     if (mainWindow == d->mainWindow) {
         return;
     }
 
     d->disconnectConfigureDialog();
 
     d->mainWindow = mainWindow;
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->setMainWindow(mainWindow);
 #endif
 
     d->connectConfigureDialog();
 }
 
 static void open_or_raise(QWidget *w)
 {
     if (w->isMinimized()) {
         KWindowSystem::unminimizeWindow(w->winId());
         w->raise();
     } else if (w->isVisible()) {
         w->raise();
     } else {
         w->show();
     }
 }
 
 void KleopatraApplication::toggleMainWindowVisibility()
 {
     if (mainWindow()) {
         mainWindow()->setVisible(!mainWindow()->isVisible());
     } else {
         openOrRaiseMainWindow();
     }
 }
 
 void KleopatraApplication::restoreMainWindow()
 {
     qCDebug(KLEOPATRA_LOG) << "restoring main window";
 
     // Sanity checks
     if (!isSessionRestored()) {
         qCDebug(KLEOPATRA_LOG) << "Not in session restore";
         return;
     }
 
     if (mainWindow()) {
         qCDebug(KLEOPATRA_LOG) << "Already have main window";
         return;
     }
 
     MainWindow *mw = new MainWindow;
     if (KMainWindow::canBeRestored(1)) {
         // restore to hidden state, Mainwindow::readProperties() will
         // restore saved visibility.
         mw->restore(1, false);
     }
 
     mw->setAttribute(Qt::WA_DeleteOnClose);
     setMainWindow(mw);
     d->connectConfigureDialog();
 
 }
 
 void KleopatraApplication::openOrRaiseMainWindow()
 {
     MainWindow *mw = mainWindow();
     if (!mw) {
         mw = new MainWindow;
         mw->setAttribute(Qt::WA_DeleteOnClose);
         setMainWindow(mw);
         d->connectConfigureDialog();
     }
     open_or_raise(mw);
     UpdateNotification::checkUpdate(mw);
 }
 
 void KleopatraApplication::openConfigDialogWithForeignParent(WId parentWId)
 {
     if (!d->configureDialog) {
         d->configureDialog = new ConfigureDialog;
         d->configureDialog->setAttribute(Qt::WA_DeleteOnClose);
         d->connectConfigureDialog();
     }
 
     // This is similar to what the commands do.
     if (parentWId) {
         if (QWidget *pw = QWidget::find(parentWId)) {
             d->configureDialog->setParent(pw, d->configureDialog->windowFlags());
         } else {
             d->configureDialog->setAttribute(Qt::WA_NativeWindow, true);
             KWindowSystem::setMainWindow(d->configureDialog->windowHandle(), parentWId);
         }
     }
 
     open_or_raise(d->configureDialog);
 
     // If we have a parent we want to raise over it.
     if (parentWId) {
         d->configureDialog->raise();
     }
 }
 
 void KleopatraApplication::openOrRaiseConfigDialog()
 {
     openConfigDialogWithForeignParent(0);
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 void KleopatraApplication::startMonitoringSmartCard()
 {
     d->readerStatus.startMonitoring();
 }
 #endif // QT_NO_SYSTEMTRAYICON
 
 void KleopatraApplication::importCertificatesFromFile(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     openOrRaiseMainWindow();
     if (!files.empty()) {
         mainWindow()->importCertificatesFromFile(files);
     }
 }
 
 void KleopatraApplication::encryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setEncryptionPolicy(Force);
     cmd->setSigningPolicy(Allow);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setSigningPolicy(Force);
     cmd->setEncryptionPolicy(Deny);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signEncryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::decryptFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Decrypt);
     cmd->start();
 }
 
 void KleopatraApplication::verifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Verify);
     cmd->start();
 }
 
 void KleopatraApplication::decryptVerifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->start();
 }
 
 void KleopatraApplication::checksumFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     QStringList verifyFiles, createFiles;
 
     for (const QString &file : files) {
         if (isChecksumFile(file)) {
             verifyFiles << file;
         } else {
             createFiles << file;
         }
     }
 
     if (!verifyFiles.isEmpty()) {
         auto *const cmd = new ChecksumVerifyFilesCommand(verifyFiles, nullptr);
         cmd->start();
     }
     if (!createFiles.isEmpty()) {
         auto *const cmd = new ChecksumCreateFilesCommand(createFiles, nullptr);
         cmd->start();
     }
 }
 
 void KleopatraApplication::setIgnoreNewInstance(bool ignore)
 {
     d->ignoreNewInstance = ignore;
 }
 
 bool KleopatraApplication::ignoreNewInstance() const
 {
     return d->ignoreNewInstance;
 }
diff --git a/src/smartcard/readerstatus.cpp b/src/smartcard/readerstatus.cpp
index f33f05e5a..8ccf6f3d7 100644
--- a/src/smartcard/readerstatus.cpp
+++ b/src/smartcard/readerstatus.cpp
@@ -1,845 +1,848 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     smartcard/readerstatus.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2020 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 "readerstatus.h"
 
 #include "keypairinfo.h"
 
 #include <utils/gnupg-helper.h>
 
 #include <Libkleo/FileSystemWatcher>
 #include <Libkleo/Stl_Util>
 
 #include <gpgme++/context.h>
 #include <gpgme++/defaultassuantransaction.h>
 #include <gpgme++/key.h>
 
 #include <gpg-error.h>
 
 #include "kleopatra_debug.h"
 #include "openpgpcard.h"
 #include "netkeycard.h"
 #include "pivcard.h"
 
 #include <QStringList>
 #include <QFileInfo>
 #include <QMutex>
 #include <QWaitCondition>
 #include <QThread>
 #include <QPointer>
 
 #include <memory>
 #include <vector>
 #include <set>
 #include <list>
 #include <algorithm>
 #include <iterator>
 #include <utility>
 #include <cstdlib>
 
 #include "utils/kdtoolsglobal.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 
 static ReaderStatus *self = nullptr;
 
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 static const char *flags[] = {
     "NOCARD",
     "PRESENT",
     "ACTIVE",
     "USABLE",
 };
 static_assert(sizeof flags / sizeof * flags == Card::_NumScdStates, "");
 
 static const char *prettyFlags[] = {
     "NoCard",
     "CardPresent",
     "CardActive",
     "CardUsable",
     "CardError",
 };
 static_assert(sizeof prettyFlags / sizeof * prettyFlags == Card::NumStates, "");
 
 #if 0
 We need this once we have support for multiple readers in scdaemons
 interface.
 static unsigned int parseFileName(const QString &fileName, bool *ok)
 {
     QRegExp rx(QLatin1String("reader_(\\d+)\\.status"));
     if (ok) {
         *ok = false;
     }
     if (rx.exactMatch(QFileInfo(fileName).fileName())) {
         return rx.cap(1).toUInt(ok, 10);
     }
     return 0;
 }
 #endif
 
 Q_DECLARE_METATYPE(GpgME::Error)
 
 namespace
 {
 static QDebug operator<<(QDebug s, const std::vector< std::pair<std::string, std::string> > &v)
 {
     typedef std::pair<std::string, std::string> pair;
     s << '(';
     for (const pair &p : v) {
         s << "status(" << QString::fromStdString(p.first) << ") =" << QString::fromStdString(p.second) << '\n';
     }
     return s << ')';
 }
 
 static const char *app_types[] = {
     "_", // will hopefully never be used as an app-type :)
     "openpgp",
     "piv",
     "nks",
     "p15",
     "dinsig",
     "geldkarte",
 };
 static_assert(sizeof app_types / sizeof * app_types == Card::NumAppTypes, "");
 
 static Card::AppType parse_app_type(const std::string &s)
 {
     qCDebug(KLEOPATRA_LOG) << "parse_app_type(" << s.c_str() << ")";
     const char **it = std::find_if(std::begin(app_types), std::end(app_types),
                                 [&s](const char *type) {
                                     return ::strcasecmp(s.c_str(), type) == 0;
                                 });
     if (it == std::end(app_types)) {
         qCDebug(KLEOPATRA_LOG) << "App type not found";
         return Card::UnknownApplication;
     }
     return static_cast<Card::AppType>(it - std::begin(app_types));
 }
 
 static int parse_app_version(const std::string &s)
 {
     return std::atoi(s.c_str());
 }
 
 static Card::PinState parse_pin_state(const QString &s)
 {
     bool ok;
     int i = s.toInt(&ok);
     if (!ok) {
         qCDebug(KLEOPATRA_LOG) << "Failed to parse pin state" << s;
         return Card::UnknownPinState;
     }
     switch (i) {
     case -4: return Card::NullPin;
     case -3: return Card::PinBlocked;
     case -2: return Card::NoPin;
     case -1: return Card::UnknownPinState;
     default:
         if (i < 0) {
             return Card::UnknownPinState;
         } else {
             return Card::PinOk;
         }
     }
 }
 
 template<typename T>
 static std::unique_ptr<T> gpgagent_transact(std::shared_ptr<Context> &gpgAgent, const char *command, std::unique_ptr<T> transaction, Error &err)
 {
     qCDebug(KLEOPATRA_LOG) << "gpgagent_transact(" << command << ")";
     err = gpgAgent->assuanTransact(command, std::move(transaction));
     if (err.code()) {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_transact(" << command << "):" << QString::fromLocal8Bit(err.asString());
         if (err.code() >= GPG_ERR_ASS_GENERAL && err.code() <= GPG_ERR_ASS_UNKNOWN_INQUIRE) {
             qCDebug(KLEOPATRA_LOG) << "Assuan problem, killing context";
             gpgAgent.reset();
         }
         return std::unique_ptr<T>();
     }
     std::unique_ptr<AssuanTransaction> t = gpgAgent->takeLastAssuanTransaction();
     return std::unique_ptr<T>(dynamic_cast<T*>(t.release()));
 }
 
 static std::unique_ptr<DefaultAssuanTransaction> gpgagent_default_transact(std::shared_ptr<Context> &gpgAgent, const char *command, Error &err)
 {
     return gpgagent_transact(gpgAgent, command, std::unique_ptr<DefaultAssuanTransaction>(new DefaultAssuanTransaction), err);
 }
 
 static const std::string gpgagent_data(std::shared_ptr<Context> gpgAgent, const char *command, Error &err)
 {
     const std::unique_ptr<DefaultAssuanTransaction> t = gpgagent_default_transact(gpgAgent, command, err);
     if (t.get()) {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_data(" << command << "): got" << QString::fromStdString(t->data());
         return t->data();
     } else {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_data(" << command << "): t == NULL";
         return std::string();
     }
 }
 
 static const std::vector< std::pair<std::string, std::string> > gpgagent_statuslines(std::shared_ptr<Context> gpgAgent, const char *what, Error &err)
 {
     const std::unique_ptr<DefaultAssuanTransaction> t = gpgagent_default_transact(gpgAgent, what, err);
     if (t.get()) {
         qCDebug(KLEOPATRA_LOG) << "agent_getattr_status(" << what << "): got" << t->statusLines();
         return t->statusLines();
     } else {
         qCDebug(KLEOPATRA_LOG) << "agent_getattr_status(" << what << "): t == NULL";
         return std::vector<std::pair<std::string, std::string> >();
     }
 }
 
 static const std::string gpgagent_status(const std::shared_ptr<Context> &gpgAgent, const char *what, Error &err)
 {
     const auto lines = gpgagent_statuslines (gpgAgent, what, err);
     // The status is only the last attribute
     // e.g. for SCD SERIALNO it would only be "SERIALNO" and for SCD GETATTR FOO
     // it would only be FOO
     const char *p = strrchr(what, ' ');
     const char *needle = (p + 1) ? (p + 1) : what;
     for (const auto &pair: lines) {
         if (pair.first == needle) {
             return pair.second;
         }
     }
     return std::string();
 }
 
 static const std::string scd_getattr_status(std::shared_ptr<Context> &gpgAgent, const char *what, Error &err)
 {
     std::string cmd = "SCD GETATTR ";
     cmd += what;
     return gpgagent_status(gpgAgent, cmd.c_str(), err);
 }
 
 static const char * get_openpgp_card_manufacturer_from_serial_number(const std::string &serialno)
 {
     qCDebug(KLEOPATRA_LOG) << "get_openpgp_card_manufacturer_from_serial_number(" << serialno.c_str() << ")";
 
     const bool isProperOpenPGPCardSerialNumber =
         serialno.size() == 32 && serialno.substr(0, 12) == "D27600012401";
     if (isProperOpenPGPCardSerialNumber) {
         const char *sn = serialno.c_str();
         const int manufacturerId = xtoi_2(sn + 16)*256 + xtoi_2(sn + 18);
         switch (manufacturerId) {
             case 0x0001: return "PPC Card Systems";
             case 0x0002: return "Prism";
             case 0x0003: return "OpenFortress";
             case 0x0004: return "Wewid";
             case 0x0005: return "ZeitControl";
             case 0x0006: return "Yubico";
             case 0x0007: return "OpenKMS";
             case 0x0008: return "LogoEmail";
 
             case 0x002A: return "Magrathea";
 
             case 0x1337: return "Warsaw Hackerspace";
 
             case 0xF517: return "FSIJ";
 
             /* 0x0000 and 0xFFFF are defined as test cards per spec,
                0xFF00 to 0xFFFE are assigned for use with randomly created
                serial numbers.  */
             case 0x0000:
             case 0xffff: return "test card";
             default: return (manufacturerId & 0xff00) == 0xff00 ? "unmanaged S/N range" : "unknown";
         }
     } else {
         return "unknown";
     }
 }
 
 static const std::string get_manufacturer(std::shared_ptr<Context> &gpgAgent, Error &err)
 {
     // The result of SCD GETATTR MANUFACTURER is the manufacturer ID as unsigned number
     // optionally followed by the name of the manufacturer, e.g.
     // 6 Yubico
     // 65534 unmanaged S/N range
     const auto manufacturerIdAndName = scd_getattr_status(gpgAgent, "MANUFACTURER", err);
     if (err.code()) {
         if (err.code() == GPG_ERR_INV_NAME) {
             qCDebug(KLEOPATRA_LOG) << "get_manufacturer(): Querying for attribute MANUFACTURER not yet supported; needs GnuPG 2.2.21+";
         } else {
             qCDebug(KLEOPATRA_LOG) << "get_manufacturer(): GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
         }
         return std::string();
     }
     const auto startOfManufacturerName = manufacturerIdAndName.find(' ');
     if (startOfManufacturerName == std::string::npos) {
         // only ID without manufacturer name
         return "unknown";
     }
     const auto manufacturerName = manufacturerIdAndName.substr(startOfManufacturerName + 1);
     return manufacturerName;
 }
 
 static void handle_openpgp_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto ret = new OpenPGPCard();
     ret->setSerialNumber(ci->serialNumber());
 
     ret->setManufacturer(get_manufacturer(gpg_agent, err));
     if (err.code()) {
         // fallback, e.g. if gpg does not yet support querying for the MANUFACTURER attribute
         ret->setManufacturer(get_openpgp_card_manufacturer_from_serial_number(ci->serialNumber()));
     }
 
     const auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --keypairinfo", err);
     if (err.code()) {
         ci->setStatus(Card::CardError);
         return;
     }
     ret->setKeyPairInfo(info);
     ci.reset(ret);
 }
 
 static void readKeyPairInfoFromPIVCard(const std::string &keyRef, PIVCard *pivCard, const std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     const std::string command = std::string("SCD READKEY --info-only -- ") + keyRef;
     const auto keyPairInfoLines = gpgagent_statuslines(gpg_agent, command.c_str(), err);
     if (err) {
         qCWarning(KLEOPATRA_LOG) << "readKeyPairInfoFromPIVCard(): Error on " << QString::fromStdString(command) << ":"
                 << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
         return;
     }
     for (const auto &pair: keyPairInfoLines) {
         if (pair.first == "KEYPAIRINFO") {
             const KeyPairInfo info = KeyPairInfo::fromStatusLine(pair.second);
             if (info.grip.empty()) {
                 qCWarning(KLEOPATRA_LOG) << "Invalid KEYPAIRINFO status line"
                         << QString::fromStdString(pair.second);
                 continue;
             }
             pivCard->setKeyAlgorithm(keyRef, info.algorithm);
         } else {
             qCWarning(KLEOPATRA_LOG) << "readKeyPairInfoFromPIVCard(): Unexpected status line on "
                     << QString::fromStdString(command) << ":" << QString::fromStdString(pair.first)
                     << QString::fromStdString(pair.second);
         }
     }
 }
 
 static void readCertificateFromPIVCard(const std::string &keyRef, PIVCard *pivCard, const std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     const std::string command = std::string("SCD READCERT ") + keyRef;
     const std::string certificateData = gpgagent_data(gpg_agent, command.c_str(), err);
     if (err && err.code() != GPG_ERR_NOT_FOUND) {
         qCWarning(KLEOPATRA_LOG) << "readCertificateFromPIVCard(" << QString::fromStdString(keyRef) << "): Error on "
                 << QString::fromStdString(command) << ":" << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
         return;
     }
     if (certificateData.empty()) {
         qCDebug(KLEOPATRA_LOG) << "readCertificateFromPIVCard(" << QString::fromStdString(keyRef) << "): No certificate stored on card";
         return;
     }
     qCDebug(KLEOPATRA_LOG) << "readCertificateFromPIVCard(" << QString::fromStdString(keyRef) << "): Found certificate stored on card";
     pivCard->setCertificateData(keyRef, certificateData);
 }
 
 static void handle_piv_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto pivCard = new PIVCard();
     pivCard->setSerialNumber(ci->serialNumber());
 
     const auto displaySerialnumber = scd_getattr_status(gpg_agent, "$DISPSERIALNO", err);
     if (err) {
         qCWarning(KLEOPATRA_LOG) << "handle_piv_card(): Error on GETATTR $DISPSERIALNO:"
                   << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
     }
     pivCard->setDisplaySerialNumber(err ? ci->serialNumber() : displaySerialnumber);
 
     const auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --force", err);
     if (err) {
         ci->setStatus(Card::CardError);
         return;
     }
     pivCard->setCardInfo(info);
 
     for (const std::string &keyRef : PIVCard::supportedKeys()) {
         if (!pivCard->keyGrip(keyRef).empty()) {
             readKeyPairInfoFromPIVCard(keyRef, pivCard, gpg_agent);
             readCertificateFromPIVCard(keyRef, pivCard, gpg_agent);
         }
     }
 
     ci.reset(pivCard);
 }
 
 static void handle_netkey_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto nkCard = new NetKeyCard();
     nkCard->setSerialNumber(ci->serialNumber());
     ci.reset(nkCard);
 
     ci->setAppVersion(parse_app_version(scd_getattr_status(gpg_agent, "NKS-VERSION", err)));
 
     if (err.code()) {
         qCDebug(KLEOPATRA_LOG) << "NKS-VERSION resulted in error" << err.asString();
         ci->setErrorMsg(QStringLiteral ("NKS-VERSION failed: ") + QString::fromUtf8(err.asString()));
         return;
     }
 
     if (ci->appVersion() != 3) {
         qCDebug(KLEOPATRA_LOG) << "not a NetKey v3 card, giving up. Version:" << ci->appVersion();
         ci->setErrorMsg(QStringLiteral("NetKey v%1 cards are not supported.").arg(ci->appVersion()));
         return;
     }
     // the following only works for NKS v3...
     const auto chvStatus = QString::fromStdString(
             scd_getattr_status(gpg_agent, "CHV-STATUS", err)).split(QLatin1Char(' '));
     if (err.code()) {
         qCDebug(KLEOPATRA_LOG) << "no CHV-STATUS" << err.asString();
         ci->setErrorMsg(QStringLiteral ("CHV-Status failed: ") + QString::fromUtf8(err.asString()));
         return;
     }
 
     std::vector<Card::PinState> states;
     states.reserve(chvStatus.count());
     // CHV Status for NKS v3 is
     // Pin1 (Normal pin) Pin2 (Normal PUK)
     // SigG1 SigG PUK.
     int num = 0;
     for (const auto &state: chvStatus) {
         const auto parsed = parse_pin_state (state);
         states.push_back(parsed);
         if (parsed == Card::NullPin) {
             if (num == 0) {
                 ci->setHasNullPin(true);
             }
         }
         ++num;
     }
     nkCard->setPinStates(states);
 
     // check for keys to learn:
     const std::unique_ptr<DefaultAssuanTransaction> result = gpgagent_default_transact(gpg_agent, "SCD LEARN --keypairinfo", err);
     if (err.code() || !result.get()) {
         if (err) {
             ci->setErrorMsg(QString::fromLatin1(err.asString()));
         } else {
             ci->setErrorMsg(QStringLiteral("Invalid internal state. No result."));
         }
         return;
     }
     const std::vector<std::string> keyPairInfos = result->statusLine("KEYPAIRINFO");
     if (keyPairInfos.empty()) {
         return;
     }
     nkCard->setKeyPairInfo(keyPairInfos);
 }
 
 static std::shared_ptr<Card> get_card_status(unsigned int slot, std::shared_ptr<Context> &gpg_agent)
 {
     qCDebug(KLEOPATRA_LOG) << "get_card_status(" << slot << ',' << gpg_agent.get() << ')';
     auto ci = std::shared_ptr<Card> (new Card());
     if (slot != 0 || !gpg_agent) {
         // In the future scdaemon should support multiple slots but
         // not yet (2.1.18)
         return ci;
     }
 
     Error err;
     ci->setSerialNumber(gpgagent_status(gpg_agent, "SCD SERIALNO", err));
     if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
         ci->setStatus(Card::NoCard);
         return ci;
     }
     if (err.code()) {
         ci->setStatus(Card::CardError);
         return ci;
     }
     ci->setStatus(Card::CardPresent);
 
     const auto verbatimType = scd_getattr_status(gpg_agent, "APPTYPE", err);
     ci->setAppType(parse_app_type(verbatimType));
     if (err.code()) {
         return ci;
     }
 
     // Handle different card types
     if (ci->appType() == Card::NksApplication) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found Netkey card" << ci->serialNumber().c_str() << "end";
         handle_netkey_card(ci, gpg_agent);
         return ci;
     } else if (ci->appType() == Card::OpenPGPApplication) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found OpenPGP card" << ci->serialNumber().c_str() << "end";
         handle_openpgp_card(ci, gpg_agent);
         return ci;
     } else if (ci->appType() == Card::PivApplication) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found PIV card" << ci->serialNumber().c_str() << "end";
         handle_piv_card(ci, gpg_agent);
         return ci;
     } else {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: unhandled application:" << verbatimType.c_str();
         return ci;
     }
 
     return ci;
 }
 
 static std::vector<std::shared_ptr<Card> > update_cardinfo(std::shared_ptr<Context> &gpgAgent)
 {
     // Multiple smartcard readers are only supported internally by gnupg
     // but not by scdaemon (Status gnupg 2.1.18)
     // We still pretend that there can be multiple cards inserted
     // at once but we don't handle it yet.
     const auto ci = get_card_status(0, gpgAgent);
     return std::vector<std::shared_ptr<Card> >(1, ci);
 }
 } // namespace
 
 struct Transaction {
     QByteArray command;
     QPointer<QObject> receiver;
     const char *slot;
     AssuanTransaction* assuanTransaction;
 };
 
 static const Transaction updateTransaction = { "__update__", nullptr, nullptr, nullptr };
 static const Transaction quitTransaction   = { "__quit__",   nullptr, nullptr, nullptr };
 
 namespace
 {
 class ReaderStatusThread : public QThread
 {
     Q_OBJECT
 public:
     explicit ReaderStatusThread(QObject *parent = nullptr)
         : QThread(parent),
           m_gnupgHomePath(Kleo::gnupgHomeDirectory()),
           m_transactions(1, updateTransaction)   // force initial scan
     {
         connect(this, &ReaderStatusThread::oneTransactionFinished,
                 this, &ReaderStatusThread::slotOneTransactionFinished);
     }
 
     std::vector<std::shared_ptr<Card> > cardInfos() const
     {
         const QMutexLocker locker(&m_mutex);
         return m_cardInfos;
     }
 
     Card::Status cardStatus(unsigned int slot) const
     {
         const QMutexLocker locker(&m_mutex);
         if (slot < m_cardInfos.size()) {
             return m_cardInfos[slot]->status();
         } else {
             return Card::NoCard;
         }
     }
 
     void addTransaction(const Transaction &t)
     {
         const QMutexLocker locker(&m_mutex);
         m_transactions.push_back(t);
         m_waitForTransactions.wakeOne();
     }
 
 Q_SIGNALS:
-    void anyCardHasNullPinChanged(bool);
+    void firstCardWithNullPinChanged(const std::string &serialNumber);
     void anyCardCanLearnKeysChanged(bool);
     void cardChanged(unsigned int);
     void oneTransactionFinished(const GpgME::Error &err);
 
 public Q_SLOTS:
     void ping()
     {
         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[GUI]::ping()";
         addTransaction(updateTransaction);
     }
 
     void stop()
     {
         const QMutexLocker locker(&m_mutex);
         m_transactions.push_front(quitTransaction);
         m_waitForTransactions.wakeOne();
     }
 
 private Q_SLOTS:
     void slotOneTransactionFinished(const GpgME::Error &err)
     {
         std::list<Transaction> ft;
         KDAB_SYNCHRONIZED(m_mutex)
         ft.splice(ft.begin(), m_finishedTransactions);
         Q_FOREACH (const Transaction &t, ft)
             if (t.receiver && t.slot && *t.slot) {
                 QMetaObject::invokeMethod(t.receiver, t.slot, Qt::DirectConnection, Q_ARG(GpgME::Error, err));
             }
     }
 
 private:
     void run() override {
         while (true) {
             std::shared_ptr<Context> gpgAgent;
 
             QByteArray command;
             bool nullSlot = false;
             AssuanTransaction* assuanTransaction = nullptr;
             std::list<Transaction> item;
             std::vector<std::shared_ptr<Card> > oldCards;
 
             Error err;
             std::unique_ptr<Context> c = Context::createForEngine(AssuanEngine, &err);
             if (err.code() == GPG_ERR_NOT_SUPPORTED) {
                 return;
             }
             gpgAgent = std::shared_ptr<Context>(c.release());
 
             KDAB_SYNCHRONIZED(m_mutex) {
 
                 while (m_transactions.empty()) {
                     // go to sleep waiting for more work:
                     qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: waiting for commands";
                     m_waitForTransactions.wait(&m_mutex);
                 }
 
                 // splice off the first transaction without
                 // copying, so we own it without really importing
                 // it into this thread (the QPointer isn't
                 // thread-safe):
                 item.splice(item.end(),
                             m_transactions, m_transactions.begin());
 
                 // make local copies of the interesting stuff so
                 // we can release the mutex again:
                 command = item.front().command;
                 nullSlot = !item.front().slot;
                 // we take ownership of the assuan transaction
                 std::swap(assuanTransaction, item.front().assuanTransaction);
                 oldCards = m_cardInfos;
             }
 
             qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: new iteration command=" << command << " ; nullSlot=" << nullSlot;
             // now, let's see what we got:
             if (nullSlot && command == quitTransaction.command) {
                 return;    // quit
             }
 
             if ((nullSlot && command == updateTransaction.command)) {
 
                 std::vector<std::shared_ptr<Card> > newCards = update_cardinfo(gpgAgent);
 
                 newCards.resize(std::max(newCards.size(), oldCards.size()));
                 oldCards.resize(std::max(newCards.size(), oldCards.size()));
 
                 KDAB_SYNCHRONIZED(m_mutex)
                 m_cardInfos = newCards;
 
                 std::vector<std::shared_ptr<Card> >::const_iterator
                 nit = newCards.begin(), nend = newCards.end(),
                 oit = oldCards.begin(), oend = oldCards.end();
 
                 unsigned int idx = 0;
                 bool anyLC = false;
-                bool anyNP = false;
+                std::string firstCardWithNullPin;
                 bool anyError = false;
                 while (nit != nend && oit != oend) {
                     const auto optr = (*oit).get();
                     const auto nptr = (*nit).get();
                     if ((optr && !nptr) || (!optr && nptr) || (optr && nptr && *optr != *nptr)) {
                         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: slot" << idx << ": card Changed";
                         Q_EMIT cardChanged(idx);
                     }
                     if ((*nit)->canLearnKeys()) {
                         anyLC = true;
                     }
-                    if ((*nit)->hasNullPin()) {
-                        anyNP = true;
+                    if ((*nit)->hasNullPin() && firstCardWithNullPin.empty()) {
+                        firstCardWithNullPin = (*nit)->serialNumber();
                     }
                     if ((*nit)->status() == Card::CardError) {
                         anyError = true;
                     }
                     ++nit;
                     ++oit;
                     ++idx;
                 }
 
-                Q_EMIT anyCardHasNullPinChanged(anyNP);
+                Q_EMIT firstCardWithNullPinChanged(firstCardWithNullPin);
                 Q_EMIT anyCardCanLearnKeysChanged(anyLC);
 
                 if (anyError) {
                     gpgAgent.reset();
                 }
             } else {
                 GpgME::Error err;
                 if (assuanTransaction) {
                     (void)gpgagent_transact(gpgAgent, command.constData(), std::unique_ptr<AssuanTransaction>(assuanTransaction), err);
                 } else {
                     (void)gpgagent_default_transact(gpgAgent, command.constData(), err);
                 }
 
                 KDAB_SYNCHRONIZED(m_mutex)
                 // splice 'item' into m_finishedTransactions:
                 m_finishedTransactions.splice(m_finishedTransactions.end(), item);
 
                 Q_EMIT oneTransactionFinished(err);
             }
         }
     }
 
 private:
     mutable QMutex m_mutex;
     QWaitCondition m_waitForTransactions;
     const QString m_gnupgHomePath;
     // protected by m_mutex:
     std::vector<std::shared_ptr<Card> > m_cardInfos;
     std::list<Transaction> m_transactions, m_finishedTransactions;
 };
 
 }
 
 class ReaderStatus::Private : ReaderStatusThread
 {
     friend class Kleo::SmartCard::ReaderStatus;
     ReaderStatus *const q;
 public:
     explicit Private(ReaderStatus *qq)
         : ReaderStatusThread(qq),
           q(qq),
           watcher()
     {
         KDAB_SET_OBJECT_NAME(watcher);
 
         qRegisterMetaType<Card::Status>("Kleo::SmartCard::Card::Status");
         qRegisterMetaType<GpgME::Error>("GpgME::Error");
 
         watcher.whitelistFiles(QStringList(QStringLiteral("reader_*.status")));
         watcher.addPath(Kleo::gnupgHomeDirectory());
         watcher.setDelay(100);
 
         connect(this, &::ReaderStatusThread::cardChanged,
                 q, &ReaderStatus::cardChanged);
-        connect(this, &::ReaderStatusThread::anyCardHasNullPinChanged,
-                q, &ReaderStatus::anyCardHasNullPinChanged);
+        connect(this, &::ReaderStatusThread::firstCardWithNullPinChanged,
+                q, &ReaderStatus::firstCardWithNullPinChanged);
         connect(this, &::ReaderStatusThread::anyCardCanLearnKeysChanged,
                 q, &ReaderStatus::anyCardCanLearnKeysChanged);
 
         connect(&watcher, &FileSystemWatcher::triggered, this, &::ReaderStatusThread::ping);
 
     }
     ~Private()
     {
         stop();
         if (!wait(100)) {
             terminate();
             wait();
         }
     }
 
 private:
-    bool anyCardHasNullPinImpl() const
+    std::string firstCardWithNullPinImpl() const
     {
         const auto cis = cardInfos();
-        return std::any_of(cis.cbegin(), cis.cend(),
-                           [](const std::shared_ptr<Card> &ci) { return ci->hasNullPin(); });
+        const auto firstWithNullPin = std::find_if(cis.cbegin(), cis.cend(),
+                                                   [](const std::shared_ptr<Card> &ci) { return ci->hasNullPin(); });
+        return firstWithNullPin != cis.cend() ? (*firstWithNullPin)->serialNumber() : std::string();
     }
 
     bool anyCardCanLearnKeysImpl() const
     {
         const auto cis = cardInfos();
         return std::any_of(cis.cbegin(), cis.cend(),
                            [](const std::shared_ptr<Card> &ci) { return ci->canLearnKeys(); });
     }
 
 private:
     FileSystemWatcher watcher;
 };
 
 ReaderStatus::ReaderStatus(QObject *parent)
     : QObject(parent), d(new Private(this))
 {
     self = this;
+
+    qRegisterMetaType<std::string>("std::string");
 }
 
 ReaderStatus::~ReaderStatus()
 {
     self = nullptr;
 }
 
 // slot
 void ReaderStatus::startMonitoring()
 {
     d->start();
 }
 
 // static
 ReaderStatus *ReaderStatus::mutableInstance()
 {
     return self;
 }
 
 // static
 const ReaderStatus *ReaderStatus::instance()
 {
     return self;
 }
 
 Card::Status ReaderStatus::cardStatus(unsigned int slot) const
 {
     return d->cardStatus(slot);
 }
 
-bool ReaderStatus::anyCardHasNullPin() const
+std::string ReaderStatus::firstCardWithNullPin() const
 {
-    return d->anyCardHasNullPinImpl();
+    return d->firstCardWithNullPinImpl();
 }
 
 bool ReaderStatus::anyCardCanLearnKeys() const
 {
     return d->anyCardCanLearnKeysImpl();
 }
 
 std::vector<Card::PinState> ReaderStatus::pinStates(unsigned int slot) const
 {
     const auto ci = d->cardInfos();
     if (slot < ci.size()) {
         return ci[slot]->pinStates();
     } else {
         return std::vector<Card::PinState>();
     }
 }
 
 void ReaderStatus::startSimpleTransaction(const QByteArray &command, QObject *receiver, const char *slot)
 {
     const Transaction t = { command, receiver, slot, nullptr };
     d->addTransaction(t);
 }
 
 void ReaderStatus::startTransaction(const QByteArray &command, QObject *receiver, const char *slot, std::unique_ptr<AssuanTransaction> transaction)
 {
     const Transaction t = { command, receiver, slot, transaction.release() };
     d->addTransaction(t);
 }
 
 void ReaderStatus::updateStatus()
 {
     d->ping();
 }
 
 std::vector <std::shared_ptr<Card> > ReaderStatus::getCards() const
 {
     return d->cardInfos();
 }
 
 #include "readerstatus.moc"
diff --git a/src/smartcard/readerstatus.h b/src/smartcard/readerstatus.h
index 27e34c68c..f7d3a03c1 100644
--- a/src/smartcard/readerstatus.h
+++ b/src/smartcard/readerstatus.h
@@ -1,86 +1,86 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     smartcard/readerstatus.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef __KLEOPATRA__SMARTCARD__READERSTATUS_H___
 #define __KLEOPATRA__SMARTCARD__READERSTATUS_H___
 
 #include <QObject>
 #include <QMetaType>
 
 #include "card.h"
 
 #include <vector>
 #include <memory>
 
 #include "kleopatra_debug.h"
 
 namespace GpgME
 {
 class AssuanTransaction;
 }
 
 namespace Kleo
 {
 namespace SmartCard
 {
 
 class ReaderStatus : public QObject
 {
     Q_OBJECT
 public:
     explicit ReaderStatus(QObject *parent = nullptr);
     ~ReaderStatus();
 
     static const ReaderStatus *instance();
     static ReaderStatus *mutableInstance();
 
     void startSimpleTransaction(const QByteArray &cmd, QObject *receiver, const char *slot);
     void startTransaction(const QByteArray &cmd, QObject *receiver, const char *slot, std::unique_ptr<GpgME::AssuanTransaction> transaction);
 
     Card::Status cardStatus(unsigned int slot) const;
-    bool anyCardHasNullPin() const;
+    std::string firstCardWithNullPin() const;
     bool anyCardCanLearnKeys() const;
 
     std::vector<Card::PinState> pinStates(unsigned int slot) const;
 
     std::vector<std::shared_ptr<Card> > getCards() const;
 
     template <typename T>
     std::shared_ptr<T> getCard(const std::string &serialNumber) const
     {
         for (const auto &card: getCards()) {
             if (card->serialNumber() == serialNumber) {
                 qCDebug(KLEOPATRA_LOG) << "ReaderStatus::getCard() - Found card with serial number" << QString::fromStdString(serialNumber);
                 return std::dynamic_pointer_cast<T>(card);
             }
         }
         qCDebug(KLEOPATRA_LOG) << "ReaderStatus::getCard() - Did not find card with serial number" << QString::fromStdString(serialNumber);
         return std::shared_ptr<T>();
     }
 
 public Q_SLOTS:
     void updateStatus();
     void startMonitoring();
 
 Q_SIGNALS:
-    void anyCardHasNullPinChanged(bool);
+    void firstCardWithNullPinChanged(const std::string &serialNumber);
     void anyCardCanLearnKeysChanged(bool);
     void cardChanged(unsigned int slot);
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 } // namespace SmartCard
 } // namespace Kleo
 
 Q_DECLARE_METATYPE(Kleo::SmartCard::Card::Status)
 
 #endif /* __KLEOPATRA__SMARTCARD__READERSTATUS_H___ */
diff --git a/src/systrayicon.cpp b/src/systrayicon.cpp
index 3fe4d81b1..b1edd741b 100644
--- a/src/systrayicon.cpp
+++ b/src/systrayicon.cpp
@@ -1,256 +1,254 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     systemtrayicon.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 "systrayicon.h"
 
 #ifndef QT_NO_SYSTEMTRAYICON
 
 #include "mainwindow.h"
 #include "kleopatraapplication.h"
 
 #include <smartcard/readerstatus.h>
 
 #include <utils/clipboardmenu.h>
 
 #include <commands/importcertificatefromclipboardcommand.h>
 #include <commands/encryptclipboardcommand.h>
 #include <commands/signclipboardcommand.h>
 #include <commands/decryptverifyclipboardcommand.h>
 #include <commands/setinitialpincommand.h>
 #include <commands/learncardkeyscommand.h>
 
 #include <QIcon>
 #include <KLocalizedString>
 #include <KAboutApplicationDialog>
 #include <KAboutData>
 #include <KActionMenu>
 #include <QEventLoopLocker>
 
 #include <QMenu>
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QPointer>
 #include <QSignalBlocker>
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 
 class SysTrayIcon::Private
 {
     friend class ::SysTrayIcon;
     SysTrayIcon *const q;
 public:
     explicit Private(SysTrayIcon *qq);
     ~Private();
 
 private:
     void slotAbout()
     {
         if (!aboutDialog) {
             aboutDialog = new KAboutApplicationDialog(KAboutData::applicationData());
             aboutDialog->setAttribute(Qt::WA_DeleteOnClose);
         }
 
         if (aboutDialog->isVisible()) {
             aboutDialog->raise();
         } else {
             aboutDialog->show();
         }
     }
 
     void enableDisableActions()
     {
         //work around a Qt bug (seen with Qt 4.4.0, Windows): QClipBoard->mimeData() triggers QClipboard::changed(),
         //triggering slotEnableDisableActions again
         const QSignalBlocker blocker(QApplication::clipboard());
         openCertificateManagerAction.setEnabled(!q->mainWindow() || !q->mainWindow()->isVisible());
-        setInitialPinAction.setEnabled(anyCardHasNullPin);
+        setInitialPinAction.setEnabled(!firstCardWithNullPin.empty());
         learnCertificatesAction.setEnabled(anyCardCanLearnKeys);
 
-        q->setAttentionWanted((anyCardHasNullPin || anyCardCanLearnKeys) && !q->attentionWindow());
+        q->setAttentionWanted((!firstCardWithNullPin.empty() || anyCardCanLearnKeys) && !q->attentionWindow());
     }
 
     void slotSetInitialPin()
     {
         SetInitialPinCommand *cmd = new SetInitialPinCommand;
         q->setAttentionWindow(cmd->dialog());
         startCommand(cmd);
     }
 
     void slotLearnCertificates()
     {
         LearnCardKeysCommand *cmd = new LearnCardKeysCommand(GpgME::CMS);
         q->setAttentionWindow(cmd->dialog());
         startCommand(cmd);
     }
     void startCommand(Command *cmd)
     {
         Q_ASSERT(cmd);
         cmd->setParent(q->mainWindow());
         cmd->start();
     }
 
 private:
-    bool anyCardHasNullPin;
-    bool anyCardCanLearnKeys;
-    bool learningInProgress;
+    std::string firstCardWithNullPin;
+    bool anyCardCanLearnKeys = false;
+    bool learningInProgress = false;
 
     QMenu menu;
     QAction openCertificateManagerAction;
     QAction configureAction;
     QAction aboutAction;
     QAction quitAction;
 
     ClipboardMenu clipboardMenu;
 
     QMenu cardMenu;
     QAction updateCardStatusAction;
     QAction setInitialPinAction;
     QAction learnCertificatesAction;
 
     QPointer<KAboutApplicationDialog> aboutDialog;
     QEventLoopLocker eventLoopLocker;
 };
 
 SysTrayIcon::Private::Private(SysTrayIcon *qq)
     : q(qq),
-      anyCardHasNullPin(false),
-      anyCardCanLearnKeys(false),
       menu(),
       openCertificateManagerAction(i18n("&Open Certificate Manager..."), q),
       configureAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("&Configure %1...", KAboutData::applicationData().componentName()), q),
       aboutAction(QIcon::fromTheme(QStringLiteral("kleopatra")), i18n("&About %1...", KAboutData::applicationData().componentName()), q),
       quitAction(QIcon::fromTheme(QStringLiteral("application-exit")),i18n("&Shutdown Kleopatra"), q),
       clipboardMenu(q),
       cardMenu(i18n("SmartCard")),
       updateCardStatusAction(i18n("Update Card Status"), q),
       setInitialPinAction(i18n("Set NetKey v3 Initial PIN..."), q),
       learnCertificatesAction(i18n("Learn NetKey v3 Card Certificates"), q),
       aboutDialog()
 {
     q->setNormalIcon(QIcon::fromTheme(QStringLiteral("kleopatra")));
     q->setAttentionIcon(QIcon::fromTheme(QStringLiteral("secure-card")));
 
     KDAB_SET_OBJECT_NAME(menu);
     KDAB_SET_OBJECT_NAME(openCertificateManagerAction);
     KDAB_SET_OBJECT_NAME(configureAction);
     KDAB_SET_OBJECT_NAME(aboutAction);
     KDAB_SET_OBJECT_NAME(quitAction);
     KDAB_SET_OBJECT_NAME(clipboardMenu);
     KDAB_SET_OBJECT_NAME(cardMenu);
     KDAB_SET_OBJECT_NAME(setInitialPinAction);
     KDAB_SET_OBJECT_NAME(learnCertificatesAction);
 
     connect(&openCertificateManagerAction, SIGNAL(triggered()), qApp, SLOT(openOrRaiseMainWindow()));
     connect(&configureAction, SIGNAL(triggered()), qApp, SLOT(openOrRaiseConfigDialog()));
     connect(&aboutAction, SIGNAL(triggered()), q, SLOT(slotAbout()));
     connect(&quitAction, &QAction::triggered, QCoreApplication::instance(), &QCoreApplication::quit);
     connect(&updateCardStatusAction, &QAction::triggered, ReaderStatus::instance(), &ReaderStatus::updateStatus);
     connect(&setInitialPinAction, SIGNAL(triggered()), q, SLOT(slotSetInitialPin()));
     connect(&learnCertificatesAction, SIGNAL(triggered()), q, SLOT(slotLearnCertificates()));
 
     connect(QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)),
             q, SLOT(slotEnableDisableActions()));
 
     menu.addAction(&openCertificateManagerAction);
     menu.addAction(&configureAction);
     menu.addAction(&aboutAction);
     menu.addSeparator();
     menu.addMenu(clipboardMenu.clipboardMenu()->menu());
     menu.addSeparator();
     menu.addMenu(&cardMenu);
     cardMenu.addAction(&updateCardStatusAction);
     cardMenu.addAction(&setInitialPinAction);
     cardMenu.addAction(&learnCertificatesAction);
     menu.addSeparator();
     menu.addAction(&quitAction);
 
     q->setContextMenu(&menu);
     clipboardMenu.setMainWindow(q->mainWindow());
 }
 
 SysTrayIcon::Private::~Private() {}
 
 SysTrayIcon::SysTrayIcon(QObject *p)
     : SystemTrayIcon(p), d(new Private(this))
 {
     slotEnableDisableActions();
 }
 
 SysTrayIcon::~SysTrayIcon()
 {
 }
 
 MainWindow *SysTrayIcon::mainWindow() const
 {
     return static_cast<MainWindow *>(SystemTrayIcon::mainWindow());
 }
 
 QDialog *SysTrayIcon::attentionWindow() const
 {
     return static_cast<QDialog *>(SystemTrayIcon::attentionWindow());
 }
 
 void SysTrayIcon::doActivated()
 {
     if (const QWidget *const aw = attentionWindow())
         if (aw->isVisible()) {
             return;    // ignore clicks while an attention window is open.
         }
-    if (d->anyCardHasNullPin) {
+    if (!d->firstCardWithNullPin.empty()) {
         d->slotSetInitialPin();
     } else if (d->anyCardCanLearnKeys) {
         d->slotLearnCertificates();
     } else {
         // Toggle visibility of MainWindow
         KleopatraApplication::instance()->toggleMainWindowVisibility();
     }
 }
 
-void SysTrayIcon::setAnyCardHasNullPin(bool on)
+void SysTrayIcon::setFirstCardWithNullPin(const std::string &serialNumber)
 {
-    if (d->anyCardHasNullPin == on) {
+    if (d->firstCardWithNullPin == serialNumber) {
         return;
     }
-    d->anyCardHasNullPin = on;
+    d->firstCardWithNullPin = serialNumber;
     slotEnableDisableActions();
 }
 
 void SysTrayIcon::setAnyCardCanLearnKeys(bool on)
 {
     if (d->anyCardCanLearnKeys == on || d->learningInProgress) {
         return;
     }
     d->anyCardCanLearnKeys = on;
     slotEnableDisableActions();
 }
 
 void SysTrayIcon::slotEnableDisableActions()
 {
     d->enableDisableActions();
 }
 
 /* We need this as the readerstatus might update even
  * while the loading is in progress. */
 void SysTrayIcon::setLearningInProgress(bool value)
 {
     if (value) {
         setAnyCardCanLearnKeys(false);
     }
     d->learningInProgress = value;
 }
 
 #include "moc_systrayicon.cpp"
 
 #endif // QT_NO_SYSTEMTRAYICON
diff --git a/src/systrayicon.h b/src/systrayicon.h
index a1e372bb9..61235d658 100644
--- a/src/systrayicon.h
+++ b/src/systrayicon.h
@@ -1,51 +1,51 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     systrayicon.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef __KLEOPATRA_SYSTRAYICON_H__
 #define __KLEOPATRA_SYSTRAYICON_H__
 
 #include <utils/systemtrayicon.h>
 #ifndef QT_NO_SYSTEMTRAYICON
 
 #include <utils/pimpl_ptr.h>
 
 class MainWindow;
 class QDialog;
 
 class SysTrayIcon : public Kleo::SystemTrayIcon
 {
     Q_OBJECT
 public:
     explicit SysTrayIcon(QObject *parent = nullptr);
     ~SysTrayIcon() override;
 
     MainWindow *mainWindow() const;
     QDialog *attentionWindow() const;
 
     void setLearningInProgress(bool value);
 
 public Q_SLOTS:
-    void setAnyCardHasNullPin(bool);
+    void setFirstCardWithNullPin(const std::string &serialNumber);
     void setAnyCardCanLearnKeys(bool);
 
 private:
     void doActivated() override;
     void slotEnableDisableActions() override;
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
     Q_PRIVATE_SLOT(d, void slotAbout())
     Q_PRIVATE_SLOT(d, void slotSetInitialPin())
     Q_PRIVATE_SLOT(d, void slotLearnCertificates())
 };
 
 #endif // QT_NO_SYSTEMTRAYICON
 
 #endif /* __KLEOPATRA_SYSTRAYICON_H__ */
diff --git a/src/view/keylistcontroller.cpp b/src/view/keylistcontroller.cpp
index a7013f7fa..d0cd66dfc 100644
--- a/src/view/keylistcontroller.cpp
+++ b/src/view/keylistcontroller.cpp
@@ -1,801 +1,801 @@
 /* -*- 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-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 "tooltippreferences.h"
 #include "kleopatra_debug.h"
 #include "commands/exportcertificatecommand.h"
 #include "commands/exportopenpgpcertstoservercommand.h"
 #include "commands/exportsecretkeycommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/changepassphrasecommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "commands/reloadkeyscommand.h"
 #include "commands/refreshx509certscommand.h"
 #include "commands/refreshopenpgpcertscommand.h"
 #include "commands/detailscommand.h"
 #include "commands/deletecertificatescommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 #include "commands/signencryptfoldercommand.h"
 #include "commands/clearcrlcachecommand.h"
 #include "commands/dumpcrlcachecommand.h"
 #include "commands/dumpcertificatecommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/changeexpirycommand.h"
 #include "commands/changeownertrustcommand.h"
 #include "commands/changeroottrustcommand.h"
 #include "commands/certifycertificatecommand.h"
 #include "commands/adduseridcommand.h"
 #include "commands/newcertificatecommand.h"
 #include "commands/checksumverifyfilescommand.h"
 #include "commands/checksumcreatefilescommand.h"
 #include "commands/exportpaperkeycommand.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/key.h>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 
 #include <QAbstractItemView>
 #include <QPointer>
 #include <QItemSelectionModel>
 #include <QAction>
 
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 
 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 slotProgress(const QString &what, int current, int total)
     {
         Q_EMIT q->progress(current, total);
         if (!what.isEmpty()) {
             Q_EMIT q->message(what);
         }
     }
     void slotActionTriggered();
     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;
 };
 
 KeyListController::Private::Private(KeyListController *qq)
     : q(qq),
       actions(),
       views(),
       commands(),
       parentWidget(),
       tabWidget(),
       flatModel(),
       hierarchicalModel()
 {
     connect(KeyCache::mutableInstance().get(), SIGNAL(added(GpgME::Key)),
             q, SLOT(slotAddKey(GpgME::Key)));
     connect(KeyCache::mutableInstance().get(), SIGNAL(aboutToRemove(GpgME::Key)),
             q, SLOT(slotAboutToRemoveKey(GpgME::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;
 }
 
 static const struct {
     const char *signal;
     const char *slot;
 } tabs2controller[] = {
     { SIGNAL(viewAdded(QAbstractItemView*)),            SLOT(addView(QAbstractItemView*))                },
     { SIGNAL(viewAboutToBeRemoved(QAbstractItemView*)), SLOT(removeView(QAbstractItemView*))             },
     { SIGNAL(currentViewChanged(QAbstractItemView*)),   SLOT(slotCurrentViewChanged(QAbstractItemView*)) },
 };
 static const unsigned int numTabs2Controller = sizeof tabs2controller / sizeof * tabs2controller;
 
 void KeyListController::Private::connectTabWidget()
 {
     if (!tabWidget) {
         return;
     }
     const auto views = tabWidget->views();
     std::for_each(views.cbegin(), views.cend(),
                   [this](QAbstractItemView *view) { addView(view); });
     for (unsigned int i = 0; i < numTabs2Controller; ++i) {
         connect(tabWidget, tabs2controller[i].signal, q, tabs2controller[i].slot);
     }
 }
 
 void KeyListController::Private::disconnectTabWidget()
 {
     if (!tabWidget) {
         return;
     }
     for (unsigned int i = 0; i < numTabs2Controller; ++i) {
         disconnect(tabWidget, tabs2controller[i].signal, q, tabs2controller[i].slot);
     }
     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 action_data action_data[] = {
         // File menu
         {
             "file_new_certificate", i18n("New Key Pair..."), QString(),
             "view-certificate-add", nullptr, nullptr, QStringLiteral("Ctrl+N"), false, true
         },
         {
             "file_export_certificates", i18n("Export..."), i18n("Export the selected certificate (public key) to a file"),
             "view-certificate-export", nullptr, nullptr, QStringLiteral("Ctrl+E"), false, true
         },
         {
             "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"), false, true
         },
         {
             "file_export_secret_keys", i18n("Export Secret Keys..."), QString(),
             "view-certificate-export-secret", nullptr, nullptr, QString(), false, true
         },
         {
             "file_export_paper_key", i18n("Print Secret Key..."), QString(),
             "document-print", nullptr, nullptr, QString(), false, true
         },
         {
             "file_lookup_certificates", i18n("Lookup on Server..."), i18n("Search for certificates online using a public keyserver"),
             "edit-find", nullptr, nullptr, QStringLiteral("Shift+Ctrl+I"), false, true
         },
         {
             "file_import_certificates", i18n("Import..."), i18n("Import a certificate from a file"),
             "view-certificate-import", nullptr, nullptr, QStringLiteral("Ctrl+I"), false, true
         },
         {
             "file_decrypt_verify_files", i18n("Decrypt/Verify..."), i18n("Decrypt and/or verify files"),
             "document-edit-decrypt-verify", nullptr, nullptr, QString(), false, true
         },
         {
             "file_sign_encrypt_files", i18n("Sign/Encrypt..."), i18n("Encrypt and/or sign files"),
             "document-edit-sign-encrypt", nullptr, nullptr, QString(), false, true
         },
         {
             "file_sign_encrypt_folder", i18n("Sign/Encrypt Folder..."), i18n("Encrypt and/or sign folders"),
             nullptr/*"folder-edit-sign-encrypt"*/, nullptr, nullptr, QString(), false, true
         },
         {
             "file_checksum_create_files", i18n("Create Checksum Files..."), QString(),
             nullptr/*"document-checksum-create"*/, nullptr, nullptr, QString(), false, true
         },
         {
             "file_checksum_verify_files", i18n("Verify Checksum Files..."), QString(),
             nullptr/*"document-checksum-verify"*/, nullptr, nullptr, QString(), false, true
         },
         // View menu
         {
             "view_redisplay", i18n("Redisplay"), QString(),
             "view-refresh", nullptr, nullptr, QStringLiteral("F5"), false, true
         },
         {
             "view_stop_operations", i18n("Stop Operation"), QString(),
             "process-stop", this, SLOT(cancelCommands()), QStringLiteral("Escape"), false, false
         },
         {
             "view_certificate_details", i18n("Details"), QString(),
             "dialog-information", nullptr, nullptr, QString(), false, true
         },
         // Certificate menu
         {
             "certificates_delete", i18n("Delete"), i18n("Delete selected certificates"),
             "edit-delete", nullptr, nullptr, QStringLiteral("Delete"), false, true
         },
         {
             "certificates_certify_certificate", i18n("Certify..."), i18n("Certify the validity of the selected certificate"),
             "view-certificate-sign", nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_change_expiry", i18n("Change Expiry Date..."), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_change_owner_trust", i18n("Change Certification Trust..."), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_trust_root", i18n("Trust Root Certificate"), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_distrust_root", i18n("Distrust Root Certificate"), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_change_passphrase", i18n("Change Passphrase..."), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_add_userid", i18n("Add User-ID..."), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "certificates_dump_certificate", i18n("Technical Details"), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         // Tools menu
         {
             "tools_refresh_x509_certificates", i18n("Refresh X.509 Certificates"), QString(),
             "view-refresh", nullptr, nullptr, QString(), false, true
         },
         {
             "tools_refresh_openpgp_certificates", i18n("Refresh OpenPGP Certificates"), QString(),
             "view-refresh", nullptr, nullptr, QString(), false, true
         },
         {
             "crl_clear_crl_cache", i18n("Clear CRL Cache"), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "crl_dump_crl_cache", i18n("Dump CRL Cache"), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         {
             "crl_import_crl", i18n("Import CRL From File..."), QString(),
             nullptr, nullptr, nullptr, QString(), false, true
         },
         // Window menu
         // (come from TabWidget)
         // Help menu
         // (come from MainWindow)
     };
 
     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<NewCertificateCommand>(coll->action(QStringLiteral("file_new_certificate")));
     //---
     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")));
     //---
     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")));
     registerActionForCommand<ChangeExpiryCommand>(coll->action(QStringLiteral("certificates_change_expiry")));
     registerActionForCommand<ChangePassphraseCommand>(coll->action(QStringLiteral("certificates_change_passphrase")));
     registerActionForCommand<AddUserIDCommand>(coll->action(QStringLiteral("certificates_add_userid")));
     //---
     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, SIGNAL(triggered()), this, SLOT(slotActionTriggered()));
     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, SIGNAL(destroyed(QObject*)),
             q, SLOT(slotDestroyed(QObject*)));
     connect(view, SIGNAL(doubleClicked(QModelIndex)),
             q, SLOT(slotDoubleClicked(QModelIndex)));
     connect(view, SIGNAL(activated(QModelIndex)),
             q, SLOT(slotActivated(QModelIndex)));
     connect(view->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             q, SLOT(slotSelectionChanged(QItemSelection,QItemSelection)));
 
     view->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(view, SIGNAL(customContextMenuRequested(QPoint)),
             q, SLOT(slotContextMenu(QPoint)));
 }
 
 void KeyListController::Private::connectCommand(Command *cmd)
 {
     if (!cmd) {
         return;
     }
     connect(cmd, SIGNAL(destroyed(QObject*)), q, SLOT(slotDestroyed(QObject*)));
     connect(cmd, SIGNAL(finished()), q, SLOT(slotCommandFinished()));
     //connect( cmd, SIGNAL(canceled()), q, SLOT(slotCommandCanceled()) );
     connect(cmd, &Command::info, q, &KeyListController::message);
     connect(cmd, SIGNAL(progress(QString,int,int)), q, SLOT(slotProgress(QString,int,int)));
 }
 
 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;
     }
 
     DetailsCommand *const c = new DetailsCommand(view, q);
     if (parentWidget) {
         c->setParentWidget(parentWidget);
     }
 
     c->setIndex(idx);
     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);
     Q_FOREACH (const Private::action_item &ai, 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 (std::all_of(keys.cbegin(), keys.cend(), std::mem_fn(&Key::hasSecret))) {
         result |= Command::NeedSecretKey;
     } else if (!std::any_of(keys.cbegin(), keys.cend(), std::mem_fn(&Key::hasSecret))) {
         result |= Command::MustNotBeSecretKey;
     }
 
     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 (all_secret_are_not_owner_trust_ultimate(keys)) {
         result |= Command::MayOnlyBeSecretKeyIfOwnerTrustIsNotYetUltimate;
     }
 
     result |= find_root_restrictions(keys);
 
     if (const ReaderStatus *rs = ReaderStatus::instance()) {
-        if (rs->anyCardHasNullPin()) {
+        if (!rs->firstCardWithNullPin().empty()) {
             result |= Command::AnyCardHasNullPin;
         }
         if (rs->anyCardCanLearnKeys()) {
             result |= Command::AnyCardCanLearnKeys;
         }
     }
 
     return result;
 }
 
 void KeyListController::Private::slotActionTriggered()
 {
     if (const QObject *const s = q->sender()) {
         const auto it = std::find_if(actions.cbegin(), actions.cend(),
                                      [this](const action_item &item) { return item.action == q->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(s->objectName()) << "\"";
         else {
             qCDebug(KLEOPATRA_LOG) << "I don't know anything about action(?) \"%s\"", qPrintable(s->objectName());
         }
     } else {
         qCDebug(KLEOPATRA_LOG) << "not called through a signal/slot connection (sender() == NULL)";
     }
 }
 
 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"