Make device configuration const, protect non-const with ::atomic

Signed-off-by: Szczepan Zalega <szczepan@nitrokey.com>

2 files changed, 48 insertions, 43 deletions

diff --git a/device.cc b/device.cc
index 8c3c799..6eaaca5 100644
--- a/device.cc
+++ b/device.cc
@@ -9,20 +9,26 @@
 
 using namespace nitrokey::device;
 using namespace nitrokey::log;
+using namespace std::chrono;
 
-Device::Device()
-    : m_vid(0),
-      m_pid(0),
+Device::Device(const uint16_t vid, const uint16_t pid, const DeviceModel model,
+               const milliseconds send_receive_delay, const int retry_receiving_count,
+               const milliseconds retry_timeout)
+    : m_vid(vid),
+      m_pid(pid),
       m_retry_sending_count(3),
-      m_retry_receiving_count(40),
-      m_retry_timeout(100),
+      m_retry_receiving_count(retry_receiving_count),
+      m_retry_timeout(retry_timeout),
       mp_devhandle(NULL),
-      last_command_status(0){}
+      last_command_status(0),
+      m_model(model),
+      m_send_receive_delay(send_receive_delay)
+{}
 
 bool Device::disconnect() {
   Log::instance()(__PRETTY_FUNCTION__, Loglevel::DEBUG_L2);
 
-  if(mp_devhandle== nullptr) return false;
+  if(mp_devhandle == nullptr) return false;
   hid_close(mp_devhandle);
   mp_devhandle = NULL;
   hid_exit();
@@ -31,9 +37,8 @@ bool Device::disconnect() {
 bool Device::connect() {
   Log::instance()(__PRETTY_FUNCTION__, Loglevel::DEBUG_L2);
 
-//   hid_init();
+//   hid_init(); // done automatically on hid_open
   mp_devhandle = hid_open(m_vid, m_pid, NULL);
-  // hid_init();
   return mp_devhandle != NULL;
 }
 
@@ -41,7 +46,7 @@ int Device::send(const void *packet) {
   Log::instance()(__PRETTY_FUNCTION__, Loglevel::DEBUG_L2);
 
   if (mp_devhandle == NULL)
-    throw std::runtime_error("Attempted HID send on an invalid descriptor.");
+    throw std::runtime_error("Attempted HID send on an invalid descriptor."); //TODO migrate except to library_error
 
   return (hid_send_feature_report(
       mp_devhandle, (const unsigned char *)(packet), HID_REPORT_SIZE));
@@ -54,7 +59,7 @@ int Device::recv(void *packet) {
   Log::instance()(__PRETTY_FUNCTION__, Loglevel::DEBUG_L2);
 
   if (mp_devhandle == NULL)
-    throw std::runtime_error("Attempted HID receive on an invalid descriptor.");
+    throw std::runtime_error("Attempted HID receive on an invalid descriptor."); //TODO migrate except to library_error
 
   // FIXME extract error handling and repeating to parent function in
   // device_proto:192
@@ -84,19 +89,11 @@ int Device::recv(void *packet) {
   return status;
 }
 
-Stick10::Stick10() {
-  m_vid = 0x20a0;
-  m_pid = 0x4108;
-  m_model = DeviceModel::PRO;
-    m_send_receive_delay = 100ms;
-  m_retry_receiving_count = 100;
-}
+Stick10::Stick10():
+  Device(0x20a0, 0x4108, DeviceModel::PRO, 100ms, 100, 100ms)
+  {}
 
-Stick20::Stick20() {
-  m_vid = 0x20a0;
-  m_pid = 0x4109;
-  m_retry_timeout = 200ms;
-  m_model = DeviceModel::STORAGE;
-  m_send_receive_delay = 200ms;
-  m_retry_receiving_count = 40;
-}
+
+Stick20::Stick20():
+  Device(0x20a0, 0x4109, DeviceModel::STORAGE, 200ms, 40, 200ms)
+  {}
diff --git a/include/device.h b/include/device.h
index f686fbd..938fc75 100644
--- a/include/device.h
+++ b/include/device.h
@@ -8,9 +8,12 @@
 
 // TODO !! SEMAPHORE
 
+#include <atomic>
+
 namespace nitrokey {
 namespace device {
     using namespace std::chrono_literals;
+    using std::chrono::milliseconds;
 
     struct EnumClassHash
     {
@@ -22,6 +25,7 @@ namespace device {
     };
 
 enum class DeviceModel{
+    UNKNOWN,
     PRO,
     STORAGE
 };
@@ -29,8 +33,11 @@ enum class DeviceModel{
 class Device {
 
 public:
-  Device();
-  virtual ~Device(){disconnect();}
+    Device(const uint16_t vid, const uint16_t pid, const DeviceModel model,
+                   const milliseconds send_receive_delay, const int retry_receiving_count,
+                   const milliseconds retry_timeout);
+
+    virtual ~Device(){disconnect();}
 
   // lack of device is not actually an error,
   // so it doesn't throw
@@ -51,31 +58,32 @@ public:
   int get_retry_receiving_count() const { return m_retry_receiving_count; };
   int get_retry_sending_count() const { return m_retry_sending_count; };
   std::chrono::milliseconds get_retry_timeout() const { return m_retry_timeout; };
-    std::chrono::milliseconds get_send_receive_delay() const {return m_send_receive_delay;}
+  std::chrono::milliseconds get_send_receive_delay() const {return m_send_receive_delay;}
 
-    int get_last_command_status() {auto a = last_command_status; last_command_status = 0; return a;};
-    void set_last_command_status(uint8_t _err) { last_command_status = _err;} ;
-    bool last_command_sucessfull() const {return last_command_status == 0;};
-    DeviceModel get_device_model() const {return m_model;}
+  int get_last_command_status() {int a = last_command_status; last_command_status = 0; return a;};
+  void set_last_command_status(uint8_t _err) { last_command_status = _err;} ;
+  bool last_command_sucessfull() const {return last_command_status == 0;};
+  DeviceModel get_device_model() const {return m_model;}
 private:
-    uint8_t last_command_status;
+  std::atomic<uint8_t> last_command_status;
 
- protected:
-  uint16_t m_vid;
-  uint16_t m_pid;
-    DeviceModel m_model;
+protected:
+  const uint16_t m_vid;
+  const uint16_t m_pid;
+  const DeviceModel m_model;
 
   /*
    *	While the project uses Signal11 portable HIDAPI
    *	library, there's no way of doing it asynchronously,
    *	hence polling.
    */
-  int m_retry_sending_count;
-  int m_retry_receiving_count;
-  std::chrono::milliseconds m_retry_timeout;
-  std::chrono::milliseconds m_send_receive_delay;
+  const int m_retry_sending_count;
+  const int m_retry_receiving_count;
+  const std::chrono::milliseconds m_retry_timeout;
+  const std::chrono::milliseconds m_send_receive_delay;
+
+  std::atomic<hid_device *>mp_devhandle;
 
-  hid_device *mp_devhandle;
 };
 
 class Stick10 : public Device {