refactor classic {1,4}K support

cli/cli/MainClass.cpp

 //
 
 #include <iostream>
+#include <algorithm>
 #include <sysexits.h>
+#include <unistd.h>
 #include <iomanip>
 #include <fstream>
 #include <libnfc_cpptools/StringUtils.h>
 #include <libnfc_cpptools/FreeFareDevice.h>
 #include <libnfc_cpptools/Result.h>
 #include <libnfc_cpptools/LibNfcContext.h>
+#include <libnfc_cpptools/FreeFareTagClassic.h>
 #include "CommandLineParser.h"
 #include "MainClass.h"
 
 #define EX_MAP_KEYS_ERROR 15
 #define EX_READ_ERROR 16
 #define EX_WRITE_ERROR 17
+#define EX_NFC_TAG_NOT_SUPPORTED 18
 
 MainClass::MainClass(int argc, char *argv[])
     : _argc(argc)
                             }
                         }
                         else {
-                            auto tag = getTag(tagUid, tags);
-                            if (tag == 0) {
+                            auto genericTag = getTag(tagUid, tags);
+                            if (genericTag == nullptr) {
                                 std::cerr << "Tag not found" << std::endl;
                                 res = EX_NFC_TAG_NOT_FOUND;
                             }
-                            else {
+                            else if (genericTag->getType() == LibNfc::FreeFare::FreeFareTag::MIFARE_CLASSIC_1K
+                                    || genericTag->getType() == LibNfc::FreeFare::FreeFareTag::MIFARE_CLASSIC_4K) {
+                                auto tag = std::static_pointer_cast<LibNfc::FreeFare::FreeFareTagClassic>(genericTag);
                                 if (action == Read) {
                                     res = read(tag, keys);
                                 }
                                     res = write(tag, keys, inputData);
                                 }
                             }
+                            else {
+                                std::cerr << "Tag not supported" << std::endl;
+                                res = EX_NFC_TAG_NOT_SUPPORTED;
+                            }
                         }
                     }
                     device->close();
     return res;
 }
 
-int MainClass::mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys)
+int MainClass::mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys)
 {
     auto mappedKeysResult = tag->mapKeys(keys, printPercentMapKeys);
     if (!mappedKeysResult) {
     return EX_OK;
 }
 
-int MainClass::read(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys)
+int MainClass::read(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys)
 {
     auto readResult = tag->read(keys, printPercentMapKeys, printPercentDump);
     if (!readResult) {
     return EX_OK;
 }
 
-int MainClass::write(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys, const std::string &data)
+int MainClass::write(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys, const std::string &data)
 {
     auto writeResult = tag->write(keys, data, false, printPercentMapKeys, printPercentWrite);
     if (!writeResult) {
         writeResult.print();
         return EX_WRITE_ERROR;
     }
-//    std::vector<LibNfc::FreeFare::FreeFareSector> sectors;
+//    std::vector<LibNfc::FreeFare::FreeFareClassicSector> sectors;
 //    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 1024);
 //    for (int i = 0; i < 16; ++i) {
-//        LibNfc::FreeFare::FreeFareSector LibNfc::FreeFare::FreeFareSector(d.substr(i * 64, 64));
-//        sectors.push_back(LibNfc::FreeFare::FreeFareSector);
+//        LibNfc::FreeFare::FreeFareClassicSector LibNfc::FreeFare::FreeFareClassicSector(d.substr(i * 64, 64));
+//        sectors.push_back(LibNfc::FreeFare::FreeFareClassicSector);
 //    }
 //    printSectors(sectors);
     return EX_OK;
 }
 
-void MainClass::printSectors(const std::vector<LibNfc::FreeFare::FreeFareSector> &sectors)
+void MainClass::printSectors(const std::vector<LibNfc::FreeFare::FreeFareClassicSector> &sectors)
 {
     for(int s = 0; s < sectors.size(); ++s) {
         cout() << "+Sector: " << s << std::endl;
         cout() << "+Trailer key A: " << (sector.hasKeyA() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyA()) : std::string(12, '-'))
         << "\t AC bits: " << (sector.hasAccessBits() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getAccessBits()) : std::string(8, '-'))
         << "\t key B: " << (sector.hasKeyB() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyB()) : std::string(12, '-')) << std::endl;
-        LibNfc::FreeFare::FreeFareAccessBits accessBitsDbo = sector.getAccessBitsDbo();
+        LibNfc::FreeFare::FreeFareClassicAccessBits accessBitsDbo = sector.getAccessBitsDbo();
         for (int b = 0; b < 3; ++b) {
             cout() << "+Block: " << b << " ";
             printBlockAccessBits(accessBitsDbo, b);
     }
 }
 
-void MainClass::printBlockAccessBits(const LibNfc::FreeFare::FreeFareAccessBits &accessBits, int block)
+void MainClass::printBlockAccessBits(const LibNfc::FreeFare::FreeFareClassicAccessBits &accessBits, int block)
 {
     cout() << "read: " << (accessBits.canKeyAReadBlock(block) ? "A" : " ") << (accessBits.canKeyBReadBlock(block) ? "B" : " ");
     cout() << "\t write: " << (accessBits.canKeyAWriteBlock(block) ? "A" : " ") << (accessBits.canKeyBWriteBlock(block) ? "B" : " ");
     cout() << "\t decrement: " << (accessBits.canKeyADecrementBlock(block) ? "A" : " ") << (accessBits.canKeyBDecrementBlock(block) ? "B" : " ") << std::endl;
 }
 
-void MainClass::printTrailerAccessBits(const LibNfc::FreeFare::FreeFareAccessBits &accessBits)
+void MainClass::printTrailerAccessBits(const LibNfc::FreeFare::FreeFareClassicAccessBits &accessBits)
 {
     cout() << "key A read: " << (accessBits.canKeyAReadKeyATrailer() ? "A" : " ") << (accessBits.canKeyBReadKeyATrailer() ? "B" : " ");
     cout() << "\t key A write: " << (accessBits.canKeyAWriteKeyATrailer() ? "A" : " ") << (accessBits.canKeyBWriteKeyATrailer() ? "B" : " ");

cli/cli/MainClass.h

 
 #include <memory>
 #include <libnfc_cpptools/FreeFareTag.h>
+#include <libnfc_cpptools/FreeFareTagClassic.h>
 #include <libnfc_cpptools/NfcDevice.h>
 
 class MainClass {
 
     std::shared_ptr<LibNfc::FreeFare::FreeFareTag> getTag(const std::string& tagUid, std::vector<std::shared_ptr<LibNfc::FreeFare::FreeFareTag>> tags);
 
-    int mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys);
+    int mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys);
 
-    int read(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys);
+    int read(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys);
 
-    int write(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys, const std::string& data);
+    int write(std::shared_ptr<LibNfc::FreeFare::FreeFareTagClassic> tag, std::vector<std::string> keys, const std::string& data);
 
     LibNfc::Utils::Result<std::vector<std::string>> readFile(const std::string& filePath);
 
     LibNfc::Utils::Result<std::vector<std::string>> readStream(std::istream& stream);
 
-    void printSectors(const std::vector<LibNfc::FreeFare::FreeFareSector>& sectors);
+    void printSectors(const std::vector<LibNfc::FreeFare::FreeFareClassicSector>& sectors);
 
-    void printBlockAccessBits(const LibNfc::FreeFare::FreeFareAccessBits& accessBits, int block);
+    void printBlockAccessBits(const LibNfc::FreeFare::FreeFareClassicAccessBits& accessBits, int block);
 
-    void printTrailerAccessBits(const LibNfc::FreeFare::FreeFareAccessBits& accessBits);
+    void printTrailerAccessBits(const LibNfc::FreeFare::FreeFareClassicAccessBits& accessBits);
 
     void printVersion();
 

libnfc_cpptools/CMakeLists.txt

 
 set(SOURCE_FILES
         inc/libnfc_cpptools/Result.h
-        src/libnfc/LibNfcInternal.cpp
-        src/libnfc/LibNfcInternal.h
+        src/libnfc/LibNfcContextInternal.cpp
+        src/libnfc/LibNfcContextInternal.h
         src/libnfc/NfcDeviceInternal.cpp
         src/libnfc/NfcDeviceInternal.h
         src/freefare/FreeFareDeviceInternal.cpp
         src/freefare/FreeFareDeviceInternal.h
-        src/freefare/FreeFareTagInternal.cpp
-        src/freefare/FreeFareTagInternal.h
+        src/freefare/Tags/FreeFareTagInternal.cpp
+        src/freefare/Tags/FreeFareTagInternal.h
         src/utils/StringUtils.cpp
         inc/libnfc_cpptools/StringUtils.h
-        src/freefare/FreeFareAccessBits.cpp
-        inc/libnfc_cpptools/FreeFareAccessBits.h
+        src/freefare/Tags/Classic/FreeFareClassicAccessBits.cpp
+        inc/libnfc_cpptools/FreeFareClassicAccessBits.h
         src/libnfc/LibNfcContext.cpp
         inc/libnfc_cpptools/LibNfcContext.h
         src/libnfc/NfcDevice.cpp
         inc/libnfc_cpptools/NfcDevice.h
         src/freefare/FreeFareDevice.cpp
         inc/libnfc_cpptools/FreeFareDevice.h
-        src/freefare/FreeFareTag.cpp
+        src/freefare/Tags/FreeFareTag.cpp
         inc/libnfc_cpptools/FreeFareTag.h
-        src/freefare/FreeFareSector.cpp
-        inc/libnfc_cpptools/FreeFareSector.h
+        src/freefare/Tags/Classic/FreeFareClassicSector.cpp
+        inc/libnfc_cpptools/FreeFareClassicSector.h
         src/utils/ArrayUtils.cpp
         inc/libnfc_cpptools/ArrayUtils.h
-        )
+        src/freefare/Tags/Classic/FreeFareTagClassicInternal.cpp src/freefare/Tags/Classic/FreeFareTagClassicInternal.h src/freefare/Tags/Classic/FreeFareTagClassic.cpp inc/libnfc_cpptools/FreeFareTagClassic.h)
 
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
 target_link_libraries(${PROJECT_NAME}

libnfc_cpptools/inc/libnfc_cpptools/FreeFareAccessBits.h → libnfc_cpptools/inc/libnfc_cpptools/FreeFareClassicAccessBits.h

 namespace FreeFare
 {
 
-class FreeFareAccessBits
+class FreeFareClassicAccessBits
 {
 public:
 
     static const char nonInvertedBitPosition[4][4];
     static const char invertedBitPosition[4][4];
 
-    FreeFareAccessBits();
-    explicit FreeFareAccessBits(const std::string& bits);
-    ~FreeFareAccessBits() = default;
+    FreeFareClassicAccessBits();
+    explicit FreeFareClassicAccessBits(const std::string& bits);
+    ~FreeFareClassicAccessBits() = default;
 
     char getUserData() const;
     void setUserData(const char& data);

libnfc_cpptools/inc/libnfc_cpptools/FreeFareSector.h → libnfc_cpptools/inc/libnfc_cpptools/FreeFareClassicSector.h

 
 #include <string>
 #include <libnfc_cpptools/Result.h>
-#include <libnfc_cpptools/FreeFareAccessBits.h>
+#include <libnfc_cpptools/FreeFareClassicAccessBits.h>
 
 namespace LibNfc
 {
 namespace FreeFare
 {
 
-class FreeFareSector
+class FreeFareClassicSector
 {
 public:
-    explicit FreeFareSector(const std::string& data = "");
-    ~FreeFareSector() = default;
+    explicit FreeFareClassicSector(const std::string& data = "");
+    ~FreeFareClassicSector() = default;
 
     const std::string& getBlock(int block) const;
 
 
     std::string getAccessBits() const;
 
-    FreeFareAccessBits getAccessBitsDbo() const;
+    FreeFareClassicAccessBits getAccessBitsDbo() const;
 
     void setBlock(int block, const std::string& data);
 
 
     void setAccessBits(const std::string& accessBits);
 
-    void setAccessBits(const FreeFareAccessBits& accessBits);
+    void setAccessBits(const FreeFareClassicAccessBits& accessBits);
 
     bool hasBlock(int block) const;
 

libnfc_cpptools/inc/libnfc_cpptools/FreeFareTag.h

 #define LIBNFC_CPPTOOLS_FREEFARETAGBUSINESS_H
 
 
-#include <boost/shared_ptr.hpp>
-#include <libnfc_cpptools/FreeFareSector.h>
+#include <memory>
+#include <libnfc_cpptools/FreeFareClassicSector.h>
 
 namespace LibNfc
 {
     explicit FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag);
     ~FreeFareTag() = default;
 
-    LibNfc::Utils::ResultBool authenticate(int sector, const std::string& key, int keyType);
-
-    LibNfc::Utils::Result<MappedKeys> mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb = nullptr);
-
-    LibNfc::Utils::ResultString readBlock(int sector, int block, const std::string& key, int keyType);
-
-    LibNfc::Utils::Result<FreeFareSector> readSector(int sector, const std::string& key, int keyType);
-
-    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(const MappedKeys& keys, std::function<void(int, int)> cb = nullptr);
-
-    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(const std::vector<std::string>& keys, std::function<void(int, int)> mapCb = nullptr,
-                                        std::function<void(int, int)> readCb = nullptr);
-
-    LibNfc::Utils::ResultBool writeBlock(int sector, int block, const std::string& key, int keyType, const std::string& data);
-
-    LibNfc::Utils::ResultBool writeSector(int sector, const std::string& key, int keyType, const std::string& data);
-
-    LibNfc::Utils::ResultBool write(const MappedKeys& keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb = nullptr);
-
-    LibNfc::Utils::ResultBool write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
-                     std::function<void(int, int)> mapCb = nullptr, std::function<void(int, int)> writeCb = nullptr);
-
     const std::string& getUid() const;
 
     FreeFareTagType getType() const;

libnfc_cpptools/inc/libnfc_cpptools/FreeFareTagClassic.h

+//
+// Created by robin on 10/8/17.
+//
+
+#ifndef NFC_CPPTOOLS_FREEFARETAGCLASSIC_H
+#define NFC_CPPTOOLS_FREEFARETAGCLASSIC_H
+
+#include "FreeFareTag.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareTagClassicInternal;
+
+class FreeFareTagClassic : public FreeFareTag
+{
+public:
+    explicit FreeFareTagClassic(std::shared_ptr<FreeFareTagClassicInternal> tag);
+
+    LibNfc::Utils::ResultBool authenticate(int sector, const std::string& key, int keyType);
+
+    LibNfc::Utils::Result<MappedKeys> mapKeys(const std::vector<std::string>& keys,
+                                              std::function<void(int, int)> cb = nullptr);
+
+    LibNfc::Utils::ResultString readBlock(int sector, int block, const std::string& key, int keyType);
+
+    LibNfc::Utils::Result<FreeFareClassicSector> readSector(int sector, const std::string& key, int keyType);
+
+    LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> read(const MappedKeys& keys,
+                                                            std::function<void(int, int)> cb = nullptr);
+
+    LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> read(const std::vector<std::string>& keys,
+                                                            std::function<void(int, int)> mapCb = nullptr,
+                                                            std::function<void(int, int)> readCb = nullptr);
+
+    LibNfc::Utils::ResultBool writeBlock(int sector,
+                                         int block,
+                                         const std::string& key,
+                                         int keyType,
+                                         const std::string& data);
+
+    LibNfc::Utils::ResultBool writeSector(int sector, const std::string& key, int keyType, const std::string& data);
+
+    LibNfc::Utils::ResultBool write(const MappedKeys& keys,
+                                    const std::string& data,
+                                    bool writeSector0,
+                                    std::function<void(int, int)> cb = nullptr);
+
+    LibNfc::Utils::ResultBool write(const std::vector<std::string>& keys,
+                                    const std::string& data,
+                                    bool writeSector0,
+                                    std::function<void(int, int)> mapCb = nullptr,
+                                    std::function<void(int, int)> writeCb = nullptr);
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //NFC_CPPTOOLS_FREEFARETAGCLASSIC_H

libnfc_cpptools/inc/libnfc_cpptools/LibNfcContext.h

 namespace Core
 {
 
-class LibNfcInternal;
+class LibNfcContextInternal;
 
 class LibNfcContext
 {
     static std::string getLibNfcCppToolsVersion();
 
 protected:
-    std::shared_ptr<LibNfcInternal> _libNfc;
+    std::shared_ptr<LibNfcContextInternal> _libNfc;
 };
 
 }; // Core

libnfc_cpptools/inc/libnfc_cpptools/Result.h

 template <class T> class Result
 {
 public:
-    Result();
     Result(const Result<T>& other);
 
     static const Result<T> ok(const T& data);
     const Result<T>& print() const;
 
 private:
+    Result();
+
     T _data;
 
     std::string _error;

libnfc_cpptools/src/freefare/FreeFareDevice.cpp

 // Created by robin on 7/22/16.
 //
 
+#include <libnfc_cpptools/FreeFareTagClassic.h>
 #include "libnfc_cpptools/FreeFareDevice.h"
 #include "FreeFareDeviceInternal.h"
+#include "Tags/Classic/FreeFareTagClassicInternal.h"
 
 namespace LibNfc
 {
     auto tags = tagsResult.getData();
     std::vector<std::shared_ptr<FreeFareTag>> tagsBusiness;
     for (auto tag : tags) {
-        tagsBusiness.push_back(std::make_shared<FreeFareTag>(tag));
+        if (tag->getType() == MIFARE_CLASSIC_1K || tag->getType() == MIFARE_CLASSIC_4K) {
+            tagsBusiness.push_back(std::make_shared<FreeFareTagClassic>(std::dynamic_pointer_cast<FreeFareTagClassicInternal>(tag)));
+        }
+        else {
+            tagsBusiness.push_back(std::make_shared<FreeFareTag>(tag));
+        }
     }
     return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>>::ok(tagsBusiness);
 }

libnfc_cpptools/src/freefare/FreeFareDeviceInternal.cpp

 // Created by robin on 6/19/16.
 //
 
+#include <Tags/Classic/FreeFareTagClassicInternal.h>
 #include "FreeFareDeviceInternal.h"
 
 namespace LibNfc
     }
     std::vector<std::shared_ptr<FreeFareTagInternal>> tagList;
     for (size_t i = 0; tags[i] != 0; ++i) {
-        tagList.push_back(std::make_shared<FreeFareTagInternal>(tags[i]));
+        auto type = freefare_get_tag_type(tags[i]);
+        if (type == MIFARE_CLASSIC_1K || type == MIFARE_CLASSIC_4K) {
+            tagList.push_back(std::make_shared<FreeFareTagClassicInternal>(tags[i]));
+        }
+        else {
+            tagList.push_back(std::make_shared<FreeFareTagInternal>(tags[i]));
+        }
     }
     return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>>::ok(tagList);
 }

libnfc_cpptools/src/freefare/FreeFareDeviceInternal.h

 
 #include <freefare.h>
 #include "NfcDeviceInternal.h"
-#include "FreeFareTagInternal.h"
+#include "Tags/FreeFareTagInternal.h"
 
 namespace LibNfc
 {

libnfc_cpptools/src/freefare/FreeFareTagInternal.h

-//
-// Created by robin on 6/19/16.
-//
-
-#ifndef LIBNFC_CPPTOOLS_FREEFARETAG_H
-#define LIBNFC_CPPTOOLS_FREEFARETAG_H
-
-#include <freefare.h>
-#include <string>
-#include "libnfc_cpptools/Result.h"
-
-namespace LibNfc
-{
-namespace FreeFare
-{
-
-class FreeFareTagInternal
-{
-public:
-
-    explicit FreeFareTagInternal(FreefareTag tag);
-    ~FreeFareTagInternal();
-
-    LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
-
-    LibNfc::Utils::ResultString readBlock(int sector, int block, std::string key, int keyType);
-
-    LibNfc::Utils::ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
-
-    int getFirstBlock(int sector) const;
-
-    int getLastBlock(int sector) const;
-
-    int getSectorBlockCount(int sector);
-
-    const freefare_tag * getTag() const;
-
-    freefare_tag_type getType() const;
-
-    const std::string & getUid() const;
-
-private:
-    FreefareTag _tag;
-
-    freefare_tag_type _type;
-
-    std::string _uid;
-};
-
-}; // FreeFare
-}; // LibNfc
-
-#endif //LIBNFC_CPPTOOLS_FREEFARETAG_H

libnfc_cpptools/src/freefare/FreeFareAccessBits.cpp → libnfc_cpptools/src/freefare/Tags/Classic/FreeFareClassicAccessBits.cpp

 
 #include <cstring>
 #include <iostream>
-#include "libnfc_cpptools/FreeFareAccessBits.h"
+#include "libnfc_cpptools/FreeFareClassicAccessBits.h"
 #include "libnfc_cpptools/StringUtils.h"
 #include "libnfc_cpptools/ArrayUtils.h"
 
 namespace FreeFare
 {
 
-const char FreeFareAccessBits::nonInvertedBitPosition[4][4] = {
+const char FreeFareClassicAccessBits::nonInvertedBitPosition[4][4] = {
         {0,  0,  0,  0 },
         {11, 10, 9,  8 },
         {23, 22, 21, 20},
         {19, 18, 17, 16}};
 
-const char FreeFareAccessBits::invertedBitPosition[4][4] = {
+const char FreeFareClassicAccessBits::invertedBitPosition[4][4] = {
         {0,  0,  0,  0 },
         {7,  6,  5,  4 },
         {3,  2,  1,  0},
         {15, 14, 13, 12}};
 
-FreeFareAccessBits::FreeFareAccessBits()
+FreeFareClassicAccessBits::FreeFareClassicAccessBits()
     : _bits("\xff\x0f\00\x00", 4)
 {
 }
 
-FreeFareAccessBits::FreeFareAccessBits(const std::string &bits)
+FreeFareClassicAccessBits::FreeFareClassicAccessBits(const std::string &bits)
     : _bits(LibNfc::Utils::StringUtils::ensureSize(bits, 4))
 {
 }
 
-char FreeFareAccessBits::getUserData() const
+char FreeFareClassicAccessBits::getUserData() const
 {
     return _bits[_bits.length() - 1];
 }
 
-void FreeFareAccessBits::setUserData(const char &data)
+void FreeFareClassicAccessBits::setUserData(const char &data)
 {
     _bits[_bits.length() - 1] = data;
 }
 
-void FreeFareAccessBits::setBit(int i, int j, const bool& value)
+void FreeFareClassicAccessBits::setBit(int i, int j, const bool& value)
 {
     char buf[_bits.length()];
     memcpy(buf, _bits.c_str(), _bits.length());
     _bits = std::string(buf, _bits.length());
 }
 
-bool FreeFareAccessBits::getBit(int i, int j) const
+bool FreeFareClassicAccessBits::getBit(int i, int j) const
 {
     const char* buf = _bits.c_str();
     return LibNfc::Utils::ArrayUtils::getArrayBit(buf, nonInvertedBitPosition[i][j]) && !LibNfc::Utils::ArrayUtils::getArrayBit(buf, invertedBitPosition[i][j]);
 }
 
-std::string FreeFareAccessBits::getBits() const
+std::string FreeFareClassicAccessBits::getBits() const
 {
     return _bits;
 }
 
-bool FreeFareAccessBits::canKeyAReadBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyAReadBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c3 || (!c1 && !c2 && c3);
 }
 
-bool FreeFareAccessBits::canKeyBReadBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyBReadBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 || !c2 || !c3;
 }
 
-bool FreeFareAccessBits::canKeyAWriteBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyAWriteBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-bool FreeFareAccessBits::canKeyBWriteBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyBWriteBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c2 && !c3) || (c1 && !c3) || (!c1 && c2 && c3);
 }
 
-bool FreeFareAccessBits::canKeyAIncrementBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyAIncrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-bool FreeFareAccessBits::canKeyBIncrementBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyBIncrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2 && !c3) || (c1 && c2 && !c3);
 }
 
-bool FreeFareAccessBits::canKeyADecrementBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyADecrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2) || (c1 && c2 && !c3);
 }
 
-bool FreeFareAccessBits::canKeyBDecrementBlock(int block) const
+bool FreeFareClassicAccessBits::canKeyBDecrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2) || (c1 && c2 && !c3);
 }
 
-bool FreeFareAccessBits::canKeyAReadKeyATrailer() const
+bool FreeFareClassicAccessBits::canKeyAReadKeyATrailer() const
 {
     return false;
 }
 
-bool FreeFareAccessBits::canKeyBReadKeyATrailer() const
+bool FreeFareClassicAccessBits::canKeyBReadKeyATrailer() const
 {
     return false;
 }
 
-bool FreeFareAccessBits::canKeyAWriteKeyATrailer() const
+bool FreeFareClassicAccessBits::canKeyAWriteKeyATrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2;
 }
 
-bool FreeFareAccessBits::canKeyBWriteKeyATrailer() const
+bool FreeFareClassicAccessBits::canKeyBWriteKeyATrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && c2 && c3) || (c1 && !c2 && !c3);
 }
 
-bool FreeFareAccessBits::canKeyAReadAccessBitsTrailer() const
+bool FreeFareClassicAccessBits::canKeyAReadAccessBitsTrailer() const
 {
     return true;
 }
 
-bool FreeFareAccessBits::canKeyBReadAccessBitsTrailer() const
+bool FreeFareClassicAccessBits::canKeyBReadAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return c1 || (c2 && c3);
 }
 
-bool FreeFareAccessBits::canKeyAWriteAccessBitsTrailer() const
+bool FreeFareClassicAccessBits::canKeyAWriteAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2 && c3;
 }
 
-bool FreeFareAccessBits::canKeyBWriteAccessBitsTrailer() const
+bool FreeFareClassicAccessBits::canKeyBWriteAccessBitsTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && c2 && c3) || (c1 && !c2 && c3);
 }
 
-bool FreeFareAccessBits::canKeyAReadKeyBTrailer() const
+bool FreeFareClassicAccessBits::canKeyAReadKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return (!c1 && !c2) || (!c1 && !c3);
 }
 
-bool FreeFareAccessBits::canKeyBReadKeyBTrailer() const
+bool FreeFareClassicAccessBits::canKeyBReadKeyBTrailer() const
 {
     return false;
 }
 
-bool FreeFareAccessBits::canKeyAWriteKeyBTrailer() const
+bool FreeFareClassicAccessBits::canKeyAWriteKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);
     return !c1 && !c2;
 }
 
-bool FreeFareAccessBits::canKeyBWriteKeyBTrailer() const
+bool FreeFareClassicAccessBits::canKeyBWriteKeyBTrailer() const
 {
     bool c1 = getBit(1, 3);
     bool c2 = getBit(2, 3);

libnfc_cpptools/src/freefare/FreeFareSector.cpp → libnfc_cpptools/src/freefare/Tags/Classic/FreeFareClassicSector.cpp

 //
 
 #include "libnfc_cpptools/StringUtils.h"
-#include "libnfc_cpptools/FreeFareSector.h"
+#include "libnfc_cpptools/FreeFareClassicSector.h"
 
 namespace LibNfc
 {
 namespace FreeFare
 {
 
-FreeFareSector::FreeFareSector(const std::string &data)
+FreeFareClassicSector::FreeFareClassicSector(const std::string &data)
 {
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
     for (unsigned int i = 0; i < 4; ++i) {
     }
 }
 
-const std::string &FreeFareSector::getBlock(int block) const
+const std::string &FreeFareClassicSector::getBlock(int block) const
 {
     return _blocks[block];
 }
 
-std::string FreeFareSector::getKeyA() const
+std::string FreeFareClassicSector::getKeyA() const
 {
     return _blocks[3].substr(0, 6);
 }
 
-std::string FreeFareSector::getKeyB() const
+std::string FreeFareClassicSector::getKeyB() const
 {
     return _blocks[3].substr(10, 6);
 }
 
-std::string FreeFareSector::getAccessBits() const
+std::string FreeFareClassicSector::getAccessBits() const
 {
     return _blocks[3].substr(6, 4);
 }
 
-FreeFareAccessBits FreeFareSector::getAccessBitsDbo() const
+FreeFareClassicAccessBits FreeFareClassicSector::getAccessBitsDbo() const
 {
-    return FreeFareAccessBits(getAccessBits());
+    return FreeFareClassicAccessBits(getAccessBits());
 }
 
-void FreeFareSector::setBlock(int block, const std::string &data)
+void FreeFareClassicSector::setBlock(int block, const std::string &data)
 {
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 16);
     if (block == 3) {
     }
 }
 
-void FreeFareSector::setKeyA(const std::string &key)
+void FreeFareClassicSector::setKeyA(const std::string &key)
 {
     std::string k = LibNfc::Utils::StringUtils::ensureSize(key, 6);
     for (int i = 0; i < k.size(); ++i) {
     _hasKeyA = !key.empty();
 }
 
-void FreeFareSector::setKeyB(const std::string &key)
+void FreeFareClassicSector::setKeyB(const std::string &key)
 {
     std::string k = LibNfc::Utils::StringUtils::ensureSize(key, 6);
     for (int i = 0; i < k.size(); ++i) {
     _hasKeyB = !key.empty();
 }
 
-void FreeFareSector::setAccessBits(const std::string &accessBits)
+void FreeFareClassicSector::setAccessBits(const std::string &accessBits)
 {
     std::string a = LibNfc::Utils::StringUtils::ensureSize(accessBits, 4);
     for (int i = 0; i < a.size(); ++i) {
     _hasAccessBits = !accessBits.empty();
 }
 
-void FreeFareSector::setAccessBits(const FreeFareAccessBits &accessBits)
+void FreeFareClassicSector::setAccessBits(const FreeFareClassicAccessBits &accessBits)
 {
     setAccessBits(accessBits.getBits());
 }
 
-bool FreeFareSector::hasBlock(int block) const
+bool FreeFareClassicSector::hasBlock(int block) const
 {
     if (block == 3) {
         return _hasKeyA && _hasKeyB && _hasAccessBits;
     return _haveBlocks[block];
 }
 
-bool FreeFareSector::hasKeyA() const
+bool FreeFareClassicSector::hasKeyA() const
 {
     return _hasKeyA;
 }
 
-bool FreeFareSector::hasKeyB() const
+bool FreeFareClassicSector::hasKeyB() const
 {
     return _hasKeyB;
 }
 
-bool FreeFareSector::hasAccessBits() const
+bool FreeFareClassicSector::hasAccessBits() const
 {
     return _hasAccessBits;
 }

libnfc_cpptools/src/freefare/FreeFareTag.cpp → libnfc_cpptools/src/freefare/Tags/Classic/FreeFareTagClassic.cpp

 //
-// Created by robin on 7/22/16.
+// Created by robin on 10/8/17.
 //
 
-#include "libnfc_cpptools/FreeFareTag.h"
-#include "libnfc_cpptools/StringUtils.h"
-#include "FreeFareTagInternal.h"
+#include <libnfc_cpptools/StringUtils.h>
+#include "libnfc_cpptools/FreeFareTagClassic.h"
+#include "FreeFareTagClassicInternal.h"
 
 namespace LibNfc
 {
 namespace FreeFare
 {
 
-std::string FreeFareTag::getTagTypeString(FreeFareTag::FreeFareTagType type)
+FreeFareTagClassic::FreeFareTagClassic(std::shared_ptr<FreeFareTagClassicInternal> tag)
+        : FreeFareTag(tag)
 {
-    if (type == FreeFareTagType::FELICA)
-    {
-        return "FELICA";
-    }
-    if (type == FreeFareTagType::MIFARE_MINI)
-    {
-        return "MIFARE_MINI";
-    }
-    if (type == FreeFareTagType::MIFARE_CLASSIC_1K)
-    {
-        return "MIFARE_CLASSIC_1K";
-    }
-    if (type == FreeFareTagType::MIFARE_CLASSIC_4K)
-    {
-        return "MIFARE_CLASSIC_4K";
-    }
-    if (type == FreeFareTagType::MIFARE_DESFIRE)
-    {
-        return "MIFARE_DESFIRE";
-    }
-    if (type == FreeFareTagType::MIFARE_ULTRALIGHT)
-    {
-        return "MIFARE_ULTRALIGHT";
-    }
-    if (type == FreeFareTagType::MIFARE_ULTRALIGHT_C)
-    {
-        return "MIFARE_ULTRALIGHT_C";
-    }
-    return "UNKNOWN";
 }
 
-FreeFareTag::FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag)
-    : _tag(tag)
+LibNfc::Utils::ResultBool FreeFareTagClassic::authenticate(int sector, const std::string& key, int keyType)
 {
+    return std::static_pointer_cast<FreeFareTagClassicInternal>(_tag)->authenticate(sector, key, keyType);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::authenticate(int sector, const std::string& key, int keyType)
-{
-    return _tag->authenticate(sector, key, keyType);
-}
-
-LibNfc::Utils::Result<MappedKeys> FreeFareTag::mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<MappedKeys> FreeFareTagClassic::mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb)
 {
     MappedKeys mappedKeys;
     unsigned long done = 0;
     return LibNfc::Utils::Result<MappedKeys>::ok(mappedKeys);
 }
 
-LibNfc::Utils::ResultString FreeFareTag::readBlock(int sector, int block, const std::string& key, int keyType)
+LibNfc::Utils::ResultString FreeFareTagClassic::readBlock(int sector, int block, const std::string& key, int keyType)
 {
-    return _tag->readBlock(sector, block, key, keyType);
+    return std::static_pointer_cast<FreeFareTagClassicInternal>(_tag)->readBlock(sector, block, key, keyType);
 }
 
-LibNfc::Utils::Result<FreeFareSector> FreeFareTag::readSector(int sector, const std::string& key, int keyType)
+LibNfc::Utils::Result<FreeFareClassicSector> FreeFareTagClassic::readSector(int sector, const std::string& key, int keyType)
 {
     std::string res;
-    int lastBlock = _tag->getSectorBlockCount(sector);
+    int lastBlock = std::static_pointer_cast<FreeFareTagClassicInternal>(_tag)->getSectorBlockCount(sector);
     for (int i = 0; i < lastBlock; ++i) {
         auto data = readBlock(sector, i, key, keyType);
         if (data) {
             res += data.getData();
         }
         else {
-            return LibNfc::Utils::Result<FreeFareSector>::error(data);
+            return LibNfc::Utils::Result<FreeFareClassicSector>::error(data);
         }
     }
-    return LibNfc::Utils::Result<FreeFareSector>::ok(FreeFareSector(res));
+    return LibNfc::Utils::Result<FreeFareClassicSector>::ok(FreeFareClassicSector(res));
 }
 
-LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(const MappedKeys& keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> FreeFareTagClassic::read(const MappedKeys& keys, std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
-        return LibNfc::Utils::Result<std::vector<FreeFareSector>>::error("Must have 16 sectors keys");
+        return LibNfc::Utils::Result<std::vector<FreeFareClassicSector>>::error("Must have 16 sectors keys");
     }
     int done = 0;
     int total = 4 * keys.size();
-    std::vector<FreeFareSector> sectors;
+    std::vector<FreeFareClassicSector> sectors;
     for (int s = 0; s < keys.size(); ++s) {
         auto sectorKey = keys[s];
-        FreeFareSector sector;
+        FreeFareClassicSector sector;
         bool keyA = false;
         bool keyB = false;
         for (int b = 0; b < 3; ++b) {
         }
 
         sector.setBlock(b, dataA);
-        FreeFareAccessBits accessBitsDboA = sector.getAccessBitsDbo();
+        FreeFareClassicAccessBits accessBitsDboA = sector.getAccessBitsDbo();
         sector.setBlock(b, dataB);
-        FreeFareAccessBits accessBitsDboB = sector.getAccessBitsDbo();
+        FreeFareClassicAccessBits accessBitsDboB = sector.getAccessBitsDbo();
         sector.setKeyA(keyA ? sectorKey.first : "");
         sector.setKeyB(keyB ? sectorKey.second : "");
 
         cb(total, total);
     }
 
-    return LibNfc::Utils::Result<std::vector<FreeFareSector>>::ok(sectors);
+    return LibNfc::Utils::Result<std::vector<FreeFareClassicSector>>::ok(sectors);
 }
 
-LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(const std::vector<std::string>& keys,
+LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> FreeFareTagClassic::read(const std::vector<std::string>& keys,
                                                                      std::function<void(int, int)> mapCb,
                                                                      std::function<void(int, int)> readCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
-        return LibNfc::Utils::Result<std::vector<FreeFareSector>>::error(mappedKeysResult);
+        return LibNfc::Utils::Result<std::vector<FreeFareClassicSector>>::error(mappedKeysResult);
     }
     return read(mappedKeysResult.getData(), readCb);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::writeBlock(int sector, int block, const std::string& key, int keyType, const std::string& data)
+LibNfc::Utils::ResultBool FreeFareTagClassic::writeBlock(int sector, int block, const std::string& key, int keyType, const std::string& data)
 {
-    return _tag->writeBlock(sector, block, key, keyType, LibNfc::Utils::StringUtils::ensureSize(data, 16));
+    return std::static_pointer_cast<FreeFareTagClassicInternal>(_tag)->writeBlock(sector, block, key, keyType, LibNfc::Utils::StringUtils::ensureSize(data, 16));
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::writeSector(int sector, const std::string& key, int keyType, const std::string& data)
+LibNfc::Utils::ResultBool FreeFareTagClassic::writeSector(int sector, const std::string& key, int keyType, const std::string& data)
 {
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
     std::string errors;
     return LibNfc::Utils::ResultBool::error(errors);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::write(const MappedKeys& keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb)
+LibNfc::Utils::ResultBool FreeFareTagClassic::write(const MappedKeys& keys,
+                                             const std::string& data,
+                                             bool writeSector0,
+                                             std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
         return LibNfc::Utils::ResultBool::error("Must have 16 sectors keys");
     return LibNfc::Utils::ResultBool::error(errors);
 }
 
-LibNfc::Utils::ResultBool FreeFareTag::write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
-                                      std::function<void(int, int)> mapCb, std::function<void(int, int)> writeCb)
+LibNfc::Utils::ResultBool FreeFareTagClassic::write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
+                                             std::function<void(int, int)> mapCb, std::function<void(int, int)> writeCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
     return write(mappedKeysResult.getData(), data, writeSector0, writeCb);
 }
 
-const std::string &FreeFareTag::getUid() const
-{
-    return _tag->getUid();
-}
-
-FreeFareTag::FreeFareTagType FreeFareTag::getType() const
-{
-    auto type = _tag->getType();
-    if (type == freefare_tag_type::FELICA)
-    {
-        return FreeFareTagType::FELICA;
-    }
-    if (type == freefare_tag_type::MIFARE_MINI)
-    {
-        return FreeFareTagType::MIFARE_MINI;
-    }
-    if (type == freefare_tag_type::MIFARE_CLASSIC_1K)
-    {
-        return FreeFareTagType::MIFARE_CLASSIC_1K;
-    }
-    if (type == freefare_tag_type::MIFARE_CLASSIC_4K)
-    {
-        return FreeFareTagType::MIFARE_CLASSIC_4K;
-    }
-    if (type == freefare_tag_type::MIFARE_DESFIRE)
-    {
-        return FreeFareTagType::MIFARE_DESFIRE;
-    }
-    if (type == freefare_tag_type::MIFARE_ULTRALIGHT)
-    {
-        return FreeFareTagType::MIFARE_ULTRALIGHT;
-    }
-    if (type == freefare_tag_type::MIFARE_ULTRALIGHT_C)
-    {
-        return FreeFareTagType::MIFARE_ULTRALIGHT_C;
-    }
-    return FreeFareTagType::UNKNOWN;
-}
-
-std::shared_ptr<FreeFareTagInternal> FreeFareTag::getTag() const
-{
-    return _tag;
-}
-
 }; // FreeFare
-}; // LibNfc
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareTagInternal.cpp → libnfc_cpptools/src/freefare/Tags/Classic/FreeFareTagClassicInternal.cpp

 //
-// Created by robin on 6/19/16.
+// Created by robin on 10/8/17.
 //
 
-#include <sstream>
-#include <map>
-#include "FreeFareTagInternal.h"
+#include "FreeFareTagClassicInternal.h"
 
 namespace LibNfc
 {
 namespace FreeFare
 {
 
-FreeFareTagInternal::FreeFareTagInternal(FreefareTag tag)
-    : _tag(tag)
+FreeFareTagClassicInternal::FreeFareTagClassicInternal(FreefareTag tag)
+        : FreeFareTagInternal(tag)
 {
-    _type = freefare_get_tag_type(tag);
-    _uid = freefare_get_tag_uid(tag);
 }
 
-FreeFareTagInternal::~FreeFareTagInternal()
-{
-    freefare_free_tag(_tag);
-}
-
-LibNfc::Utils::ResultBool FreeFareTagInternal::authenticate(int sector, std::string key, int keyType)
+LibNfc::Utils::ResultBool FreeFareTagClassicInternal::authenticate(int sector, std::string key, int keyType)
 {
 
     if (mifare_classic_connect(_tag) != 0) {
     return LibNfc::Utils::ResultBool::ok(true);
 }
 
-LibNfc::Utils::ResultString FreeFareTagInternal::readBlock(int sector, int block, std::string key, int keyType)
+LibNfc::Utils::ResultString FreeFareTagClassicInternal::readBlock(int sector, int block, std::string key, int keyType)
 {
     if (mifare_classic_connect(_tag) != 0) {
         return LibNfc::Utils::ResultString::error("Failed to connect to MIFARE tag");
     return LibNfc::Utils::ResultString::ok(std::string((const char*)data, sizeof(data)));
 }
 
-LibNfc::Utils::ResultBool FreeFareTagInternal::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+LibNfc::Utils::ResultBool FreeFareTagClassicInternal::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
 {
     if (mifare_classic_connect(_tag) != 0) {
         return LibNfc::Utils::ResultBool::error("Failed to connect to MIFARE tag");
     return LibNfc::Utils::ResultBool::ok(true);
 }
 
-const freefare_tag *FreeFareTagInternal::getTag() const
-{
-    return _tag;
-}
-
-int FreeFareTagInternal::getFirstBlock(int sector) const
+int FreeFareTagClassicInternal::getFirstBlock(int sector) const
 {
     return mifare_classic_sector_first_block(sector);
 }
 
-int FreeFareTagInternal::getLastBlock(int sector) const
+int FreeFareTagClassicInternal::getLastBlock(int sector) const
 {
     return mifare_classic_sector_last_block(sector);
 }
 
-int FreeFareTagInternal::getSectorBlockCount(int sector)
+int FreeFareTagClassicInternal::getSectorBlockCount(int sector)
 {
     return mifare_classic_sector_block_count(sector);
 }
-
-freefare_tag_type FreeFareTagInternal::getType() const
-{
-    return _type;
-}
-
-const std::string &FreeFareTagInternal::getUid() const
-{
-    return _uid;
-}
-
 }; // FreeFare
 }; // LibNfc

libnfc_cpptools/src/freefare/Tags/Classic/FreeFareTagClassicInternal.h

+//
+// Created by robin on 10/8/17.
+//
+
+#ifndef NFC_CPPTOOLS_FREEFARETAGCLASSICINTERNAL_H
+#define NFC_CPPTOOLS_FREEFARETAGCLASSICINTERNAL_H
+
+#include "Tags/FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareTagClassicInternal : public FreeFareTagInternal
+{
+public:
+    explicit FreeFareTagClassicInternal(FreefareTag tag);
+    ~FreeFareTagClassicInternal() override = default;
+
+    LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
+
+    LibNfc::Utils::ResultString readBlock(int sector, int block, std::string key, int keyType);
+
+    LibNfc::Utils::ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
+
+    int getFirstBlock(int sector) const;
+
+    int getLastBlock(int sector) const;
+
+    int getSectorBlockCount(int sector);
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //NFC_CPPTOOLS_FREEFARETAGCLASSICINTERNAL_H

libnfc_cpptools/src/freefare/Tags/FreeFareTag.cpp

+//
+// Created by robin on 7/22/16.
+//
+
+#include "libnfc_cpptools/FreeFareTag.h"
+#include "libnfc_cpptools/StringUtils.h"
+#include "FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+std::string FreeFareTag::getTagTypeString(FreeFareTag::FreeFareTagType type)
+{
+    if (type == FreeFareTagType::FELICA)
+    {
+        return "FELICA";
+    }
+    if (type == FreeFareTagType::MIFARE_MINI)
+    {
+        return "MIFARE_MINI";
+    }
+    if (type == FreeFareTagType::MIFARE_CLASSIC_1K)
+    {
+        return "MIFARE_CLASSIC_1K";
+    }
+    if (type == FreeFareTagType::MIFARE_CLASSIC_4K)
+    {
+        return "MIFARE_CLASSIC_4K";
+    }
+    if (type == FreeFareTagType::MIFARE_DESFIRE)
+    {
+        return "MIFARE_DESFIRE";
+    }
+    if (type == FreeFareTagType::MIFARE_ULTRALIGHT)
+    {
+        return "MIFARE_ULTRALIGHT";
+    }
+    if (type == FreeFareTagType::MIFARE_ULTRALIGHT_C)
+    {
+        return "MIFARE_ULTRALIGHT_C";
+    }
+    return "UNKNOWN";
+}
+
+FreeFareTag::FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag)
+    : _tag(tag)
+{
+}
+
+
+const std::string &FreeFareTag::getUid() const
+{
+    return _tag->getUid();
+}
+
+FreeFareTag::FreeFareTagType FreeFareTag::getType() const
+{
+    auto type = _tag->getType();
+    if (type == freefare_tag_type::FELICA)
+    {
+        return FreeFareTagType::FELICA;
+    }
+    if (type == freefare_tag_type::MIFARE_MINI)
+    {
+        return FreeFareTagType::MIFARE_MINI;
+    }
+    if (type == freefare_tag_type::MIFARE_CLASSIC_1K)
+    {
+        return FreeFareTagType::MIFARE_CLASSIC_1K;
+    }
+    if (type == freefare_tag_type::MIFARE_CLASSIC_4K)
+    {
+        return FreeFareTagType::MIFARE_CLASSIC_4K;
+    }
+    if (type == freefare_tag_type::MIFARE_DESFIRE)
+    {
+        return FreeFareTagType::MIFARE_DESFIRE;
+    }
+    if (type == freefare_tag_type::MIFARE_ULTRALIGHT)
+    {
+        return FreeFareTagType::MIFARE_ULTRALIGHT;
+    }
+    if (type == freefare_tag_type::MIFARE_ULTRALIGHT_C)
+    {
+        return FreeFareTagType::MIFARE_ULTRALIGHT_C;
+    }
+    return FreeFareTagType::UNKNOWN;
+}
+
+std::shared_ptr<FreeFareTagInternal> FreeFareTag::getTag() const
+{
+    return _tag;
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/Tags/FreeFareTagInternal.cpp

+//
+// Created by robin on 6/19/16.
+//
+
+#include <sstream>
+#include <map>
+#include "FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+FreeFareTagInternal::FreeFareTagInternal(FreefareTag tag)
+    : _tag(tag)
+    , _type(freefare_get_tag_type(tag))
+    , _uid(freefare_get_tag_uid(tag))
+{
+}
+
+FreeFareTagInternal::~FreeFareTagInternal()
+{
+    freefare_free_tag(_tag);
+}
+
+const freefare_tag *FreeFareTagInternal::getTag() const
+{
+    return _tag;
+}
+
+freefare_tag_type FreeFareTagInternal::getType() const
+{
+    return _type;
+}
+
+const std::string &FreeFareTagInternal::getUid() const
+{
+    return _uid;
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/Tags/FreeFareTagInternal.h

+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef LIBNFC_CPPTOOLS_FREEFARETAG_H
+#define LIBNFC_CPPTOOLS_FREEFARETAG_H
+
+#include <freefare.h>
+#include <string>
+#include "libnfc_cpptools/Result.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareTagInternal
+{
+public:
+
+    explicit FreeFareTagInternal(FreefareTag tag);
+    virtual ~FreeFareTagInternal();
+
+    const freefare_tag * getTag() const;
+
+    freefare_tag_type getType() const;
+
+    const std::string & getUid() const;
+
+protected:
+    const FreefareTag _tag;
+
+    const freefare_tag_type _type;
+
+    const std::string _uid;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //LIBNFC_CPPTOOLS_FREEFARETAG_H

libnfc_cpptools/src/libnfc/LibNfcContext.cpp

 
 #include <algorithm>
 #include "libnfc_cpptools/LibNfcContext.h"
-#include "LibNfcInternal.h"
+#include "LibNfcContextInternal.h"
 
 #define Q(x) #x
 #define QUOTE(x) Q(x)
 
 LibNfcContext::LibNfcContext()
 {
-    _libNfc = std::make_shared<LibNfcInternal>();
+    _libNfc = std::make_shared<LibNfcContextInternal>();
 }
 
 LibNfcContext::~LibNfcContext()
 
 std::string LibNfcContext::getLibNfcVersion()
 {
-    return LibNfcInternal::getVersion();
+    return LibNfcContextInternal::getVersion();
 }
 
 void LibNfcContext::clean()

libnfc_cpptools/src/libnfc/LibNfcInternal.cpp → libnfc_cpptools/src/libnfc/LibNfcContextInternal.cpp

 //
 
 #include <boost/shared_ptr.hpp>
-#include "LibNfcInternal.h"
+#include "LibNfcContextInternal.h"
 
 namespace LibNfc
 {
 namespace Core
 {
 
-LibNfcInternal::LibNfcInternal()
+LibNfcContextInternal::LibNfcContextInternal()
     : _context(0)
 {
 }
 
-LibNfcInternal::~LibNfcInternal()
+LibNfcContextInternal::~LibNfcContextInternal()
 {
     clean();
 }
 
-LibNfc::Utils::ResultBool LibNfcInternal::init()
+LibNfc::Utils::ResultBool LibNfcContextInternal::init()
 {
     nfc_init(&_context);
     if (!_context) {
     return LibNfc::Utils::ResultBool::ok(true);
 }
 
-std::string LibNfcInternal::getVersion()
+std::string LibNfcContextInternal::getVersion()
 {
     return nfc_version();
 }
 
-void LibNfcInternal::clean()
+void LibNfcContextInternal::clean()
 {
     nfc_exit(_context);
     _context = 0;
 }
 
-LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>> LibNfcInternal::getDevices() const
+LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>> LibNfcContextInternal::getDevices() const
 {
     nfc_connstring devices[16];
     ::memset((char*)devices, 0, sizeof(devices));
     return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>>::ok(devicesList);
 }
 
-nfc_context *LibNfcInternal::getContext() const
+nfc_context *LibNfcContextInternal::getContext() const
 {
     return _context;
 }

libnfc_cpptools/src/libnfc/LibNfcInternal.h → libnfc_cpptools/src/libnfc/LibNfcContextInternal.h

 
 class NfcDeviceInternal;
 
-class LibNfcInternal
+class LibNfcContextInternal
 {
 public:
-    LibNfcInternal();
-    virtual ~LibNfcInternal();
+    LibNfcContextInternal();
+    virtual ~LibNfcContextInternal();
 
     LibNfc::Utils::ResultBool init();
 

libnfc_cpptools/src/libnfc/NfcDeviceInternal.cpp

 namespace Core
 {
 
-NfcDeviceInternal::NfcDeviceInternal(const LibNfcInternal* libNfc, const std::string& str)
+NfcDeviceInternal::NfcDeviceInternal(const LibNfcContextInternal* libNfc, const std::string& str)
     : _connStr(str)
     , _device(nullptr)
     , _libNfc(libNfc)

libnfc_cpptools/src/libnfc/NfcDeviceInternal.h

 #include <string>
 #include <nfc/nfc-types.h>
 #include "libnfc_cpptools/Result.h"
-#include "LibNfcInternal.h"
+#include "LibNfcContextInternal.h"
 
 namespace LibNfc
 {
 namespace Core
 {
 
-class LibNfcInternal;
+class LibNfcContextInternal;
 
 class NfcDeviceInternal
 {
 public:
-    NfcDeviceInternal(const LibNfcInternal* libNfc, const std::string& connStr);
+    NfcDeviceInternal(const LibNfcContextInternal* libNfc, const std::string& connStr);
     ~NfcDeviceInternal();
 
     LibNfc::Utils::ResultBool open();
 
     nfc_device* _device;
 
-    const LibNfcInternal* _libNfc;
+    const LibNfcContextInternal* _libNfc;
 };
 
 }; // Core

tests/test-main.cpp

 #include <libnfc_cpptools/LibNfcContext.h>
 #include <libnfc_cpptools/StringUtils.h>
 #include <libnfc_cpptools/ArrayUtils.h>
-#include <libnfc_cpptools/FreeFareAccessBits.h>
+#include <libnfc_cpptools/FreeFareClassicAccessBits.h>
 
 TEST(StringUtils, rawToHumanChar)
 {
 TEST(AccessBitsDbo, getBit)
 {
   const unsigned char buf[4] = {0x05, 0xa3, 0xcf, 0x00};
-  LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+  LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.getBit(1, 0));
   ASSERT_TRUE(dbo.getBit(2, 0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock1)
 {
   const unsigned char buf[4] = {0xff, 0x0f, 0x00, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_TRUE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock2)
 {
   const unsigned char buf[4] = {0xef, 0x0f, 0x01, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_TRUE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock3)
 {
   const unsigned char buf[4] = {0xfe, 0x1f, 0x00, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_TRUE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock4)
 {
   const unsigned char buf[4] = {0xee, 0x1f, 0x01, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_TRUE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock5)
 {
   const unsigned char buf[4] = {0xff, 0x0e, 0x10, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_TRUE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock6)
 {
   const unsigned char buf[4] = {0xef, 0x0e, 0x11, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock7)
 {
   const unsigned char buf[4] = {0xfe, 0x1e, 0x10, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadBlock(0));
   ASSERT_TRUE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisBlock8)
 {
   const unsigned char buf[4] = {0xee, 0x1e, 0x11, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadBlock(0));
   ASSERT_FALSE(dbo.canKeyBReadBlock(0));
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer1)
 {
   const unsigned char buf[4] = {0xff, 0x0f, 0x00, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer2)
 {
   const unsigned char buf[4] = {0x7f, 0x0f, 0x08, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer3)
 {
   const unsigned char buf[4] = {0xf7, 0x8f, 0x00, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer4)
 {
   const unsigned char buf[4] = {0x77, 0x8f, 0x08, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer5)
 {
   const unsigned char buf[4] = {0xff, 0x07, 0x80, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer6)
 {
   const unsigned char buf[4] = {0x7f, 0x07, 0x88, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer7)
 {
   const unsigned char buf[4] = {0xf7, 0x87, 0x80, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
 TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer8)
 {
   const unsigned char buf[4] = {0x77, 0x87, 0x88, 0x00};
-    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+    LibNfc::FreeFare::FreeFareClassicAccessBits dbo((const char*)buf);
 
   ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
   ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());