fixes; cli dump and map

cli/Interface/MainClass.cpp

     for (size_t i = 0; i < devices.size(); ++i) {
         std::cout << devices[i]->getConnStr() << std::endl;
     }
+    std::cout << "Using first device" << std::endl;
 
     auto device = devices[0];
     auto open = device->open();
     }
 
     FreeFareDeviceBusiness freeFareDevice(device);
-    auto tags = freeFareDevice.getTags();
-    if (!tags) {
-        tags.print();
+    auto tagsResult = freeFareDevice.getTags();
+    if (!tagsResult) {
+        tagsResult.print();
         return 5;
     }
 
-    std::cout << "Found " << tags.getData().size() << " tags:" << std::endl;
-    for (size_t i = 0; i < tags.getData().size(); ++i) {
-        auto tag = tags.getData()[i];
+    auto tags = tagsResult.getData();
+    if (tags.size() == 0) {
+        std::cerr << "No tag found" << std::endl;
+        return 6;
+    }
+
+    std::cout << "Found " << tagsResult.getData().size() << " tags:" << std::endl;
+    for (size_t i = 0; i < tagsResult.getData().size(); ++i) {
+        auto tag = tagsResult.getData()[i];
         std::cout << "UID: " << tag->getUid() << std::endl;
         std::cout << "Type: " << tag->getType() << std::endl;
-        mapKeys(tag);
     }
+    std::cout << "Using first tag" << std::endl;
+
+    auto tag = tags[0];
+
+    std::vector<std::string> keys;
+//    keys.push_back(StringUtils::humanToRaw("8829da9daf76").getData());
+//    keys.push_back(StringUtils::humanToRaw("ffffffffffff").getData());
+    keys.push_back(StringUtils::humanToRaw("484558414354").getData());
+
+    int res = dump(tag, keys); //mapKeys(tag);
 
     device->close();
     libNfc.clean();
 
-    return 0;
+    return res;
 }
 
-int MainClass::mapKeys(std::shared_ptr<FreeFareTagBusiness> tag)
+int MainClass::mapKeys(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    std::vector<std::string> keys;
-    keys.push_back(StringUtils::humanToRaw("8829da9daf76").getData());
     auto mappedKeysResult = tag->mapKeys(keys);
     if (!mappedKeysResult) {
         mappedKeysResult.print();
     return 0;
 }
 
-int MainClass::dump(std::shared_ptr<FreeFareTagBusiness> tag)
+int MainClass::dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    for(int s = 0; s < 16; ++s)
-    {
+    auto dumpResult = tag->dump(keys);
+    if (!dumpResult) {
+        dumpResult.print();
+        return 7;
+    }
+    auto dump = dumpResult.getData();
+    for(int s = 0; s < 16; ++s) {
         std::cout << "+Sector: " << s << std::endl;
-        auto sectorResult = tag->readSector(s, StringUtils::humanToRaw("8829da9daf76").getData(), MFC_KEY_A);
-        if (!sectorResult)
-        {
-            sectorResult.print();
+        auto sector = dump[s];
+        for (int b = 0; b < 3; ++b) {
+            std::cout << (sector.hasBlock(b) ? StringUtils::rawToHuman(sector.getBlock(b)) : std::string(32, '-')) << std::endl;
         }
-        else
-        {
-            auto sector = sectorResult.getData();
-            for (int b = 0; b < 3; ++b)
-            {
-                std::cout << StringUtils::rawToHuman(sector.getBlock(b)) << std::endl;
-            }
-            std::cout << StringUtils::rawToHuman(sector.getKeyA()) << " "
-            << StringUtils::rawToHuman(sector.getAccessBits()) << " "
-            << StringUtils::rawToHuman(sector.getKeyB()) << std::endl;
+        std::cout << (sector.hasKeyA() ? StringUtils::rawToHuman(sector.getKeyA()) : std::string(12, '-')) << " "
+            << (sector.hasAccessBits() ? StringUtils::rawToHuman(sector.getAccessBits()) : std::string(8, '-'))  << " "
+            << (sector.hasKeyB() ? StringUtils::rawToHuman(sector.getKeyB()) : std::string(12, '-')) << std::endl;
+        AccessBitsDbo accessBitsDbo = sector.getAccessBitsDbo();
+        for (int b = 0; b < 3; ++b) {
+            std::cout << "+Block: " << b << " ";
+            printBlockAccessBits(accessBitsDbo, b);
         }
+        std::cout << "+Block: 4 ";
+        printTrailerAccessBits(accessBitsDbo);
     }
     return 0;
 }
 
+void MainClass::printBlockAccessBits(const AccessBitsDbo &accessBits, int block)
+{
+    std::cout << "read: " << (accessBits.canKeyAReadBlock(block) ? "A" : "") << (accessBits.canKeyBReadBlock(block) ? "B" : "");
+    std::cout << " write: " << (accessBits.canKeyAWriteBlock(block) ? "A" : "") << (accessBits.canKeyBWriteBlock(block) ? "B" : "");
+    std::cout << " increment: " << (accessBits.canKeyAIncrementBlock(block) ? "A" : "") << (accessBits.canKeyBIncrementBlock(block) ? "B" : "");
+    std::cout << " decrement: " << (accessBits.canKeyADecrementBlock(block) ? "A" : "") << (accessBits.canKeyBDecrementBlock(block) ? "B" : "") << std::endl;
+}
+
+void MainClass::printTrailerAccessBits(const AccessBitsDbo &accessBits)
+{
+    std::cout << "key A read: " << (accessBits.canKeyAReadKeyATrailer() ? "A" : "") << (accessBits.canKeyBReadKeyATrailer() ? "B" : "");
+    std::cout << " key A write: " << (accessBits.canKeyAWriteKeyATrailer() ? "A" : "") << (accessBits.canKeyBWriteKeyATrailer() ? "B" : "");
+
+    std::cout << " AC bits read: " << (accessBits.canKeyAReadAccessBitsTrailer() ? "A" : "") << (accessBits.canKeyBReadAccessBitsTrailer() ? "B" : "");
+    std::cout << " AC bits write: " << (accessBits.canKeyAWriteAccessBitsTrailer() ? "A" : "") << (accessBits.canKeyBWriteAccessBitsTrailer() ? "B" : "");
 
+    std::cout << " key B read: " << (accessBits.canKeyAReadKeyBTrailer() ? "A" : "") << (accessBits.canKeyBReadKeyBTrailer() ? "B" : "");
+    std::cout << " key B write: " << (accessBits.canKeyAWriteKeyBTrailer() ? "A" : "") << (accessBits.canKeyBWriteKeyBTrailer() ? "B" : "") << std::endl;;
+}

cli/Interface/MainClass.h

 
     int main();
 
-    int mapKeys(std::shared_ptr<FreeFareTagBusiness> tag);
+    int mapKeys(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys);
 
-    int dump(std::shared_ptr<FreeFareTagBusiness> tag);
+    int dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys);
+
+    void printBlockAccessBits(const AccessBitsDbo& accessBits, int block);
+
+    void printTrailerAccessBits(const AccessBitsDbo& accessBits);
 
 private:
     int _argc;

src/Business/FreeFareTagBusiness.cpp

             return Result<SectorDbo>::error(data);
         }
     }
-    return SectorDbo::parse(res);
+    return Result<SectorDbo>::ok(SectorDbo(res));
 }
 
 const std::string &FreeFareTagBusiness::getUid() const
     return _tag;
 }
 
-Result<std::vector<std::vector<std::pair<std::string, std::string>>>> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys)
+Result<MappedKeys> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys)
 {
     std::vector<std::vector<std::pair<std::string, std::string>>> mappedKeys;
 
         for (int j = 0; j < 4; ++j) {
             std::pair<std::string, std::string> blockKeys;
             for (auto key : keys) {
-                auto res = authenticate(i, j, key, MFC_KEY_A);
-                if (res) {
+                if (authenticate(i, j, key, MFC_KEY_A)) {
                     blockKeys.first = key;
                 }
-                res = authenticate(i, j, key, MFC_KEY_B);
-                if (res) {
+                if (authenticate(i, j, key, MFC_KEY_B)) {
                     blockKeys.second = key;
                 }
+                if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
+                    break;
+                }
             }
             sectorKeys.push_back(blockKeys);
         }
     }
 
     return Result<std::vector<std::vector<std::pair<std::string, std::string>>>>::ok(mappedKeys);
-}
+}
+
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(MappedKeys keys)
+{
+    if (keys.size() != 16) {
+        return Result<std::vector<SectorDbo>>::error("Must have 16 sectors");
+    }
+    for (int i = 0; i < keys.size(); ++i) {
+        auto key = keys[i];
+        if (key.size() != 4) {
+            return Result<std::vector<SectorDbo>>::error("Must have 4 keys in sector " + i);
+        }
+    }
+    std::vector<SectorDbo> sectors;
+    for (int s = 0; s < keys.size(); ++s) {
+        auto sectorKeys = keys[s];
+        SectorDbo sector;
+        bool keyA = false;
+        bool keyB = false;
+        for (int b = 0; b < sectorKeys.size() - 1; ++b) {
+            auto blockKey = sectorKeys[b];
+            std::string data = "";
+            if (!blockKey.first.empty()) {
+                auto blockResult = readBlock(s, b, blockKey.first, MFC_KEY_A);
+                if (blockResult) {
+                    data = blockResult.getData();
+                    keyA = true;
+                }
+            }
+            if (!blockKey.second.empty()) {
+                auto blockResult = readBlock(s, b, blockKey.second, MFC_KEY_B);
+                if (blockResult) {
+                    data = blockResult.getData();
+                    keyB = true;
+                }
+            }
+            sector.setBlock(b, data);
+        }
+        int b = sectorKeys.size() - 1;
+        auto blockKey = sectorKeys[b];
+        std::string data = "";
+        if (!blockKey.first.empty()) {
+            auto blockResult = readBlock(s, b, blockKey.first, MFC_KEY_A);
+            if (blockResult) {
+                data = blockResult.getData();
+                keyA = true;
+            }
+        }
+        if (!blockKey.second.empty()) {
+            auto blockResult = readBlock(s, b, blockKey.second, MFC_KEY_B);
+            if (blockResult) {
+                data = blockResult.getData();
+                keyB = true;
+            }
+        }
+        sector.setBlock(b, data);
+        AccessBitsDbo accessBitsDbo = sector.getAccessBitsDbo();
+
+        sector.setKeyA(keyA ? blockKey.first : "");
+        sector.setKeyB(keyB ? blockKey.second : "");
+        std::string accessBits;
+        if (!data.empty())
+        {
+            if ((keyA && accessBitsDbo.canKeyAReadAccessBitsTrailer()) || (keyB && accessBitsDbo.canKeyBReadAccessBitsTrailer())) {
+                accessBits = accessBitsDbo.getBits();
+            }
+        }
+        sector.setAccessBits(accessBits);
+
+        sectors.push_back(sector);
+    }
+
+    return Result<std::vector<SectorDbo>>::ok(sectors);
+}
+
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(std::vector<std::string> keys)
+{
+    auto mappedKeysResult = mapKeys(keys);
+    if (!mappedKeysResult) {
+        return Result<std::vector<SectorDbo>>::error(mappedKeysResult);
+    }
+    return dump(mappedKeysResult.getData());
+}

src/Business/FreeFareTagBusiness.h

 #include <DataAccess/FreeFareTag.h>
 #include <DataAccess/SectorDbo.h>
 
+typedef std::vector<std::vector<std::pair<std::string, std::string>>> MappedKeys;
+
 class FreeFareTagBusiness
 {
 public:
 
     Result<SectorDbo> readSector(int sector, std::string key, int keyType);
 
-    Result<std::vector<std::vector<std::pair<std::string, std::string>>>> mapKeys(std::vector<std::string> keys);
+    Result<MappedKeys> mapKeys(std::vector<std::string> keys);
+
+    Result<std::vector<SectorDbo>> dump(MappedKeys keys);
+
+    Result<std::vector<SectorDbo>> dump(std::vector<std::string> keys);
 
     const std::string& getUid() const;
 

src/CMakeLists.txt

         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 DataAccess/SectorDbo.cpp DataAccess/SectorDbo.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 DataAccess/SectorDbo.cpp DataAccess/SectorDbo.h DBO/ArrayUtils.cpp DBO/ArrayUtils.h)
 
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
 target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/AccessBitsDbo.cpp

 #include <cstring>
 #include <iostream>
 #include "AccessBitsDbo.h"
+#include "StringUtils.h"
+#include "ArrayUtils.h"
 
 const char AccessBitsDbo::nonInvertedBitPosition[4][4] = {
         {0,  0,  0,  0 },
 }
 
 AccessBitsDbo::AccessBitsDbo(const std::string &bits)
-    : _bits(bits.substr(0, 4))
+    : _bits(StringUtils::ensureSize(bits, 4))
 {
 }
 
     _bits[_bits.length() - 1] = data;
 }
 
-void AccessBitsDbo::setBit(const char& i, const char& j, const bool& value)
+void AccessBitsDbo::setBit(int i, int j, const bool& value)
 {
     char buf[_bits.length()];
     memcpy(buf, _bits.c_str(), _bits.length());
 
-    setArrayBit(buf, nonInvertedBitPosition[i][j], value);
-    setArrayBit(buf, invertedBitPosition[i][j], !value);
+    ArrayUtils::setArrayBit(buf, nonInvertedBitPosition[i][j], value);
+    ArrayUtils::setArrayBit(buf, invertedBitPosition[i][j], !value);
 
     _bits = std::string(buf, _bits.length());
 }
 
-void AccessBitsDbo::setArrayBit(char *buf, const char &bitPosition, const bool &value)
-{
-    char byteOffset = (char)(bitPosition / 8);
-    char bitOffset = (char)(7 - (bitPosition % 8));
-    if(value)
-    {
-        buf[byteOffset] |=  (1 << bitOffset);
-    }
-    else
-    {
-        buf[byteOffset] &= ~(1 << bitOffset);
-    }
-}
-
-void AccessBitsDbo::setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value)
-{
-    setArrayBit((char*)buf, bitPosition, value);
-}
-
-bool AccessBitsDbo::getBit(const char &i, const char &j) const
+bool AccessBitsDbo::getBit(int i, int j) const
 {
     const char* buf = _bits.c_str();
-    return getArrayBit(buf, nonInvertedBitPosition[i][j]) && !getArrayBit(buf, invertedBitPosition[i][j]);
-}
-
-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;
+    return ArrayUtils::getArrayBit(buf, nonInvertedBitPosition[i][j]) && !ArrayUtils::getArrayBit(buf, invertedBitPosition[i][j]);
 }
 
-bool AccessBitsDbo::getArrayBit(const unsigned char *buf, const char &bitPosition)
+std::string AccessBitsDbo::getBits() const
 {
-    return getArrayBit((const char *)buf, bitPosition);
+    return _bits;
 }
 
-bool AccessBitsDbo::canKeyAReadBlock(const char &block) const
+bool AccessBitsDbo::canKeyAReadBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c3 || (!c1 && !c2 && c3);
 }
 
-bool AccessBitsDbo::canKeyBReadBlock(const char &block) const
+bool AccessBitsDbo::canKeyBReadBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 || !c2 || !c3;
 }
 
-bool AccessBitsDbo::canKeyAWriteBlock(const char &block) const
+bool AccessBitsDbo::canKeyAWriteBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-bool AccessBitsDbo::canKeyBWriteBlock(const char &block) const
+bool AccessBitsDbo::canKeyBWriteBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c2 && !c3) || (c1 && !c3) || (!c1 && c2 && c3);
 }
 
-bool AccessBitsDbo::canKeyAIncrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyAIncrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return !c1 && !c2 && !c3;
 }
 
-bool AccessBitsDbo::canKeyBIncrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyBIncrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2 && !c3) || (c1 && c2 && !c3);
 }
 
-bool AccessBitsDbo::canKeyADecrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyADecrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);
     return (!c1 && !c2) || (c1 && c2 && !c3);
 }
 
-bool AccessBitsDbo::canKeyBDecrementBlock(const char &block) const
+bool AccessBitsDbo::canKeyBDecrementBlock(int block) const
 {
     bool c1 = getBit(1, block);
     bool c2 = getBit(2, block);

src/DBO/AccessBitsDbo.h

     char getUserData() const;
     void setUserData(const char& data);
 
-    void setBit(const char& i, const char& j, const bool& value);
-    bool getBit(const char& i, const char& j) const;
+    void setBit(int i, int j, const bool& value);
+    bool getBit(int i, int j) const;
+    std::string getBits() const;
 
-    bool canKeyAReadBlock(const char& block) const;
-    bool canKeyBReadBlock(const char& block) const;
+    bool canKeyAReadBlock(int block) const;
+    bool canKeyBReadBlock(int block) const;
 
-    bool canKeyAWriteBlock(const char& block) const;
-    bool canKeyBWriteBlock(const char& block) const;
+    bool canKeyAWriteBlock(int block) const;
+    bool canKeyBWriteBlock(int block) const;
 
-    bool canKeyAIncrementBlock(const char& block) const;
-    bool canKeyBIncrementBlock(const char& block) const;
+    bool canKeyAIncrementBlock(int block) const;
+    bool canKeyBIncrementBlock(int block) const;
 
-    bool canKeyADecrementBlock(const char& block) const;
-    bool canKeyBDecrementBlock(const char& block) const;
+    bool canKeyADecrementBlock(int block) const;
+    bool canKeyBDecrementBlock(int block) const;
 
     bool canKeyAReadKeyATrailer() const;
     bool canKeyBReadKeyATrailer() 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 bool getArrayBit(const char *buf, const char &bitPosition);
-    static bool getArrayBit(const unsigned char *buf, const char &bitPosition);
-
 private:
     std::string _bits;
 };

src/DBO/ArrayUtils.cpp

+//
+// Created by robin on 7/23/16.
+//
+
+#include "ArrayUtils.h"
+
+
+void ArrayUtils::setArrayBit(char *buf, const char &bitPosition, const bool &value)
+{
+    char byteOffset = (char)(bitPosition / 8);
+    char bitOffset = (char)(7 - (bitPosition % 8));
+    if(value)
+    {
+        buf[byteOffset] |=  (1 << bitOffset);
+    }
+    else
+    {
+        buf[byteOffset] &= ~(1 << bitOffset);
+    }
+}
+
+void ArrayUtils::setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value)
+{
+    setArrayBit((char*)buf, bitPosition, value);
+}
+
+bool ArrayUtils::getArrayBit(const char *buf, const char &bitPosition)
+{
+    char byteOffset = (char)(bitPosition / 8);
+    char bitOffset = (char)(7 - (bitPosition % 8));
+    return (buf[byteOffset] >> bitOffset) & 1 == 1;
+}
+
+bool ArrayUtils::getArrayBit(const unsigned char *buf, const char &bitPosition)
+{
+    return getArrayBit((const char *)buf, bitPosition);
+}

src/DBO/ArrayUtils.h

+//
+// Created by robin on 7/23/16.
+//
+
+#ifndef MIFARE_TOOLS_ARRAYUTILS_H
+#define MIFARE_TOOLS_ARRAYUTILS_H
+
+
+class ArrayUtils
+{
+public:
+    static void setArrayBit(char *buf, const char &bitPosition, const bool &value);
+    static void setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value);
+    static bool getArrayBit(const char *buf, const char &bitPosition);
+    static bool getArrayBit(const unsigned char *buf, const char &bitPosition);
+
+};
+
+
+#endif //MIFARE_TOOLS_ARRAYUTILS_H

src/DBO/StringUtils.cpp

     return rawToHuman((unsigned long)c);
 }
 
-std::string StringUtils::rawToHuman(std::string raw)
+std::string StringUtils::rawToHuman(const std::string& raw)
 {
     std::string human;
     for (size_t i = 0; i < raw.size(); ++i) {
     return human;
 }
 
-ResultString StringUtils::humanToRaw(std::string human)
+ResultString StringUtils::humanToRaw(const std::string& human)
 {
     if (human.size() % 2 != 0) {
         return ResultString::error("Malformed hex data: invalid length");
     return ResultString::ok(raw);
 }
 
-std::string StringUtils::toLower(std::string str)
+std::string StringUtils::toLower(const std::string& str)
 {
     std::string lower;
     for (size_t i = 0; i < str.size(); ++i) {
     return c;
 }
 
-std::string StringUtils::toUpper(std::string str)
+std::string StringUtils::toUpper(const std::string& str)
 {
     std::string upper;
     for (size_t i = 0; i < str.size(); ++i) {
     }
     return c;
 }
+
+std::string StringUtils::ensureSize(const std::string &data, int size)
+{
+    if (data.size() >= size) {
+        return data.substr(0, size);
+    }
+    else {
+        std::string d = data;
+        while (d.size() < size) {
+            d += '\0';
+        }
+        return d;
+    }
+}
+
+

src/DBO/StringUtils.h

     static std::string rawToHuman(int c);
     static std::string rawToHuman(unsigned long c);
     static std::string rawToHuman(long c);
-    static std::string rawToHuman(std::string raw);
+    static std::string rawToHuman(const std::string& raw);
 
-    static ResultString humanToRaw(std::string human);
+    static ResultString humanToRaw(const std::string& human);
 
-    static std::string toLower(std::string str);
+    static std::string toLower(const std::string& str);
     static char toLower(char c);
 
-    static std::string toUpper(std::string str);
+    static std::string toUpper(const std::string& str);
     static char toUpper(char c);
+
+    static std::string ensureSize(const std::string& data, int size);
 };
 
 

src/DataAccess/SectorDbo.cpp

 // Created by robin on 7/22/16.
 //
 
+#include <DBO/StringUtils.h>
 #include "SectorDbo.h"
 
-Result<SectorDbo> SectorDbo::parse(std::string data)
+SectorDbo::SectorDbo(const std::string &data)
 {
-    if (data.length() != 64) {
-        return Result<SectorDbo>::error("Data length must be 64");
-    }
-    SectorDbo dbo;
+    std::string d = StringUtils::ensureSize(data, 64);
     for (int i = 0; i < 4; ++i) {
-        dbo._blocks[i] = data.substr(16 * i, 16);
+        _blocks[i] = d.substr(16 * i, 16);
+        _haveBlocks[i] = true;
     }
-    return Result<SectorDbo>::ok(dbo);
 }
 
 const std::string &SectorDbo::getBlock(int block) const
 {
     return _blocks[3].substr(6, 4);
 }
+
+AccessBitsDbo SectorDbo::getAccessBitsDbo() const
+{
+    return AccessBitsDbo(getAccessBits());
+}
+
+void SectorDbo::setBlock(int block, const std::string &data)
+{
+    std::string d = StringUtils::ensureSize(data, 16);
+    if (block == 3) {
+        setKeyA(d.substr(0, 6));
+        setKeyB(d.substr(10, 6));
+        setAccessBits(d.substr(6, 4));
+    }
+    else {
+        _haveBlocks[block] = !data.empty();
+        _blocks[block] = d;
+    }
+}
+
+void SectorDbo::setKeyA(const std::string &key)
+{
+    std::string k = StringUtils::ensureSize(key, 6);
+    for (int i = 0; i < k.size(); ++i) {
+        _blocks[3][i] = k[i];
+    }
+    _hasKeyA = !key.empty();
+}
+
+void SectorDbo::setKeyB(const std::string &key)
+{
+    std::string k = StringUtils::ensureSize(key, 6);
+    for (int i = 0; i < k.size(); ++i) {
+        _blocks[3][10 + i] = k[i];
+    }
+    _hasKeyB = !key.empty();
+}
+
+void SectorDbo::setAccessBits(const std::string &accessBits)
+{
+    std::string a = StringUtils::ensureSize(accessBits, 4);
+    for (int i = 0; i < a.size(); ++i) {
+        _blocks[3][6 + i] = a[i];
+    }
+    _hasAccessBits = !accessBits.empty();
+}
+
+void SectorDbo::setAccessBits(const AccessBitsDbo &accessBits)
+{
+    setAccessBits(accessBits.getBits());
+}
+
+bool SectorDbo::hasBlock(int block) const
+{
+    if (block == 3) {
+        return _hasKeyA && _hasKeyB && _hasAccessBits;
+    }
+    return _haveBlocks[block];
+}
+
+bool SectorDbo::hasKeyA() const
+{
+    return _hasKeyA;
+}
+
+bool SectorDbo::hasKeyB() const
+{
+    return _hasKeyB;
+}
+
+bool SectorDbo::hasAccessBits() const
+{
+    return _hasAccessBits;
+}

src/DataAccess/SectorDbo.h

 
 #include <string>
 #include <DBO/Result.h>
+#include <DBO/AccessBitsDbo.h>
 
 class SectorDbo
 {
 public:
+    SectorDbo(const std::string& data = "");
 
     const std::string& getBlock(int block) const;
 
 
     std::string getAccessBits() const;
 
-    static Result<SectorDbo> parse(std::string data);
+    AccessBitsDbo getAccessBitsDbo() const;
+
+    void setBlock(int block, const std::string& data);
+
+    void setKeyA(const std::string& key);
+
+    void setKeyB(const std::string& key);
+
+    void setAccessBits(const std::string& accessBits);
+
+    void setAccessBits(const AccessBitsDbo& accessBits);
+
+    bool hasBlock(int block) const;
+
+    bool hasKeyA() const;
+
+    bool hasKeyB() const;
+
+    bool hasAccessBits() const;
 
 protected:
     std::string _blocks[4];
+
+    bool _haveBlocks[3];
+
+    bool _hasKeyA;
+
+    bool _hasKeyB;
+
+    bool _hasAccessBits;
 };
 
 

tests/test-main.cpp

 #include <gtest/gtest.h>
 #include <DataAccess/LibNfc.h>
 #include <DBO/StringUtils.h>
+#include <DBO/ArrayUtils.h>
 #include <DBO/AccessBitsDbo.h>
 
 TEST(StringUtils, rawToHumanChar)
   ASSERT_EQ(StringUtils::humanToRaw("1a\n00f").getError(), "Malformed hex data at char 2");
 }
 
-TEST(AccessBitsDbo, getArrayBitimple)
+TEST(StringUtils, ensureSize)
+{
+  ASSERT_EQ(StringUtils::ensureSize("test", 3), "tes");
+  ASSERT_EQ(StringUtils::ensureSize("test", 4), "test");
+  ASSERT_EQ(StringUtils::ensureSize("test", 5), std::string({'t', 'e', 's', 't', '\0'}));
+}
+
+TEST(ArrayUtils, getArrayBitimple)
 {
   const unsigned char buf[] = {0x04};
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 0));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 1));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 2));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 3));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 4));
-  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 5));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 6));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 7));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 0));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 1));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 2));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 3));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 4));
+  ASSERT_TRUE(ArrayUtils::getArrayBit(buf, 5));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 6));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 7));
 }
 
-TEST(AccessBitsDbo, getArrayBitMultiple)
+TEST(ArrayUtils, getArrayBitMultiple)
 {
   const unsigned char buf[] = {0x80, 0x14, 0x01};
-  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 0));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 1));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 2));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 3));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 4));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 5));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 6));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 7));
-
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 8));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 9));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 10));
-  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 11));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 12));
-  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 13));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 14));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 15));
-
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 16));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 17));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 18));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 19));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 20));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 21));
-  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 22));
-  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 23));
+  ASSERT_TRUE(ArrayUtils::getArrayBit(buf, 0));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 1));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 2));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 3));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 4));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 5));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 6));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 7));
+
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 8));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 9));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 10));
+  ASSERT_TRUE(ArrayUtils::getArrayBit(buf, 11));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 12));
+  ASSERT_TRUE(ArrayUtils::getArrayBit(buf, 13));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 14));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 15));
+
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 16));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 17));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 18));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 19));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 20));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 21));
+  ASSERT_FALSE(ArrayUtils::getArrayBit(buf, 22));
+  ASSERT_TRUE(ArrayUtils::getArrayBit(buf, 23));
 }
 
 TEST(AccessBitsDbo, getBit)