smartcard 1.0.46 → 2.0.0

package/src/async_workers.cpp

@@ -0,0 +1,234 @@
+#include "async_workers.h"
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include <cstring>
+
+// ============================================================================
+// WaitForChangeWorker
+// ============================================================================
+
+WaitForChangeWorker::WaitForChangeWorker(
+    Napi::Env env,
+    SCARDCONTEXT context,
+    std::vector<std::string> readerNames,
+    std::vector<DWORD> currentStates,
+    DWORD timeout,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      context_(context),
+      readerNames_(std::move(readerNames)),
+      timeout_(timeout),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+
+    // Initialize reader states
+    states_.resize(readerNames_.size());
+    for (size_t i = 0; i < readerNames_.size(); i++) {
+        memset(&states_[i], 0, sizeof(SCARD_READERSTATE));
+        states_[i].szReader = readerNames_[i].c_str();
+        states_[i].dwCurrentState = (i < currentStates.size()) ? currentStates[i] : SCARD_STATE_UNAWARE;
+    }
+}
+
+void WaitForChangeWorker::Execute() {
+    // This runs on worker thread - safe to block
+    result_ = SCardGetStatusChange(context_, timeout_, states_.data(), states_.size());
+}
+
+void WaitForChangeWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        // Build array of reader states
+        Napi::Array changes = Napi::Array::New(env);
+
+        for (size_t i = 0; i < states_.size(); i++) {
+            Napi::Object reader = Napi::Object::New(env);
+            reader.Set("name", Napi::String::New(env, readerNames_[i]));
+            reader.Set("state", Napi::Number::New(env, states_[i].dwEventState));
+            reader.Set("changed", Napi::Boolean::New(env,
+                (states_[i].dwEventState & SCARD_STATE_CHANGED) != 0));
+
+            if (states_[i].cbAtr > 0) {
+                reader.Set("atr", Napi::Buffer<uint8_t>::Copy(
+                    env, states_[i].rgbAtr, states_[i].cbAtr));
+            } else {
+                reader.Set("atr", env.Null());
+            }
+
+            changes.Set(static_cast<uint32_t>(i), reader);
+        }
+
+        deferred_.Resolve(changes);
+    } else if (result_ == SCARD_E_CANCELLED) {
+        // Cancelled - resolve with null
+        deferred_.Resolve(env.Null());
+    } else if (result_ == SCARD_E_TIMEOUT) {
+        // Timeout - resolve with empty array
+        deferred_.Resolve(Napi::Array::New(env, 0));
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void WaitForChangeWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// TransmitWorker
+// ============================================================================
+
+TransmitWorker::TransmitWorker(
+    Napi::Env env,
+    SCARDHANDLE card,
+    DWORD protocol,
+    std::vector<uint8_t> sendBuffer,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      card_(card),
+      protocol_(protocol),
+      sendBuffer_(std::move(sendBuffer)),
+      recvLength_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+    // Pre-allocate receive buffer (max APDU response size)
+    recvBuffer_.resize(258);
+}
+
+void TransmitWorker::Execute() {
+    // Select protocol-specific PCI structure
+    const SCARD_IO_REQUEST* pioSendPci;
+    if (protocol_ == SCARD_PROTOCOL_T0) {
+        pioSendPci = SCARD_PCI_T0;
+    } else if (protocol_ == SCARD_PROTOCOL_T1) {
+        pioSendPci = SCARD_PCI_T1;
+    } else {
+        pioSendPci = SCARD_PCI_RAW;
+    }
+
+    recvLength_ = static_cast<DWORD>(recvBuffer_.size());
+
+    result_ = SCardTransmit(
+        card_,
+        pioSendPci,
+        sendBuffer_.data(),
+        static_cast<DWORD>(sendBuffer_.size()),
+        nullptr,
+        recvBuffer_.data(),
+        &recvLength_
+    );
+}
+
+void TransmitWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(
+            env, recvBuffer_.data(), recvLength_);
+        deferred_.Resolve(buffer);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void TransmitWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// ControlWorker
+// ============================================================================
+
+ControlWorker::ControlWorker(
+    Napi::Env env,
+    SCARDHANDLE card,
+    DWORD controlCode,
+    std::vector<uint8_t> sendBuffer,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      card_(card),
+      controlCode_(controlCode),
+      sendBuffer_(std::move(sendBuffer)),
+      bytesReturned_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+    // Pre-allocate receive buffer
+    recvBuffer_.resize(256);
+}
+
+void ControlWorker::Execute() {
+    result_ = SCardControl(
+        card_,
+        controlCode_,
+        sendBuffer_.empty() ? nullptr : sendBuffer_.data(),
+        static_cast<DWORD>(sendBuffer_.size()),
+        recvBuffer_.data(),
+        static_cast<DWORD>(recvBuffer_.size()),
+        &bytesReturned_
+    );
+}
+
+void ControlWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(
+            env, recvBuffer_.data(), bytesReturned_);
+        deferred_.Resolve(buffer);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void ControlWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// ConnectWorker
+// ============================================================================
+
+ConnectWorker::ConnectWorker(
+    Napi::Env env,
+    SCARDCONTEXT context,
+    std::string readerName,
+    DWORD shareMode,
+    DWORD preferredProtocols,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      context_(context),
+      readerName_(std::move(readerName)),
+      shareMode_(shareMode),
+      preferredProtocols_(preferredProtocols),
+      card_(0),
+      activeProtocol_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+}
+
+void ConnectWorker::Execute() {
+    result_ = SCardConnect(
+        context_,
+        readerName_.c_str(),
+        shareMode_,
+        preferredProtocols_,
+        &card_,
+        &activeProtocol_
+    );
+}
+
+void ConnectWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Object card = PCSCCard::NewInstance(env, card_, activeProtocol_, readerName_);
+        deferred_.Resolve(card);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void ConnectWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}

package/src/async_workers.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <string>
+#include "platform/pcsc.h"
+
+// Async worker for SCardGetStatusChange
+class WaitForChangeWorker : public Napi::AsyncWorker {
+public:
+    WaitForChangeWorker(Napi::Env env,
+                        SCARDCONTEXT context,
+                        std::vector<std::string> readerNames,
+                        std::vector<DWORD> currentStates,
+                        DWORD timeout,
+                        Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDCONTEXT context_;
+    std::vector<std::string> readerNames_;
+    std::vector<SCARD_READERSTATE> states_;
+    DWORD timeout_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardTransmit
+class TransmitWorker : public Napi::AsyncWorker {
+public:
+    TransmitWorker(Napi::Env env,
+                   SCARDHANDLE card,
+                   DWORD protocol,
+                   std::vector<uint8_t> sendBuffer,
+                   Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDHANDLE card_;
+    DWORD protocol_;
+    std::vector<uint8_t> sendBuffer_;
+    std::vector<uint8_t> recvBuffer_;
+    DWORD recvLength_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardControl
+class ControlWorker : public Napi::AsyncWorker {
+public:
+    ControlWorker(Napi::Env env,
+                  SCARDHANDLE card,
+                  DWORD controlCode,
+                  std::vector<uint8_t> sendBuffer,
+                  Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDHANDLE card_;
+    DWORD controlCode_;
+    std::vector<uint8_t> sendBuffer_;
+    std::vector<uint8_t> recvBuffer_;
+    DWORD bytesReturned_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardConnect
+class ConnectWorker : public Napi::AsyncWorker {
+public:
+    ConnectWorker(Napi::Env env,
+                  SCARDCONTEXT context,
+                  std::string readerName,
+                  DWORD shareMode,
+                  DWORD preferredProtocols,
+                  Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDCONTEXT context_;
+    std::string readerName_;
+    DWORD shareMode_;
+    DWORD preferredProtocols_;
+    SCARDHANDLE card_;
+    DWORD activeProtocol_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};

package/src/pcsc_card.cpp

@@ -0,0 +1,248 @@
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+#include <cstring>
+
+Napi::FunctionReference PCSCCard::constructor;
+
+Napi::Object PCSCCard::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Card", {
+        InstanceAccessor("protocol", &PCSCCard::GetProtocolValue, nullptr),
+        InstanceAccessor("connected", &PCSCCard::GetConnectedValue, nullptr),
+        InstanceAccessor("atr", &PCSCCard::GetAtr, nullptr),
+        InstanceMethod("transmit", &PCSCCard::Transmit),
+        InstanceMethod("control", &PCSCCard::Control),
+        InstanceMethod("getStatus", &PCSCCard::GetStatus),
+        InstanceMethod("disconnect", &PCSCCard::Disconnect),
+        InstanceMethod("reconnect", &PCSCCard::Reconnect),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Card", func);
+    return exports;
+}
+
+Napi::Object PCSCCard::NewInstance(Napi::Env env, SCARDHANDLE card,
+                                    DWORD protocol, const std::string& readerName) {
+    Napi::Object obj = constructor.New({});
+    PCSCCard* cardObj = Napi::ObjectWrap<PCSCCard>::Unwrap(obj);
+    cardObj->card_ = card;
+    cardObj->protocol_ = protocol;
+    cardObj->readerName_ = readerName;
+    cardObj->connected_ = true;
+    return obj;
+}
+
+PCSCCard::PCSCCard(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCCard>(info),
+      card_(0),
+      protocol_(SCARD_PROTOCOL_UNDEFINED),
+      connected_(false) {
+    // Properties set via NewInstance
+}
+
+PCSCCard::~PCSCCard() {
+    if (connected_ && card_ != 0) {
+        SCardDisconnect(card_, SCARD_LEAVE_CARD);
+        connected_ = false;
+        card_ = 0;
+    }
+}
+
+Napi::Value PCSCCard::GetProtocolValue(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), protocol_);
+}
+
+Napi::Value PCSCCard::GetConnectedValue(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), connected_);
+}
+
+Napi::Value PCSCCard::GetAtr(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        return env.Null();
+    }
+
+    // Get ATR via SCardStatus
+    DWORD readerLen = 0;
+    DWORD state = 0;
+    DWORD protocol = 0;
+    BYTE atr[MAX_ATR_SIZE];
+    DWORD atrLen = sizeof(atr);
+
+    LONG result = SCardStatus(card_, nullptr, &readerLen, &state, &protocol, atr, &atrLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        return env.Null();
+    }
+
+    return Napi::Buffer<uint8_t>::Copy(env, atr, atrLen);
+}
+
+Napi::Value PCSCCard::Transmit(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Expected command buffer").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::vector<uint8_t> sendBuffer;
+
+    if (info[0].IsBuffer()) {
+        Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+        sendBuffer.assign(buffer.Data(), buffer.Data() + buffer.Length());
+    } else if (info[0].IsArray()) {
+        Napi::Array arr = info[0].As<Napi::Array>();
+        sendBuffer.reserve(arr.Length());
+        for (uint32_t i = 0; i < arr.Length(); i++) {
+            sendBuffer.push_back(static_cast<uint8_t>(arr.Get(i).As<Napi::Number>().Uint32Value()));
+        }
+    } else {
+        Napi::TypeError::New(env, "Expected Buffer or Array").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Create promise for async transmit
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    TransmitWorker* worker = new TransmitWorker(
+        env, card_, protocol_, sendBuffer, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCCard::Control(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected control code").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD controlCode = info[0].As<Napi::Number>().Uint32Value();
+
+    std::vector<uint8_t> sendBuffer;
+    if (info.Length() > 1) {
+        if (info[1].IsBuffer()) {
+            Napi::Buffer<uint8_t> buffer = info[1].As<Napi::Buffer<uint8_t>>();
+            sendBuffer.assign(buffer.Data(), buffer.Data() + buffer.Length());
+        } else if (info[1].IsArray()) {
+            Napi::Array arr = info[1].As<Napi::Array>();
+            sendBuffer.reserve(arr.Length());
+            for (uint32_t i = 0; i < arr.Length(); i++) {
+                sendBuffer.push_back(static_cast<uint8_t>(arr.Get(i).As<Napi::Number>().Uint32Value()));
+            }
+        }
+    }
+
+    // Create promise for async control
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    ControlWorker* worker = new ControlWorker(
+        env, card_, controlCode, sendBuffer, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCCard::GetStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD readerLen = 0;
+    DWORD state = 0;
+    DWORD protocol = 0;
+    BYTE atr[MAX_ATR_SIZE];
+    DWORD atrLen = sizeof(atr);
+
+    // First call to get reader name length
+    LONG result = SCardStatus(card_, nullptr, &readerLen, &state, &protocol, atr, &atrLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object status = Napi::Object::New(env);
+    status.Set("state", Napi::Number::New(env, state));
+    status.Set("protocol", Napi::Number::New(env, protocol));
+    status.Set("atr", Napi::Buffer<uint8_t>::Copy(env, atr, atrLen));
+
+    return status;
+}
+
+Napi::Value PCSCCard::Disconnect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        return env.Undefined();
+    }
+
+    DWORD disposition = SCARD_LEAVE_CARD;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        disposition = info[0].As<Napi::Number>().Uint32Value();
+    }
+
+    LONG result = SCardDisconnect(card_, disposition);
+    connected_ = false;
+    card_ = 0;
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCCard::Reconnect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD shareMode = SCARD_SHARE_SHARED;
+    DWORD preferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
+    DWORD initialization = SCARD_LEAVE_CARD;
+
+    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();
+    }
+    if (info.Length() > 2 && info[2].IsNumber()) {
+        initialization = info[2].As<Napi::Number>().Uint32Value();
+    }
+
+    DWORD activeProtocol = 0;
+    LONG result = SCardReconnect(card_, shareMode, preferredProtocols, initialization, &activeProtocol);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    protocol_ = activeProtocol;
+    return Napi::Number::New(env, activeProtocol);
+}

package/src/pcsc_card.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <napi.h>
+#include <string>
+#include <vector>
+#include "platform/pcsc.h"
+
+class PCSCCard : public Napi::ObjectWrap<PCSCCard> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Env env, SCARDHANDLE card,
+                                     DWORD protocol, const std::string& readerName);
+
+    PCSCCard(const Napi::CallbackInfo& info);
+    ~PCSCCard();
+
+    // Accessors
+    SCARDHANDLE GetHandle() const { return card_; }
+    DWORD GetProtocol() const { return protocol_; }
+    bool IsConnected() const { return connected_; }
+
+private:
+    static Napi::FunctionReference constructor;
+
+    SCARDHANDLE card_;
+    DWORD protocol_;
+    std::string readerName_;
+    bool connected_;
+
+    // JavaScript-exposed methods
+    Napi::Value Transmit(const Napi::CallbackInfo& info);
+    Napi::Value Control(const Napi::CallbackInfo& info);
+    Napi::Value GetStatus(const Napi::CallbackInfo& info);
+    Napi::Value Disconnect(const Napi::CallbackInfo& info);
+    Napi::Value Reconnect(const Napi::CallbackInfo& info);
+
+    // Getters
+    Napi::Value GetProtocolValue(const Napi::CallbackInfo& info);
+    Napi::Value GetConnectedValue(const Napi::CallbackInfo& info);
+    Napi::Value GetAtr(const Napi::CallbackInfo& info);
+};