write methods

cli/Interface/MainClass.cpp

     CommandLineOption optionHelp(&parser, "help", 'h', "Show this help");
 
     CommandLineOption optionMap(&parser, "map", 'm', "Map keys for the tag");
-    CommandLineOption optionDump(&parser, "dump", 'd', "Dump the tag");
-    CommandLineOption optionDevices(&parser, "devices", 'l', "List NFC devices");
+    CommandLineOption optionDump(&parser, "read", 'r', "Read the tag");
+    CommandLineOption optionDevices(&parser, "devices", 'd', "List NFC devices");
     CommandLineOption optionTags(&parser, "tags", 't', "List NFC tags");
 
     CommandLineOption optionDevice(&parser, "device", 'e', "Use the device DEVICE", "DEVICE");
                                     res = mapKeys(tag, keys);
                                 }
                                 else {
-                                    std::cerr << "Must select an action (map|dump|devices|tags)" << std::endl;
+                                    std::cerr << "Must select an action (map|read|devices|tags)" << std::endl;
                                     res = EX_USAGE;
                                 }
                             }
 
 int MainClass::dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    auto dumpResult = tag->dump(keys, printPercentMapKeys, printPercentDump);
+    auto dumpResult = tag->read(keys, printPercentMapKeys, printPercentDump);
     if (!dumpResult) {
         dumpResult.print();
         return EX_DUMP_ERROR;

src/Business/FreeFareTagBusiness.cpp

 // Created by robin on 7/22/16.
 //
 
+#include <DBO/StringUtils.h>
 #include "FreeFareTagBusiness.h"
 
 FreeFareTagBusiness::FreeFareTagBusiness(std::shared_ptr<FreeFareTag> tag)
     return _tag->authenticate(sector, key, keyType);
 }
 
-ResultString FreeFareTagBusiness::readBlock(int sector, int block, std::string key, int keyType)
-{
-    return _tag->readBlock(sector, block, key, keyType);
-}
-
-Result<SectorDbo> FreeFareTagBusiness::readSector(int sector, std::string key, int keyType)
-{
-    std::string res;
-    int lastBlock = _tag->getSectorBlockCount(sector);
-    for (int i = 0; i < lastBlock; ++i) {
-        auto data = readBlock(sector, i, key, keyType);
-        if (data) {
-            res += data.getData();
-        }
-        else {
-            return Result<SectorDbo>::error(data);
-        }
-    }
-    return Result<SectorDbo>::ok(SectorDbo(res));
-}
-
-const std::string &FreeFareTagBusiness::getUid() const
-{
-    return _tag->getUid();
-}
-
-freefare_tag_type FreeFareTagBusiness::getType() const
-{
-    return _tag->getType();
-}
-
-std::shared_ptr<FreeFareTag> FreeFareTagBusiness::getTag() const
-{
-    return _tag;
-}
-
 Result<MappedKeys> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb)
 {
     MappedKeys mappedKeys;
     return Result<MappedKeys>::ok(mappedKeys);
 }
 
-Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(MappedKeys keys, std::function<void(int, int)> cb)
+ResultString FreeFareTagBusiness::readBlock(int sector, int block, std::string key, int keyType)
+{
+    return _tag->readBlock(sector, block, key, keyType);
+}
+
+Result<SectorDbo> FreeFareTagBusiness::readSector(int sector, std::string key, int keyType)
+{
+    std::string res;
+    int lastBlock = _tag->getSectorBlockCount(sector);
+    for (int i = 0; i < lastBlock; ++i) {
+        auto data = readBlock(sector, i, key, keyType);
+        if (data) {
+            res += data.getData();
+        }
+        else {
+            return Result<SectorDbo>::error(data);
+        }
+    }
+    return Result<SectorDbo>::ok(SectorDbo(res));
+}
+
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::read(MappedKeys keys, std::function<void(int, int)> cb)
 {
     if (keys.size() != 16) {
-        return Result<std::vector<SectorDbo>>::error("Must have 16 sectors");
+        return Result<std::vector<SectorDbo>>::error("Must have 16 sectors keys");
     }
     int done = 0;
     int total = 4 * keys.size();
     return Result<std::vector<SectorDbo>>::ok(sectors);
 }
 
-Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(std::vector<std::string> keys, std::function<void(int, int)> mapCb, std::function<void(int, int)> dumpCb)
+Result<std::vector<SectorDbo>> FreeFareTagBusiness::read(std::vector<std::string> keys, std::function<void(int, int)> mapCb,
+                                                         std::function<void(int, int)> dumpCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
         return Result<std::vector<SectorDbo>>::error(mappedKeysResult);
     }
-    return dump(mappedKeysResult.getData(), dumpCb);
+    return read(mappedKeysResult.getData(), dumpCb);
+}
+
+ResultBool FreeFareTagBusiness::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+{
+    return _tag->writeBlock(sector, block, key, keyType, StringUtils::ensureSize(data, 16));
+}
+
+ResultBool FreeFareTagBusiness::writeSector(int sector, std::string key, int keyType, const std::string &data)
+{
+    std::string d = StringUtils::ensureSize(data, 64);
+    std::string errors;
+    for (int b = 0; b < 4; ++b) {
+        auto result = writeBlock(sector, b, key, keyType, d.substr(b * 16, 16));
+        if (!result) {
+            errors += std::string(errors.empty() ? "" : "\n") + "Failed to write sector " + std::to_string(sector) +
+                      " block " + std::to_string(b) + " with key " + (keyType == MFC_KEY_A ? "A" : "B") + ": " + result.getError();
+        }
+    }
+    if (errors.empty()) {
+        return ResultBool::ok(true);
+    }
+    return ResultBool::error(errors);
+}
+
+ResultBool FreeFareTagBusiness::write(MappedKeys keys, const std::string &data, bool writeSector0, std::function<void(int, int)> cb)
+{
+    if (keys.size() != 16) {
+        return ResultBool::error("Must have 16 sectors keys");
+    }
+    std::string d = StringUtils::ensureSize(data, 1024);
+    std::string errors;
+    int done = 0;
+    int total = 4 * (keys.size() - (writeSector0 ? 0 : 1));
+    for (int s = writeSector0 ? 0 : 1; s < keys.size(); ++s) {
+        auto sectorKey = keys[s];
+        for (int b = 0; b < 4; ++b) {
+            std::string blockData = d.substr((s * 64) + (b * 16), 16);
+            if (cb != 0 && done < total) {
+                bool keyA = false;
+                bool keyB = false;
+                std::string sectorErrors;
+                if (!sectorKey.first.empty()) {
+                    auto resultA = writeBlock(s, b, sectorKey.first, MFC_KEY_A, blockData);
+                    if (resultA) {
+                        keyA = true;
+                    }
+                    else {
+                        sectorErrors = "Failed to write sector " + std::to_string(s) +
+                                       " block " + std::to_string(b) + " with key A: " + resultA.getError();
+                    }
+                }
+                if (!keyA && !sectorKey.second.empty()) {
+                    auto resultB = writeBlock(s, b, sectorKey.first, MFC_KEY_A, blockData);
+                    if (resultB) {
+                        keyB = true;
+                    }
+                    else {
+                        sectorErrors = std::string(sectorErrors.empty() ? "" : "\n") + "Failed to write sector " + std::to_string(s) +
+                                       " block " + std::to_string(b) + " with key B: " + resultB.getError();
+                    }
+                }
+                if (!keyA && !keyB) {
+                    errors += std::string(errors.empty() ? "" : "\n") + sectorErrors;
+                }
+                cb(++done, total);
+            }
+        }
+    }
+    if (cb != 0 && done < total) {
+        cb(total, total);
+    }
+    if (errors.empty()) {
+        return ResultBool::ok(true);
+    }
+    return ResultBool::error(errors);
+}
+
+ResultBool FreeFareTagBusiness::write(std::vector<std::string> keys, const std::string &data, bool writeSector0,
+                                      std::function<void(int, int)> mapCb, std::function<void(int, int)> dumpCb)
+{
+    auto mappedKeysResult = mapKeys(keys, mapCb);
+    if (!mappedKeysResult) {
+        return ResultBool::error(mappedKeysResult);
+    }
+    return write(mappedKeysResult.getData(), data, writeSector0, dumpCb);
+}
+
+const std::string &FreeFareTagBusiness::getUid() const
+{
+    return _tag->getUid();
+}
+
+freefare_tag_type FreeFareTagBusiness::getType() const
+{
+    return _tag->getType();
+}
+
+std::shared_ptr<FreeFareTag> FreeFareTagBusiness::getTag() const
+{
+    return _tag;
 }

src/Business/FreeFareTagBusiness.h

 
     ResultBool authenticate(int sector, std::string key, int keyType);
 
+    Result<MappedKeys> mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb = 0);
+
     ResultString readBlock(int sector, int block, std::string key, int keyType);
 
     Result<SectorDbo> readSector(int sector, std::string key, int keyType);
 
-    Result<MappedKeys> mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb = 0);
+    Result<std::vector<SectorDbo>> read(MappedKeys keys, std::function<void(int, int)> cb = 0);
+
+    Result<std::vector<SectorDbo>> read(std::vector<std::string> keys, std::function<void(int, int)> mapCb = 0,
+                                        std::function<void(int, int)> dumpCb = 0);
+
+    ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
+
+    ResultBool writeSector(int sector, std::string key, int keyType, const std::string& data);
 
-    Result<std::vector<SectorDbo>> dump(MappedKeys keys, std::function<void(int, int)> cb  = 0);
+    ResultBool write(MappedKeys keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb = 0);
 
-    Result<std::vector<SectorDbo>> dump(std::vector<std::string> keys, std::function<void(int, int)> mapCb = 0, std::function<void(int, int)> dumpCb = 0);
+    ResultBool write(std::vector<std::string> keys, const std::string& data, bool writeSector0,
+                     std::function<void(int, int)> mapCb = 0, std::function<void(int, int)> dumpCb = 0);
 
     const std::string& getUid() const;
 

src/DBO/StringUtils.cpp

 
 std::string StringUtils::ensureSize(const std::string &data, int size)
 {
-    if (data.size() >= size) {
+    if (data.size() == size) {
+        return data;
+    }
+    else if (data.size() > size) {
         return data.substr(0, size);
     }
     else {
-        std::string d = data;
-        while (d.size() < size) {
-            d += '\0';
-        }
-        return d;
+        return data + std::string(size - data.size(), '\0');
     }
 }
 

src/DataAccess/FreeFareTag.cpp

 
 ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int keyType)
 {
-
     if (mifare_classic_connect(_tag) != 0) {
         return ResultString::error("Failed to connect to MIFARE tag");
     }
     return ResultString::ok(std::string((const char*)data, sizeof(data)));
 }
 
+ResultBool FreeFareTag::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+{
+    if (mifare_classic_connect(_tag) != 0) {
+        return ResultBool::error("Failed to connect to MIFARE tag");
+    }
+    block = mifare_classic_sector_first_block((MifareClassicBlockNumber)sector) + block;
+    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");
+    }
+
+    if (mifare_classic_write(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)data.c_str())) {
+        return ResultBool::error("Failed to write data to MIFARE tag");
+    }
+    mifare_classic_disconnect(_tag);
+    return ResultBool::ok(true);
+}
+
 const freefare_tag *FreeFareTag::getTag() const
 {
     return _tag;

src/DataAccess/FreeFareTag.h

 
     ResultString readBlock(int sector, int block, std::string key, int keyType);
 
+    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;