aboutsummaryrefslogtreecommitdiff
path: root/include/device.h
diff options
context:
space:
mode:
authorSzczepan Zalega <szczepan@nitrokey.com>2017-03-11 17:18:59 +0100
committerSzczepan Zalega <szczepan@nitrokey.com>2017-03-11 17:18:59 +0100
commit22d05ce647281056d71fbd3c31df3bcd6396188d (patch)
tree90208930f54c47987bfd5ffcf0a0acaaad2510da /include/device.h
parented5044da43172d86a1aa475473561a4818b7c69c (diff)
parentac6b9c18ef55f4cd36e85069cf0cf82c14e04404 (diff)
downloadlibnitrokey-22d05ce647281056d71fbd3c31df3bcd6396188d.tar.gz
libnitrokey-22d05ce647281056d71fbd3c31df3bcd6396188d.tar.bz2
Merge branch 'libnitrokey_3'
Diffstat (limited to 'include/device.h')
-rw-r--r--include/device.h85
1 files changed, 65 insertions, 20 deletions
diff --git a/include/device.h b/include/device.h
index 62c4073..7b300e5 100644
--- a/include/device.h
+++ b/include/device.h
@@ -1,16 +1,18 @@
#ifndef DEVICE_H
#define DEVICE_H
#include <chrono>
-#include <hidapi/hidapi.h>
-#include "inttypes.h"
+#include "hidapi/hidapi.h"
+#include <cstdint>
+#include <string>
#define HID_REPORT_SIZE 65
-// TODO !! SEMAPHORE
+#include <atomic>
namespace nitrokey {
namespace device {
using namespace std::chrono_literals;
+ using std::chrono::milliseconds;
struct EnumClassHash
{
@@ -26,11 +28,39 @@ enum class DeviceModel{
STORAGE
};
+#include <atomic>
+
class Device {
public:
- Device();
- virtual ~Device(){disconnect();}
+
+ struct ErrorCounters{
+ using cnt = std::atomic_int;
+ cnt wrong_CRC;
+ cnt CRC_other_than_awaited;
+ cnt busy;
+ cnt total_retries;
+ cnt sending_error;
+ cnt receiving_error;
+ cnt total_comm_runs;
+ cnt successful_storage_commands;
+ cnt command_successful_recv;
+ cnt recv_executed;
+ cnt sends_executed;
+ cnt busy_progressbar;
+ cnt command_result_not_equal_0_recv;
+ cnt communication_successful;
+ cnt low_level_reconnect;
+ std::string get_as_string();
+
+ } m_counters = {};
+
+
+ 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();
// lack of device is not actually an error,
// so it doesn't throw
@@ -48,34 +78,49 @@ public:
*/
virtual int recv(void *packet);
+ /***
+ * Returns true if some device is visible by OS with given VID and PID
+ * whether the device is connected through HID API or not.
+ * @return true if visible by OS
+ */
+ bool could_be_enumerated();
+
+ void show_stats();
+// ErrorCounters get_stats(){ return m_counters; }
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 = std::atomic_exchange(&last_command_status, static_cast<uint8_t>(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;
+ void _reconnect();
+ bool _connect();
+ bool _disconnect();
- 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;
+ static std::atomic_int instances_count;
};
class Stick10 : public Device {