smartcard 1.0.46 → 2.0.0

package/src/pcsc_context.cpp

@@ -0,0 +1,224 @@
+#include "pcsc_context.h"
+#include "pcsc_reader.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+#include <cstring>
+
+Napi::FunctionReference PCSCContext::constructor;
+
+Napi::Object PCSCContext::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Context", {
+        InstanceMethod("listReaders", &PCSCContext::ListReaders),
+        InstanceMethod("waitForChange", &PCSCContext::WaitForChange),
+        InstanceMethod("cancel", &PCSCContext::Cancel),
+        InstanceMethod("close", &PCSCContext::Close),
+        InstanceAccessor("isValid", &PCSCContext::GetIsValid, nullptr),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Context", func);
+    return exports;
+}
+
+Napi::Object PCSCContext::NewInstance(Napi::Env env) {
+    return constructor.New({});
+}
+
+PCSCContext::PCSCContext(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCContext>(info), context_(0), valid_(false) {
+
+    Napi::Env env = info.Env();
+
+    // Establish PC/SC context
+    LONG result = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, &context_);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return;
+    }
+
+    valid_ = true;
+}
+
+PCSCContext::~PCSCContext() {
+    if (valid_ && context_ != 0) {
+        SCardReleaseContext(context_);
+        valid_ = false;
+        context_ = 0;
+    }
+}
+
+Napi::Value PCSCContext::ListReaders(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        Napi::Error::New(env, "Context is not valid").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // First call to get buffer size
+    DWORD readersLen = 0;
+    LONG result = SCardListReaders(context_, nullptr, nullptr, &readersLen);
+
+    if (result == SCARD_E_NO_READERS_AVAILABLE) {
+        // No readers - return empty array
+        return Napi::Array::New(env, 0);
+    }
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Allocate buffer and get reader names
+    std::vector<char> readersBuffer(readersLen);
+    result = SCardListReaders(context_, nullptr, readersBuffer.data(), &readersLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Parse multi-string result (null-separated, double-null terminated)
+    std::vector<std::string> readerNames;
+    const char* p = readersBuffer.data();
+    while (*p != '\0') {
+        readerNames.push_back(std::string(p));
+        p += strlen(p) + 1;
+    }
+
+    // Get initial state for each reader
+    std::vector<SCARD_READERSTATE> states(readerNames.size());
+    for (size_t i = 0; i < readerNames.size(); i++) {
+        states[i].szReader = readerNames[i].c_str();
+        states[i].dwCurrentState = SCARD_STATE_UNAWARE;
+    }
+
+    // Get current state (non-blocking with 0 timeout)
+    result = SCardGetStatusChange(context_, 0, states.data(), states.size());
+
+    // Create Reader objects
+    Napi::Array readers = Napi::Array::New(env, readerNames.size());
+    for (size_t i = 0; i < readerNames.size(); i++) {
+        std::vector<uint8_t> atr;
+        if (result == SCARD_S_SUCCESS && states[i].cbAtr > 0) {
+            atr.assign(states[i].rgbAtr, states[i].rgbAtr + states[i].cbAtr);
+        }
+        DWORD state = (result == SCARD_S_SUCCESS) ? states[i].dwEventState : 0;
+
+        Napi::Object reader = PCSCReader::NewInstance(env, context_, readerNames[i], state, atr);
+        readers.Set(static_cast<uint32_t>(i), reader);
+    }
+
+    return readers;
+}
+
+Napi::Value PCSCContext::WaitForChange(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        Napi::Error::New(env, "Context is not valid").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Parse arguments: readers array (optional), timeout (optional)
+    std::vector<std::string> readerNames;
+    std::vector<DWORD> currentStates;
+    DWORD timeout = INFINITE;
+
+    size_t argIndex = 0;
+
+    // First argument can be array of readers or timeout
+    if (info.Length() > 0 && info[0].IsArray()) {
+        Napi::Array readersArray = info[0].As<Napi::Array>();
+        for (uint32_t i = 0; i < readersArray.Length(); i++) {
+            Napi::Value item = readersArray.Get(i);
+            if (item.IsObject()) {
+                // It's a Reader object
+                Napi::Object obj = item.As<Napi::Object>();
+                if (obj.Has("name")) {
+                    readerNames.push_back(obj.Get("name").As<Napi::String>().Utf8Value());
+                    if (obj.Has("state")) {
+                        currentStates.push_back(obj.Get("state").As<Napi::Number>().Uint32Value());
+                    } else {
+                        currentStates.push_back(SCARD_STATE_UNAWARE);
+                    }
+                }
+            } else if (item.IsString()) {
+                readerNames.push_back(item.As<Napi::String>().Utf8Value());
+                currentStates.push_back(SCARD_STATE_UNAWARE);
+            }
+        }
+        argIndex++;
+    }
+
+    // Next argument is timeout
+    if (info.Length() > argIndex && info[argIndex].IsNumber()) {
+        timeout = info[argIndex].As<Napi::Number>().Uint32Value();
+    }
+
+    // If no readers specified, get all readers
+    if (readerNames.empty()) {
+        DWORD readersLen = 0;
+        LONG result = SCardListReaders(context_, nullptr, nullptr, &readersLen);
+
+        if (result == SCARD_E_NO_READERS_AVAILABLE) {
+            // Add PnP notification to detect when readers are attached
+            readerNames.push_back("\\\\?PnP?\\Notification");
+            currentStates.push_back(SCARD_STATE_UNAWARE);
+        } else if (result == SCARD_S_SUCCESS) {
+            std::vector<char> readersBuffer(readersLen);
+            result = SCardListReaders(context_, nullptr, readersBuffer.data(), &readersLen);
+            if (result == SCARD_S_SUCCESS) {
+                const char* p = readersBuffer.data();
+                while (*p != '\0') {
+                    readerNames.push_back(std::string(p));
+                    currentStates.push_back(SCARD_STATE_UNAWARE);
+                    p += strlen(p) + 1;
+                }
+            }
+        }
+    }
+
+    // Create promise and start async worker
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    WaitForChangeWorker* worker = new WaitForChangeWorker(
+        env, context_, readerNames, currentStates, timeout, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCContext::Cancel(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        return env.Undefined();
+    }
+
+    LONG result = SCardCancel(context_);
+    if (result != SCARD_S_SUCCESS && result != SCARD_E_INVALID_HANDLE) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCContext::Close(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (valid_ && context_ != 0) {
+        SCardReleaseContext(context_);
+        valid_ = false;
+        context_ = 0;
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCContext::GetIsValid(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), valid_);
+}

package/src/pcsc_context.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <napi.h>
+#include <string>
+#include <vector>
+#include "platform/pcsc.h"
+
+class PCSCContext : public Napi::ObjectWrap<PCSCContext> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Env env);
+
+    PCSCContext(const Napi::CallbackInfo& info);
+    ~PCSCContext();
+
+    // Get the raw context handle (for use by other classes)
+    SCARDCONTEXT GetContext() const { return context_; }
+    bool IsValid() const { return valid_; }
+
+private:
+    static Napi::FunctionReference constructor;
+
+    SCARDCONTEXT context_;
+    bool valid_;
+
+    // JavaScript-exposed methods
+    Napi::Value ListReaders(const Napi::CallbackInfo& info);
+    Napi::Value WaitForChange(const Napi::CallbackInfo& info);
+    Napi::Value Cancel(const Napi::CallbackInfo& info);
+    Napi::Value Close(const Napi::CallbackInfo& info);
+    Napi::Value GetIsValid(const Napi::CallbackInfo& info);
+};

package/src/pcsc_errors.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "platform/pcsc.h"
+
+// Convert PC/SC error codes to human-readable strings
+// Using explicit casts to handle unsigned->signed on macOS
+inline const char* GetPCSCErrorString(LONG code) {
+    // Cast to unsigned for comparison to avoid sign issues
+    DWORD ucode = static_cast<DWORD>(code);
+
+    if (ucode == SCARD_S_SUCCESS) return "Success";
+    if (ucode == SCARD_E_CANCELLED) return "Operation cancelled";
+    if (ucode == SCARD_E_CANT_DISPOSE) return "Cannot dispose handle";
+    if (ucode == SCARD_E_INSUFFICIENT_BUFFER) return "Insufficient buffer";
+    if (ucode == SCARD_E_INVALID_ATR) return "Invalid ATR";
+    if (ucode == SCARD_E_INVALID_HANDLE) return "Invalid handle";
+    if (ucode == SCARD_E_INVALID_PARAMETER) return "Invalid parameter";
+    if (ucode == SCARD_E_INVALID_TARGET) return "Invalid target";
+    if (ucode == SCARD_E_INVALID_VALUE) return "Invalid value";
+    if (ucode == SCARD_E_NO_MEMORY) return "Not enough memory";
+    if (ucode == SCARD_E_NO_SERVICE) return "PC/SC service not running";
+    if (ucode == SCARD_E_NO_SMARTCARD) return "No smart card present";
+    if (ucode == SCARD_E_NOT_READY) return "Reader not ready";
+    if (ucode == SCARD_E_NOT_TRANSACTED) return "Transaction failed";
+    if (ucode == SCARD_E_PCI_TOO_SMALL) return "PCI struct too small";
+    if (ucode == SCARD_E_PROTO_MISMATCH) return "Protocol mismatch";
+    if (ucode == SCARD_E_READER_UNAVAILABLE) return "Reader unavailable";
+    if (ucode == SCARD_E_SERVICE_STOPPED) return "PC/SC service stopped";
+    if (ucode == SCARD_E_SHARING_VIOLATION) return "Sharing violation";
+    if (ucode == SCARD_E_SYSTEM_CANCELLED) return "System cancelled operation";
+    if (ucode == SCARD_E_TIMEOUT) return "Operation timed out";
+    if (ucode == SCARD_E_UNKNOWN_CARD) return "Unknown card type";
+    if (ucode == SCARD_E_UNKNOWN_READER) return "Unknown reader";
+    if (ucode == SCARD_E_NO_READERS_AVAILABLE) return "No readers available";
+    if (ucode == SCARD_F_COMM_ERROR) return "Communication error";
+    if (ucode == SCARD_F_INTERNAL_ERROR) return "Internal error";
+    if (ucode == SCARD_W_REMOVED_CARD) return "Card was removed";
+    if (ucode == SCARD_W_RESET_CARD) return "Card was reset";
+    if (ucode == SCARD_W_UNPOWERED_CARD) return "Card is unpowered";
+    if (ucode == SCARD_W_UNRESPONSIVE_CARD) return "Card is unresponsive";
+    if (ucode == SCARD_W_UNSUPPORTED_CARD) return "Card is not supported";
+
+    return "Unknown PC/SC error";
+}
+
+// Get the error code value
+inline LONG GetPCSCErrorCode(LONG code) {
+    return code;
+}

package/src/pcsc_reader.cpp

@@ -0,0 +1,89 @@
+#include "pcsc_reader.h"
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+
+Napi::FunctionReference PCSCReader::constructor;
+
+Napi::Object PCSCReader::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Reader", {
+        InstanceAccessor("name", &PCSCReader::GetNameValue, nullptr),
+        InstanceAccessor("state", &PCSCReader::GetStateValue, nullptr),
+        InstanceAccessor("atr", &PCSCReader::GetAtrValue, nullptr),
+        InstanceMethod("connect", &PCSCReader::Connect),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Reader", func);
+    return exports;
+}
+
+Napi::Object PCSCReader::NewInstance(Napi::Env env, SCARDCONTEXT context,
+                                      const std::string& name, DWORD state,
+                                      const std::vector<uint8_t>& atr) {
+    Napi::Object obj = constructor.New({});
+    PCSCReader* reader = Napi::ObjectWrap<PCSCReader>::Unwrap(obj);
+    reader->context_ = context;
+    reader->name_ = name;
+    reader->state_ = state;
+    reader->atr_ = atr;
+    return obj;
+}
+
+PCSCReader::PCSCReader(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCReader>(info),
+      context_(0),
+      state_(SCARD_STATE_UNAWARE) {
+    // Properties set via NewInstance
+}
+
+void PCSCReader::UpdateState(DWORD state, const std::vector<uint8_t>& atr) {
+    state_ = state;
+    atr_ = atr;
+}
+
+Napi::Value PCSCReader::GetNameValue(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), name_);
+}
+
+Napi::Value PCSCReader::GetStateValue(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), state_);
+}
+
+Napi::Value PCSCReader::GetAtrValue(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (atr_.empty()) {
+        return env.Null();
+    }
+
+    Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(env, atr_.data(), atr_.size());
+    return buffer;
+}
+
+Napi::Value PCSCReader::Connect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    // Parse arguments: shareMode (optional), preferredProtocols (optional)
+    DWORD shareMode = SCARD_SHARE_SHARED;
+    DWORD preferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
+
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        shareMode = info[0].As<Napi::Number>().Uint32Value();
+    }
+
+    if (info.Length() > 1 && info[1].IsNumber()) {
+        preferredProtocols = info[1].As<Napi::Number>().Uint32Value();
+    }
+
+    // Create promise for async connection
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    ConnectWorker* worker = new ConnectWorker(
+        env, context_, name_, shareMode, preferredProtocols, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}

package/src/pcsc_reader.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <napi.h>
+#include <string>
+#include <vector>
+#include "platform/pcsc.h"
+
+class PCSCReader : public Napi::ObjectWrap<PCSCReader> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Env env, SCARDCONTEXT context,
+                                     const std::string& name, DWORD state,
+                                     const std::vector<uint8_t>& atr);
+
+    PCSCReader(const Napi::CallbackInfo& info);
+
+    // Accessors
+    const std::string& GetName() const { return name_; }
+    DWORD GetState() const { return state_; }
+    const std::vector<uint8_t>& GetAtr() const { return atr_; }
+    SCARDCONTEXT GetContext() const { return context_; }
+
+    // Update state (called from monitoring)
+    void UpdateState(DWORD state, const std::vector<uint8_t>& atr);
+
+private:
+    static Napi::FunctionReference constructor;
+
+    std::string name_;
+    SCARDCONTEXT context_;
+    DWORD state_;
+    std::vector<uint8_t> atr_;
+
+    // JavaScript-exposed methods
+    Napi::Value GetNameValue(const Napi::CallbackInfo& info);
+    Napi::Value GetStateValue(const Napi::CallbackInfo& info);
+    Napi::Value GetAtrValue(const Napi::CallbackInfo& info);
+    Napi::Value Connect(const Napi::CallbackInfo& info);
+};

package/src/platform/pcsc.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// Cross-platform PC/SC header
+// Normalizes differences between Windows, macOS, and Linux PC/SC libraries
+
+#ifdef _WIN32
+    #include <winscard.h>
+    #pragma comment(lib, "winscard.lib")
+#elif __APPLE__
+    #include <PCSC/winscard.h>
+    #include <PCSC/wintypes.h>
+#else
+    // Linux
+    #include <winscard.h>
+    #include <reader.h>
+#endif
+
+// Normalize error codes that may be missing on some platforms
+#ifndef SCARD_E_NO_READERS_AVAILABLE
+    #define SCARD_E_NO_READERS_AVAILABLE 0x8010002E
+#endif
+
+#ifndef SCARD_E_NO_SERVICE
+    #define SCARD_E_NO_SERVICE 0x8010001D
+#endif
+
+// Windows uses LPTSTR which can be wide, macOS/Linux use char*
+// This ensures we work with char* consistently
+#ifdef _WIN32
+    #ifndef SCARD_AUTOALLOCATE
+        #define SCARD_AUTOALLOCATE ((DWORD)-1)
+    #endif
+#endif
+
+// Helper macro for unused parameters
+#define PCSC_UNUSED(x) (void)(x)