basic libnfc operations

CMakeLists.txt

@@ -3,6 +3,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMakeMod
 set(PROJECT_NAME mifare-tools)
 project(${PROJECT_NAME})
 find_package(GTest)
+set(LIBS ${LIBS} nfc)
 add_subdirectory(src)
 if (GTEST_FOUND)
     enable_testing()

src/CMakeLists.txt

@@ -10,7 +10,10 @@ set(SOURCE_FILES
   DBO/CommandLineOption.h
   DBO/Result.hxx
   DBO/Result.h
-  )
+  DataAccess/LibNfc.cpp
+  DataAccess/LibNfc.h
+        DataAccess/NfcDevice.cpp
+        DataAccess/NfcDevice.h DataAccess/FreeFareDevice.cpp DataAccess/FreeFareDevice.h)
 
 add_executable(${PROJECT_NAME} ${SOURCE_FILES})
 target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/Result.h

@@ -2,51 +2,57 @@
 // Created by robin on 8/9/15.
 //
 
-#ifndef PDNS_SLAVE_RESULT_H
-#define PDNS_SLAVE_RESULT_H
+#ifndef RESULT_H
+#define RESULT_H
 
 # include <string>
 # include <vector>
+# include <iostream>
 
 template <class T> class Result
 {
 public:
-    Result();
-
-    Result(const T& data);
-
-    virtual ~Result();
-
-    Result<T>& ok(const T& data);
+    static const Result<T> ok(const T& data);
+    static const Result<T> strerror();
+    static const Result<T> error(const std::string& error);
+    template <class U> static const Result<T> error(const Result<U>& other);
 
     T& getData();
-
-    bool isSuccess() const;
-
-    Result<T>& addWarning(const std::string& warning);
-
-    const std::vector<std::string>& getWarnings() const;
-
-    Result<T>& error(const std::string& error);
-
+    const bool isSuccess() const;
     const std::string& getError() const;
 
     bool operator !() const;
-
     operator bool() const;
 
+    template<class U>
+    friend std::ostream& operator<<(std::ostream& os, const Result<U>& res);
+
     const Result<T>& print() const;
 
 private:
-    T _data;
+    Result();
 
-    std::vector<std::string> _warnings;
+    T _data;
 
     std::string _error;
+
+    bool _success;
 };
 
-typedef Result<bool> BResult;
+typedef Result<bool> ResultBool;
+
+typedef Result<int> ResultInt;
+
+typedef Result<long> ResultLong;
+
+typedef Result<float> ResultFloat;
+
+typedef Result<double> ResultDouble;
+
+typedef Result<char> ResultChar;
+
+typedef Result<std::string> ResultString;
 
 # include "DBO/Result.hxx"
 
-#endif //PDNS_SLAVE_RESULT_H
+#endif //RESULT_H

src/DBO/Result.hxx

@@ -2,8 +2,9 @@
 // Created by robin on 8/9/15.
 //
 
-#include <iostream>
 #include "Result.h"
+#include <errno.h>
+#include <string.h>
 
 template<class T>
 Result<T>::Result()
@@ -11,46 +12,52 @@ Result<T>::Result()
 }
 
 template<class T>
-Result<T>::Result(const T &data)
-        : _data(data)
+const Result<T> Result<T>::ok(const T& data)
 {
+    Result<T> r;
+    r._success = true;
+    r._data = data;
+    return r;
 }
 
 template<class T>
-Result<T>::~Result()
+const Result<T> Result<T>::strerror()
 {
+    Result<T> r;
+    r._success = false;
+    r._error = ::strerror(errno);
+    return r;
 }
 
 template<class T>
-Result<T> &Result<T>::ok(const T &data)
+const Result<T> Result<T>::error(const std::string& error)
 {
-    _data = data;
-    return *this;
+    Result<T> r;
+    r._success = false;
+    r._error = error;
+    return r;
 }
 
 template<class T>
-T &Result<T>::getData()
+template<class U>
+const Result<T> Result<T>::error(const Result<U>& other)
 {
-    return _data;
+    Result<T> r;
+    r._success = false;
+    r.error(other.getError());
+    return r;
 }
 
 template<class T>
-bool Result<T>::isSuccess() const
+T &Result<T>::getData()
 {
-    return _error.empty();
+    return _data;
 }
 
 template<class T>
-const std::vector<std::string>& Result<T>::getWarnings() const
+const bool Result<T>::isSuccess() const
 {
-    return _warnings;
-}
-
-template<class T>
-Result<T>& Result<T>::addWarning(const std::string &warning)
-{
-    _warnings.push_back(warning);
-    return *this;
+    return _success;
 }
 
 template<class T>
@@ -66,24 +73,26 @@ Result<T>::operator bool() const
 }
 
 template<class T>
-Result<T> &Result<T>::error(const std::string &error)
+const std::string &Result<T>::getError() const
 {
-    _error = error;
-    return *this;
+    return _error;
 }
 
-template<class T>
-const std::string &Result<T>::getError() const
+template<class U>
+std::ostream& operator<<(std::ostream& os, const Result<U>& res)
 {
-    return _error;
+    if (res._success) {
+        os << "Success";// << res._data;
+    }
+    else {
+        os << "Error: " << (res._error.empty() ? "Unknown error" : res._error);
+    }
+    return os;
 }
 
 template<class T>
 const Result<T>& Result<T>::print() const
 {
-    for (auto warning : _warnings)
-        std::cerr << "WARNING: " << warning << std::endl;
-    if (!isSuccess())
-        std::cerr << "ERROR: " << _error << std::endl;
+    (_success ? std::cout : std::cerr) << *this << std::endl;
     return *this;
-}
+}

src/DataAccess/FreeFareDevice.cpp

@@ -0,0 +1,10 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include "FreeFareDevice.h"
+
+FreeFareDevice::FreeFareDevice(NfcDevice *device)
+    : _device(device)
+{
+}

src/DataAccess/FreeFareDevice.h

@@ -0,0 +1,22 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFAREDEVICE_H
+#define MIFARE_TOOLS_FREEFAREDEVICE_H
+
+
+#include "NfcDevice.h"
+#include <freefare.h>
+
+class FreeFareDevice
+{
+public:
+    FreeFareDevice(NfcDevice* device);
+
+private:
+    NfcDevice* _device;
+};
+
+
+#endif //MIFARE_TOOLS_FREEFAREDEVICE_H

src/DataAccess/LibNfc.cpp

@@ -0,0 +1,67 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include "LibNfc.h"
+
+LibNfc::LibNfc()
+    : _context(0)
+{
+}
+
+ResultBool LibNfc::init()
+{
+    if (isInitialized()) {
+        return ResultBool::error("LibNfc is already initialized");
+    }
+    nfc_init(&_context);
+    if (!_context) {
+        return ResultBool::error("LibNfc could not be initialized");
+    }
+    return ResultBool::ok(true);
+}
+
+std::string LibNfc::getVersion()
+{
+    return nfc_version();
+}
+
+LibNfc::~LibNfc()
+{
+    clean();
+}
+
+bool LibNfc::isInitialized()
+{
+    return _context != 0;
+}
+
+void LibNfc::clean()
+{
+    if (isInitialized()) {
+        nfc_exit(_context);
+        _context = 0;
+    }
+}
+
+Result<std::vector<NfcDevice*>> LibNfc::getDevices()
+{
+    if (!isInitialized()) {
+        return Result<std::vector<NfcDevice*>>::error("LibNfc is not initialized");
+    }
+    nfc_connstring devices[16];
+    size_t count = nfc_list_devices(_context, devices, sizeof(devices));
+    if (count < 0) {
+        return Result<std::vector<NfcDevice*>>::error("Failed to list NFC devices");
+    }
+    std::vector<NfcDevice*> devicesList;
+    for (size_t i = 0; i < count; ++i) {
+        devicesList.push_back(new NfcDevice(this, devices[i]));
+    }
+    return Result<std::vector<NfcDevice*>>::ok(devicesList);
+}
+
+nfc_context *LibNfc::getContext() const
+{
+    return _context;
+}

src/DataAccess/LibNfc.h

@@ -0,0 +1,37 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFC_H
+#define MIFARE_TOOLS_LIBNFC_H
+
+#include <nfc/nfc.h>
+#include "NfcDevice.h"
+#include "DBO/Result.h"
+
+class NfcDevice;
+
+class LibNfc
+{
+public:
+    LibNfc();
+    ~LibNfc();
+
+    ResultBool init();
+
+    void clean();
+
+    bool isInitialized();
+
+    Result<std::vector<NfcDevice*>> getDevices();
+
+    static std::string getVersion();
+
+    nfc_context* getContext() const;
+
+private:
+    nfc_context* _context;
+};
+
+
+#endif //MIFARE_TOOLS_LIBNFC_H

src/DataAccess/NfcDevice.cpp

@@ -0,0 +1,42 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include "NfcDevice.h"
+
+NfcDevice::NfcDevice(LibNfc* libNfc, std::string str)
+    : _connStr(str)
+    , _device(0)
+    , _libNfc(libNfc)
+{
+}
+
+NfcDevice::~NfcDevice()
+{
+    close();
+}
+
+ResultBool NfcDevice::open()
+{
+    if (isOpened()) {
+        return ResultBool::error("NFC device is already opened");
+    }
+    _device = nfc_open(_libNfc->getContext(), _connStr.c_str());
+    if (!_device) {
+        return ResultBool::error("Failed to open NFC device");
+    }
+    return ResultBool::ok(true);
+}
+
+bool NfcDevice::isOpened()
+{
+    return _device != 0;
+}
+
+void NfcDevice::close()
+{
+    if (isOpened()) {
+        nfc_close(_device);
+        _device = 0;
+    }
+}

src/DataAccess/NfcDevice.h

@@ -0,0 +1,47 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_NFCDEVICEDBO_H
+#define MIFARE_TOOLS_NFCDEVICEDBO_H
+
+
+#include <string>
+#include <nfc/nfc-types.h>
+#include <DBO/Result.h>
+#include "LibNfc.h"
+
+class LibNfc;
+
+class NfcDevice
+{
+public:
+    NfcDevice(LibNfc* libNfc, std::string connStr);
+    ~NfcDevice();
+
+    ResultBool open();
+
+    void close();
+
+    bool isOpened();
+
+    const std::string &getConnStr() const
+    {
+        return _connStr;
+    }
+
+    void setConnStr(const std::string &connStr)
+    {
+        _connStr = connStr;
+    }
+
+private:
+    std::string _connStr;
+
+    nfc_device* _device;
+
+    LibNfc* _libNfc;
+};
+
+
+#endif //MIFARE_TOOLS_NFCDEVICEDBO_H

src/Interface/MainClass.cpp

@@ -5,6 +5,7 @@
 #include <iostream>
 #include <sysexits.h>
 #include <DBO/Result.h>
+#include <DataAccess/LibNfc.h>
 #include "CommandLineParser.h"
 #include "MainClass.h"
 
@@ -16,6 +17,43 @@ MainClass::MainClass(int argc, char *argv[])
 
 int MainClass::main()
 {
+    std::cout << "LibNfc version: " << LibNfc::getVersion() << std::endl;
+
+    LibNfc libNfc;
+    auto init = libNfc.init();
+    if (!init) {
+        init.print();
+        return 1;
+    }
+
+    auto devices = libNfc.getDevices();
+    if (!devices) {
+        devices.print();
+        return 2;
+    }
+    if (devices.getData().size() == 0) {
+        std::cerr << "No NFC device found" << std::endl;
+        return 3;
+    }
+
+    std::cout << "Found " << devices.getData().size() << " devices: " << std::endl;
+    for (size_t i = 0; i < devices.getData().size(); ++i) {
+        std::cout << devices.getData()[i]->getConnStr() << std::endl;
+    }
+    for (size_t i = 1; i < devices.getData().size(); ++i) {
+        delete devices.getData()[i];
+    }
+
+    auto device = devices.getData()[0];
+    auto open = device->open();
+    if (!open) {
+        open.print();
+        return 4;
+    }
+
+
+
+    device->close();
 
     return 0;
 }