std::shared_ptr<Chip> RFIDeasReaderUnit::createChip(std::string type)
{
std::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
setTagIdBitsLengthFct setagfct;
if (chip)
{
std::shared_ptr<ReaderCardAdapter> rca;
if (type == CHIP_GENERICTAG)
{
rca = getDefaultReaderCardAdapter();
*(void**)(&setagfct) = LibraryManager::getInstance()->getFctFromName("setTagIdBitsLengthOfGenericTagChip", LibraryManager::CARDS_TYPE);
setagfct(&chip, d_lastTagIdBitsLength);
}
else
return chip;
if (rca)
{
rca->setDataTransport(getDataTransport());
}
}
return chip;
}
std::shared_ptr<OK5553ReaderCardAdapter> OK5553ReaderUnit::getDefaultOK5553ReaderCardAdapter()
{
std::shared_ptr<ReaderCardAdapter> adapter = getDefaultReaderCardAdapter();
if (!adapter->getDataTransport())
adapter->setDataTransport(getDataTransport());
return std::dynamic_pointer_cast<OK5553ReaderCardAdapter>(adapter);
}
std::vector<uint8_t> STidPRGReaderUnit::readBlocks(uint8_t start, uint8_t end)
{
EXCEPTION_ASSERT_WITH_LOG(end - start <= 11, LibLogicalAccessException,
"Cannot read "
"that many block.");
auto ret = getDefaultReaderCardAdapter()->sendCommand({0x41, start, end, 0});
return ret;
}
std::shared_ptr<LCDDisplay> ReaderUnit::getLCDDisplay()
{
if (d_lcdDisplay)
{
d_lcdDisplay->setReaderCardAdapter(getDefaultReaderCardAdapter());
}
return d_lcdDisplay;
}
std::shared_ptr<LEDBuzzerDisplay> ReaderUnit::getLEDBuzzerDisplay()
{
if (d_ledBuzzerDisplay)
{
d_ledBuzzerDisplay->setReaderCardAdapter(getDefaultReaderCardAdapter());
}
return d_ledBuzzerDisplay;
}
std::shared_ptr<Chip> NFCReaderUnit::createChip(std::string type)
{
LOG(LogLevel::INFOS) << "Create chip " << type;
std::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
if (chip)
{
LOG(LogLevel::INFOS) << "Chip (" << chip->getCardType() << ") created, creating other associated objects...";
std::shared_ptr<ReaderCardAdapter> rca = getDefaultReaderCardAdapter();
std::shared_ptr<Commands> commands;
std::shared_ptr<ResultChecker> resultChecker(new ISO7816ResultChecker()); // default one
if (type == "Mifare1K" || type == "Mifare4K" || type == "Mifare")
{
commands.reset(new MifareNFCCommands());
}
else if (type == "DESFireEV1")
{
commands.reset(new DESFireEV1ISO7816Commands());
resultChecker.reset(new DESFireISO7816ResultChecker());
}
else if (type == "DESFire")
{
commands.reset(new DESFireISO7816Commands());
resultChecker.reset(new DESFireISO7816ResultChecker());
}
if (rca)
{
rca->setResultChecker(resultChecker);
std::shared_ptr<DataTransport> dt = getDataTransport();
if (dt)
{
LOG(LogLevel::INFOS) << "Data transport forced to a specific one.";
rca->setDataTransport(dt);
}
dt = rca->getDataTransport();
if (dt)
{
dt->setReaderUnit(shared_from_this());
}
}
if (commands)
{
commands->setReaderCardAdapter(rca);
commands->setChip(chip);
chip->setCommands(commands);
}
LOG(LogLevel::INFOS) << "Object creation done.";
}
return chip;
}
STidPRGReaderUnit::STidPRGReaderUnit() : ReaderUnit(READER_STIDPRG)
{
d_readerUnitConfig = std::make_shared<STidPRGReaderUnitConfiguration>();
setDefaultReaderCardAdapter(std::make_shared<STidPRGReaderCardAdapter>());
auto dt = std::make_shared<STidPRGDataTransport>();
dt->setPortBaudRate(9600);
getDefaultReaderCardAdapter()->setDataTransport(dt);
setDataTransport(dt);
}
std::shared_ptr<Chip> OK5553ReaderUnit::createChip(std::string type)
{
LOG(LogLevel::INFOS) << "Create chip " << type;
std::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
if (chip)
{
std::shared_ptr<ReaderCardAdapter> rca;
std::shared_ptr<Commands> commands;
if (type == "Mifare1K" || type == "Mifare4K" || type == "Mifare")
{
commands.reset(new MifareOK5553Commands);
rca = getDefaultReaderCardAdapter();
}
else if (type == "MifareUltralight")
{
commands.reset(new MifareUltralightOK5553Commands());
rca = getDefaultReaderCardAdapter();
}
else if (type == "GenericTag")
{
rca = getDefaultReaderCardAdapter();
}
else if (type == "DESFire")
{
rca.reset(new ISO7816OK5553ReaderCardAdapter());
commands.reset(new DESFireISO7816Commands());
}
if (rca)
{
rca->setDataTransport(getDataTransport());
if (commands)
{
commands->setReaderCardAdapter(rca);
commands->setChip(chip);
chip->setCommands(commands);
}
}
}
return chip;
}
bool STidPRGReaderUnit::login(const std::vector<uint8_t> &password)
{
EXCEPTION_ASSERT_WITH_LOG(password.size() == 4, LibLogicalAccessException,
"Password must be 4 bytes.");
std::vector<uint8_t> cmd = {0x30, 0, 0, 4};
cmd.insert(cmd.end(), password.begin(), password.end());
auto ret = getDefaultReaderCardAdapter()->sendCommand(cmd);
return true;
}
std::shared_ptr<Chip> STidPRGReaderUnit::getCurrentChip()
{
auto ret = getDefaultReaderCardAdapter()->sendCommand({0x21, 0, 0, 0});
if (ret.size() > 3)
{
auto uid_len = ret[2];
if (static_cast<size_t>(3 + uid_len) >= ret.size())
{
auto card_uid = std::vector<uint8_t>(ret.begin() + 3, ret.end());
auto chip = createChip("Prox", card_uid);
auto cmd = std::make_shared<ProxCommand>();
cmd->setReaderCardAdapter(getDefaultReaderCardAdapter());
chip->setCommands(cmd);
return chip;
}
else
assert(0);
}
return nullptr;
}
bool STidPRGReaderUnit::format(uint8_t start, uint8_t end,
const std::vector<uint8_t> &pwd)
{
EXCEPTION_ASSERT_WITH_LOG(end - start <= 11, LibLogicalAccessException,
"Cannot use "
"that many block.");
EXCEPTION_ASSERT_WITH_LOG(pwd.size() == 4, LibLogicalAccessException,
"Password should be 4 bytes.");
std::vector<uint8_t> cmd = {0x34, start, end, 4};
cmd.insert(cmd.end(), pwd.begin(), pwd.end());
auto ret = getDefaultReaderCardAdapter()->sendCommand(cmd);
return true;
}
bool STidPRGReaderUnit::writePassword(const std::vector<uint8_t> &old,
const std::vector<uint8_t> &new_pass)
{
EXCEPTION_ASSERT_WITH_LOG(old.size() == 4, LibLogicalAccessException,
"Password must be 4 bytes.");
EXCEPTION_ASSERT_WITH_LOG(new_pass.size() == 4, LibLogicalAccessException,
"Password must be 4 bytes.");
std::vector<uint8_t> cmd = {0x33, 0, 0, 8};
cmd.insert(cmd.end(), old.begin(), old.end());
cmd.insert(cmd.end(), new_pass.begin(), new_pass.end());
auto ret = getDefaultReaderCardAdapter()->sendCommand(cmd);
return true;
}
std::shared_ptr<Chip> AxessTMC13ReaderUnit::createChip(std::string type)
{
std::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
if (chip)
{
std::shared_ptr<ReaderCardAdapter> rca;
if (type == CHIP_GENERICTAG)
rca = getDefaultReaderCardAdapter();
else
return chip;
rca->setDataTransport(getDataTransport());
}
return chip;
}
boost::shared_ptr<Chip> DeisterReaderUnit::createChip(std::string type)
{
boost::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
if (chip)
{
boost::shared_ptr<ReaderCardAdapter> rca;
if (type == "Mifare1K" || type == "Mifare4K" || type == "Mifare")
rca = getDefaultReaderCardAdapter();
else
return chip;
rca->setDataTransport(getDataTransport());
}
return chip;
}
boost::shared_ptr<Chip> AxessTMCLegicReaderUnit::createChip(std::string type)
{
boost::shared_ptr<Chip> chip = ReaderUnit::createChip(type);
if (chip)
{
boost::shared_ptr<ReaderCardAdapter> rca;
if (type == "LegicPrime")
rca = getDefaultReaderCardAdapter();
else
return chip;
rca->setDataTransport(getDataTransport());
}
return chip;
}
std::shared_ptr<Chip> IdOnDemandReaderUnit::createChip(std::string type)
{
std::shared_ptr<Chip> chip;
std::shared_ptr<ReaderCardAdapter> rca;
if (type == CHIP_GENERICTAG)
{
chip.reset(new GenericTagIdOnDemandChip());
std::shared_ptr<Commands> commands(new GenericTagIdOnDemandCommands());
commands->setChip(chip);
chip->setCommands(commands);
rca = getDefaultReaderCardAdapter();
rca->setDataTransport(getDataTransport());
commands->setReaderCardAdapter(rca);
}
else
{
chip = ReaderUnit::createChip(type);
}
return chip;
}
bool STidPRGReaderUnit::writeBlock(uint8_t start, uint8_t end,
const std::vector<uint8_t> &data)
{
EXCEPTION_ASSERT_WITH_LOG(end >= start, LibLogicalAccessException,
"Invalid block number")
EXCEPTION_ASSERT_WITH_LOG(end - start <= 8, LibLogicalAccessException,
"Cannot write "
"that many block.");
EXCEPTION_ASSERT_WITH_LOG(static_cast<int>(data.size()) == (end - start + 1) * 4,
LibLogicalAccessException,
"Not enough or too many bytes of data.");
uint8_t p1 = static_cast<uint8_t>(((end & 0xFF) << 4) | (start & 0xFF));
std::vector<uint8_t> cmd = {0x42, p1, 0,
static_cast<uint8_t>((end - start + 1) * 4)};
cmd.insert(cmd.end(), data.begin(), data.end());
auto ret = getDefaultReaderCardAdapter()->sendCommand(cmd);
return true;
}
std::shared_ptr<IdOnDemandReaderCardAdapter> IdOnDemandReaderUnit::getDefaultIdOnDemandReaderCardAdapter()
{
std::shared_ptr<ReaderCardAdapter> adapter = getDefaultReaderCardAdapter();
return std::dynamic_pointer_cast<IdOnDemandReaderCardAdapter>(adapter);
}
std::shared_ptr<AxessTMC13ReaderCardAdapter> AxessTMC13ReaderUnit::getDefaultAxessTMC13ReaderCardAdapter()
{
std::shared_ptr<ReaderCardAdapter> adapter = getDefaultReaderCardAdapter();
return std::dynamic_pointer_cast<AxessTMC13ReaderCardAdapter>(adapter);
}
void STidPRGReaderUnit::toggleBuzzer(bool on)
{
uint8_t p1 = static_cast<uint8_t>(on ? 0x10 : 0x00);
getDefaultReaderCardAdapter()->sendCommand({0x2D, p1, 0x00, 0x00});
}
std::shared_ptr<NFCReaderCardAdapter> NFCReaderUnit::getDefaultNFCReaderCardAdapter()
{
return std::dynamic_pointer_cast<NFCReaderCardAdapter>(getDefaultReaderCardAdapter());
}
boost::shared_ptr<DeisterReaderCardAdapter> DeisterReaderUnit::getDefaultDeisterReaderCardAdapter()
{
boost::shared_ptr<ReaderCardAdapter> adapter = getDefaultReaderCardAdapter();
return boost::dynamic_pointer_cast<DeisterReaderCardAdapter>(adapter);
}
boost::shared_ptr<AxessTMCLegicReaderCardAdapter> AxessTMCLegicReaderUnit::getDefaultAxessTMCLegicReaderCardAdapter()
{
boost::shared_ptr<ReaderCardAdapter> adapter = getDefaultReaderCardAdapter();
return boost::dynamic_pointer_cast<AxessTMCLegicReaderCardAdapter>(adapter);
}
void STidPRGReaderUnit::select_chip_type()
{
// Chip type shall be 0x03 for writable 13.56
getDefaultReaderCardAdapter()->sendCommand({0x20, 0x03, 0, 0x00});
}
std::shared_ptr<ReaderCardAdapter> OmnikeyXX21ReaderUnit::getReaderCardAdapter(std::string /*type*/)
{
return getDefaultReaderCardAdapter();
}
void STidPRGReaderUnit::ihm_control(uint8_t device, int duration)
{
uint8_t p2 = static_cast<uint8_t>(duration / 100);
getDefaultReaderCardAdapter()->sendCommand({0x2F, device, p2, 0x00});
}
