string utils; cli

CMakeLists.txt

@@ -1,5 +1,22 @@
 cmake_minimum_required(VERSION 2.8)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/")
+
+execute_process(COMMAND git log --pretty=format:%h -n 1
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_SHA1)
+
+execute_process(COMMAND git symbolic-ref -q --short HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_REF_NAME)
+if ("${GIT_REF_NAME}" EQUAL "")
+    execute_process(COMMAND git describe --tags --exact-match
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_REF_NAME)
+endif()
+string(STRIP "${GIT_REF_NAME}" GIT_REF_NAME)
+string(STRIP "${GIT_SHA1}" GIT_SHA1)
+add_definitions(-DGIT_SHA1=${GIT_SHA1} -DGIT_REF_NAME=${GIT_REF_NAME})
+
 set(PROJECT_NAME mifare-tools)
 project(${PROJECT_NAME})
 find_package(GTest)

cli/DBO/CommandLineOption.cpp

@@ -4,8 +4,9 @@
 
 #include "CommandLineOption.h"
 
-CommandLineOption::CommandLineOption(const std::string &longName, char shortName, const std::string &description,
-                                     const std::string &valueName, const std::string &defaultValue)
+CommandLineOption::CommandLineOption(CommandLineParser* parser, const std::string &longName, char shortName,
+                                     const std::string &description, const std::string &valueName,
+                                     const std::string &defaultValue)
     : _longName(longName)
     , _shortName(shortName)
     , _description(description)
@@ -13,6 +14,7 @@ CommandLineOption::CommandLineOption(const std::string &longName, char shortName
     , _defaultValue(defaultValue)
     , _isSet(false)
 {
+    parser->addOption(this);
 }
 
 const std::string &CommandLineOption::getLongName() const

cli/DBO/CommandLineOption.h

@@ -7,12 +7,16 @@
 
 # include <string>
 # include <vector>
+#include <Interface/CommandLineParser.h>
+
+class CommandLineParser;
 
 class CommandLineOption
 {
 public:
-    CommandLineOption(const std::string& longName, char shortName, const std::string& description,
-                      const std::string& valueName = "", const std::string& defaultValue = "");
+    CommandLineOption(CommandLineParser* parser, const std::string& longName, char shortName,
+                      const std::string& description, const std::string& valueName = "",
+                      const std::string& defaultValue = "");
 
     const std::string &getLongName() const;
 

cli/Interface/CommandLineParser.cpp

@@ -60,15 +60,39 @@ void CommandLineParser::addOption(CommandLineOption* opt)
 int CommandLineParser::showHelp(int status, bool stdErr)
 {
     auto& out = stdErr ? std::cerr : std::cout;
+    int longestName = 0;
+    int longestValue = 0;
+    for (auto opt : _options) {
+        if (opt->getLongName().length() > longestName) {
+            longestName = opt->getLongName().length();
+        }
+        std::string value = "<" + opt->getValueName();
+        if (!opt->getDefaultValue().empty()) {
+            value += opt->getDefaultValue();
+        }
+        value += ">";
+        if (value.length() > longestValue) {
+            longestValue = value.length();
+        }
+    }
     out << "Options:" << std::endl;
     for (auto opt : _options)
     {
         out << "  -" << opt->getShortName() << ", --" << opt->getLongName();
+        out << std::string(longestName - opt->getLongName().length() + 2, ' ');
         if (opt->hasValue())
         {
-            out << " <" << opt->getValueName() << "=" << opt->getDefaultValue() << ">";
+            std::string value = "<" + opt->getValueName();
+            if (!opt->getDefaultValue().empty()) {
+                value += opt->getDefaultValue();
+            }
+            value += ">";
+            out << value << std::string(longestValue - value.length() + 2, ' ');
+        }
+        else {
+            out << std::string(longestValue + 2, ' ');
         }
-        out << " " << opt->getDescription() << std::endl;
+        out << opt->getDescription() << std::endl;
     }
     return status;
 }

cli/Interface/CommandLineParser.h

@@ -7,6 +7,8 @@
 
 # include "../DBO/CommandLineOption.h"
 
+class CommandLineOption;
+
 class CommandLineParser
 {
 public:

cli/Interface/MainClass.cpp

@@ -4,9 +4,10 @@
 
 #include <iostream>
 #include <sysexits.h>
+#include <iomanip>
+#include <fstream>
 #include <DBO/StringUtils.h>
 #include <Business/FreeFareDeviceBusiness.h>
-#include <iomanip>
 #include "DBO/Result.h"
 #include "Business/LibNfcBusiness.h"
 #include "CommandLineParser.h"
@@ -18,9 +19,61 @@ MainClass::MainClass(int argc, char *argv[])
 {
 }
 
+#define Q(x) #x
+#define QUOTE(x) Q(x)
+
+#ifndef GIT_SHA1
+#define GIT_SHA1 "unknown"
+#endif
+
+#ifndef GIT_REF_NAME
+#define GIT_REF_NAME "unknown"
+#endif
+
 int MainClass::main()
 {
-    std::cout << "LibNfc version: " << LibNfcBusiness::getVersion() << std::endl;
+    CommandLineParser parser(_argc, _argv);
+    CommandLineOption optionVersion(&parser, "version", 'v', "Show libnfc and mifare-tools versions");
+    CommandLineOption optionHelp(&parser, "help", 'h', "Show this help");
+
+    CommandLineOption optionDevice(&parser, "device", 'd', "Use the device DEVICE", "DEVICE");
+    CommandLineOption optionUid(&parser, "uid", 'u', "Use the UID tag", "UID");
+
+    CommandLineOption optionKeyFile(&parser, "key-file", 'f', "Path to a file containing keys", "FILE");
+
+    if (!parser.parse()) {
+        return parser.showHelp(EX_USAGE);
+    }
+    if (optionVersion.isSet()) {
+        printVersion();
+        return 0;
+    }
+    if (optionHelp.isSet()) {
+        return parser.showHelp(0, false);
+    }
+
+    std::string deviceName = "";
+    if (!optionDevice.isSet()) {
+        deviceName = optionDevice.getValue();
+    }
+
+    std::string tagUid = "";
+    if (!optionUid.isSet()) {
+        tagUid = optionUid.getValue();
+    }
+
+    std::vector<std::string> keys;
+    if (optionKeyFile.isSet()) {
+        for (auto filePath : optionKeyFile.getValues()) {
+            auto keysResult = readFile(filePath);
+            if (!keysResult) {
+                keysResult.print();
+                return 1;
+            }
+            auto fileKeys = keysResult.getData();
+            keys.insert(keys.end(), fileKeys.begin(), fileKeys.end());
+        }
+    }
 
     LibNfcBusiness libNfc;
     auto init = libNfc.init();
@@ -35,18 +88,11 @@ int MainClass::main()
         return 2;
     }
     auto devices = devicesResult.getData();
-    if (devices.size() == 0) {
-        std::cerr << "No NFC device found" << std::endl;
+    std::shared_ptr<NfcDeviceBusiness> device = getDevice(deviceName, devices);
+    if (device == 0) {
+        std::cerr << "NFC device not found" << std::endl;
         return 3;
     }
-
-    std::cout << "Found " << devices.size() << " devices: " << std::endl;
-    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();
     if (!open) {
         open.print();
@@ -66,20 +112,16 @@ int MainClass::main()
         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;
+    auto tag = getTag(tagUid, tags);
+    if (tag == 0) {
+        std::cerr << "Tag not found" << std::endl;
+        return 6;
     }
-    std::cout << "Using first tag" << std::endl;
 
-    auto tag = tags[0];
-
-    std::vector<std::string> keys;
+//    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());
+//    keys.push_back(StringUtils::humanToRaw("484558414354").getData());
 
     int res = dump(tag, keys);
 //    int res = mapKeys(tag, keys);
@@ -169,5 +211,71 @@ void MainClass::printTrailerAccessBits(const AccessBitsDbo &accessBits)
 
 void MainClass::printPercent(int done, int total)
 {
-    std::cout << "\r" << std::fixed << std::setprecision(1) <<  ((float)done / (float)total * 100.0) << "%" << std::flush;
+    std::cout << "\r\033[2K" << std::fixed << std::setprecision(1) << ((float)done / (float)total * 100.0) << "%" << std::flush;
+}
+
+void MainClass::printVersion() const
+{
+    std::cout << "LibNfc version: " << LibNfcBusiness::getVersion() << std::endl;
+    std::cout << "Mifare-tools version: " << QUOTE(GIT_REF_NAME) << "-" << QUOTE(GIT_SHA1) << std::endl;
+}
+
+std::shared_ptr<NfcDeviceBusiness> MainClass::getDevice(const std::string &deviceName, std::vector<std::shared_ptr<NfcDeviceBusiness>> devices)
+{
+    if (deviceName.empty()) {
+        if (devices.size() > 0) {
+            return devices[0];
+        }
+    }
+    else {
+        for (auto d : devices) {
+            if (d->getConnStr() == deviceName) {
+                return d;
+            }
+        }
+    }
+    return 0;
+}
+
+std::shared_ptr<FreeFareTagBusiness> MainClass::getTag(const std::string &tagUid,
+                                                       std::vector<std::shared_ptr<FreeFareTagBusiness>> tags)
+{
+    if (tagUid.empty()) {
+        if (tags.size() > 0) {
+            return tags[0];
+        }
+    }
+    else {
+        for (auto t : tags) {
+            if (t->getUid() == tagUid) {
+                return t;
+            }
+        }
+    }
+    return 0;
+}
+
+Result<std::vector<std::string>> MainClass::readFile(const std::string &filePath)
+{
+    std::vector<std::string> lines;
+    std::ifstream fileInput(filePath);
+    if (fileInput) {
+        while (!fileInput.eof()) {
+            std::string line;
+            std::getline(fileInput, line);
+            line = StringUtils::removeSpaces(line);
+            if (line.compare(0, 1, "#") != 0 && line.compare(0, 1, "+") != 0) {
+                auto keyResult = StringUtils::humanToRaw(line);
+                if (!keyResult) {
+                    return Result<std::vector<std::string>>::error("Invalid file data");
+                }
+                line = keyResult.getData();
+                lines.push_back(line);
+            }
+        }
+    }
+    else {
+        return Result<std::vector<std::string>>::error("Failed to open file: " + std::string(strerror(errno)));
+    }
+    return Result<std::vector<std::string>>::ok(lines);
 }

cli/Interface/MainClass.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <Business/FreeFareTagBusiness.h>
+#include <Business/NfcDeviceBusiness.h>
 
 class MainClass {
 public:
@@ -14,14 +15,22 @@ public:
 
     int main();
 
+    std::shared_ptr<NfcDeviceBusiness> getDevice(const std::string& deviceName, std::vector<std::shared_ptr<NfcDeviceBusiness>> devices);
+
+    std::shared_ptr<FreeFareTagBusiness> getTag(const std::string& tagUid, std::vector<std::shared_ptr<FreeFareTagBusiness>> tags);
+
     int mapKeys(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys);
 
     int dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys);
 
+    Result<std::vector<std::string>> readFile(const std::string& filePath);
+
     void printBlockAccessBits(const AccessBitsDbo& accessBits, int block);
 
     void printTrailerAccessBits(const AccessBitsDbo& accessBits);
 
+    void printVersion() const;
+
     static void printPercent(int done, int total);
 
 private:

src/DBO/StringUtils.cpp

@@ -2,6 +2,7 @@
 // Created by robin on 6/20/16.
 //
 
+#include <algorithm>
 #include "StringUtils.h"
 
 const std::string StringUtils::hex = "0123456789abcdef";
@@ -122,4 +123,30 @@ std::string StringUtils::ensureSize(const std::string &data, int size)
     }
 }
 
+std::string StringUtils::ltrim(const std::string& s)
+{
+    std::string data = s;
+    data.erase(data.begin(), std::find_if(data.begin(), data.end(),
+                                    std::not1(std::ptr_fun<int, int>(std::isspace))));
+    return data;
+}
+
+std::string StringUtils::rtrim(const std::string& s)
+{
+    std::string data = s;
+    data.erase(std::find_if(data.rbegin(), data.rend(),
+                         std::not1(std::ptr_fun<int, int>(std::isspace))).base(), data.end());
+    return data;
+}
 
+std::string StringUtils::trim(const std::string& s)
+{
+    return ltrim(rtrim(s));
+}
+
+std::string StringUtils::removeSpaces(const std::string &s)
+{
+    std::string data = s;
+    data.erase(std::remove_if(data.begin(), data.end(), std::ptr_fun<int, int>(std::isspace)), data.end());
+    return data;
+}

src/DBO/StringUtils.h

@@ -33,6 +33,11 @@ public:
     static char toUpper(char c);
 
     static std::string ensureSize(const std::string& data, int size);
+
+    static std::string ltrim(const std::string& s);
+    static std::string rtrim(const std::string& s);
+    static std::string trim(const std::string& s);
+    static std::string removeSpaces(const std::string& s);
 };
 
 

tests/test-main.cpp

@@ -100,6 +100,38 @@ TEST(StringUtils, ensureSize)
   ASSERT_EQ(StringUtils::ensureSize("test", 5), std::string({'t', 'e', 's', 't', '\0'}));
 }
 
+TEST(StringUtils, ltrim)
+{
+  ASSERT_EQ(StringUtils::ltrim("  \n 42"), "42");
+  ASSERT_EQ(StringUtils::ltrim("  \n 42 \n"), "42 \n");
+  ASSERT_EQ(StringUtils::ltrim("42  \n "), "42  \n ");
+  ASSERT_EQ(StringUtils::ltrim(" 42 \n 42  \n "), "42 \n 42  \n ");
+}
+
+TEST(StringUtils, rtrim)
+{
+  ASSERT_EQ(StringUtils::rtrim("  \n 42"), "  \n 42");
+  ASSERT_EQ(StringUtils::rtrim("  \n 42 \n"), "  \n 42");
+  ASSERT_EQ(StringUtils::rtrim("42  \n "), "42");
+  ASSERT_EQ(StringUtils::rtrim(" 42 \n 42  \n "), " 42 \n 42");
+}
+
+TEST(StringUtils, trim)
+{
+  ASSERT_EQ(StringUtils::trim("  \n 42"), "42");
+  ASSERT_EQ(StringUtils::trim("  \n 42 \n"), "42");
+  ASSERT_EQ(StringUtils::trim("42  \n "), "42");
+  ASSERT_EQ(StringUtils::trim(" 42 \n 42  \n "), "42 \n 42");
+}
+
+TEST(StringUtils, removeSpaces)
+{
+  ASSERT_EQ(StringUtils::removeSpaces("  \n 42"), "42");
+  ASSERT_EQ(StringUtils::removeSpaces("  \n 42 \n"), "42");
+  ASSERT_EQ(StringUtils::removeSpaces("42  \n "), "42");
+  ASSERT_EQ(StringUtils::removeSpaces(" 42 \n 42  \n "), "4242");
+}
+
 TEST(ArrayUtils, getArrayBitimple)
 {
   const unsigned char buf[] = {0x04};