test

Signed-off-by: Raul Metsma <raul@metsma.ee>

Author: metsma

lib/libelectronic-id

@@ -44,12 +44,12 @@ namespace
 // Use common base64-encoding defaults.
 constexpr auto BASE64_OPTIONS = QByteArray::Base64Encoding | QByteArray::KeepTrailingEquals;
 
-QVariantMap createAuthenticationToken(const QString& signatureAlgorithm,
+QVariantMap createAuthenticationToken(QByteArrayView signatureAlgorithm,
                                       const QByteArray& certificateDer, const QByteArray& signature)
 {
     return QVariantMap {
         {"unverifiedCertificate", QString(certificateDer.toBase64(BASE64_OPTIONS))},
-        {"algorithm", signatureAlgorithm},
+        {"algorithm", QLatin1String(signatureAlgorithm)},
         {"signature", QString(signature)},
         {"format", QStringLiteral("web-eid:1.0")},
         {"appVersion",
@@ -123,8 +123,7 @@ QVariantMap Authenticate::onConfirm(WebEidUI* window,
                                     const EidCertificateAndPinInfo& certAndPinInfo)
 {
     try {
-        const auto signatureAlgorithm =
-            QString::fromStdString(certAndPinInfo.eid->authSignatureAlgorithm());
+        const std::string_view signatureAlgorithm = certAndPinInfo.eid->authSignatureAlgorithm();
         pcsc_cpp::byte_vector pin;
         // Reserve space for APDU overhead (5 bytes) + PIN padding (16 bytes) to prevent PIN memory
         // reallocation. The 16-byte limit comes from the max PIN length of 12 bytes across all card
@@ -145,7 +144,7 @@ QVariantMap Authenticate::onConfirm(WebEidUI* window,
             emit retry(RetriableError::PIN_VERIFY_DISABLED);
             break;
         default:
-            emit verifyPinFailed(failure.status(), failure.retries());
+            emit verifyPinFailed(failure.status(), failure.retries(), certAndPinInfo.eid);
         }
         if (failure.retries() > 0) {
             throw CommandHandlerVerifyPinFailed(failure.what());

src/controller/command-handlers/authenticate.cpp

@@ -117,7 +117,7 @@ QVariantMap Sign::onConfirm(WebEidUI* window, const EidCertificateAndPinInfo& ce
             emit retry(RetriableError::PIN_VERIFY_DISABLED);
             break;
         default:
-            emit verifyPinFailed(failure.status(), failure.retries());
+            emit verifyPinFailed(failure.status(), failure.retries(), certAndPinInfo.eid);
         }
         // Retries > 0 means that there are retries remaining,
         // < 0 means that retry count is unknown, == 0 means that the PIN is blocked.

src/controller/command-handlers/sign.cpp

@@ -45,7 +45,8 @@ class CommandHandler : public QObject
     void multipleCertificatesReady(const QUrl& origin,
                                    const std::vector<EidCertificateAndPinInfo>& certAndPinInfos);
     void singleCertificateReady(const QUrl& origin, const EidCertificateAndPinInfo& certAndPinInfo);
-    void verifyPinFailed(electronic_id::VerifyPinFailed::Status status, qint8 retriesLeft);
+    void verifyPinFailed(electronic_id::VerifyPinFailed::Status status, qint8 retriesLeft,
+                         electronic_id::ElectronicID::ptr eid);
 
 protected:
     CommandHandler(const CommandWithArguments& cmd) : command(cmd) {}

src/controller/commandhandler.hpp

@@ -113,11 +113,22 @@ void Controller::startCommandExecution()
     // When the command handler run thread retrieves certificates successfully, call
     // onCertificatesLoaded() that starts card event monitoring while user enters the PIN.
     connect(commandHandler.get(), &CommandHandler::singleCertificateReady, this,
-            &Controller::onCertificatesLoaded);
+            [this](const QUrl&, const EidCertificateAndPinInfo& info) {
+                onCertificatesLoaded({info.eid},
+                                     commandType() != CommandType::SIGN);
+            });
     connect(commandHandler.get(), &CommandHandler::multipleCertificatesReady, this,
-            &Controller::onCertificatesLoaded);
+            [this](const QUrl&, const std::vector<EidCertificateAndPinInfo>& infos) {
+                std::vector<ElectronicID::ptr> eids;
+                eids.reserve(infos.size());
+                for (const auto& info : infos) {
+                    eids.push_back(info.eid);
+                }
+                onCertificatesLoaded(std::move(eids), true);
+            });
+    // verifyPinFailed restarts monitoring for the selected card.
     connect(commandHandler.get(), &CommandHandler::verifyPinFailed, this,
-            &Controller::onCertificatesLoaded);
+            [this](auto, auto, ElectronicID::ptr eid) { onCertificatesLoaded({std::move(eid)}); });
 
     // UI setup.
     createWindow();
@@ -167,11 +178,13 @@ try {
     onCriticalFailure(error.what());
 }
 
-void Controller::onCertificatesLoaded() noexcept
+void Controller::onCertificatesLoaded(std::vector<ElectronicID::ptr> eids,
+                                      bool watchPnpNotifications) noexcept
 try {
-    auto* cardEventMonitorThread = new CardEventMonitorThread(this, commandType());
+    auto* cardEventMonitorThread =
+        new CardEventMonitorThread(this, commandType(), std::move(eids), watchPnpNotifications);
     connect(this, &Controller::stopCardEventMonitorThread, cardEventMonitorThread,
-            &CardEventMonitorThread::requestInterruption);
+            &CardEventMonitorThread::cancelWait);
     connect(cardEventMonitorThread, &ControllerChildThread::failure, this,
             &Controller::onCriticalFailure);
     connect(cardEventMonitorThread, &CardEventMonitorThread::cardEvent, this, &Controller::onRetry);
@@ -225,6 +238,8 @@ try {
     // Command handler signals are still connected, disconnect them so that they can be
     // reconnected during next execution.
     commandHandler->disconnect();
+    // Cancel any blocked card event monitors before waiting for threads to finish.
+    emit stopCardEventMonitorThread();
     // Before restarting, wait until child threads finish.
     waitForChildThreads();
 

src/controller/controller.cpp

@@ -50,7 +50,8 @@ class Controller : public QObject
     onCardsAvailable(const std::vector<electronic_id::ElectronicID::ptr>& availableEids) noexcept;
 
     // Called when CommandHandlerRunThread finishes execution.
-    void onCertificatesLoaded() noexcept;
+    void onCertificatesLoaded(std::vector<electronic_id::ElectronicID::ptr> eids,
+                              bool watchPnpNotifications = false) noexcept;
 
     // Called either directly from onDialogOK().
     void onConfirmCommandHandler(const EidCertificateAndPinInfo& certAndPinInfo) noexcept;

src/controller/controller.hpp

@@ -24,55 +24,37 @@
 
 #include "controllerchildthread.hpp"
 
+#include "utils/utils.hpp"
+
 class CardEventMonitorThread : public ControllerChildThread
 {
     Q_OBJECT
 
 public:
     using eid_ptr = electronic_id::ElectronicID::ptr;
-    using eid_ptr_vector = std::vector<electronic_id::ElectronicID::ptr>;
+    using eid_ptr_vector = std::vector<eid_ptr>;
 
-    CardEventMonitorThread(QObject* parent, CommandType commandType) :
-        ControllerChildThread(commandType, parent)
+    CardEventMonitorThread(QObject* parent, CommandType commandType, eid_ptr_vector eids,
+                           bool watchPnpNotifications = false) :
+        ControllerChildThread(commandType, parent), eids(std::move(eids)),
+        monitor(makeMonitor(this->eids, watchPnpNotifications))
     {
     }
 
-    void run() override
+    void cancelWait()
     {
-        QMutexLocker lock {&controllerChildThreadMutex};
+        requestInterruption();
+        monitor.cancel();
+    }
 
+    void run() override
+    {
         qDebug() << "Starting" << metaObject()->className() << uintptr_t(this) << "for command"
                  << commandType();
 
-        auto initialCards = getSupportedCardsIgnoringExceptions();
-        sortByReaderNameAndAtr(initialCards);
-
-        while (!isInterruptionRequested()) {
-            using namespace std::chrono_literals;
-            waitForControllerNotify.wait(&controllerChildThreadMutex, 1s);
-
-            eid_ptr_vector updatedCards {};
-
-            try {
-                updatedCards = electronic_id::availableSupportedCards();
-                sortByReaderNameAndAtr(updatedCards);
-            } catch (const std::exception& error) {
-                // Ignore smart card layer errors, they will be handled during next card operation.
-                qWarning() << metaObject()->className() << "ignoring" << commandType()
-                           << "error:" << error;
-            }
-
-            // If interruption was requested during wait, exit without emitting.
-            if (isInterruptionRequested()) {
-                return;
-            }
-
-            // If there was a change in connected supported cards, exit after emitting a card event.
-            if (!areEqualByReaderNameAndAtr(initialCards, updatedCards)) {
-                qDebug() << metaObject()->className() << "card change detected";
-                emit cardEvent();
-                return;
-            }
+        if (monitor.wait() && !isInterruptionRequested()) {
+            qDebug() << metaObject()->className() << "card change detected";
+            emit cardEvent();
         }
     }
 
@@ -82,42 +64,21 @@ class CardEventMonitorThread : public ControllerChildThread
 private:
     void doRun() override
     {
-        // Unused as run() has been overriden.
+        // Unused as run() has been overridden.
     }
 
-    eid_ptr_vector getSupportedCardsIgnoringExceptions()
+    static pcsc_cpp::CardEventMonitor makeMonitor(const eid_ptr_vector& eids,
+                                                   bool watchPnpNotifications)
     {
-        while (!isInterruptionRequested()) {
-            try {
-                return electronic_id::availableSupportedCards();
-            } catch (const std::exception& error) {
-                // Ignore smart card layer errors, they will be handled during next card operation.
-                qWarning() << metaObject()->className() << "ignoring" << commandType()
-                           << "error:" << error;
-            }
-            using namespace std::chrono_literals;
-            waitForControllerNotify.wait(&controllerChildThreadMutex, 1s);
+        REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(eids)
+        std::vector<std::reference_wrapper<const pcsc_cpp::SmartCard>> cards;
+        cards.reserve(eids.size());
+        for (const auto& eid : eids) {
+            cards.push_back(eid->smartcard());
         }
-        // Interruption was requested, return empty list.
-        return {};
+        return pcsc_cpp::CardEventMonitor(std::move(cards), watchPnpNotifications);
     }
 
-    static void sortByReaderNameAndAtr(eid_ptr_vector& a)
-    {
-        std::sort(a.begin(), a.end(), [](const eid_ptr& c1, const eid_ptr& c2) {
-            if (c1->smartcard().readerName() != c2->smartcard().readerName()) {
-                return c1->smartcard().readerName() < c2->smartcard().readerName();
-            }
-            return c1->smartcard().atr() < c2->smartcard().atr();
-        });
-    }
-
-    static bool areEqualByReaderNameAndAtr(const eid_ptr_vector& a, const eid_ptr_vector& b)
-    {
-        return std::equal(a.cbegin(), a.cend(), b.cbegin(), b.cend(),
-                          [](const eid_ptr& c1, const eid_ptr& c2) {
-                              return c1->smartcard().readerName() == c2->smartcard().readerName()
-                                  && c1->smartcard().atr() == c2->smartcard().atr();
-                          });
-    }
+    eid_ptr_vector eids;
+    pcsc_cpp::CardEventMonitor monitor;
 };