Merge branch 'OSX_merge_cleaned'

This merge:
- fixes issues with invalid mutex
- moves tests to Python 3
- allows to compile the code natively under Visual Studio with CMake
- allows to compile under QtCreator under MS Windows
- fixes some issues with test suite
- allows to run tests under Windows
- allows to compile using QMake (and easy adding to Qt projects)
- decreases delays between sending commands thus increasing 2x
communication speed

7 files changed, 34 insertions, 24 deletions

diff --git a/include/command.h b/include/command.h
index 3f711c0..279754a 100644
--- a/include/command.h
+++ b/include/command.h
@@ -11,7 +11,7 @@
 #define print_to_ss_volatile(x) ( ss << " " << (#x) <<":\t" << "***********" << std::endl );
 #endif
 #define hexdump_to_ss(x) (ss << #x":\n"\
-                          << ::nitrokey::misc::hexdump((const char *) (&x), sizeof x, false));
+                          << ::nitrokey::misc::hexdump((const uint8_t *) (&x), sizeof x, false));
 
 namespace nitrokey {
     namespace proto {
diff --git a/include/device_proto.h b/include/device_proto.h
index b557384..bb14b42 100644
--- a/include/device_proto.h
+++ b/include/device_proto.h
@@ -37,6 +37,9 @@
 
 namespace nitrokey {
     namespace proto {
+      extern std::mutex send_receive_mtx;
+
+
 /*
  *	POD types for HID proto commands
  *	Instances are meant to be __packed.
@@ -215,7 +218,6 @@ namespace nitrokey {
               using namespace ::nitrokey::log;
               using namespace std::chrono_literals;
 
-              static std::mutex send_receive_mtx;
               std::lock_guard<std::mutex> guard(send_receive_mtx);
 
               LOG(__FUNCTION__, Loglevel::DEBUG_L2);
@@ -306,12 +308,13 @@ namespace nitrokey {
                   }
                   if (resp.device_status == static_cast<uint8_t>(stick10::device_status::busy)) {
                     dev->m_counters.busy++;
-                    if (busy_counter++<10) {
+                    if (busy_counter++<3) {
                       receiving_retry_counter++;
                       LOG("Status busy, not decreasing receiving_retry_counter counter: " +
                                       std::to_string(receiving_retry_counter), Loglevel::DEBUG_L2);
                     } else {
                       retry_timeout *= 2;
+                      retry_timeout = std::min(retry_timeout, 300ms);
                       busy_counter = 0;
                       LOG("Status busy, decreasing receiving_retry_counter counter: " +
                                       std::to_string(receiving_retry_counter) + ", current delay:"
@@ -352,12 +355,6 @@ namespace nitrokey {
 
               clear_packet(outp);
 
-              if (!resp.isCRCcorrect())
-                LOGD(std::string("Accepting response from device with invalid CRC. ")
-                     + "Command ID: " + std::to_string(resp.command_id) + " " +
-                         commandid_to_string(static_cast<CommandID>(resp.command_id))
-                );
-
 
               if (status <= 0) {
                 dev->m_counters.receiving_error++;
@@ -398,6 +395,14 @@ namespace nitrokey {
                 dev->m_counters.successful_storage_commands++;
               }
 
+              if (!resp.isCRCcorrect())
+                LOG(std::string("Accepting response from device with invalid CRC. ")
+                     + "Command ID: " + std::to_string(resp.command_id) + " " +
+                         commandid_to_string(static_cast<CommandID>(resp.command_id)) + "  "
+			+ "Reported and calculated: " + std::to_string(resp.crc) + "!=" + std::to_string(resp.calculate_CRC()),
+			Loglevel::WARNING
+                );
+
               // See: DeviceResponse
               return resp;
             }
diff --git a/include/dissect.h b/include/dissect.h
index 69a5129..06b99fa 100644
--- a/include/dissect.h
+++ b/include/dissect.h
@@ -22,7 +22,7 @@ class QueryDissector : semantics::non_constructible {
 
 #ifdef LOG_VOLATILE_DATA
     out << "Raw HID packet:" << std::endl;
-    out << ::nitrokey::misc::hexdump((const char *)(&pod), sizeof pod);
+    out << ::nitrokey::misc::hexdump((const uint8_t *)(&pod), sizeof pod);
 #endif
 
     out << "Contents:" << std::endl;
@@ -87,7 +87,7 @@ class ResponseDissector : semantics::non_constructible {
 
 #ifdef LOG_VOLATILE_DATA
     out << "Raw HID packet:" << std::endl;
-    out << ::nitrokey::misc::hexdump((const char *)(&pod), sizeof pod);
+    out << ::nitrokey::misc::hexdump((const uint8_t *)(&pod), sizeof pod);
 #endif
 
     out << "Device status:\t" << pod.device_status + 0 << " "
diff --git a/include/misc.h b/include/misc.h
index 176b77c..25f3107 100644
--- a/include/misc.h
+++ b/include/misc.h
@@ -62,7 +62,7 @@ typename T::CommandPayload get_payload(){
         CMDTYPE::CommandTransaction::run(stick, p);
     }
 
-    std::string hexdump(const char *p, size_t size, bool print_header=true, bool print_ascii=true,
+    std::string hexdump(const uint8_t *p, size_t size, bool print_header=true, bool print_ascii=true,
         bool print_empty=true);
     uint32_t stm_crc32(const uint8_t *data, size_t size);
     std::vector<uint8_t> hex_string_to_byte(const char* hexString);
diff --git a/include/stick10_commands.h b/include/stick10_commands.h
index e863328..8f3ceef 100644
--- a/include/stick10_commands.h
+++ b/include/stick10_commands.h
@@ -130,7 +130,7 @@ class WriteToHOTPSlot : Command<CommandID::WRITE_TO_SLOT> {
             ss << std::hex << std::setw(2) << std::setfill('0')<< (int) i << " " ;
         ss << std::endl;
         ss << "slot_counter:\t[" << (int)slot_counter << "]\t"
-         << ::nitrokey::misc::hexdump((const char *)(&slot_counter), sizeof slot_counter, false);
+         << ::nitrokey::misc::hexdump((const uint8_t *)(&slot_counter), sizeof slot_counter, false);
 
       return ss.str();
     }
@@ -334,7 +334,7 @@ class ReadSlot : Command<CommandID::READ_SLOT> {
         ss << std::hex << std::setw(2) << std::setfill('0')<< (int) i << " " ;
       ss << std::endl;
       ss << "slot_counter:\t[" << (int)slot_counter << "]\t"
-         << ::nitrokey::misc::hexdump((const char *)(&slot_counter), sizeof slot_counter, false);
+         << ::nitrokey::misc::hexdump((const uint8_t *)(&slot_counter), sizeof slot_counter, false);
       return ss.str();
     }
   } __packed;
@@ -372,13 +372,13 @@ class GetStatus : Command<CommandID::GET_STATUS> {
       ss  << "firmware_version:\t"
           << "[" << firmware_version << "]" << "\t"
           << ::nitrokey::misc::hexdump(
-          (const char *)(&firmware_version), sizeof firmware_version, false);
+          (const uint8_t *)(&firmware_version), sizeof firmware_version, false);
       ss << "card_serial_u32:\t" << std::hex << card_serial_u32 << std::endl;
       ss << "card_serial:\t"
-         << ::nitrokey::misc::hexdump((const char *)(card_serial),
+         << ::nitrokey::misc::hexdump((const uint8_t *)(card_serial),
                                       sizeof card_serial, false);
       ss << "general_config:\t"
-         << ::nitrokey::misc::hexdump((const char *)(general_config),
+         << ::nitrokey::misc::hexdump((const uint8_t *)(general_config),
                                       sizeof general_config, false);
         ss << "numlock:\t" << (int)numlock << std::endl;
         ss << "capslock:\t" << (int)capslock << std::endl;
diff --git a/include/stick10_commands_0.8.h b/include/stick10_commands_0.8.h
index 4209380..361682d 100644
--- a/include/stick10_commands_0.8.h
+++ b/include/stick10_commands_0.8.h
@@ -94,7 +94,7 @@ namespace nitrokey {
                       ss << "id:\t" << (int)id << std::endl;
 #ifdef LOG_VOLATILE_DATA
                       ss << "data:" << std::endl
-                         << ::nitrokey::misc::hexdump((const char *) (&data), sizeof data);
+                         << ::nitrokey::misc::hexdump((const uint8_t *) (&data), sizeof data);
 #else
                       ss << " Volatile data not logged" << std::endl;
 #endif
@@ -113,7 +113,7 @@ namespace nitrokey {
                       std::stringstream ss;
 #ifdef LOG_VOLATILE_DATA
                       ss << "data:" << std::endl
-                         << ::nitrokey::misc::hexdump((const char *) (&data), sizeof data);
+                         << ::nitrokey::misc::hexdump((const uint8_t *) (&data), sizeof data);
 #else
                       ss << " Volatile data not logged" << std::endl;
 #endif
@@ -165,7 +165,7 @@ namespace nitrokey {
                       ss << "\tuse_tokenID(2):\t" << use_tokenID << std::endl;
                       ss << "slot_number:\t" << (int) (slot_number) << std::endl;
                       ss << "slot_counter_or_interval:\t[" << (int) slot_counter_or_interval << "]\t"
-                         << ::nitrokey::misc::hexdump((const char *) (&slot_counter_or_interval), sizeof slot_counter_or_interval, false);
+                         << ::nitrokey::misc::hexdump((const uint8_t *) (&slot_counter_or_interval), sizeof slot_counter_or_interval, false);
 
                       ss << "slot_token_id:\t";
                       for (auto i : slot_token_id)
diff --git a/include/stick20_commands.h b/include/stick20_commands.h
index 5f99d28..eb58af7 100644
--- a/include/stick20_commands.h
+++ b/include/stick20_commands.h
@@ -111,7 +111,7 @@ namespace nitrokey {
                   std::string dissect() const {
                     std::stringstream ss;
                     ss << "_padding:" << std::endl
-                       << ::nitrokey::misc::hexdump((const char *) (_padding),
+                       << ::nitrokey::misc::hexdump((const uint8_t *) (_padding),
                                                     sizeof _padding);
                     print_to_ss((int) SendCounter_u8);
                     print_to_ss((int) SendDataType_u8);
@@ -138,9 +138,9 @@ namespace nitrokey {
                     union{
                     uint8_t VersionInfo_au8[4];
                         struct {
-                            uint8_t __reserved;
+                            uint8_t _reserved;
                             uint8_t minor;
-                            uint8_t __reserved2;
+                            uint8_t _reserved2;
                             uint8_t major;
                         } __packed versionInfo;
                     } __packed;
@@ -184,14 +184,19 @@ namespace nitrokey {
                       print_to_ss( MagicNumber_StickConfig_u16 );
                       print_to_ss((int) ReadWriteFlagUncryptedVolume_u8 );
                       print_to_ss((int) ReadWriteFlagCryptedVolume_u8 );
+                      print_to_ss((int) ReadWriteFlagHiddenVolume_u8 );
                       print_to_ss((int) VersionInfo_au8[1] );
                       print_to_ss((int) VersionInfo_au8[3] );
-                      print_to_ss((int) ReadWriteFlagHiddenVolume_u8 );
                       print_to_ss((int) FirmwareLocked_u8 );
                       print_to_ss((int) NewSDCardFound_u8 );
+                      print_to_ss((int) NewSDCardFound_st.NewCard );
+                      print_to_ss((int) NewSDCardFound_st.Counter );
                       print_to_ss((int) SDFillWithRandomChars_u8 );
                       print_to_ss( ActiveSD_CardID_u32 );
                       print_to_ss((int) VolumeActiceFlag_u8 );
+                      print_to_ss((int) VolumeActiceFlag_st.unencrypted );
+                      print_to_ss((int) VolumeActiceFlag_st.encrypted );
+                      print_to_ss((int) VolumeActiceFlag_st.hidden);
                       print_to_ss((int) NewSmartCardFound_u8 );
                       print_to_ss((int) UserPwRetryCount );
                       print_to_ss((int) AdminPwRetryCount );