added business

cli/Interface/MainClass.cpp

 
 #include <iostream>
 #include <sysexits.h>
-#include <Business/StringUtils.h>
+#include <DBO/StringUtils.h>
+#include <Business/FreeFareDeviceBusiness.h>
 #include "DBO/Result.h"
-#include "Business/LibNfc.h"
-#include "Business/FreeFareDevice.h"
+#include "Business/LibNfcBusiness.h"
+#include "Business/FreeFareDeviceBusiness.h"
 #include "CommandLineParser.h"
 #include "MainClass.h"
 
 
 int MainClass::main()
 {
-    std::cout << "LibNfc version: " << LibNfc::getVersion() << std::endl;
+    std::cout << "LibNfc version: " << LibNfcBusiness::getVersion() << std::endl;
 
-    LibNfc libNfc;
+    LibNfcBusiness libNfc;
     auto init = libNfc.init();
     if (!init) {
         init.print();
         return 1;
     }
 
-    auto devices = libNfc.getDevices();
-    if (!devices) {
-        devices.print();
+    auto devicesResult = libNfc.getDevices();
+    if (!devicesResult) {
+        devicesResult.print();
         return 2;
     }
-    if (devices.getData().size() == 0) {
+    auto devices = devicesResult.getData();
+    if (devices.size() == 0) {
         std::cerr << "No NFC device found" << std::endl;
         return 3;
     }
 
-    std::cout << "Found " << devices.getData().size() << " devices: " << std::endl;
-    for (size_t i = 0; i < devices.getData().size(); ++i) {
-        std::cout << devices.getData()[i]->getConnStr() << std::endl;
+    std::cout << "Found " << devices.size() << " devices: " << std::endl;
+    for (size_t i = 0; i < devices.size(); ++i) {
+        std::cout << devices[i]->getConnStr() << std::endl;
     }
 
-    auto device = devices.getData()[0];
+    auto device = devices[0];
     auto open = device->open();
     if (!open) {
         open.print();
         return 4;
     }
 
-    FreeFareDevice freeFareDevice(device);
+    FreeFareDeviceBusiness freeFareDevice(device);
     auto tags = freeFareDevice.getTags();
     if (!tags) {
         tags.print();

src/Business/FreeFareDeviceBusiness.cpp

+//
+// Created by robin on 7/22/16.
+//
+
+#include "FreeFareDeviceBusiness.h"
+
+FreeFareDeviceBusiness::FreeFareDeviceBusiness(std::shared_ptr<NfcDeviceBusiness> device)
+    : _device(device),
+      _freeFareDevice(std::make_shared<FreeFareDevice>(_device->getDevice()))
+{
+}
+
+Result<std::vector<std::shared_ptr<FreeFareTagBusiness>>> FreeFareDeviceBusiness::getTags() const
+{
+    if (!_device->isOpened()) {
+        return Result<std::vector<std::shared_ptr<FreeFareTagBusiness>>>::error("Device is not opened");
+    }
+    auto tagsResult = _freeFareDevice->getTags();
+    if (!tagsResult) {
+        return Result<std::vector<std::shared_ptr<FreeFareTagBusiness>>>::error(tagsResult);
+    }
+    auto tags = tagsResult.getData();
+    std::vector<std::shared_ptr<FreeFareTagBusiness>> tagsBusiness;
+    for (auto tag : tags) {
+        tagsBusiness.push_back(std::make_shared<FreeFareTagBusiness>(tag));
+    }
+    return Result<std::vector<std::shared_ptr<FreeFareTagBusiness>>>::ok(tagsBusiness);
+}

src/Business/FreeFareDeviceBusiness.h

+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+#define MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+
+
+#include <DataAccess/FreeFareDevice.h>
+#include "NfcDeviceBusiness.h"
+#include "FreeFareTagBusiness.h"
+
+class FreeFareDeviceBusiness
+{
+public:
+    FreeFareDeviceBusiness(std::shared_ptr<NfcDeviceBusiness> device);
+
+    Result<std::vector<std::shared_ptr<FreeFareTagBusiness>>> getTags() const;
+
+protected:
+    std::shared_ptr<NfcDeviceBusiness> _device;
+
+    std::shared_ptr<FreeFareDevice> _freeFareDevice;
+};
+
+
+#endif //MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H

src/Business/FreeFareTagBusiness.cpp

+//
+// Created by robin on 7/22/16.
+//
+
+#include "FreeFareTagBusiness.h"
+
+FreeFareTagBusiness::FreeFareTagBusiness(std::shared_ptr<FreeFareTag> tag)
+    : _tag(tag)
+{
+}
+
+ResultBool FreeFareTagBusiness::authenticate(int sector, int block, std::string key, int keyType)
+{
+    return _tag->authenticate(sector, block, key, keyType);
+}
+
+ResultString FreeFareTagBusiness::readBlock(int sector, int block, std::string key, int keyType)
+{
+    return _tag->readBlock(sector, block, key, keyType);
+}
+
+ResultString FreeFareTagBusiness::readSector(int sector, std::string key, int keyType)
+{
+    std::string res;
+    for (int i = 0; i < 4; ++i) {
+        auto data = readBlock(sector, i, key, keyType);
+        if (data) {
+            res += data.getData();
+        }
+        else {
+            return data;
+        }
+    }
+    return ResultString::ok(res);
+}
+
+const std::string &FreeFareTagBusiness::getUid() const
+{
+    return _tag->getUid();
+}
+
+std::shared_ptr<FreeFareTag> FreeFareTagBusiness::getTag() const
+{
+    return _tag;
+}

src/Business/FreeFareTagBusiness.h

+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+#define MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+
+
+#include <boost/shared_ptr.hpp>
+#include <DataAccess/FreeFareTag.h>
+
+class FreeFareTagBusiness
+{
+public:
+    FreeFareTagBusiness(std::shared_ptr<FreeFareTag> tag);
+
+    ResultBool authenticate(int sector, int block, std::string key, int keyType);
+
+    ResultString readBlock(int sector, int block, std::string key, int keyType);
+
+    ResultString readSector(int sector, std::string key, int keyType);
+
+    const std::string & getUid() const;
+
+    std::shared_ptr<FreeFareTag> getTag() const;
+
+protected:
+    std::shared_ptr<FreeFareTag> _tag;
+};
+
+
+#endif //MIFARE_TOOLS_FREEFARETAGBUSINESS_H

src/Business/LibNfcBusiness.cpp

+//
+// Created by robin on 7/22/16.
+//
+
+#include <algorithm>
+#include "LibNfcBusiness.h"
+
+LibNfcBusiness::LibNfcBusiness()
+{
+    _libNfc = std::make_shared<LibNfc>();
+}
+
+LibNfcBusiness::~LibNfcBusiness()
+{
+    _libNfc->clean();
+}
+
+ResultBool LibNfcBusiness::init()
+{
+    if (isInitialized()) {
+        return ResultBool::error("LibNfc is already initialized");
+    }
+    return _libNfc->init();
+}
+
+std::string LibNfcBusiness::getVersion()
+{
+    return LibNfc::getVersion();
+}
+
+void LibNfcBusiness::clean()
+{
+    if (isInitialized()) {
+        _libNfc->clean();
+    }
+}
+
+bool LibNfcBusiness::isInitialized() const
+{
+    return _libNfc->getContext() != 0;
+}
+
+Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>> LibNfcBusiness::getDevices() const
+{
+    if (!isInitialized()) {
+        return Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>>::error("LibNfc is not initialized");
+    }
+    auto devicesResult = _libNfc->getDevices();
+    if (!devicesResult) {
+        return Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>>::error(devicesResult);
+    }
+    auto devices = devicesResult.getData();
+    std::vector<std::shared_ptr<NfcDeviceBusiness>> devicesBusiness;
+    for (auto device : devices) {
+        devicesBusiness.push_back(std::make_shared<NfcDeviceBusiness>(device));
+    }
+    return Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>>::ok(devicesBusiness);
+}
+
+std::shared_ptr<LibNfc> LibNfcBusiness::getLibNfc() const
+{
+    return _libNfc;
+}

src/Business/LibNfcBusiness.h

+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFCBUSINESS_H
+#define MIFARE_TOOLS_LIBNFCBUSINESS_H
+
+
+#include <DBO/Result.h>
+#include <DataAccess/LibNfc.h>
+#include "NfcDeviceBusiness.h"
+
+class LibNfcBusiness
+{
+public:
+    LibNfcBusiness();
+    virtual ~LibNfcBusiness();
+
+    ResultBool init();
+
+    void clean();
+
+    bool isInitialized() const;
+
+    Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>> getDevices() const;
+
+    std::shared_ptr<LibNfc> getLibNfc() const;
+
+    static std::string getVersion();
+
+protected:
+    std::shared_ptr<LibNfc> _libNfc;
+};
+
+
+#endif //MIFARE_TOOLS_LIBNFCBUSINESS_H

src/Business/NfcDeviceBusiness.cpp

+//
+// Created by robin on 7/22/16.
+//
+
+#include "NfcDeviceBusiness.h"
+
+NfcDeviceBusiness::NfcDeviceBusiness(std::shared_ptr<NfcDevice> device)
+    : _device(device)
+{
+}
+
+ResultBool NfcDeviceBusiness::open()
+{
+    if (isOpened()) {
+        return ResultBool::error("NFC device is already opened");
+    }
+    return _device->open();
+}
+
+void NfcDeviceBusiness::close()
+{
+    if (isOpened()) {
+        _device->close();
+    }
+}
+
+bool NfcDeviceBusiness::isOpened() const
+{
+    return _device->getDevice() != 0;
+}
+
+const std::string &NfcDeviceBusiness::getConnStr() const
+{
+    return _device->getConnStr();
+}
+
+std::shared_ptr<NfcDevice> NfcDeviceBusiness::getDevice() const
+{
+    return _device;
+}

src/Business/NfcDeviceBusiness.h

+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+#define MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+
+
+#include <DataAccess/NfcDevice.h>
+
+class NfcDeviceBusiness
+{
+public:
+    NfcDeviceBusiness(std::shared_ptr<NfcDevice> device);
+
+    ResultBool open();
+
+    void close();
+
+    bool isOpened() const;
+
+    const std::string & getConnStr() const;
+
+    std::shared_ptr<NfcDevice> getDevice() const;
+
+protected:
+    std::shared_ptr<NfcDevice> _device;
+};
+
+
+#endif //MIFARE_TOOLS_NFCDEVICEBUSINESS_H

src/CMakeLists.txt

 set(SOURCE_FILES
         DBO/Result.hxx
         DBO/Result.h
-        Business/LibNfc.cpp
-        Business/LibNfc.h
-        Business/NfcDevice.cpp
-        Business/NfcDevice.h
-        Business/FreeFareDevice.cpp
-        Business/FreeFareDevice.h
-        Business/FreeFareTag.cpp
-        Business/FreeFareTag.h
-        Business/StringUtils.cpp Business/StringUtils.h DBO/AccessBitsDbo.cpp DBO/AccessBitsDbo.h)
+        DataAccess/LibNfc.cpp
+        DataAccess/LibNfc.h
+        DataAccess/NfcDevice.cpp
+        DataAccess/NfcDevice.h
+        DataAccess/FreeFareDevice.cpp
+        DataAccess/FreeFareDevice.h
+        DataAccess/FreeFareTag.cpp
+        DataAccess/FreeFareTag.h
+        DBO/StringUtils.cpp DBO/StringUtils.h DBO/AccessBitsDbo.cpp DBO/AccessBitsDbo.h Business/LibNfcBusiness.cpp Business/LibNfcBusiness.h Business/NfcDeviceBusiness.cpp Business/NfcDeviceBusiness.h Business/FreeFareDeviceBusiness.cpp Business/FreeFareDeviceBusiness.h Business/FreeFareTagBusiness.cpp Business/FreeFareTagBusiness.h)
 
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
 target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/AccessBitsDbo.cpp

 {
 }
 
-const char AccessBitsDbo::getUserData() const
+char AccessBitsDbo::getUserData() const
 {
     return _bits[_bits.length() - 1];
 }
     setArrayBit((char*)buf, bitPosition, value);
 }
 
-const bool AccessBitsDbo::getBit(const char &i, const char &j) const
+bool AccessBitsDbo::getBit(const char &i, const char &j) const
 {
     const char* buf = _bits.c_str();
     return getArrayBit(buf, nonInvertedBitPosition[i][j]) && !getArrayBit(buf, invertedBitPosition[i][j]);
 }
 
-const bool AccessBitsDbo::getArrayBit(const char *buf, const char &bitPosition)
+bool AccessBitsDbo::getArrayBit(const char *buf, const char &bitPosition)
 {
     char byteOffset = (char)(bitPosition / 8);
     char bitOffset = (char)(7 - (bitPosition % 8));
     return (buf[byteOffset] >> bitOffset) & 1 == 1;
 }
 
-const bool AccessBitsDbo::getArrayBit(const unsigned char *buf, const char &bitPosition)
+bool AccessBitsDbo::getArrayBit(const unsigned char *buf, const char &bitPosition)
 {
     return getArrayBit((const char *)buf, bitPosition);
 }
 
-const bool AccessBitsDbo::canKeyAReadBlock(const char &block) const
+bool AccessBitsDbo::canKeyAReadBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c3 || (!c1 && !c2 && c3);
 }
 
-const bool AccessBitsDbo::canKeyBReadBlock(const char &block) const
+bool AccessBitsDbo::canKeyBReadBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 || !c2 || !c3;
 }
 
-const bool AccessBitsDbo::canKeyAWriteBlock(const char &block) const
+bool AccessBitsDbo::canKeyAWriteBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-const bool AccessBitsDbo::canKeyBWriteBlock(const char &block) const
+bool AccessBitsDbo::canKeyBWriteBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c2 && !c3) || (c1 && !c3) || (!c1 && c2 && c3);
 }
 
-const bool AccessBitsDbo::canKeyAIncrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyAIncrementBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-const bool AccessBitsDbo::canKeyBIncrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyBIncrementBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2 && !c3) || (c1 && c2 && !c3);
 }
 
-const bool AccessBitsDbo::canKeyADecrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyADecrementBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2) || (c1 && c2 && !c3);
 }
 
-const bool AccessBitsDbo::canKeyBDecrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyBDecrementBlock(const char &block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2) || (c1 && c2 && !c3);
 }
 
-const bool AccessBitsDbo::canKeyAReadKeyATrailer() const
+bool AccessBitsDbo::canKeyAReadKeyATrailer() const
 {
     return false;
 }
 
-const bool AccessBitsDbo::canKeyBReadKeyATrailer() const
+bool AccessBitsDbo::canKeyBReadKeyATrailer() const
 {
     return false;
 }
 
-const bool AccessBitsDbo::canKeyAWriteKeyATrailer() const
+bool AccessBitsDbo::canKeyAWriteKeyATrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2;
 }
 
-const bool AccessBitsDbo::canKeyBWriteKeyATrailer() const
+bool AccessBitsDbo::canKeyBWriteKeyATrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && c2 && c3) || (c1 && !c2 && !c3);
 }
 
-const bool AccessBitsDbo::canKeyAReadAccessBitsTrailer() const
+bool AccessBitsDbo::canKeyAReadAccessBitsTrailer() const
 {
     return true;
 }
 
-const bool AccessBitsDbo::canKeyBReadAccessBitsTrailer() const
+bool AccessBitsDbo::canKeyBReadAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return c1 || (c2 && c3);
 }
 
-const bool AccessBitsDbo::canKeyAWriteAccessBitsTrailer() const
+bool AccessBitsDbo::canKeyAWriteAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2 && c3;
 }
 
-const bool AccessBitsDbo::canKeyBWriteAccessBitsTrailer() const
+bool AccessBitsDbo::canKeyBWriteAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && c2 && c3) || (c1 && !c2 && c3);
 }
 
-const bool AccessBitsDbo::canKeyAReadKeyBTrailer() const
+bool AccessBitsDbo::canKeyAReadKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && !c2) || (!c1 && !c3);
 }
 
-const bool AccessBitsDbo::canKeyBReadKeyBTrailer() const
+bool AccessBitsDbo::canKeyBReadKeyBTrailer() const
 {
     return false;
 }
 
-const bool AccessBitsDbo::canKeyAWriteKeyBTrailer() const
+bool AccessBitsDbo::canKeyAWriteKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2;
 }
 
-const bool AccessBitsDbo::canKeyBWriteKeyBTrailer() const
+bool AccessBitsDbo::canKeyBWriteKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);

src/DBO/AccessBitsDbo.h

     AccessBitsDbo();
     AccessBitsDbo(const std::string& bits);
 
-    const char getUserData() const;
+    char getUserData() const;
     void setUserData(const char& data);
 
     void setBit(const char& i, const char& j, const bool& value);
-    const bool getBit(const char& i, const char& j) const;
+    bool getBit(const char& i, const char& j) const;
 
-    const bool canKeyAReadBlock(const char& block) const;
-    const bool canKeyBReadBlock(const char& block) const;
+    bool canKeyAReadBlock(const char& block) const;
+    bool canKeyBReadBlock(const char& block) const;
 
-    const bool canKeyAWriteBlock(const char& block) const;
-    const bool canKeyBWriteBlock(const char& block) const;
+    bool canKeyAWriteBlock(const char& block) const;
+    bool canKeyBWriteBlock(const char& block) const;
 
-    const bool canKeyAIncrementBlock(const char& block) const;
-    const bool canKeyBIncrementBlock(const char& block) const;
+    bool canKeyAIncrementBlock(const char& block) const;
+    bool canKeyBIncrementBlock(const char& block) const;
 
-    const bool canKeyADecrementBlock(const char& block) const;
-    const bool canKeyBDecrementBlock(const char& block) const;
+    bool canKeyADecrementBlock(const char& block) const;
+    bool canKeyBDecrementBlock(const char& block) const;
 
-    const bool canKeyAReadKeyATrailer() const;
-    const bool canKeyBReadKeyATrailer() const;
+    bool canKeyAReadKeyATrailer() const;
+    bool canKeyBReadKeyATrailer() const;
 
-    const bool canKeyAWriteKeyATrailer() const;
-    const bool canKeyBWriteKeyATrailer() const;
+    bool canKeyAWriteKeyATrailer() const;
+    bool canKeyBWriteKeyATrailer() const;
 
-    const bool canKeyAReadAccessBitsTrailer() const;
-    const bool canKeyBReadAccessBitsTrailer() const;
+    bool canKeyAReadAccessBitsTrailer() const;
+    bool canKeyBReadAccessBitsTrailer() const;
 
-    const bool canKeyAWriteAccessBitsTrailer() const;
-    const bool canKeyBWriteAccessBitsTrailer() const;
+    bool canKeyAWriteAccessBitsTrailer() const;
+    bool canKeyBWriteAccessBitsTrailer() const;
 
-    const bool canKeyAReadKeyBTrailer() const;
-    const bool canKeyBReadKeyBTrailer() const;
+    bool canKeyAReadKeyBTrailer() const;
+    bool canKeyBReadKeyBTrailer() const;
 
-    const bool canKeyAWriteKeyBTrailer() const;
-    const bool canKeyBWriteKeyBTrailer() const;
+    bool canKeyAWriteKeyBTrailer() const;
+    bool canKeyBWriteKeyBTrailer() const;
 
     static void setArrayBit(char *buf, const char &bitPosition, const bool &value);
     static void setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value);
-    static const bool getArrayBit(const char *buf, const char &bitPosition);
-    static const bool getArrayBit(const unsigned char *buf, const char &bitPosition);
+    static bool getArrayBit(const char *buf, const char &bitPosition);
+    static bool getArrayBit(const unsigned char *buf, const char &bitPosition);
 
 private:
     std::string _bits;

src/Business/FreeFareDevice.cpp → src/DataAccess/FreeFareDevice.cpp

 
 Result<std::vector<std::shared_ptr<FreeFareTag>>> FreeFareDevice::getTags()
 {
-    if (!_device->isOpened()) {
-        return Result<std::vector<std::shared_ptr<FreeFareTag>>>::error("Device is not opened");
-    }
     FreefareTag* tags = freefare_get_tags(_device->getDevice());
     if (!tags) {
         return Result<std::vector<std::shared_ptr<FreeFareTag>>>::error("Failed to get MIFARE tags");

src/Business/FreeFareTag.cpp → src/DataAccess/FreeFareTag.cpp

     return _uid;
 }
 
-ResultBool FreeFareTag::authenticate(int sector, std::string key, int keyType)
+ResultBool FreeFareTag::authenticate(int sector, int block, std::string key, int keyType)
 {
     if (mifare_classic_connect(_tag) != 0) {
         return ResultBool::error("Failed to connect to MIFARE tag");
     }
 
-    MifareClassicBlockNumber block = mifare_classic_sector_last_block((MifareClassicBlockNumber)sector);
-    if (mifare_classic_authenticate(_tag, block, (const unsigned char*)key.c_str(), (MifareClassicKeyType)keyType) != 0) {
+//    MifareClassicBlockNumber block = mifare_classic_sector_last_block((MifareClassicBlockNumber)sector);
+    if (mifare_classic_authenticate(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)key.c_str(), (MifareClassicKeyType)keyType) != 0) {
         return ResultBool::error("Failed to authenticate to MIFARE tag");
     }
 
     return ResultBool::ok(true);
 }
 
-ResultString FreeFareTag::readSector(int sector, std::string key, int keyType)
-{
-    if (mifare_classic_connect(_tag) != 0) {
-        return ResultString::error("Failed to connect to MIFARE tag");
-    }
-
-    MifareClassicBlockNumber firstBlock = mifare_classic_sector_first_block((MifareClassicBlockNumber)sector);
-    MifareClassicBlockNumber lastBlock = mifare_classic_sector_last_block((MifareClassicBlockNumber)sector);
-    std::string allData;
-    for (MifareClassicBlockNumber block = firstBlock; block <= lastBlock; ++block) {
-        if (mifare_classic_authenticate(_tag, block, (const unsigned char *) key.c_str(),
-                                        (MifareClassicKeyType) keyType) != 0) {
-            return ResultString::error("Failed to authenticate to MIFARE tag");
-        }
-
-        MifareClassicBlock data;
-        if (mifare_classic_read(_tag, block, &data)) {
-            return ResultString::error("Failed to read MIFARE tag data");
-        }
-        allData += std::string((const char*)data, sizeof(data));
-    }
-
-    mifare_classic_disconnect(_tag);
-    return ResultString::ok(allData);
-}
-
 ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int keyType)
 {
     if (mifare_classic_connect(_tag) != 0) {

src/Business/FreeFareTag.h → src/DataAccess/FreeFareTag.h

     FreeFareTag(FreefareTag tag);
     ~FreeFareTag();
 
-    ResultBool authenticate(int sector, std::string key, int keyType);
-
-    ResultString readSector(int sector, std::string key, int keyType);
+    ResultBool authenticate(int sector, int block, std::string key, int keyType);
 
     ResultString readBlock(int sector, int block, std::string key, int keyType);
 

src/Business/LibNfc.cpp → src/DataAccess/LibNfc.cpp

 {
 }
 
+LibNfc::~LibNfc()
+{
+    clean();
+}
+
 ResultBool LibNfc::init()
 {
-    if (isInitialized()) {
-        return ResultBool::error("LibNfc is already initialized");
-    }
     nfc_init(&_context);
     if (!_context) {
         return ResultBool::error("LibNfc could not be initialized");
     return nfc_version();
 }
 
-LibNfc::~LibNfc()
-{
-    clean();
-}
-
-bool LibNfc::isInitialized()
-{
-    return _context != 0;
-}
-
 void LibNfc::clean()
 {
-    if (isInitialized()) {
-        nfc_exit(_context);
-        _context = 0;
-    }
+    nfc_exit(_context);
+    _context = 0;
 }
 
-Result<std::vector<std::shared_ptr<NfcDevice>>> LibNfc::getDevices()
+Result<std::vector<std::shared_ptr<NfcDevice>>> LibNfc::getDevices() const
 {
-    if (!isInitialized()) {
-        return Result<std::vector<std::shared_ptr<NfcDevice>>>::error("LibNfc is not initialized");
-    }
     nfc_connstring devices[16];
     size_t count = nfc_list_devices(_context, devices, sizeof(devices));
     if (count < 0) {
-        return Result<std::vector<std::shared_ptr<NfcDevice>>>::error("Failed to list NFC devices");
+        return Result<std::vector<std::shared_ptr<NfcDevice>>>::error("Failed to list NFC devices: " + count);
     }
     std::vector<std::shared_ptr<NfcDevice>> devicesList;
     for (size_t i = 0; i < count; ++i) {

src/Business/LibNfc.h → src/DataAccess/LibNfc.h

 {
 public:
     LibNfc();
-    ~LibNfc();
+    virtual ~LibNfc();
 
     ResultBool init();
 
     void clean();
 
-    bool isInitialized();
-
-    Result<std::vector<std::shared_ptr<NfcDevice>>> getDevices();
+    Result<std::vector<std::shared_ptr<NfcDevice>>> getDevices() const;
 
     static std::string getVersion();
 
     nfc_context* getContext() const;
 
-private:
+protected:
     nfc_context* _context;
 };
 

src/Business/NfcDevice.cpp → src/DataAccess/NfcDevice.cpp

 
 #include "NfcDevice.h"
 
-NfcDevice::NfcDevice(LibNfc* libNfc, std::string str)
+NfcDevice::NfcDevice(const LibNfc* libNfc, const std::string& str)
     : _connStr(str)
     , _device(0)
     , _libNfc(libNfc)
 
 ResultBool NfcDevice::open()
 {
-    if (isOpened()) {
-        return ResultBool::error("NFC device is already opened");
-    }
     _device = nfc_open(_libNfc->getContext(), _connStr.c_str());
     if (!_device) {
         return ResultBool::error("Failed to open NFC device");
     return ResultBool::ok(true);
 }
 
-bool NfcDevice::isOpened()
-{
-    return _device != 0;
-}
-
 void NfcDevice::close()
 {
-    if (isOpened()) {
-        nfc_close(_device);
-        _device = 0;
-    }
+    nfc_close(_device);
+    _device = 0;
 }
 
 nfc_device *NfcDevice::getDevice() const
     return _device;
 }
 
-void NfcDevice::setConnStr(const std::string &connStr)
-{
-    _connStr = connStr;
-}
-
 const std::string &NfcDevice::getConnStr() const
 {
     return _connStr;

src/Business/NfcDevice.h → src/DataAccess/NfcDevice.h

 class NfcDevice
 {
 public:
-    NfcDevice(LibNfc* libNfc, std::string connStr);
+    NfcDevice(const LibNfc* libNfc, const std::string& connStr);
     ~NfcDevice();
 
     ResultBool open();
 
     void close();
 
-    bool isOpened();
-
     const std::string & getConnStr() const;
 
-    void setConnStr(const std::string &connStr);
-
     nfc_device * getDevice() const;
 
 private:
 
     nfc_device* _device;
 
-    LibNfc* _libNfc;
+    const LibNfc* _libNfc;
 };
 
 

tests/test-main.cpp

 #include <iostream>
 #include <string.h>
 #include <gtest/gtest.h>
-#include <Business/LibNfc.h>
-#include <Business/StringUtils.h>
+#include <DataAccess/LibNfc.h>
+#include <DBO/StringUtils.h>
 #include <DBO/AccessBitsDbo.h>
 
 TEST(StringUtils, rawToHumanChar)