pcscreaderunit.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_PCSCREADERUNIT_HPP
#define LOGICALACCESS_PCSCREADERUNIT_HPP
 
#include <logicalaccess/utils.hpp>
#include <logicalaccess/plugins/readers/pcsc/pcscreaderunitconfiguration.hpp>
#include <logicalaccess/plugins/readers/iso7816/iso7816readerunit.hpp>
#include <logicalaccess/plugins/readers/pcsc/pcsc_fwd.hpp>
#include <logicalaccess/lla_fwd.hpp>
#include <logicalaccess/plugins/readers/pcsc/pcsc_connection.hpp>
 
namespace logicalaccess
{
class LLA_READERS_PCSC_API PCSCReaderUnit : public ISO7816ReaderUnit
{
  public:
    explicit PCSCReaderUnit(const std::string &name);
 
    virtual ~PCSCReaderUnit();
 
    std::string getName() const override;
 
    void setName(const std::string &name);
 
    std::string getConnectedName() override;
 
    virtual PCSCReaderUnitType getPCSCType() const;
 
    void setCardType(std::string cardType) override
    {
        d_card_type = cardType;
    }
 
    bool waitInsertion(unsigned int maxwait) override;
 
    bool waitRemoval(unsigned int maxwait) override;
 
    bool connect() override;
 
    virtual bool connect(PCSCShareMode share_mode);
 
    void disconnect() override;
 
    bool isConnected() override;
 
    bool connectToReader() override;
 
    void disconnectFromReader() override;
 
    const SCARDHANDLE &getHandle() const;
 
    unsigned long getActiveProtocol() const;
 
    PCSCShareMode getShareMode() const;
 
    std::shared_ptr<Chip> createChip(std::string type) override;
 
    std::shared_ptr<Chip> getSingleChip() override;
 
    std::vector<std::shared_ptr<Chip>> getChipList() override;
 
    virtual ByteVector getCardSerialNumber();
 
    std::string getReaderSerialNumber() override;
 
    const ByteVector &getATR() const;
 
    virtual std::shared_ptr<PCSCReaderCardAdapter> getDefaultPCSCReaderCardAdapter();
 
    virtual std::shared_ptr<ReaderCardAdapter> getReaderCardAdapter(std::string type);
 
    void serialize(boost::property_tree::ptree &parentNode) override;
 
    void unSerialize(boost::property_tree::ptree &node) override;
 
    std::shared_ptr<ReaderUnitConfiguration> getConfiguration() override;
 
    void setConfiguration(std::shared_ptr<ReaderUnitConfiguration> config) override;
 
    virtual void changeReaderKey(std::shared_ptr<ReaderMemoryKeyStorage> keystorage,
                                 const ByteVector &key);
 
    std::shared_ptr<PCSCReaderUnitConfiguration> getPCSCConfiguration()
    {
        return std::dynamic_pointer_cast<PCSCReaderUnitConfiguration>(getConfiguration());
    }
 
    std::shared_ptr<PCSCReaderProvider> getPCSCReaderProvider() const;
 
    static std::shared_ptr<PCSCReaderUnit>
    createPCSCReaderUnit(const std::string &readerName);
 
    void makeProxy(std::shared_ptr<PCSCReaderUnit> readerUnit,
                   std::shared_ptr<PCSCReaderUnitConfiguration> readerUnitConfig);
 
    virtual void getT_CL_ISOType(bool &isTypeA, bool &isTypeB);
 
    virtual void cardConnected()
    {
    }
 
    std::shared_ptr<PCSCReaderUnit> getProxyReaderUnit() const;
 
 
    void setCardTechnologies(const TechnoBitset &bitset) override;
 
    TechnoBitset getCardTechnologies() override;
 
    std::shared_ptr<LCDDisplay> getLCDDisplay() override;
 
    void setLCDDisplay(std::shared_ptr<LCDDisplay> d) override;
 
    std::shared_ptr<LEDBuzzerDisplay> getLEDBuzzerDisplay() override;
 
    void setLEDBuzzerDisplay(std::shared_ptr<LEDBuzzerDisplay> lbd) override;
 
    ReaderServicePtr getService(const ReaderServiceType &type) override;
 
    void beginTransaction();
 
    void endTransaction(DWORD dwDisposition = SCARD_LEAVE_CARD);
 
    void reset(int action = 0);
 
  protected:
    bool reconnect(int action = 0) override;
 
    std::shared_ptr<Chip> adjustChip(std::shared_ptr<Chip> c);
 
    std::shared_ptr<ResultChecker> createDefaultResultChecker() const override;
 
    std::shared_ptr<CardProbe> createCardProbe() override;
 
    void configure_mifareplus_chip(std::shared_ptr<Chip> c,
                                   std::shared_ptr<Commands> &commands,
                                   std::shared_ptr<ResultChecker> &resultChecker) const;
 
    void detect_mifareplus_security_level(std::shared_ptr<Chip> c);
 
    std::string d_name;
 
    std::string d_connectedName;
 
    void setSingleChip(std::shared_ptr<Chip> chip);
 
    std::shared_ptr<SAMChip> getSAMChip() override;
 
    void setSAMChip(std::shared_ptr<SAMChip> t) override;
 
    std::shared_ptr<ISO7816ReaderUnit> getSAMReaderUnit() override;
 
    void setSAMReaderUnit(std::shared_ptr<ISO7816ReaderUnit> t) override;
 
    // Internal helper for waitInsertion
    using SPtrStringVector  = std::vector<std::shared_ptr<std::string>>;
    using ReaderStateVector = std::vector<SCARD_READERSTATE>;
 
    std::tuple<SPtrStringVector, ReaderStateVector> prepare_poll_parameters();
 
    void waitInsertion_create_proxy(const std::string &reader_name);
 
    virtual bool process_insertion(const std::string &cardType, unsigned int maxwait,
                                   const ElapsedTimeCounter &elapsed);
 
  public:
    void setup_pcsc_connection(PCSCShareMode share_mode);
 
    void teardown_pcsc_connection();
 
  protected:
    std::unique_ptr<PCSCConnection> connection_;
 
    ByteVector atr_;
 
    std::shared_ptr<PCSCReaderUnit> d_proxyReaderUnit;
};
}
 
#endif