libusbreaderunit.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_LIBUSBREADERUNIT_HPP
#define LOGICALACCESS_LIBUSBREADERUNIT_HPP
 
#include <logicalaccess/readerproviders/readerunit.hpp>
#include <logicalaccess/plugins/readers/libusb/libusbreaderunitconfiguration.hpp>
#include <logicalaccess/plugins/readers/libusb/lla_readers_libusb_api.hpp>
#include <logicalaccess/plugins/llacommon/logs.hpp>
#include <logicalaccess/myexception.hpp>
 
#include <libusb.h>
#include <map>
 
namespace logicalaccess
{
#define READER_LIBUSB "LibUSB"
#define LIBUSB_DEVICE_YUBIKEY_VENDORID 0x1050
#define LIBUSB_DEVICE_ONLYKEY_VENDORID 0x1D50
#define HID_SET_REPORT 0x09
 
class LibUSBReaderCardAdapter;
class LibUSBReaderProvider;
 
class LLA_READERS_LIBUSB_API LibUSBReaderUnit : public ReaderUnit
{
  public:
    LibUSBReaderUnit(struct libusb_device* device);
 
    virtual ~LibUSBReaderUnit();
 
    std::string getName() const override;
    
    void setName(const std::string& name);
 
    std::string getConnectedName() override;
 
    void setCardType(std::string cardType) override;
 
    bool waitInsertion(unsigned int maxwait) override;
 
    bool waitRemoval(unsigned int maxwait) override;
 
    std::shared_ptr<Chip> createChip(std::string type) override;
 
    std::vector<unsigned char> getNumber(std::shared_ptr<Chip> chip) override;
 
    std::shared_ptr<Chip> getSingleChip() override;
 
    std::vector<std::shared_ptr<Chip>> getChipList() override;
 
    bool connect() override;
 
    void disconnect() override;
 
    bool isConnected() override;
 
    bool connectToReader() override;
 
    void disconnectFromReader() override;
 
    std::string getReaderSerialNumber() override;
 
    virtual std::shared_ptr<LibUSBReaderCardAdapter> getDefaultLibUSBReaderCardAdapter();
 
    void serialize(boost::property_tree::ptree &parentNode) override;
 
    void unSerialize(boost::property_tree::ptree &node) override;
 
    std::shared_ptr<LibUSBReaderUnitConfiguration> getLibUSBConfiguration()
    {
        return std::dynamic_pointer_cast<LibUSBReaderUnitConfiguration>(getConfiguration());
    }
 
    std::shared_ptr<LibUSBReaderProvider> getLibUSBReaderProvider() const;
 
    struct libusb_device *getDevice() const
    {
        return d_device;
    }
    
    struct libusb_device_handle *getHandle() const
    {
        return d_device_handle;
    }
    
    void setVendorID(uint16_t vendor_id);
 
  protected:
    struct libusb_device *d_device;
    
    struct libusb_device *d_tmp_device;
    
    struct libusb_device_handle* d_device_handle;
    
    uint16_t d_vendor_id;
    
    uint16_t d_product_id;
    
    std::string d_serial_number;
    
    std::string d_product;
    
    std::string d_name;
    
    libusb_device* look_for_device(uint16_t vendor_id, uint16_t product_id);
 
  private:
    template <typename TargetFunction, typename... Args>
    int libusb_safe_call(TargetFunction fct, Args... arg)
    {
        int ret = fct(arg...);
        if (ret < 0)
        {
            THROW_EXCEPTION_WITH_LOG(LibLogicalAccessException,
                                     "LibUSB error: " + std::string(libusb_strerror(d_device)));
        }
        return ret;
    }
};
}
 
#endif