smartcard 3.7.0 → 3.7.2

package/README.md

@@ -517,3 +517,4 @@ MIT
 ## Related Projects
 
 - [nfc-pcsc](https://www.npmjs.com/package/nfc-pcsc) - NFC library built on smartcard
+- [emv](https://github.com/tomkp/emv) - Interactive EMV chip card explorer built on smartcard. Features a terminal UI for discovering payment applications, reading card data, verifying PINs, and exploring EMV tag structures. Supports GET PROCESSING OPTIONS, application cryptogram generation (ARQC/TC), and Dynamic Data Authentication (DDA).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smartcard",
-    "version": "3.7.0",
+    "version": "3.7.2",
     "description": "PC/SC bindings for Node.js using N-API - ABI stable across Node.js versions",
     "author": "Tom KP",
     "license": "MIT",

package/src/reader_monitor.cpp

@@ -1,9 +1,14 @@
 #include "reader_monitor.h"
 #include "pcsc_errors.h"
 #include <cstring>
+#include <unordered_map>
+#include <memory>
 
 Napi::FunctionReference ReaderMonitor::constructor;
 
+// Number of iterations between forced full state refreshes (Windows reliability fix)
+static const int STATE_REFRESH_INTERVAL = 10;
+
 // Event data passed from worker thread to JS thread
 struct EventData {
     std::string eventType;
@@ -123,7 +128,7 @@ Napi::Value ReaderMonitor::Stop(const Napi::CallbackInfo& info) {
         context_ = 0;
     }
 
-    readers_.clear();
+    readerStates_.clear();
 
     return env.Undefined();
 }
@@ -139,28 +144,84 @@ void ReaderMonitor::MonitorLoop() {
     // Emit reader-attached events for all pre-existing readers (Issue #30)
     {
         std::lock_guard<std::mutex> lock(mutex_);
-        for (const auto& reader : readers_) {
-            EmitEvent("reader-attached", reader.name, reader.lastState, reader.atr);
+        for (const auto& pair : readerStates_) {
+            EmitEvent("reader-attached", pair.first, pair.second.lastState, pair.second.atr);
         }
     }
 
     // Build initial states array with PnP notification
     std::vector<SCARD_READERSTATE> states;
     std::vector<std::string> readerNames;
+    int iterationCount = 0;
 
     while (running_) {
-        // Build states array
+        // Periodic full state refresh to handle Windows PC/SC state drift (Issue #111)
+        // This ensures we don't miss events if the state tracking gets out of sync
+        if (++iterationCount >= STATE_REFRESH_INTERVAL) {
+            iterationCount = 0;
+            std::lock_guard<std::mutex> lock(mutex_);
+
+            // Get fresh state for all readers
+            std::vector<SCARD_READERSTATE> refreshStates;
+            std::vector<std::string> refreshNames;
+
+            for (const auto& pair : readerStates_) {
+                refreshNames.push_back(pair.first);
+                SCARD_READERSTATE state = {};
+                state.szReader = refreshNames.back().c_str();
+                state.dwCurrentState = SCARD_STATE_UNAWARE;  // Force fresh state
+                refreshStates.push_back(state);
+            }
+
+            if (!refreshStates.empty()) {
+                LONG refreshResult = SCardGetStatusChange(context_, 0, refreshStates.data(), refreshStates.size());
+                if (refreshResult == SCARD_S_SUCCESS) {
+                    // Check for state divergence and emit missed events
+                    for (size_t i = 0; i < refreshStates.size(); i++) {
+                        const std::string& name = refreshNames[i];
+                        auto it = readerStates_.find(name);
+                        if (it != readerStates_.end()) {
+                            DWORD oldState = it->second.lastState;
+                            DWORD newState = refreshStates[i].dwEventState & ~SCARD_STATE_CHANGED;
+
+                            bool wasPresent = (oldState & SCARD_STATE_PRESENT) != 0;
+                            bool isPresent = (newState & SCARD_STATE_PRESENT) != 0;
+
+                            if (wasPresent != isPresent) {
+                                // State diverged - emit missed event
+                                std::vector<uint8_t> atr;
+                                if (refreshStates[i].cbAtr > 0) {
+                                    atr.assign(refreshStates[i].rgbAtr,
+                                              refreshStates[i].rgbAtr + refreshStates[i].cbAtr);
+                                }
+
+                                it->second.lastState = newState;
+                                it->second.atr = atr;
+
+                                if (isPresent) {
+                                    EmitEvent("card-inserted", name, newState, atr);
+                                } else {
+                                    EmitEvent("card-removed", name, newState, {});
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Build states array using reader names from our map
         {
             std::lock_guard<std::mutex> lock(mutex_);
             states.clear();
             readerNames.clear();
 
-            // Add known readers
-            for (auto& reader : readers_) {
+            // Add known readers - use the map for name-based lookup
+            for (const auto& pair : readerStates_) {
                 SCARD_READERSTATE state = {};
-                readerNames.push_back(reader.name);
+                readerNames.push_back(pair.first);
                 state.szReader = readerNames.back().c_str();
-                state.dwCurrentState = reader.lastState;
+                state.dwCurrentState = pair.second.lastState;
                 states.push_back(state);
             }
 
@@ -184,7 +245,61 @@ void ReaderMonitor::MonitorLoop() {
         }
 
         if (result == SCARD_E_TIMEOUT) {
-            // No changes, continue
+            // Timeout - query fresh state to detect missed events (Issue #111)
+            // On Windows, dwEventState after timeout may just mirror dwCurrentState
+            // rather than reflecting actual hardware state. We must explicitly
+            // query with SCARD_STATE_UNAWARE to get the real current state.
+            std::lock_guard<std::mutex> lock(mutex_);
+
+            if (readerStates_.empty()) {
+                continue;
+            }
+
+            // Build fresh state query for all readers
+            std::vector<SCARD_READERSTATE> freshStates;
+            std::vector<std::string> freshNames;
+
+            for (const auto& pair : readerStates_) {
+                freshNames.push_back(pair.first);
+                SCARD_READERSTATE state = {};
+                state.szReader = freshNames.back().c_str();
+                state.dwCurrentState = SCARD_STATE_UNAWARE;
+                freshStates.push_back(state);
+            }
+
+            LONG freshResult = SCardGetStatusChange(context_, 0, freshStates.data(), freshStates.size());
+            if (freshResult != SCARD_S_SUCCESS) {
+                continue;
+            }
+
+            for (size_t i = 0; i < freshStates.size(); i++) {
+                const std::string& name = freshNames[i];
+                auto it = readerStates_.find(name);
+                if (it != readerStates_.end()) {
+                    DWORD freshState = freshStates[i].dwEventState & ~SCARD_STATE_CHANGED;
+                    DWORD storedState = it->second.lastState;
+
+                    bool wasPresent = (storedState & SCARD_STATE_PRESENT) != 0;
+                    bool isPresent = (freshState & SCARD_STATE_PRESENT) != 0;
+
+                    if (wasPresent != isPresent) {
+                        std::vector<uint8_t> atr;
+                        if (freshStates[i].cbAtr > 0) {
+                            atr.assign(freshStates[i].rgbAtr,
+                                      freshStates[i].rgbAtr + freshStates[i].cbAtr);
+                        }
+
+                        it->second.lastState = freshState;
+                        it->second.atr = atr;
+
+                        if (isPresent) {
+                            EmitEvent("card-inserted", name, freshState, atr);
+                        } else {
+                            EmitEvent("card-removed", name, freshState, {});
+                        }
+                    }
+                }
+            }
             continue;
         }
 
@@ -195,8 +310,9 @@ void ReaderMonitor::MonitorLoop() {
             continue;
         }
 
-        // Process changes
+        // Process changes - use reader name for lookup (Issue #111 fix)
         std::lock_guard<std::mutex> lock(mutex_);
+        bool pnpTriggered = false;
 
         for (size_t i = 0; i < states.size(); i++) {
             if (!(states[i].dwEventState & SCARD_STATE_CHANGED)) {
@@ -205,48 +321,52 @@ void ReaderMonitor::MonitorLoop() {
 
             // PnP notification - reader list changed
             if (readerNames[i] == "\\\\?PnP?\\Notification") {
+                pnpTriggered = true;
                 // Get old reader names
                 std::vector<std::string> oldNames;
-                for (const auto& r : readers_) {
-                    oldNames.push_back(r.name);
+                for (const auto& pair : readerStates_) {
+                    oldNames.push_back(pair.first);
                 }
 
-                // Update reader list
+                // Update reader list (this rebuilds readerStates_ map)
                 UpdateReaderList();
 
                 // Find new readers
-                for (const auto& r : readers_) {
+                for (const auto& pair : readerStates_) {
                     bool found = false;
                     for (const auto& old : oldNames) {
-                        if (old == r.name) {
+                        if (old == pair.first) {
                             found = true;
                             break;
                         }
                     }
                     if (!found) {
-                        EmitEvent("reader-attached", r.name, r.lastState, r.atr);
+                        EmitEvent("reader-attached", pair.first, pair.second.lastState, pair.second.atr);
                     }
                 }
 
                 // Find removed readers
                 for (const auto& old : oldNames) {
-                    bool found = false;
-                    for (const auto& r : readers_) {
-                        if (r.name == old) {
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (!found) {
+                    if (readerStates_.find(old) == readerStates_.end()) {
                         EmitEvent("reader-detached", old, 0, {});
                     }
                 }
                 continue;
             }
 
-            // Reader state change
-            if (i < readers_.size()) {
-                DWORD oldState = readers_[i].lastState;
+            // Skip reader state processing if PnP was triggered in this iteration
+            // The reader list has changed, so indices are no longer valid
+            // We'll pick up any card changes on the next iteration with fresh state
+            if (pnpTriggered) {
+                continue;
+            }
+
+            // Reader state change - look up by name, not index (Issue #111 fix)
+            const std::string& readerName = readerNames[i];
+            auto it = readerStates_.find(readerName);
+
+            if (it != readerStates_.end()) {
+                DWORD oldState = it->second.lastState;
                 DWORD newState = states[i].dwEventState;
 
                 bool wasPresent = (oldState & SCARD_STATE_PRESENT) != 0;
@@ -258,15 +378,15 @@ void ReaderMonitor::MonitorLoop() {
                     atr.assign(states[i].rgbAtr, states[i].rgbAtr + states[i].cbAtr);
                 }
 
-                // Update stored state
-                readers_[i].lastState = newState & ~SCARD_STATE_CHANGED;
-                readers_[i].atr = atr;
+                // Update stored state using the map
+                it->second.lastState = newState & ~SCARD_STATE_CHANGED;
+                it->second.atr = atr;
 
                 // Emit appropriate event
                 if (!wasPresent && isPresent) {
-                    EmitEvent("card-inserted", readerNames[i], newState, atr);
+                    EmitEvent("card-inserted", readerName, newState, atr);
                 } else if (wasPresent && !isPresent) {
-                    EmitEvent("card-removed", readerNames[i], newState, {});
+                    EmitEvent("card-removed", readerName, newState, {});
                 }
             }
         }
@@ -279,7 +399,7 @@ void ReaderMonitor::UpdateReaderList() {
     LONG result = SCardListReaders(context_, nullptr, nullptr, &readersLen);
 
     if (result == SCARD_E_NO_READERS_AVAILABLE || readersLen == 0) {
-        readers_.clear();
+        readerStates_.clear();
         return;
     }
 
@@ -312,41 +432,41 @@ void ReaderMonitor::UpdateReaderList() {
 
     SCardGetStatusChange(context_, 0, states.data(), states.size());
 
-    // Update reader list
-    readers_.clear();
+    // Update reader states map (Issue #111 fix: use map keyed by name)
+    readerStates_.clear();
     for (size_t i = 0; i < newNames.size(); i++) {
         ReaderInfo info;
-        info.name = newNames[i];
         info.lastState = states[i].dwEventState & ~SCARD_STATE_CHANGED;
         if (states[i].cbAtr > 0) {
             info.atr.assign(states[i].rgbAtr, states[i].rgbAtr + states[i].cbAtr);
         }
-        readers_.push_back(info);
+        readerStates_[newNames[i]] = info;
     }
 }
 
 void ReaderMonitor::EmitEvent(const std::string& eventType, const std::string& readerName,
                                DWORD state, const std::vector<uint8_t>& atr) {
-    // Copy data for transfer to JS thread
-    EventData* data = new EventData{eventType, readerName, state, atr};
+    // Use shared_ptr to ensure memory is freed even if ThreadSafeFunction is released
+    // before the callback executes (prevents memory leak)
+    auto data = std::make_shared<EventData>(EventData{eventType, readerName, state, atr});
 
     // Call JavaScript callback on main thread
-    tsfn_.BlockingCall(data, [](Napi::Env env, Napi::Function callback, EventData* data) {
+    // Capture shared_ptr by value to extend lifetime until callback executes
+    tsfn_.BlockingCall(data.get(), [data](Napi::Env env, Napi::Function callback, EventData* ptr) {
         // Build event object
         Napi::Object event = Napi::Object::New(env);
-        event.Set("type", Napi::String::New(env, data->eventType));
-        event.Set("reader", Napi::String::New(env, data->readerName));
-        event.Set("state", Napi::Number::New(env, data->state));
+        event.Set("type", Napi::String::New(env, ptr->eventType));
+        event.Set("reader", Napi::String::New(env, ptr->readerName));
+        event.Set("state", Napi::Number::New(env, ptr->state));
 
-        if (!data->atr.empty()) {
-            event.Set("atr", Napi::Buffer<uint8_t>::Copy(env, data->atr.data(), data->atr.size()));
+        if (!ptr->atr.empty()) {
+            event.Set("atr", Napi::Buffer<uint8_t>::Copy(env, ptr->atr.data(), ptr->atr.size()));
         } else {
             event.Set("atr", env.Null());
         }
 
         // Call the callback
         callback.Call({event});
-
-        delete data;
+        // shared_ptr automatically cleaned up when lambda is destroyed
     });
 }

package/src/reader_monitor.h

@@ -6,6 +6,7 @@
 #include <vector>
 #include <string>
 #include <mutex>
+#include <unordered_map>
 #include "platform/pcsc.h"
 
 /**
@@ -13,6 +14,9 @@
  *
  * Runs a background thread that monitors for reader/card state changes
  * and emits events to JavaScript without blocking the main thread.
+ *
+ * Issue #111 fix: Uses a map keyed by reader name instead of array indices
+ * to prevent state mismatch when readers are added/removed during monitoring.
  */
 class ReaderMonitor : public Napi::ObjectWrap<ReaderMonitor> {
 public:
@@ -36,13 +40,12 @@ private:
     // Thread-safe function for emitting events
     Napi::ThreadSafeFunction tsfn_;
 
-    // Current known reader states
+    // Current known reader states (Issue #111: keyed by reader name for reliable lookup)
     struct ReaderInfo {
-        std::string name;
         DWORD lastState;
         std::vector<uint8_t> atr;
     };
-    std::vector<ReaderInfo> readers_;
+    std::unordered_map<std::string, ReaderInfo> readerStates_;
 
     // JavaScript methods
     Napi::Value Start(const Napi::CallbackInfo& info);