diff --git a/src/smartcard/card.cpp b/src/smartcard/card.cpp
index eac09fc2d..9d8bf7fae 100644
--- a/src/smartcard/card.cpp
+++ b/src/smartcard/card.cpp
@@ -1,128 +1,119 @@
 /*  smartcard/card.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "card.h"
+
 #include "readerstatus.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
-Card::Card(): mCanLearn(false),
-              mHasNullPin(false),
-              mStatus(Status::NoCard),
-              mAppVersion(-1)
+Card::Card()
+{
+}
+
+Card::~Card()
 {
 }
 
 void Card::setStatus(Status s)
 {
     mStatus = s;
 }
 
 Card::Status Card::status() const
 {
     return mStatus;
 }
 
 void Card::setSerialNumber(const std::string &sn)
 {
     mSerialNumber = sn;
 }
 
 std::string Card::serialNumber() const
 {
     return mSerialNumber;
 }
 
 std::string Card::appName() const
 {
     return mAppName;
 }
 
 void Card::setAppName(const std::string &name)
 {
     mAppName = name;
 }
 
 void Card::setAppVersion(int version)
 {
     mAppVersion = version;
 }
 
 int Card::appVersion() const
 {
     return mAppVersion;
 }
 
 std::vector<Card::PinState> Card::pinStates() const
 {
     return mPinStates;
 }
 
 void Card::setPinStates(const std::vector<PinState> &pinStates)
 {
     mPinStates = pinStates;
 }
 
-void Card::setSlot(int slot)
-{
-    mSlot = slot;
-}
-
-int Card::slot() const
-{
-    return mSlot;
-}
-
 bool Card::hasNullPin() const
 {
     return mHasNullPin;
 }
 
 void Card::setHasNullPin(bool value)
 {
     mHasNullPin = value;
 }
 
 bool Card::canLearnKeys() const
 {
     return mCanLearn;
 }
 
 void Card::setCanLearnKeys(bool value)
 {
     mCanLearn = value;
 }
 
-bool Card::operator == (const Card& other) const
+bool Card::operator == (const Card &other) const
 {
     return mStatus == other.status()
         && mSerialNumber == other.serialNumber()
         && mAppName == other.appName()
         && mAppVersion == other.appVersion()
         && mPinStates == other.pinStates()
-        && mSlot == other.slot()
         && mCanLearn == other.canLearnKeys()
         && mHasNullPin == other.hasNullPin();
 }
 
-bool Card::operator != (const Card& other) const
+bool Card::operator != (const Card &other) const
 {
     return !operator==(other);
 }
 
 void Card::setErrorMsg(const QString &msg)
 {
     mErrMsg = msg;
 }
 
 QString Card::errorMsg() const
 {
     return mErrMsg;
 }
diff --git a/src/smartcard/card.h b/src/smartcard/card.h
index 6785a52c1..63baba8b1 100644
--- a/src/smartcard/card.h
+++ b/src/smartcard/card.h
@@ -1,95 +1,93 @@
 #ifndef SMARTCARD_CARD_H
 #define SMARTCARD_CARD_H
 /*  smartcard/card.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#include <vector>
 #include <string>
+#include <vector>
 
 #include <QString>
 
 namespace Kleo
 {
 namespace SmartCard
 {
-/** Class to work with Smartcards or other Hardware tokens. */
+/** Class representing an application on a smartcard or similar hardware token. */
 class Card
 {
 public:
     enum PinState {
         UnknownPinState,
         NullPin,
         PinBlocked,
         NoPin,
         PinOk,
 
         NumPinStates
     };
 
     enum Status {
         NoCard,
         CardPresent,
         CardActive,
         CardUsable,
 
         _NumScdStates,
 
         CardError = _NumScdStates,
 
         NumStates
     };
 
     Card();
-    virtual ~Card() {}
+    virtual ~Card();
 
-    virtual bool operator == (const Card& other) const;
-    bool operator != (const Card& other) const;
+    virtual bool operator == (const Card &other) const;
+    bool operator != (const Card &other) const;
 
     void setStatus(Status s);
     Status status() const;
 
     virtual void setSerialNumber(const std::string &sn);
     std::string serialNumber() const;
 
     std::string appName() const;
-    void setAppName(const std::string &name);
 
     void setAppVersion(int version);
     int appVersion() const;
 
     std::vector<PinState> pinStates() const;
     void setPinStates(const std::vector<PinState> &pinStates);
 
-    void setSlot(int slot);
-    int slot() const;
-
     bool hasNullPin() const;
     void setHasNullPin(bool value);
 
     bool canLearnKeys() const;
     void setCanLearnKeys(bool value);
 
     QString errorMsg() const;
     void setErrorMsg(const QString &msg);
 
+protected:
+    void setAppName(const std::string &name);
+
 private:
-    bool mCanLearn;
-    bool mHasNullPin;
-    Status mStatus;
+    bool mCanLearn = false;
+    bool mHasNullPin = false;
+    Status mStatus = NoCard;
     std::string mSerialNumber;
     std::string mAppName;
-    int mAppVersion;
+    int mAppVersion = -1;
     std::vector<PinState> mPinStates;
-    int mSlot;
     QString mErrMsg;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_CARD_H
diff --git a/src/smartcard/netkeycard.cpp b/src/smartcard/netkeycard.cpp
index ccccac2ae..2f749be85 100644
--- a/src/smartcard/netkeycard.cpp
+++ b/src/smartcard/netkeycard.cpp
@@ -1,109 +1,110 @@
 /*  smartcard/netkeycard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "netkeycard.h"
 
 #include "kleopatra_debug.h"
 
 #include <gpgme++/error.h>
 #include <gpgme++/context.h>
 #include <gpgme++/keylistresult.h>
 
 #include <memory>
 #include <string>
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string NetKeyCard::AppName = "nks";
 
 namespace
 {
 static std::string parse_keypairinfo(const std::string &kpi)
 {
     static const char hexchars[] = "0123456789abcdefABCDEF";
     return '&' + kpi.substr(0, kpi.find_first_not_of(hexchars));
 }
 
 static GpgME::Key parse_keypairinfo_and_lookup_key(GpgME::Context *ctx, const std::string &kpi)
 {
     if (!ctx) {
         return GpgME::Key();
     }
     const std::string pattern = parse_keypairinfo(kpi);
     qCDebug(KLEOPATRA_LOG) << "parse_keypairinfo_and_lookup_key: pattern=" << pattern.c_str();
     if (const auto err = ctx->startKeyListing(pattern.c_str())) {
         qCDebug(KLEOPATRA_LOG) << "parse_keypairinfo_and_lookup_key: startKeyListing failed:" << err.asString();
         return GpgME::Key();
     }
     GpgME::Error e;
     const auto key = ctx->nextKey(e);
     ctx->endKeyListing();
     qCDebug(KLEOPATRA_LOG) << "parse_keypairinfo_and_lookup_key: e=" << e.code() << "; key.isNull()" << key.isNull();
     return key;
 }
 
 } // namespace
 
-NetKeyCard::NetKeyCard()
+NetKeyCard::NetKeyCard(const Card &card)
+    : Card(card)
 {
     setAppName(AppName);
 }
 
 void NetKeyCard::setKeyPairInfo(const std::vector<std::string> &infos)
 {
     // check that any of the keys are new
     const std::unique_ptr<GpgME::Context> klc(GpgME::Context::createForProtocol(GpgME::CMS));
     if (!klc.get()) {
         return;
     }
     klc->setKeyListMode(GpgME::Ephemeral);
     klc->addKeyListMode(GpgME::Validate);
 
     setCanLearnKeys(false);
     mKeys.clear();
     for (const auto &info: infos) {
         const auto key = parse_keypairinfo_and_lookup_key(klc.get(), info);
         if (key.isNull()) {
             setCanLearnKeys(true);
         }
         mKeys.push_back(key);
     }
 }
 
 
 // State 0 -> NKS PIN Retry counter
 // State 1 -> NKS PUK Retry counter
 // State 2 -> SigG PIN Retry counter
 // State 3 -> SigG PUK Retry counter
 
 bool NetKeyCard::hasNKSNullPin() const
 {
     const auto states = pinStates();
     if (states.size() < 2) {
         qCWarning(KLEOPATRA_LOG) << "Invalid size of pin states:" << states.size();
         return false;
     }
     return states[0] == Card::NullPin;
 }
 
 bool NetKeyCard::hasSigGNullPin() const
 {
     const auto states = pinStates();
     if (states.size() < 4) {
         qCWarning(KLEOPATRA_LOG) << "Invalid size of pin states:" << states.size();
         return false;
     }
     return states[2] == Card::NullPin;
 }
 
 std::vector<GpgME::Key> NetKeyCard::keys() const
 {
     return mKeys;
 }
diff --git a/src/smartcard/netkeycard.h b/src/smartcard/netkeycard.h
index c850b8c85..09cc81c04 100644
--- a/src/smartcard/netkeycard.h
+++ b/src/smartcard/netkeycard.h
@@ -1,42 +1,42 @@
 #ifndef SMARTCARD_NETKEYCARD_H
 #define SMARTCARD_NETKEYCARD_H
 /*  smartcard/netkeycard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 
 #include "card.h"
 
 #include <gpgme++/key.h>
 
 namespace Kleo
 {
 namespace SmartCard
 {
 /** Class to work with NetKey smartcards or compatible tokens */
 class NetKeyCard: public Card
 {
 public:
-    NetKeyCard();
+    explicit NetKeyCard(const Card &card);
 
     static const std::string AppName;
 
     void setKeyPairInfo(const std::vector<std::string> &infos);
 
     bool hasSigGNullPin() const;
     bool hasNKSNullPin() const;
 
     std::vector <GpgME::Key> keys() const;
 
 private:
     std::vector <GpgME::Key> mKeys;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_CARD_H
 
diff --git a/src/smartcard/openpgpcard.cpp b/src/smartcard/openpgpcard.cpp
index 820ddb668..6c58983a4 100644
--- a/src/smartcard/openpgpcard.cpp
+++ b/src/smartcard/openpgpcard.cpp
@@ -1,199 +1,195 @@
 /*  smartcard/openpgpcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 /* Code in this file is partly based on the GNU Privacy Assistant
  * (cm-openpgp.c) git rev. 0a78795146661234070681737b3e08228616441f
  *
  * Whis is:
  * SPDX-FileCopyrightText: 2008, 2009 g 10 Code GmbH
  *
  * And may be licensed under the GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  */
 
 #include "openpgpcard.h"
 
 #include "kleopatra_debug.h"
 
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string OpenPGPCard::AppName = "openpgp";
 
-OpenPGPCard::OpenPGPCard()
+OpenPGPCard::OpenPGPCard(const Card &card)
+    : Card(card)
 {
     setAppName(AppName);
 }
 
-OpenPGPCard::OpenPGPCard(const std::string &serialno): OpenPGPCard()
-{
-    setSerialNumber(serialno);
-}
-
 // static
 std::string OpenPGPCard::pinKeyRef()
 {
     return std::string("OPENPGP.1");
 }
 
 // static
 std::string OpenPGPCard::adminPinKeyRef()
 {
     return std::string("OPENPGP.3");
 }
 
 // static
 std::string OpenPGPCard::resetCodeKeyRef()
 {
     return std::string("OPENPGP.2");
 }
 
 std::string OpenPGPCard::sigFpr() const
 {
     return mMetaInfo.value("SIGKEY-FPR");
 }
 
 std::string OpenPGPCard::encFpr() const
 {
     return mMetaInfo.value("ENCKEY-FPR");
 }
 
 std::string OpenPGPCard::authFpr() const
 {
     return mMetaInfo.value("AUTHKEY-FPR");
 }
 
 void OpenPGPCard::setKeyPairInfo(const std::vector< std::pair<std::string, std::string> > &infos)
 {
     qCDebug(KLEOPATRA_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(KLEOPATRA_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         if (pair.first == "KEY-FPR" ||
             pair.first == "KEY-TIME") {
             // Key fpr and key time need to be distinguished, the number
             // of the key decides the usage.
             const auto values = QString::fromStdString(pair.second).split(QLatin1Char(' '));
             if (values.size() < 2) {
                 qCWarning(KLEOPATRA_LOG) << "Invalid entry.";
                 setStatus(Card::CardError);
                 continue;
             }
             const auto usage = values[0];
             const auto fpr = values[1].toStdString();
             if (usage == QLatin1Char('1')) {
                 mMetaInfo.insert(std::string("SIG") + pair.first, fpr);
             } else if (usage == QLatin1Char('2')) {
                 mMetaInfo.insert(std::string("ENC") + pair.first, fpr);
             } else if (usage == QLatin1Char('3')) {
                 mMetaInfo.insert(std::string("AUTH") + pair.first, fpr);
             } else {
                 // Maybe more keyslots in the future?
                 qCDebug(KLEOPATRA_LOG) << "Unhandled keyslot";
             }
         } else if (pair.first == "KEYPAIRINFO") {
             // Fun, same as above but the other way around.
             const auto values = QString::fromStdString(pair.second).split(QLatin1Char(' '));
             if (values.size() < 2) {
                 qCWarning(KLEOPATRA_LOG) << "Invalid entry.";
                 setStatus(Card::CardError);
                 continue;
             }
             const auto usage = values[1];
             const auto grip = values[0].toStdString();
             if (usage == QLatin1String("OPENPGP.1")) {
                 mMetaInfo.insert(std::string("SIG") + pair.first, grip);
             } else if (usage == QLatin1String("OPENPGP.2")) {
                 mMetaInfo.insert(std::string("ENC") + pair.first, grip);
             } else if (usage == QLatin1String("OPENPGP.3")) {
                 mMetaInfo.insert(std::string("AUTH") + pair.first, grip);
             } else {
                 // Maybe more keyslots in the future?
                 qCDebug(KLEOPATRA_LOG) << "Unhandled keyslot";
             }
         } else {
             mMetaInfo.insert(pair.first, pair.second);
         }
     }
 }
 
 void OpenPGPCard::setSerialNumber(const std::string &serialno)
 {
     char version_buffer[6];
     const char *version = "";
 
     Card::setSerialNumber(serialno);
     const bool isProperOpenPGPCardSerialNumber =
         serialno.size() == 32 && serialno.substr(0, 12) == "D27600012401";
     if (isProperOpenPGPCardSerialNumber) {
         /* Reformat the version number to be better human readable.  */
         const char *string = serialno.c_str();
         char *p = version_buffer;
         if (string[12] != '0') {
             *p++ = string[12];
         }
         *p++ = string[13];
         *p++ = '.';
         if (string[14] != '0') {
             *p++ = string[14];
         }
         *p++ = string[15];
         *p++ = '\0';
         version = version_buffer;
     }
 
     mIsV2 = !((*version == '1' || *version == '0') && version[1] == '.');
     mCardVersion = version;
 }
 
 bool OpenPGPCard::operator == (const Card& rhs) const
 {
     const OpenPGPCard *other = dynamic_cast<const OpenPGPCard *>(&rhs);
     if (!other) {
         return false;
     }
 
     return Card::operator ==(rhs)
         && sigFpr() == other->sigFpr()
         && encFpr() == other->encFpr()
         && authFpr() == other->authFpr()
         && manufacturer() == other->manufacturer()
         && cardVersion() == other->cardVersion()
         && cardHolder() == other->cardHolder()
         && pubkeyUrl() == other->pubkeyUrl();
 }
 
 void OpenPGPCard::setManufacturer(const std::string &manufacturer)
 {
     mManufacturer = manufacturer;
 }
 
 std::string OpenPGPCard::manufacturer() const
 {
     return mManufacturer;
 }
 
 std::string OpenPGPCard::cardVersion() const
 {
     return mCardVersion;
 }
 
 std::string OpenPGPCard::cardHolder() const
 {
     auto list = QString::fromStdString(mMetaInfo.value("DISP-NAME")).split(QStringLiteral("<<"));
     std::reverse(list.begin(), list.end());
     return list.join(QLatin1Char(' ')).toStdString();
 }
 
 std::string OpenPGPCard::pubkeyUrl() const
 {
     return mMetaInfo.value("PUBKEY-URL");
 }
diff --git a/src/smartcard/openpgpcard.h b/src/smartcard/openpgpcard.h
index 56cb8fa11..54d561289 100644
--- a/src/smartcard/openpgpcard.h
+++ b/src/smartcard/openpgpcard.h
@@ -1,59 +1,58 @@
 #ifndef SMARTCARD_OPENPGPCARD_H
 #define SMARTCARD_OPENPGPCARD_H
 /*  smartcard/openpgpcard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <QMap>
 
 #include "card.h"
 
 namespace Kleo
 {
 namespace SmartCard
 {
 /** Class to work with OpenPGP smartcards or compatible tokens */
 class OpenPGPCard: public Card
 {
 public:
-    OpenPGPCard();
-    OpenPGPCard(const std::string &serialno);
+    explicit OpenPGPCard(const Card &card);
 
     static const std::string AppName;
 
     static std::string pinKeyRef();
     static std::string adminPinKeyRef();
     static std::string resetCodeKeyRef();
 
     void setSerialNumber(const std::string &sn) override;
 
     std::string encFpr() const;
     std::string sigFpr() const;
     std::string authFpr() const;
 
     void setKeyPairInfo (const std::vector< std::pair<std::string, std::string> > &infos);
 
     bool operator == (const Card& other) const override;
 
     void setManufacturer(const std::string &manufacturer);
     std::string manufacturer() const;
 
     std::string cardVersion() const;
     std::string cardHolder() const;
     std::string pubkeyUrl() const;
 private:
     bool mIsV2 = false;
     std::string mCardVersion;
     QMap <std::string, std::string> mMetaInfo;
     std::string mManufacturer;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_CARD_H
 
diff --git a/src/smartcard/pivcard.cpp b/src/smartcard/pivcard.cpp
index 5e56c85bd..893cfb2fc 100644
--- a/src/smartcard/pivcard.cpp
+++ b/src/smartcard/pivcard.cpp
@@ -1,195 +1,191 @@
 /*  smartcard/pivcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "pivcard.h"
 
 #include "keypairinfo.h"
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string PIVCard::AppName = "piv";
 
-PIVCard::PIVCard()
+PIVCard::PIVCard(const Card &card)
+    : Card(card)
 {
     setAppName(AppName);
 }
 
-PIVCard::PIVCard(const std::string &serialno): PIVCard()
-{
-    setSerialNumber(serialno);
-}
-
 // static
 std::string PIVCard::pivAuthenticationKeyRef()
 {
     return std::string("PIV.9A");
 }
 
 // static
 std::string PIVCard::cardAuthenticationKeyRef()
 {
     return std::string("PIV.9E");
 }
 
 // static
 std::string PIVCard::digitalSignatureKeyRef()
 {
     return std::string("PIV.9C");
 }
 
 // static
 std::string PIVCard::keyManagementKeyRef()
 {
     return std::string("PIV.9D");
 }
 
 // static
 std::string PIVCard::pinKeyRef()
 {
     return std::string("PIV.80");
 }
 
 // static
 std::string PIVCard::pukKeyRef()
 {
     return std::string("PIV.81");
 }
 
 // static
 const std::vector<std::string> & PIVCard::supportedKeys()
 {
     static const std::vector<std::string> keyRefs = {
         PIVCard::pivAuthenticationKeyRef(),
         PIVCard::cardAuthenticationKeyRef(),
         PIVCard::digitalSignatureKeyRef(),
         PIVCard::keyManagementKeyRef()
     };
 
     return keyRefs;
 }
 
 // static
 QString PIVCard::keyDisplayName(const std::string &keyRef)
 {
     static const QMap<std::string, QString> displayNames = {
         { PIVCard::pivAuthenticationKeyRef(), i18n("PIV Authentication Key") },
         { PIVCard::cardAuthenticationKeyRef(), i18n("Card Authentication Key") },
         { PIVCard::digitalSignatureKeyRef(), i18n("Digital Signature Key") },
         { PIVCard::keyManagementKeyRef(), i18n("Key Management Key") },
     };
 
     return displayNames.value(keyRef);
 }
 
 // static
 std::vector< std::pair<std::string, QString> > PIVCard::supportedAlgorithms(const std::string &keyRef)
 {
     if (keyRef == PIVCard::keyManagementKeyRef()) {
         return {
             { "rsa2048", i18n("RSA key transport (2048 bits)") },
             { "nistp256", i18n("ECDH (Curve P-256)") },
             { "nistp384", i18n("ECDH (Curve P-384)") }
         };
     } else if (keyRef == PIVCard::digitalSignatureKeyRef()) {
         return {
             { "rsa2048", i18n("RSA (2048 bits)") },
             { "nistp256", i18n("ECDSA (Curve P-256)") },
             { "nistp384", i18n("ECDSA (Curve P-384)") }
         };
     }
 
     // NIST SP 800-78-4 does not allow Curve P-384 for PIV Authentication key or Card Authentication key
     return {
         { "rsa2048", i18n("RSA (2048 bits)") },
         { "nistp256", i18n("ECDSA (Curve P-256)") },
     };
 }
 
 std::string PIVCard::keyGrip(const std::string& keyRef) const
 {
     return mMetaInfo.value("KEYPAIRINFO-" + keyRef);
 }
 
 namespace {
 static int parseAppVersion(const std::string &s) {
     // s is a hex-encoded, unsigned int-packed version tuple
     bool ok;
     const auto appVersion = QByteArray::fromStdString(s).toUInt(&ok, 16);
     return ok ? appVersion : -1;
 }
 }
 
 void PIVCard::setCardInfo(const std::vector< std::pair<std::string, std::string> > &infos)
 {
     qCDebug(KLEOPATRA_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(KLEOPATRA_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         if (pair.first == "APPVERSION") {
             setAppVersion(parseAppVersion(pair.second));
         } else 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);
                 setStatus(Card::CardError);
                 continue;
             }
             mMetaInfo.insert("KEYPAIRINFO-" + info.keyRef, info.grip);
         } else {
             mMetaInfo.insert(pair.first, pair.second);
         }
     }
 }
 
 std::string PIVCard::displaySerialNumber() const
 {
     return mDisplaySerialNumber;
 }
 
 void PIVCard::setDisplaySerialNumber(const std::string &serialno)
 {
     mDisplaySerialNumber = serialno;
 }
 
 std::string PIVCard::keyAlgorithm(const std::string &keyRef) const
 {
     return mMetaInfo.value("KLEO-KEYALGO-" + keyRef);
 }
 
 void PIVCard::setKeyAlgorithm(const std::string &keyRef, const std::string &algorithm)
 {
     mMetaInfo.insert("KLEO-KEYALGO-" + keyRef, algorithm);
 }
 
 std::string PIVCard::certificateData(const std::string &keyRef) const
 {
     return mMetaInfo.value("KLEO-CERTIFICATE-" + keyRef);
 }
 
 void PIVCard::setCertificateData(const std::string &keyRef, const std::string &data)
 {
     mMetaInfo.insert("KLEO-CERTIFICATE-" + keyRef, data);
 }
 
 bool PIVCard::operator == (const Card& rhs) const
 {
     const PIVCard *other = dynamic_cast<const PIVCard *>(&rhs);
     if (!other) {
         return false;
     }
 
     return Card::operator ==(rhs)
         && mMetaInfo == other->mMetaInfo;
 }
diff --git a/src/smartcard/pivcard.h b/src/smartcard/pivcard.h
index 0e44b3e02..3b4461410 100644
--- a/src/smartcard/pivcard.h
+++ b/src/smartcard/pivcard.h
@@ -1,63 +1,62 @@
 /*  smartcard/pivcard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #ifndef SMARTCARD_PIVCARD_H
 #define SMARTCARD_PIVCARD_H
 
 #include "card.h"
 
 #include <QMap>
 
 namespace Kleo
 {
 namespace SmartCard
 {
 /** Class to work with PIV smartcards or compatible tokens */
 class PIVCard: public Card
 {
 public:
-    PIVCard();
-    PIVCard(const std::string &serialno);
+    explicit PIVCard(const Card &card);
 
     static const std::string AppName;
 
     static std::string pivAuthenticationKeyRef();
     static std::string cardAuthenticationKeyRef();
     static std::string digitalSignatureKeyRef();
     static std::string keyManagementKeyRef();
 
     static std::string pinKeyRef();
     static std::string pukKeyRef();
 
     static const std::vector<std::string> & supportedKeys();
     static QString keyDisplayName(const std::string &keyRef);
     static std::vector< std::pair<std::string, QString> > supportedAlgorithms(const std::string &keyRef);
 
     std::string keyGrip(const std::string &keyRef) const;
 
     void setCardInfo (const std::vector< std::pair<std::string, std::string> > &infos);
 
     std::string displaySerialNumber() const;
     void setDisplaySerialNumber(const std::string &sn);
 
     std::string keyAlgorithm(const std::string &keyRef) const;
     void setKeyAlgorithm(const std::string &keyRef, const std::string &algorithm);
 
     std::string certificateData(const std::string &keyRef) const;
     void setCertificateData(const std::string &keyRef, const std::string &data);
 
     bool operator == (const Card& other) const override;
 
 private:
     std::string mDisplaySerialNumber;
     QMap <std::string, std::string> mMetaInfo;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_PIVCARD_H
diff --git a/src/smartcard/readerstatus.cpp b/src/smartcard/readerstatus.cpp
index b5d943370..3b73b5d6b 100644
--- a/src/smartcard/readerstatus.cpp
+++ b/src/smartcard/readerstatus.cpp
@@ -1,941 +1,937 @@
 /* -*- 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, "");
 
 Q_DECLARE_METATYPE(GpgME::Error)
 
 namespace
 {
 static QDebug operator<<(QDebug s, const std::string &string)
 {
     return s << QString::fromStdString(string);
 }
 
 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 << ')';
 }
 
 struct CardApp {
     std::string serialNumber;
     std::string appName;
 };
 
 static void logUnexpectedStatusLine(const std::pair<std::string, std::string> &line,
                                     const std::string &prefix = std::string(),
                                     const std::string &command = std::string())
 {
     qCWarning(KLEOPATRA_LOG) << (!prefix.empty() ? QString::fromStdString(prefix + ": ") : QString())
             << "Unexpected status line"
             << (!command.empty() ? QString::fromStdString(" on " + command + ":") : QLatin1String(":"))
             << QString::fromStdString(line.first)
             << QString::fromStdString(line.second);
 }
 
 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 std::vector<CardApp> getCardsAndApps(std::shared_ptr<Context> &gpgAgent, Error &err)
 {
     std::vector<CardApp> result;
     const std::string command = "SCD GETINFO all_active_apps";
     const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
     if (err) {
         return result;
     }
     for (const auto &statusLine: statusLines) {
         if (statusLine.first == "SERIALNO") {
             const auto serialNumberAndApps = QByteArray::fromStdString(statusLine.second).split(' ');
             if (serialNumberAndApps.size() >= 2) {
                 const auto serialNumber = serialNumberAndApps[0];
                 auto apps = serialNumberAndApps.mid(1);
                 // sort the apps to get a stable order independently of the currently selected application
                 std::sort(apps.begin(), apps.end());
                 for (const auto &app: apps) {
                     qCDebug(KLEOPATRA_LOG) << "getCardsAndApps(): Found card" << serialNumber << "with app" << app;
                     result.push_back({ serialNumber.toStdString(), app.toStdString() });
                 }
             } else {
                 logUnexpectedStatusLine(statusLine, "getCardsAndApps()", command);
             }
         } else {
             logUnexpectedStatusLine(statusLine, "getCardsAndApps()", command);
         }
     }
     return result;
 }
 
 static std::string switchCard(std::shared_ptr<Context> &gpgAgent, const std::string &serialNumber, Error &err)
 {
     const std::string command = "SCD SWITCHCARD " + serialNumber;
     const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
     if (err) {
         return std::string();
     }
     if (statusLines.size() == 1 && statusLines[0].first == "SERIALNO" && statusLines[0].second == serialNumber) {
         return serialNumber;
     }
     qCWarning(KLEOPATRA_LOG) << "switchCard():" << command << "returned" << statusLines
             << "(expected:" << "SERIALNO " + serialNumber << ")";
     return std::string();
 }
 
 static std::string switchApp(std::shared_ptr<Context> &gpgAgent, const std::string &serialNumber,
                              const std::string &appName, Error &err)
 {
     const std::string command = "SCD SWITCHAPP " + appName;
     const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
     if (err) {
         return std::string();
     }
     if (statusLines.size() == 1 && statusLines[0].first == "SERIALNO" &&
         statusLines[0].second.find(serialNumber + ' ' + appName) == 0) {
         return appName;
     }
     qCWarning(KLEOPATRA_LOG) << "switchApp():" << command << "returned" << statusLines
             << "(expected:" << "SERIALNO " + serialNumber + ' ' + appName + "..." << ")";
     return std::string();
 }
 
 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());
+    auto pgpCard = new OpenPGPCard(*ci);
 
-    ret->setManufacturer(get_manufacturer(gpg_agent, err));
+    pgpCard->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()));
+        pgpCard->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);
+    pgpCard->setKeyPairInfo(info);
+    ci.reset(pgpCard);
 }
 
 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 {
             logUnexpectedStatusLine(pair, "readKeyPairInfoFromPIVCard()", command);
         }
     }
 }
 
 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());
+    auto pivCard = new PIVCard(*ci);
 
     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());
+    auto nkCard = new NetKeyCard(*ci);
     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(const std::string &serialNumber, const std::string &appName, std::shared_ptr<Context> &gpg_agent)
 {
     qCDebug(KLEOPATRA_LOG) << "get_card_status(" << serialNumber << ',' << appName << ',' << gpg_agent.get() << ')';
     auto ci = std::shared_ptr<Card>(new Card());
 
     // select card
     {
         Error err;
         const auto result = switchCard(gpg_agent, serialNumber, err);
         if (err) {
             if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
                 ci->setStatus(Card::NoCard);
             } else {
                 ci->setStatus(Card::CardError);
             }
             return ci;
         }
         if (result.empty()) {
             qCWarning(KLEOPATRA_LOG) << "get_card_status: switching card failed";
             ci->setStatus(Card::CardError);
             return ci;
         }
         ci->setStatus(Card::CardPresent);
     }
 
     // select app
     {
         Error err;
         const auto result = switchApp(gpg_agent, serialNumber, appName, err);
         if (err) {
             if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
                 ci->setStatus(Card::NoCard);
             } else {
                 ci->setStatus(Card::CardError);
             }
             return ci;
         }
         if (result.empty()) {
             qCWarning(KLEOPATRA_LOG) << "get_card_status: switching app failed";
             ci->setStatus(Card::CardError);
             return ci;
         }
     }
 
     ci->setSerialNumber(serialNumber);
-    ci->setAppName(appName);
 
     // Handle different card types
-    if (ci->appName() == NetKeyCard::AppName) {
+    if (appName == NetKeyCard::AppName) {
         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->appName() == OpenPGPCard::AppName) {
+    } else if (appName == OpenPGPCard::AppName) {
         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->appName() == PIVCard::AppName) {
+    } else if (appName == PIVCard::AppName) {
         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:" << appName;
         return ci;
     }
 
     return ci;
 }
 
 static std::vector<std::shared_ptr<Card> > update_cardinfo(std::shared_ptr<Context> &gpgAgent)
 {
     qCDebug(KLEOPATRA_LOG) << "update_cardinfo()";
 
     // ensure that a card is present and that all cards are properly set up
     {
         Error err;
         const std::string serialno = gpgagent_status(gpgAgent, "SCD SERIALNO --all", err);
         if (err) {
             auto ci = std::shared_ptr<Card>(new Card());
             if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
                 ci->setStatus(Card::NoCard);
             } else {
                 ci->setStatus(Card::CardError);
             }
             return std::vector<std::shared_ptr<Card> >(1, ci);
         }
     }
 
     Error err;
     const std::vector<CardApp> cardApps = getCardsAndApps(gpgAgent, err);
     if (err) {
         auto ci = std::shared_ptr<Card>(new Card());
         if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
             ci->setStatus(Card::NoCard);
         } else {
             ci->setStatus(Card::CardError);
         }
         return std::vector<std::shared_ptr<Card> >(1, ci);
     }
 
     std::vector<std::shared_ptr<Card> > cards;
     for (const auto &cardApp: cardApps) {
         const auto card = get_card_status(cardApp.serialNumber, cardApp.appName, gpgAgent);
         cards.push_back(card);
     }
     return cards;
 }
 } // namespace
 
 struct Transaction {
     CardApp cardApp;
     QByteArray command;
     QPointer<QObject> receiver;
     const char *slot;
     AssuanTransaction* assuanTransaction;
 };
 
 static const Transaction updateTransaction = { { "__all__", "__all__" }, "__update__", nullptr, nullptr, nullptr };
 static const Transaction quitTransaction   = { { "__all__", "__all__" }, "__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 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;
 
             CardApp cardApp;
             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:
                 cardApp = item.front().cardApp;
                 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);
 
                 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;
                 std::string firstCardWithNullPin;
                 bool anyError = false;
                 while (nit != nend || oit != oend) {
                     const Card *optr = oit != oend ? (*oit).get() : nullptr;
                     const Card *nptr = nit != nend ? (*nit).get() : nullptr;
                     if ((optr && !nptr) || (!optr && nptr) || (optr && nptr && *optr != *nptr)) {
                         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: slot" << idx << ": card Changed";
                         Q_EMIT cardChanged(idx);
                     }
                     if (nptr) {
                         if (nptr->canLearnKeys()) {
                             anyLC = true;
                         }
                         if (nptr->hasNullPin() && firstCardWithNullPin.empty()) {
                             firstCardWithNullPin = (*nit)->serialNumber();
                         }
                         if (nptr->status() == Card::CardError) {
                             anyError = true;
                         }
                     }
                     if (nit != nend) {
                         ++nit;
                     }
                     if (oit != oend) {
                         ++oit;
                     }
                     ++idx;
                 }
 
                 Q_EMIT firstCardWithNullPinChanged(firstCardWithNullPin);
                 Q_EMIT anyCardCanLearnKeysChanged(anyLC);
 
                 if (anyError) {
                     gpgAgent.reset();
                 }
             } else {
                 GpgME::Error err;
                 switchCard(gpgAgent, cardApp.serialNumber, err);
                 if (!err) {
                     switchApp(gpgAgent, cardApp.serialNumber, cardApp.appName, err);
                 }
                 if (!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::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:
     std::string firstCardWithNullPinImpl() const
     {
         const auto cis = cardInfos();
         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);
 }
 
 std::string ReaderStatus::firstCardWithNullPin() const
 {
     return d->firstCardWithNullPinImpl();
 }
 
 bool ReaderStatus::anyCardCanLearnKeys() const
 {
     return d->anyCardCanLearnKeysImpl();
 }
 
 void ReaderStatus::startSimpleTransaction(const std::shared_ptr<Card> &card, const QByteArray &command, QObject *receiver, const char *slot)
 {
     const CardApp cardApp = { card->serialNumber(), card->appName() };
     const Transaction t = { cardApp, command, receiver, slot, nullptr };
     d->addTransaction(t);
 }
 
 void ReaderStatus::startTransaction(const std::shared_ptr<Card> &card, const QByteArray &command, QObject *receiver, const char *slot,
                                     std::unique_ptr<AssuanTransaction> transaction)
 {
     const CardApp cardApp = { card->serialNumber(), card->appName() };
     const Transaction t = { cardApp, 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"