35 files changed, 1149 insertions, 179 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a6f6fc..113b342 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,25 @@
+# v3.4.0 (2018-12-10)
+
+- Update to libnitrokey 3.4, causing all following changes.
+- New constant `NK_device_model_NK_DISCONNECTED` in the `NK_device_model`
+  enumeration.
+- New structures:
+    - `NK_storage_ProductionTest`
+    - `NK_storage_status`
+- New functions:
+    - `NK_get_device_model`
+    - `NK_get_library_version`
+    - `NK_get_major_library_version`
+    - `NK_get_minor_libray_version`
+    - `NK_get_status_storage`
+    - `NK_get_storage_production_info`
+    - `NK_totp_set_time_soft`
+    - `NK_wink`
+- The function `NK_totp_get_time` is now deprecated.  If applicable,
+  `NK_totp_set_time_soft` should be used instead.  See the [upstream pull
+  request #114][] for details.
+- Strings are now returned as mutable instead of constant pointers.
+
 # v3.3.0 (2018-05-21)
 
 - Change the crate license to LGPL 3.0.
@@ -10,3 +32,5 @@
 # v0.1.0 (2018-05-19)
 
 - Initial release.
+
+[upstream pull request #114]: https://github.com/Nitrokey/libnitrokey/pull/114
diff --git a/Cargo.toml b/Cargo.toml
index 5eb8f50..d64bb52 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nitrokey-sys"
-version = "3.3.0"
+version = "3.4.0"
 authors = ["Robin Krahl <robin.krahl@ireas.org>"]
 homepage = "https://code.ireas.org/nitrokey-rs/"
 repository = "https://git.ireas.org/nitrokey-sys-rs/"
diff --git a/README.md b/README.md
index 5fa6a9b..b16d412 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ devices.
 
 ```toml
 [dependencies]
-nitrokey-sys = "3.3.0"
+nitrokey-sys = "3.4.0"
 ```
 
 The version of this crate corresponds to the wrapped `libnitrokey` version.
diff --git a/build.rs b/build.rs
index e44b3c0..162cbbd 100644
--- a/build.rs
+++ b/build.rs
@@ -1,6 +1,9 @@
 extern crate cc;
 
 use std::env;
+use std::io;
+use std::io::{Read, Write};
+use std::fs;
 use std::path;
 
 struct Version {
@@ -41,7 +44,34 @@ fn get_version() -> Result<Version, String> {
     })
 }
 
+fn prepare_version_source(
+    version: &Version,
+    out_path: &path::Path,
+    library_path: &path::Path
+) -> io::Result<path::PathBuf> {
+    let out = out_path.join("version.cc");
+    let template = library_path.join("version.cc.in");
+
+    let mut file = fs::File::open(template)?;
+    let mut data = String::new();
+    file.read_to_string(&mut data)?;
+    drop(file);
+
+    let data = data
+        .replace("@PROJECT_VERSION_MAJOR@", &version.major)
+        .replace("@PROJECT_VERSION_MINOR@", &version.minor)
+        .replace("@PROJECT_VERSION_GIT@", &version.git);
+
+    let mut file = fs::File::create(&out)?;
+    file.write_all(data.as_bytes())?;
+
+    Ok(out)
+}
+
 fn main() {
+    let out_dir = env::var("OUT_DIR").expect("Environment variable OUT_DIR is not set");
+    let out_path = path::PathBuf::from(out_dir);
+
     let version = get_version().expect("Could not extract library version");
 
     let sources = [
@@ -56,10 +86,14 @@ fn main() {
     let library_dir = format!("libnitrokey-{}", version.git);
     let library_path = path::Path::new(&library_dir);
 
+    let version_source = prepare_version_source(&version, &out_path, &library_path)
+        .expect("Could not prepare the version source file");
+
     cc::Build::new()
         .cpp(true)
         .include(library_path.join("libnitrokey"))
         .files(sources.iter().map(|s| library_path.join(s)))
+        .file(version_source)
         .compile("libnitrokey.a");
 
     println!("cargo:rustc-link-lib=hidapi-libusb");
diff --git a/libnitrokey-v3.3/DeviceCommunicationExceptions.cpp b/libnitrokey-v3.4/DeviceCommunicationExceptions.cpp
index 4d62aad..4d62aad 100644
--- a/libnitrokey-v3.3/DeviceCommunicationExceptions.cpp
+++ b/libnitrokey-v3.4/DeviceCommunicationExceptions.cpp
diff --git a/libnitrokey-v3.3/LICENSE b/libnitrokey-v3.4/LICENSE
index 341c30b..341c30b 100644
--- a/libnitrokey-v3.3/LICENSE
+++ b/libnitrokey-v3.4/LICENSE
diff --git a/libnitrokey-v3.3/NK_C_API.cc b/libnitrokey-v3.4/NK_C_API.cc
index b245940..7d0a10e 100644
--- a/libnitrokey-v3.3/NK_C_API.cc
+++ b/libnitrokey-v3.4/NK_C_API.cc
@@ -21,10 +21,13 @@
 
 #include "NK_C_API.h"
 #include <iostream>
+#include <tuple>
 #include "libnitrokey/NitrokeyManager.h"
 #include <cstring>
 #include "libnitrokey/LibraryException.h"
 #include "libnitrokey/cxx_semantics.h"
+#include "libnitrokey/stick20_commands.h"
+#include "version.h"
 
 #ifdef _MSC_VER
 #ifdef _WIN32
@@ -52,11 +55,11 @@ T* duplicate_vector_and_clear(std::vector<T> &v){
     return d;
 }
 
-template <typename T>
-uint8_t * get_with_array_result(T func){
+template <typename R, typename T>
+std::tuple<int, R> get_with_status(T func, R fallback) {
     NK_last_command_status = 0;
     try {
-        return func();
+        return std::make_tuple(0, func());
     }
     catch (CommandFailedException & commandFailedException){
         NK_last_command_status = commandFailedException.last_command_status;
@@ -67,43 +70,26 @@ uint8_t * get_with_array_result(T func){
     catch (const DeviceCommunicationException &deviceException){
       NK_last_command_status = 256-deviceException.getType();
     }
-    return nullptr;
+    return std::make_tuple(NK_last_command_status, fallback);
 }
 
 template <typename T>
-const char* get_with_string_result(T func){
-    NK_last_command_status = 0;
-    try {
-        return func();
-    }
-    catch (CommandFailedException & commandFailedException){
-        NK_last_command_status = commandFailedException.last_command_status;
-    }
-    catch (LibraryException & libraryException){
-        NK_last_command_status = libraryException.exception_id();
-    }
-    catch (const DeviceCommunicationException &deviceException){
-      NK_last_command_status = 256-deviceException.getType();
+uint8_t * get_with_array_result(T func){
+    return std::get<1>(get_with_status<uint8_t*>(func, nullptr));
+}
+
+template <typename T>
+char* get_with_string_result(T func){
+    auto result = std::get<1>(get_with_status<char*>(func, nullptr));
+    if (result == nullptr) {
+        return strndup("", MAXIMUM_STR_REPLY_LENGTH);
     }
-    return "";
+    return result;
 }
 
 template <typename T>
 auto get_with_result(T func){
-    NK_last_command_status = 0;
-    try {
-        return func();
-    }
-    catch (CommandFailedException & commandFailedException){
-        NK_last_command_status = commandFailedException.last_command_status;
-    }
-    catch (LibraryException & libraryException){
-        NK_last_command_status = libraryException.exception_id();
-    }
-    catch (const DeviceCommunicationException &deviceException){
-      NK_last_command_status = 256-deviceException.getType();
-    }
-    return static_cast<decltype(func())>(0);
+    return std::get<1>(get_with_status(func, static_cast<decltype(func())>(0)));
 }
 
 template <typename T>
@@ -170,6 +156,7 @@ extern "C" {
                     case NK_STORAGE:
                         model_string = "S";
                         break;
+                    case NK_DISCONNECTED:
                     default:
                         /* no such enum value -- return error code */
                         return 0;
@@ -238,22 +225,41 @@ extern "C" {
 	}
 
 
+	NK_C_API enum NK_device_model NK_get_device_model() {
+		auto m = NitrokeyManager::instance();
+		try {
+			auto model = m->get_connected_device_model();
+			switch (model) {
+				case DeviceModel::PRO:
+				    return NK_PRO;
+				case DeviceModel::STORAGE:
+				    return NK_STORAGE;
+				default:
+				    /* unknown or not connected device */
+				    return NK_device_model::NK_DISCONNECTED;
+			}
+		} catch (const DeviceNotConnected& e) {
+			return NK_device_model::NK_DISCONNECTED;
+		}
+}
+
+
 	void clear_string(std::string &s) {
 		std::fill(s.begin(), s.end(), ' ');
 	}
 
 
-	NK_C_API const char * NK_status() {
+	NK_C_API char * NK_status() {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			string && s = m->get_status_as_string();
-			char * rs = strndup(s.c_str(), max_string_field_length);
+			char * rs = strndup(s.c_str(), MAXIMUM_STR_REPLY_LENGTH);
 			clear_string(s);
 			return rs;
 		});
 	}
 
-	NK_C_API const char * NK_device_serial_number() {
+	NK_C_API char * NK_device_serial_number() {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			string && s = m->get_serial_number();
@@ -263,11 +269,11 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char * NK_get_hotp_code(uint8_t slot_number) {
+	NK_C_API char * NK_get_hotp_code(uint8_t slot_number) {
 		return NK_get_hotp_code_PIN(slot_number, "");
 	}
 
-	NK_C_API const char * NK_get_hotp_code_PIN(uint8_t slot_number, const char *user_temporary_password) {
+	NK_C_API char * NK_get_hotp_code_PIN(uint8_t slot_number, const char *user_temporary_password) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			string && s = m->get_HOTP_code(slot_number, user_temporary_password);
@@ -277,12 +283,12 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char * NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
+	NK_C_API char * NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
 		uint8_t last_interval) {
 		return NK_get_totp_code_PIN(slot_number, challenge, last_totp_time, last_interval, "");
 	}
 
-	NK_C_API const char * NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
+	NK_C_API char * NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
 		uint8_t last_interval, const char *user_temporary_password) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
@@ -327,14 +333,14 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char* NK_get_totp_slot_name(uint8_t slot_number) {
+	NK_C_API char* NK_get_totp_slot_name(uint8_t slot_number) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			const auto slot_name = m->get_totp_slot_name(slot_number);
 			return slot_name;
 		});
 	}
-	NK_C_API const char* NK_get_hotp_slot_name(uint8_t slot_number) {
+	NK_C_API char* NK_get_hotp_slot_name(uint8_t slot_number) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			const auto slot_name = m->get_hotp_slot_name(slot_number);
@@ -353,6 +359,18 @@ extern "C" {
 		m->set_loglevel(level);
 	}
 
+	NK_C_API unsigned int NK_get_major_library_version() {
+		return get_major_library_version();
+	}
+
+	NK_C_API unsigned int NK_get_minor_library_version() {
+		return get_minor_library_version();
+	}
+
+	NK_C_API const char* NK_get_library_version() {
+		return get_library_version();
+	}
+
 	NK_C_API int NK_totp_set_time(uint64_t time) {
 		auto m = NitrokeyManager::instance();
 		return get_without_result([&]() {
@@ -360,11 +378,15 @@ extern "C" {
 		});
 	}
 
-	NK_C_API int NK_totp_get_time() {
+	NK_C_API int NK_totp_set_time_soft(uint64_t time) {
 		auto m = NitrokeyManager::instance();
 		return get_without_result([&]() {
-			m->get_time(0); // FIXME check how that should work
+			m->set_time_soft(time);
 		});
+        }
+
+	NK_C_API int NK_totp_get_time() {
+	  return 0;
 	}
 
 	NK_C_API int NK_change_admin_PIN(const char *current_PIN, const char *new_PIN) {
@@ -417,20 +439,20 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char *NK_get_password_safe_slot_name(uint8_t slot_number) {
+	NK_C_API char *NK_get_password_safe_slot_name(uint8_t slot_number) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			return m->get_password_safe_slot_name(slot_number);
 		});
 	}
 
-	NK_C_API const char *NK_get_password_safe_slot_login(uint8_t slot_number) {
+	NK_C_API char *NK_get_password_safe_slot_login(uint8_t slot_number) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			return m->get_password_safe_slot_login(slot_number);
 		});
 	}
-	NK_C_API const char *NK_get_password_safe_slot_password(uint8_t slot_number) {
+	NK_C_API char *NK_get_password_safe_slot_password(uint8_t slot_number) {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			return m->get_password_safe_slot_password(slot_number);
@@ -589,14 +611,84 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char* NK_get_status_storage_as_string() {
+	NK_C_API char* NK_get_status_storage_as_string() {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			return m->get_status_storage_as_string();
 		});
 	}
 
-	NK_C_API const char* NK_get_SD_usage_data_as_string() {
+	NK_C_API int NK_get_status_storage(NK_storage_status* out) {
+		if (out == nullptr) {
+			return -1;
+		}
+		auto m = NitrokeyManager::instance();
+		auto result = get_with_status([&]() {
+			return m->get_status_storage();
+		}, proto::stick20::DeviceConfigurationResponsePacket::ResponsePayload());
+		auto error_code = std::get<0>(result);
+		if (error_code != 0) {
+			return error_code;
+		}
+
+		auto status = std::get<1>(result);
+		out->unencrypted_volume_read_only = status.ReadWriteFlagUncryptedVolume_u8 != 0;
+		out->unencrypted_volume_active = status.VolumeActiceFlag_st.unencrypted;
+		out->encrypted_volume_read_only = status.ReadWriteFlagCryptedVolume_u8 != 0;
+		out->encrypted_volume_active = status.VolumeActiceFlag_st.encrypted;
+		out->hidden_volume_read_only = status.ReadWriteFlagHiddenVolume_u8 != 0;
+		out->hidden_volume_active = status.VolumeActiceFlag_st.hidden;
+		out->firmware_version_major = status.versionInfo.major;
+		out->firmware_version_minor = status.versionInfo.minor;
+		out->firmware_locked = status.FirmwareLocked_u8 != 0;
+		out->serial_number_sd_card = status.ActiveSD_CardID_u32;
+		out->serial_number_smart_card = status.ActiveSmartCardID_u32;
+		out->user_retry_count = status.UserPwRetryCount;
+		out->admin_retry_count = status.AdminPwRetryCount;
+		out->new_sd_card_found = status.NewSDCardFound_st.NewCard;
+		out->filled_with_random = (status.SDFillWithRandomChars_u8 & 0x01) != 0;
+		out->stick_initialized = status.StickKeysNotInitiated == 0;
+		return 0;
+	}
+
+  NK_C_API int NK_get_storage_production_info(NK_storage_ProductionTest * out){
+    if (out == nullptr) {
+      return -1;
+    }
+    auto m = NitrokeyManager::instance();
+    auto result = get_with_status([&]() {
+      return m->production_info();
+    }, proto::stick20::ProductionTest::ResponsePayload());
+
+		auto error_code = std::get<0>(result);
+		if (error_code != 0) {
+			return error_code;
+		}
+
+		stick20::ProductionTest::ResponsePayload status = std::get<1>(result);
+		// Cannot use memcpy without declaring C API struct packed
+    // (which is not parsed by Python's CFFI apparently), hence the manual way.
+#define a(x) out->x = status.x;
+		 a(FirmwareVersion_au8[0]);
+		 a(FirmwareVersion_au8[1]);
+		 a(FirmwareVersionInternal_u8);
+		 a(SD_Card_Size_u8);
+		 a(CPU_CardID_u32);
+		 a(SmartCardID_u32);
+		 a(SD_CardID_u32);
+		 a(SC_UserPwRetryCount);
+		 a(SC_AdminPwRetryCount);
+		 a(SD_Card_ManufacturingYear_u8);
+		 a(SD_Card_ManufacturingMonth_u8);
+		 a(SD_Card_OEM_u16);
+		 a(SD_WriteSpeed_u16);
+		 a(SD_Card_Manufacturer_u8);
+#undef a
+		return 0;
+  }
+
+
+NK_C_API char* NK_get_SD_usage_data_as_string() {
 		auto m = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			return m->get_SD_usage_data_as_string();
@@ -631,7 +723,7 @@ extern "C" {
 		});
 	}
 
-	NK_C_API const char* NK_list_devices_by_cpuID() {
+	NK_C_API char* NK_list_devices_by_cpuID() {
 		auto nm = NitrokeyManager::instance();
 		return get_with_string_result([&]() {
 			auto v = nm->list_devices_by_cpuID();
@@ -640,7 +732,7 @@ extern "C" {
 				res += a+";";
 			}
 			if (res.size()>0) res.pop_back(); // remove last delimiter char
-			return strndup(res.c_str(), 8192); //this buffer size sets limit to over 200 devices ID's
+			return strndup(res.c_str(), MAXIMUM_STR_REPLY_LENGTH);
 		});
 	}
 
@@ -651,7 +743,12 @@ extern "C" {
 		});
 	}
 
-
+	NK_C_API int NK_wink() {
+		auto m = NitrokeyManager::instance();
+		return get_without_result([&]() {
+			return m->wink();
+		});
+	}
 
 #ifdef __cplusplus
 }
diff --git a/libnitrokey-v3.3/NK_C_API.h b/libnitrokey-v3.4/NK_C_API.h
index 96a1950..b1bdf1e 100644
--- a/libnitrokey-v3.3/NK_C_API.h
+++ b/libnitrokey-v3.4/NK_C_API.h
@@ -25,41 +25,160 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "deprecated.h"
+
 #ifdef _MSC_VER
 #define NK_C_API __declspec(dllexport)
 #else
-#define NK_C_API 
+#define NK_C_API
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+  static const int MAXIMUM_STR_REPLY_LENGTH = 8192;
+
         /**
          * The Nitrokey device models supported by the API.
          */
         enum NK_device_model {
+						/**
+						 * Use, if no supported device is connected
+						 */
+        		NK_DISCONNECTED = 0,
             /**
              * Nitrokey Pro.
              */
-            NK_PRO,
+            NK_PRO = 1,
             /**
              * Nitrokey Storage.
              */
-            NK_STORAGE
+            NK_STORAGE = 2
         };
 
 	/**
-	 * Set debug level of messages written on stderr
-	 * @param state state=True - most messages, state=False - only errors level
-	 */
+	 * Stores the status of a Storage device.
+	 */
+        struct NK_storage_status {
+		/**
+		 * Indicates whether the unencrypted volume is read-only.
+		 */
+		bool unencrypted_volume_read_only;
+		/**
+		 * Indicates whether the unencrypted volume is active.
+		 */
+		bool unencrypted_volume_active;
+		/**
+		 * Indicates whether the encrypted volume is read-only.
+		 */
+		bool encrypted_volume_read_only;
+		/**
+		 * Indicates whether the encrypted volume is active.
+		 */
+		bool encrypted_volume_active;
+		/**
+		 * Indicates whether the hidden volume is read-only.
+		 */
+		bool hidden_volume_read_only;
+		/**
+		 * Indicates whether the hidden volume is active.
+		 */
+		bool hidden_volume_active;
+		/**
+		 * The major firmware version, e. g. 0 in v0.40.
+		 */
+		uint8_t firmware_version_major;
+		/**
+		 * The minor firmware version, e. g. 40 in v0.40.
+		 */
+		uint8_t firmware_version_minor;
+		/**
+		 * Indicates whether the firmware is locked.
+		 */
+		bool firmware_locked;
+		/**
+		 * The serial number of the SD card in the Storage stick.
+		 */
+		uint32_t serial_number_sd_card;
+		/**
+		 * The serial number of the smart card in the Storage stick.
+		 */
+		uint32_t serial_number_smart_card;
+		/**
+		 * The number of remaining login attempts for the user PIN.
+		 */
+		uint8_t user_retry_count;
+		/**
+		 * The number of remaining login attempts for the admin PIN.
+		 */
+		uint8_t admin_retry_count;
+		/**
+		 * Indicates whether a new SD card was found.
+		 */
+		bool new_sd_card_found;
+		/**
+		 * Indicates whether the SD card is filled with random characters.
+		 */
+		bool filled_with_random;
+		/**
+		 * Indicates whether the stick has been initialized by generating
+		 * the AES keys.
+		 */
+		bool stick_initialized;
+        };
+
+   struct NK_storage_ProductionTest{
+    uint8_t FirmwareVersion_au8[2];
+    uint8_t FirmwareVersionInternal_u8;
+    uint8_t SD_Card_Size_u8;
+    uint32_t CPU_CardID_u32;
+    uint32_t SmartCardID_u32;
+    uint32_t SD_CardID_u32;
+    uint8_t SC_UserPwRetryCount;
+    uint8_t SC_AdminPwRetryCount;
+    uint8_t SD_Card_ManufacturingYear_u8;
+    uint8_t SD_Card_ManufacturingMonth_u8;
+    uint16_t SD_Card_OEM_u16;
+    uint16_t SD_WriteSpeed_u16;
+    uint8_t SD_Card_Manufacturer_u8;
+  };
+
+  NK_C_API int NK_get_storage_production_info(struct NK_storage_ProductionTest * out);
+
+
+/**
+ * Set debug level of messages written on stderr
+ * @param state state=True - most messages, state=False - only errors level
+ */
 	NK_C_API void NK_set_debug(bool state);
 
 	/**
 	 * Set debug level of messages written on stderr
 	 * @param level (int) 0-lowest verbosity, 5-highest verbosity
 	 */
-  NK_C_API void NK_set_debug_level(const int level);
+	NK_C_API void NK_set_debug_level(const int level);
+
+	/**
+	 * Get the major library version, e. g. the 3 in v3.2.
+	 * @return the major library version
+	 */
+	NK_C_API unsigned int NK_get_major_library_version();
+
+	/**
+	 * Get the minor library version, e. g. the 2 in v3.2.
+	 * @return the minor library version
+	 */
+	NK_C_API unsigned int NK_get_minor_library_version();
+
+	/**
+	 * Get the library version as a string.  This is the output of
+	 * `git describe --always` at compile time, for example "v3.3" or
+	 * "v3.3-19-gaee920b".
+	 * The return value is a string literal and must not be freed.
+	 * @return the library version as a string
+	 */
+	NK_C_API const char* NK_get_library_version();
 
 	/**
 	 * Connect to device of given model. Currently library can be connected only to one device at once.
@@ -88,16 +207,24 @@ extern "C" {
 	NK_C_API int NK_logout();
 
 	/**
+	 * Query the model of the connected device.
+	 * Returns the model of the connected device or NK_DISCONNECTED.
+	 *
+	 * @return true if a device is connected and the out argument has been set
+	 */
+	NK_C_API enum NK_device_model NK_get_device_model();
+
+	/**
 	 * Return the debug status string. Debug purposes.
 	 * @return command processing error code
 	 */
-	NK_C_API const char * NK_status();
+	NK_C_API char * NK_status();
 
 	/**
 	 * Return the device's serial number string in hex.
 	 * @return string device's serial number in hex
 	 */
-	NK_C_API const char * NK_device_serial_number();
+	NK_C_API char * NK_device_serial_number();
 
 	/**
 	 * Get last command processing status. Useful for commands which returns the results of their own and could not return
@@ -114,37 +241,37 @@ extern "C" {
 
 	/**
 	 * Authenticates the user on USER privilages with user_password and sets user's temporary password on device to user_temporary_password.
-	 * @param user_password char[25](Pro) current user password
-	 * @param user_temporary_password char[25](Pro) user temporary password to be set on device for further communication (authentication command)
+	 * @param user_password char[25] current user password
+	 * @param user_temporary_password char[25] user temporary password to be set on device for further communication (authentication command)
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_user_authenticate(const char* user_password, const char* user_temporary_password);
 
 	/**
 	 * Authenticates the user on ADMIN privilages with admin_password and sets user's temporary password on device to admin_temporary_password.
-	 * @param admin_password char[25](Pro) current administrator PIN
-	 * @param admin_temporary_password char[25](Pro) admin temporary password to be set on device for further communication (authentication command)
+	 * @param admin_password char[25] current administrator PIN
+	 * @param admin_temporary_password char[25] admin temporary password to be set on device for further communication (authentication command)
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_first_authenticate(const char* admin_password, const char* admin_temporary_password);
 
 	/**
 	 * Execute a factory reset.
-	 * @param admin_password char[20](Pro) current administrator PIN
+	 * @param admin_password char[20] current administrator PIN
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_factory_reset(const char* admin_password);
 
 	/**
 	 * Generates AES key on the device
-	 * @param admin_password char[20](Pro) current administrator PIN
+	 * @param admin_password char[20] current administrator PIN
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_build_aes_key(const char* admin_password);
 
 	/**
 	 * Unlock user PIN locked after 3 incorrect codes tries.
-	 * @param admin_password char[20](Pro) current administrator PIN
+	 * @param admin_password char[20] current administrator PIN
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_unlock_user_password(const char *admin_password, const char *new_user_password);
@@ -181,16 +308,16 @@ extern "C" {
 	/**
 	 * Get name of given TOTP slot
 	 * @param slot_number TOTP slot number, slot_number<15
-	 * @return char[20](Pro) the name of the slot
+	 * @return char[20] the name of the slot
 	 */
-	NK_C_API const char * NK_get_totp_slot_name(uint8_t slot_number);
+	NK_C_API char * NK_get_totp_slot_name(uint8_t slot_number);
 
 	/**
 	 *
 	 * @param slot_number HOTP slot number, slot_number<3
-	 * @return char[20](Pro) the name of the slot
+	 * @return char[20] the name of the slot
 	 */
-	NK_C_API const char * NK_get_hotp_slot_name(uint8_t slot_number);
+	NK_C_API char * NK_get_hotp_slot_name(uint8_t slot_number);
 
 	/**
 	 * Erase HOTP slot data from the device
@@ -210,15 +337,16 @@ extern "C" {
 
 	/**
 	 * Write HOTP slot data to the device
-	 * @param slot_number HOTP slot number, slot_number<3
-	 * @param slot_name char[15](Pro) desired slot name
-	 * @param secret char[20](Pro) 160-bit secret
+	 * @param slot_number HOTP slot number, slot_number<3, 0-numbered
+	 * @param slot_name char[15] desired slot name. C string (requires ending '\0'; 16 bytes).
+	 * @param secret char[40] 160-bit or 320-bit (currently Pro v0.8 only) secret as a hex string. C string (requires ending '\0'; 41 bytes).
+	 * See NitrokeyManager::is_320_OTP_secret_supported.
 	 * @param hotp_counter uint32_t starting value of HOTP counter
 	 * @param use_8_digits should returned codes be 6 (false) or 8 digits (true)
 	 * @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock
 	 * @param use_tokenID @see token_ID
 	 * @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section
-	 * @param temporary_password char[25](Pro) admin temporary password
+	 * @param temporary_password char[25] admin temporary password
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint64_t hotp_counter,
@@ -227,15 +355,16 @@ extern "C" {
 
 	/**
 	 * Write TOTP slot data to the device
-	 * @param slot_number TOTP slot number, slot_number<15
-	 * @param slot_name char[15](Pro) desired slot name
-	 * @param secret char[20](Pro) 160-bit secret
+	 * @param slot_number TOTP slot number, slot_number<15, 0-numbered
+	 * @param slot_name char[15] desired slot name. C string (requires ending '\0'; 16 bytes).
+	 * @param secret char[40] 160-bit or 320-bit (currently Pro v0.8 only) secret as a hex string. C string (requires ending '\0'; 41 bytes).
+	 * See NitrokeyManager::is_320_OTP_secret_supported.
 	 * @param time_window uint16_t time window for this TOTP
 	 * @param use_8_digits should returned codes be 6 (false) or 8 digits (true)
 	 * @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock
 	 * @param use_tokenID @see token_ID
 	 * @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section
-	 * @param temporary_password char[20](Pro) admin temporary password
+	 * @param temporary_password char[20] admin temporary password
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint16_t time_window,
@@ -247,39 +376,39 @@ extern "C" {
 	 * @param slot_number HOTP slot number, slot_number<3
 	 * @return HOTP code
 	 */
-	NK_C_API const char * NK_get_hotp_code(uint8_t slot_number);
+	NK_C_API char * NK_get_hotp_code(uint8_t slot_number);
 
 	/**
 	 * Get HOTP code from the device (PIN protected)
 	 * @param slot_number HOTP slot number, slot_number<3
-	 * @param user_temporary_password char[25](Pro) user temporary password if PIN protected OTP codes are enabled,
+	 * @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,
 	 * otherwise should be set to empty string - ''
 	 * @return HOTP code
 	 */
-	NK_C_API const char * NK_get_hotp_code_PIN(uint8_t slot_number, const char *user_temporary_password);
+	NK_C_API char * NK_get_hotp_code_PIN(uint8_t slot_number, const char *user_temporary_password);
 
 	/**
 	 * Get TOTP code from the device
 	 * @param slot_number TOTP slot number, slot_number<15
-	 * @param challenge TOTP challenge
-	 * @param last_totp_time last time
-	 * @param last_interval last interval
+	 * @param challenge TOTP challenge -- unused
+	 * @param last_totp_time last time -- unused
+	 * @param last_interval last interval --unused
 	 * @return TOTP code
 	 */
-	NK_C_API const char * NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
+	NK_C_API char * NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
 		uint8_t last_interval);
 
 	/**
 	 * Get TOTP code from the device (PIN protected)
 	 * @param slot_number TOTP slot number, slot_number<15
-	 * @param challenge TOTP challenge
-	 * @param last_totp_time last time
-	 * @param last_interval last interval
-	 * @param user_temporary_password char[25](Pro) user temporary password if PIN protected OTP codes are enabled,
+	 * @param challenge TOTP challenge -- unused
+	 * @param last_totp_time last time -- unused
+	 * @param last_interval last interval -- unused
+	 * @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,
 	 * otherwise should be set to empty string - ''
 	 * @return TOTP code
 	 */
-	NK_C_API const char * NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge,
+	NK_C_API char * NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge,
 		uint64_t last_totp_time, uint8_t last_interval,
 		const char *user_temporary_password);
 
@@ -290,21 +419,35 @@ extern "C" {
 	 */
 	NK_C_API int NK_totp_set_time(uint64_t time);
 
+	/**
+	 * Set the device time used for TOTP to the given time.  Contrary to
+	 * {@code set_time(uint64_t)}, this command fails if {@code old_time}
+	 * &gt; {@code time} or if {@code old_time} is zero (where {@code
+	 * old_time} is the current time on the device).
+	 *
+	 * @param time new device time as Unix timestamp (seconds since
+	 *        1970-01-01)
+	 * @return command processing error code
+	 */
+	NK_C_API int NK_totp_set_time_soft(uint64_t time);
+
+	// NK_totp_get_time is deprecated -- use NK_totp_set_time_soft instead
+	DEPRECATED
 	NK_C_API int NK_totp_get_time();
 
 	//passwords
 	/**
 	 * Change administrator PIN
-	 * @param current_PIN char[25](Pro) current PIN
-	 * @param new_PIN char[25](Pro) new PIN
+	 * @param current_PIN char[25] current PIN
+	 * @param new_PIN char[25] new PIN
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_change_admin_PIN(const char *current_PIN, const char *new_PIN);
 
 	/**
 	 * Change user PIN
-	 * @param current_PIN char[25](Pro) current PIN
-	 * @param new_PIN char[25](Pro) new PIN
+	 * @param current_PIN char[25] current PIN
+	 * @param new_PIN char[25] new PIN
 	 * @return command processing error code
 	*/
 	NK_C_API int NK_change_user_PIN(const char *current_PIN, const char *new_PIN);
@@ -325,7 +468,7 @@ extern "C" {
 
 	/**
 	 * Enable password safe access
-	 * @param user_pin char[30](Pro) current user PIN
+	 * @param user_pin char[30] current user PIN
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_enable_password_safe(const char *user_pin);
@@ -341,28 +484,28 @@ extern "C" {
 	 * @param slot_number password safe slot number, slot_number<16
 	 * @return slot name
 	 */
-	NK_C_API const char *NK_get_password_safe_slot_name(uint8_t slot_number);
+	NK_C_API char *NK_get_password_safe_slot_name(uint8_t slot_number);
 
 	/**
 	 * Get password safe slot login
 	 * @param slot_number password safe slot number, slot_number<16
 	 * @return login from the PWS slot
 	 */
-	NK_C_API const char *NK_get_password_safe_slot_login(uint8_t slot_number);
+	NK_C_API char *NK_get_password_safe_slot_login(uint8_t slot_number);
 
 	/**
 	 * Get the password safe slot password
 	 * @param slot_number password safe slot number, slot_number<16
 	 * @return password from the PWS slot
 	 */
-	NK_C_API const char *NK_get_password_safe_slot_password(uint8_t slot_number);
+	NK_C_API char *NK_get_password_safe_slot_password(uint8_t slot_number);
 
 	/**
 	 * Write password safe data to the slot
 	 * @param slot_number password safe slot number, slot_number<16
-	 * @param slot_name char[11](Pro) name of the slot
-	 * @param slot_login char[32](Pro) login string
-	 * @param slot_password char[20](Pro) password string
+	 * @param slot_name char[11] name of the slot
+	 * @param slot_login char[32] login string
+	 * @param slot_password char[20] password string
 	 * @return command processing error code
 	 */
 	NK_C_API int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_name,
@@ -580,7 +723,18 @@ extern "C" {
 	 * Storage only
 	 * @return string with devices attributes
 	 */
-	NK_C_API const char* NK_get_status_storage_as_string();
+	NK_C_API char* NK_get_status_storage_as_string();
+
+	/**
+	 * Get the Storage stick status and return the command processing
+	 * error code.  If the code is zero, i. e. the command was successful,
+	 * the storage status is written to the output pointer's target.
+	 * The output pointer must not be null.
+	 *
+	 * @param out the output pointer for the storage status
+	 * @return command processing error code
+	 */
+	NK_C_API int NK_get_status_storage(struct NK_storage_status* out);
 
 	/**
 	 * Get SD card usage attributes as string.
@@ -588,7 +742,7 @@ extern "C" {
 	 * Storage only
 	 * @return string with SD card usage attributes
 	 */
-	NK_C_API const char* NK_get_SD_usage_data_as_string();
+	NK_C_API char* NK_get_SD_usage_data_as_string();
 
 	/**
 	 * Get progress value of current long operation.
@@ -612,7 +766,7 @@ extern "C" {
  * @example Example of returned data: '00005d19:dacc2cb4_p_0001:0010:02;000037c7:4cf12445_p_0001:000f:02;0001:000c:02'
  * @return string delimited id's of connected devices
  */
-	NK_C_API const char* NK_list_devices_by_cpuID();
+	NK_C_API char* NK_list_devices_by_cpuID();
 
 
 /**
@@ -625,7 +779,11 @@ extern "C" {
  */
 	NK_C_API int NK_connect_with_ID(const char* id);
 
-
+	/**
+	 * Blink red and green LED alternatively and infinitely (until device is reconnected).
+	 * @return command processing error code
+	 */
+	NK_C_API int NK_wink();
 
 #ifdef __cplusplus
 }
diff --git a/libnitrokey-v3.3/NitrokeyManager.cc b/libnitrokey-v3.4/NitrokeyManager.cc
index 2ca183c..a950e4b 100644
--- a/libnitrokey-v3.3/NitrokeyManager.cc
+++ b/libnitrokey-v3.4/NitrokeyManager.cc
@@ -234,12 +234,14 @@ using nitrokey::misc::strcpyT;
     bool NitrokeyManager::connect() {
         std::lock_guard<std::mutex> lock(mex_dev_com_manager);
         vector< shared_ptr<Device> > devices = { make_shared<Stick10>(), make_shared<Stick20>() };
+        bool connected = false;
         for( auto & d : devices ){
             if (d->connect()){
                 device = std::shared_ptr<Device>(d);
+                connected = true;
             }
         }
-        return device != nullptr;
+        return connected;
     }
 
 
@@ -630,12 +632,12 @@ using nitrokey::misc::strcpyT;
       auto resp = WriteToTOTPSlot::CommandTransaction::run(device, payload);
     }
 
-    const char * NitrokeyManager::get_totp_slot_name(uint8_t slot_number) {
+    char * NitrokeyManager::get_totp_slot_name(uint8_t slot_number) {
         if (!is_valid_totp_slot_number(slot_number)) throw InvalidSlotException(slot_number);
         slot_number = get_internal_slot_number_for_totp(slot_number);
         return get_slot_name(slot_number);
     }
-    const char * NitrokeyManager::get_hotp_slot_name(uint8_t slot_number) {
+    char * NitrokeyManager::get_hotp_slot_name(uint8_t slot_number) {
         if (!is_valid_hotp_slot_number(slot_number)) throw InvalidSlotException(slot_number);
         slot_number = get_internal_slot_number_for_hotp(slot_number);
         return get_slot_name(slot_number);
@@ -643,7 +645,7 @@ using nitrokey::misc::strcpyT;
 
   static const int max_string_field_length = 2*1024; //storage's status string is ~1k
 
-  const char * NitrokeyManager::get_slot_name(uint8_t slot_number)  {
+  char * NitrokeyManager::get_slot_name(uint8_t slot_number)  {
         auto payload = get_payload<GetSlotName>();
         payload.slot_number = slot_number;
         auto resp = GetSlotName::CommandTransaction::run(device, payload);
@@ -666,11 +668,15 @@ using nitrokey::misc::strcpyT;
         return false;
     }
 
-    bool NitrokeyManager::get_time(uint64_t time) {
+    void NitrokeyManager::set_time_soft(uint64_t time) {
         auto p = get_payload<SetTime>();
         p.reset = 0;
         p.time = time;
         SetTime::CommandTransaction::run(device, p);
+    }
+
+    bool NitrokeyManager::get_time(uint64_t time) {
+        set_time_soft(time);
         return true;
     }
 
@@ -749,7 +755,7 @@ using nitrokey::misc::strcpyT;
         LockDevice::CommandTransaction::run(device);
     }
 
-    const char *NitrokeyManager::get_password_safe_slot_name(uint8_t slot_number) {
+    char * NitrokeyManager::get_password_safe_slot_name(uint8_t slot_number) {
         if (!is_valid_password_safe_slot_number(slot_number)) throw InvalidSlotException(slot_number);
         auto p = get_payload<GetPasswordSafeSlotName>();
         p.slot_number = slot_number;
@@ -759,7 +765,7 @@ using nitrokey::misc::strcpyT;
 
     bool NitrokeyManager::is_valid_password_safe_slot_number(uint8_t slot_number) const { return slot_number < 16; }
 
-    const char *NitrokeyManager::get_password_safe_slot_login(uint8_t slot_number) {
+    char * NitrokeyManager::get_password_safe_slot_login(uint8_t slot_number) {
         if (!is_valid_password_safe_slot_number(slot_number)) throw InvalidSlotException(slot_number);
         auto p = get_payload<GetPasswordSafeSlotLogin>();
         p.slot_number = slot_number;
@@ -767,7 +773,7 @@ using nitrokey::misc::strcpyT;
         return strndup((const char *) response.data().slot_login, max_string_field_length);
     }
 
-    const char *NitrokeyManager::get_password_safe_slot_password(uint8_t slot_number) {
+    char * NitrokeyManager::get_password_safe_slot_password(uint8_t slot_number) {
         if (!is_valid_password_safe_slot_number(slot_number)) throw InvalidSlotException(slot_number);
         auto p = get_payload<GetPasswordSafeSlotPassword>();
         p.slot_number = slot_number;
@@ -1059,7 +1065,7 @@ using nitrokey::misc::strcpyT;
       stick20::ChangeUpdatePassword::CommandTransaction::run(device, p);
     }
 
-    const char * NitrokeyManager::get_status_storage_as_string(){
+    char * NitrokeyManager::get_status_storage_as_string(){
       auto p = stick20::GetDeviceStatus::CommandTransaction::run(device);
       return strndup(p.data().dissect().c_str(), max_string_field_length);
     }
@@ -1069,7 +1075,7 @@ using nitrokey::misc::strcpyT;
       return p.data();
     }
 
-    const char * NitrokeyManager::get_SD_usage_data_as_string(){
+    char * NitrokeyManager::get_SD_usage_data_as_string(){
       auto p = stick20::GetSDCardOccupancy::CommandTransaction::run(device);
       return strndup(p.data().dissect().c_str(), max_string_field_length);
     }
@@ -1131,5 +1137,13 @@ using nitrokey::misc::strcpyT;
         return current_device_id;
     }
 
+  void NitrokeyManager::wink(){
+    stick20::Wink::CommandTransaction::run(device);
+  };
+
+  stick20::ProductionTest::ResponsePayload NitrokeyManager::production_info(){
+    auto data = stick20::ProductionTest::CommandTransaction::run(device);
+    return data.data();
+  };
 
 }
diff --git a/libnitrokey-v3.3/README.md b/libnitrokey-v3.4/README.md
index 81b367a..81b367a 100644
--- a/libnitrokey-v3.3/README.md
+++ b/libnitrokey-v3.4/README.md
diff --git a/libnitrokey-v3.3/command_id.cc b/libnitrokey-v3.4/command_id.cc
index d81d487..a6c2a28 100644
--- a/libnitrokey-v3.3/command_id.cc
+++ b/libnitrokey-v3.4/command_id.cc
@@ -173,10 +173,10 @@ const char *commandid_to_string(CommandID id) {
       return "NEW_AES_KEY";
     case CommandID::WRITE_TO_SLOT_2:
       return "WRITE_TO_SLOT_2";
-      break;
     case CommandID::SEND_OTP_DATA:
       return "SEND_OTP_DATA";
-      break;
+    case CommandID::WINK:
+      return "WINK";
   }
   return "UNKNOWN";
 }
diff --git a/libnitrokey-v3.3/device.cc b/libnitrokey-v3.4/device.cc
index da54e33..80e4b38 100644
--- a/libnitrokey-v3.3/device.cc
+++ b/libnitrokey-v3.4/device.cc
@@ -69,8 +69,10 @@ bool Device::_disconnect() {
   LOG(std::string(__FUNCTION__) + std::string(m_model == DeviceModel::PRO ? "PRO" : "STORAGE"), Loglevel::DEBUG_L2);
   LOG(std::string(__FUNCTION__) +  std::string(" *IN* "), Loglevel::DEBUG_L2);
 
-  LOG(std::string("Disconnection: handle already freed: ") + std::to_string(mp_devhandle == nullptr) + " ("+m_path+")", Loglevel::DEBUG_L1);
-  if(mp_devhandle == nullptr) return false;
+  if(mp_devhandle == nullptr) {
+    LOG(std::string("Disconnection: handle already freed: ") + std::to_string(mp_devhandle == nullptr) + " ("+m_path+")", Loglevel::DEBUG_L1);
+    return false;
+  }
 
   hid_close(mp_devhandle);
   mp_devhandle = nullptr;
diff --git a/libnitrokey-v3.3/libnitrokey/CommandFailedException.h b/libnitrokey-v3.4/libnitrokey/CommandFailedException.h
index 32bd6b7..32bd6b7 100644
--- a/libnitrokey-v3.3/libnitrokey/CommandFailedException.h
+++ b/libnitrokey-v3.4/libnitrokey/CommandFailedException.h
diff --git a/libnitrokey-v3.3/libnitrokey/DeviceCommunicationExceptions.h b/libnitrokey-v3.4/libnitrokey/DeviceCommunicationExceptions.h
index f710d0b..f710d0b 100644
--- a/libnitrokey-v3.3/libnitrokey/DeviceCommunicationExceptions.h
+++ b/libnitrokey-v3.4/libnitrokey/DeviceCommunicationExceptions.h
diff --git a/libnitrokey-v3.3/libnitrokey/LibraryException.h b/libnitrokey-v3.4/libnitrokey/LibraryException.h
index 3b9d177..3b9d177 100644
--- a/libnitrokey-v3.3/libnitrokey/LibraryException.h
+++ b/libnitrokey-v3.4/libnitrokey/LibraryException.h
diff --git a/libnitrokey-v3.3/libnitrokey/LongOperationInProgressException.h b/libnitrokey-v3.4/libnitrokey/LongOperationInProgressException.h
index 865d6b5..865d6b5 100644
--- a/libnitrokey-v3.3/libnitrokey/LongOperationInProgressException.h
+++ b/libnitrokey-v3.4/libnitrokey/LongOperationInProgressException.h
diff --git a/libnitrokey-v3.3/libnitrokey/NitrokeyManager.h b/libnitrokey-v3.4/libnitrokey/NitrokeyManager.h
index 1f4cec4..d6e5df4 100644
--- a/libnitrokey-v3.3/libnitrokey/NitrokeyManager.h
+++ b/libnitrokey-v3.4/libnitrokey/NitrokeyManager.h
@@ -65,6 +65,18 @@ char * strndup(const char* str, size_t maxlen);
         stick10::ReadSlot::ResponsePayload get_HOTP_slot_data(const uint8_t slot_number);
 
         bool set_time(uint64_t time);
+        /**
+         * Set the device time used for TOTP to the given time.  Contrary to
+         * {@code set_time(uint64_t)}, this command fails if {@code old_time}
+         * &gt; {@code time} or if {@code old_time} is zero (where {@code
+         * old_time} is the current time on the device).
+         *
+         * @param time new device time as Unix timestamp (seconds since
+         *        1970-01-01)
+         */
+        void set_time_soft(uint64_t time);
+
+        [[deprecated("get_time is deprecated -- use set_time_soft instead")]]
         bool get_time(uint64_t time = 0);
         bool erase_totp_slot(uint8_t slot_number, const char *temporary_password);
         bool erase_hotp_slot(uint8_t slot_number, const char *temporary_password);
@@ -93,8 +105,8 @@ char * strndup(const char* str, size_t maxlen);
         string get_status_as_string();
         string get_serial_number();
 
-        const char * get_totp_slot_name(uint8_t slot_number);
-        const char * get_hotp_slot_name(uint8_t slot_number);
+        char * get_totp_slot_name(uint8_t slot_number);
+        char * get_hotp_slot_name(uint8_t slot_number);
 
         void change_user_PIN(const char *current_PIN, const char *new_PIN);
         void change_admin_PIN(const char *current_PIN, const char *new_PIN);
@@ -108,9 +120,9 @@ char * strndup(const char* str, size_t maxlen);
 
         void lock_device();
 
-        const char *get_password_safe_slot_name(uint8_t slot_number);
-        const char *get_password_safe_slot_password(uint8_t slot_number);
-        const char *get_password_safe_slot_login(uint8_t slot_number);
+        char * get_password_safe_slot_name(uint8_t slot_number);
+        char * get_password_safe_slot_password(uint8_t slot_number);
+        char * get_password_safe_slot_login(uint8_t slot_number);
 
         void
     write_password_safe_slot(uint8_t slot_number, const char *slot_name, const char *slot_login,
@@ -187,10 +199,10 @@ char * strndup(const char* str, size_t maxlen);
 
         void send_startup(uint64_t seconds_from_epoch);
 
-        const char * get_status_storage_as_string();
+        char * get_status_storage_as_string();
         stick20::DeviceConfigurationResponsePacket::ResponsePayload get_status_storage();
 
-        const char *get_SD_usage_data_as_string();
+        char * get_SD_usage_data_as_string();
         std::pair<uint8_t,uint8_t> get_SD_usage_data();
 
 
@@ -227,7 +239,7 @@ char * strndup(const char* str, size_t maxlen);
         uint8_t get_internal_slot_number_for_hotp(uint8_t slot_number) const;
         uint8_t get_internal_slot_number_for_totp(uint8_t slot_number) const;
         bool erase_slot(uint8_t slot_number, const char *temporary_password);
-        const char * get_slot_name(uint8_t slot_number);
+        char * get_slot_name(uint8_t slot_number);
 
         template <typename ProCommand, PasswordKind StoKind>
         void change_PIN_general(const char *current_PIN, const char *new_PIN);
@@ -276,6 +288,13 @@ char * strndup(const char* str, size_t maxlen);
        * @return Returns true, if set unencrypted volume ro/rw pin type is User, false otherwise.
        */
       bool set_unencrypted_volume_rorw_pin_type_user();
+
+      /**
+       * Blink red and green LED alternatively and infinitely (until device is reconnected).
+       */
+      void wink();
+
+      stick20::ProductionTest::ResponsePayload production_info();
     };
 }
 
diff --git a/libnitrokey-v3.3/libnitrokey/command.h b/libnitrokey-v3.4/libnitrokey/command.h
index 6852bf0..6852bf0 100644
--- a/libnitrokey-v3.3/libnitrokey/command.h
+++ b/libnitrokey-v3.4/libnitrokey/command.h
diff --git a/libnitrokey-v3.3/libnitrokey/command_id.h b/libnitrokey-v3.4/libnitrokey/command_id.h
index 1092ea9..eb0d450 100644
--- a/libnitrokey-v3.3/libnitrokey/command_id.h
+++ b/libnitrokey-v3.4/libnitrokey/command_id.h
@@ -130,6 +130,8 @@ enum class CommandID : uint8_t {
   ENABLE_ADMIN_READONLY_ENCRYPTED_LUN = 0x20 + 30,
   ENABLE_ADMIN_READWRITE_ENCRYPTED_LUN = 0x20 + 31,
   CHECK_SMARTCARD_USAGE = 0x20 + 32,
+  //v0.52+
+  WINK = 0x20 + 33,
 
   GET_PW_SAFE_SLOT_STATUS = 0x60,
   GET_PW_SAFE_SLOT_NAME = 0x61,
diff --git a/libnitrokey-v3.3/libnitrokey/cxx_semantics.h b/libnitrokey-v3.4/libnitrokey/cxx_semantics.h
index 36ed142..36ed142 100644
--- a/libnitrokey-v3.3/libnitrokey/cxx_semantics.h
+++ b/libnitrokey-v3.4/libnitrokey/cxx_semantics.h
diff --git a/libnitrokey-v3.4/libnitrokey/deprecated.h b/libnitrokey-v3.4/libnitrokey/deprecated.h
new file mode 100644
index 0000000..5a83288
--- /dev/null
+++ b/libnitrokey-v3.4/libnitrokey/deprecated.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2018 Nitrokey UG
+ *
+ * This file is part of libnitrokey.
+ *
+ * libnitrokey is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ *
+ * libnitrokey is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnitrokey. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+ */
+
+
+#ifndef LIBNITROKEY_DEPRECATED_H
+#define LIBNITROKEY_DEPRECATED_H
+
+#if defined(__GNUC__) || defined(__clang__)
+#define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#else
+#pragma message("WARNING: DEPRECATED macro is not defined for this compiler")
+#define DEPRECATED
+#endif
+
+#endif //LIBNITROKEY_DEPRECATED_H
diff --git a/libnitrokey-v3.3/libnitrokey/device.h b/libnitrokey-v3.4/libnitrokey/device.h
index f6d2380..f6d2380 100644
--- a/libnitrokey-v3.3/libnitrokey/device.h
+++ b/libnitrokey-v3.4/libnitrokey/device.h
diff --git a/libnitrokey-v3.3/libnitrokey/device_proto.h b/libnitrokey-v3.4/libnitrokey/device_proto.h
index 45a6c16..45a6c16 100644
--- a/libnitrokey-v3.3/libnitrokey/device_proto.h
+++ b/libnitrokey-v3.4/libnitrokey/device_proto.h
diff --git a/libnitrokey-v3.3/libnitrokey/dissect.h b/libnitrokey-v3.4/libnitrokey/dissect.h
index 690b5b7..690b5b7 100644
--- a/libnitrokey-v3.3/libnitrokey/dissect.h
+++ b/libnitrokey-v3.4/libnitrokey/dissect.h
diff --git a/libnitrokey-v3.3/libnitrokey/hidapi/hidapi.h b/libnitrokey-v3.4/libnitrokey/hidapi/hidapi.h
index e5bc2dc..e5bc2dc 100644
--- a/libnitrokey-v3.3/libnitrokey/hidapi/hidapi.h
+++ b/libnitrokey-v3.4/libnitrokey/hidapi/hidapi.h
diff --git a/libnitrokey-v3.3/libnitrokey/log.h b/libnitrokey-v3.4/libnitrokey/log.h
index 2a64bef..2a64bef 100644
--- a/libnitrokey-v3.3/libnitrokey/log.h
+++ b/libnitrokey-v3.4/libnitrokey/log.h
diff --git a/libnitrokey-v3.3/libnitrokey/misc.h b/libnitrokey-v3.4/libnitrokey/misc.h
index 88254dd..88254dd 100644
--- a/libnitrokey-v3.3/libnitrokey/misc.h
+++ b/libnitrokey-v3.4/libnitrokey/misc.h
diff --git a/libnitrokey-v3.3/libnitrokey/stick10_commands.h b/libnitrokey-v3.4/libnitrokey/stick10_commands.h
index f2ffba2..f2ffba2 100644
--- a/libnitrokey-v3.3/libnitrokey/stick10_commands.h
+++ b/libnitrokey-v3.4/libnitrokey/stick10_commands.h
diff --git a/libnitrokey-v3.3/libnitrokey/stick10_commands_0.8.h b/libnitrokey-v3.4/libnitrokey/stick10_commands_0.8.h
index 9477890..9477890 100644
--- a/libnitrokey-v3.3/libnitrokey/stick10_commands_0.8.h
+++ b/libnitrokey-v3.4/libnitrokey/stick10_commands_0.8.h
diff --git a/libnitrokey-v3.3/libnitrokey/stick20_commands.h b/libnitrokey-v3.4/libnitrokey/stick20_commands.h
index 4b75e6a..7efa1b6 100644
--- a/libnitrokey-v3.3/libnitrokey/stick20_commands.h
+++ b/libnitrokey-v3.4/libnitrokey/stick20_commands.h
@@ -275,6 +275,12 @@ namespace nitrokey {
                     CommandTransaction;
             };
 
+          class Wink : Command<CommandID::WINK> {
+          public:
+            typedef Transaction<command_id(), struct EmptyPayload, struct EmptyPayload>
+                CommandTransaction;
+          };
+
             class CheckSmartcardUsage : Command<CommandID::CHECK_SMARTCARD_USAGE> {
             public:
                 typedef Transaction<command_id(), struct EmptyPayload, EmptyPayload>
diff --git a/libnitrokey-v3.4/libnitrokey/version.h b/libnitrokey-v3.4/libnitrokey/version.h
new file mode 100644
index 0000000..6547af0
--- /dev/null
+++ b/libnitrokey-v3.4/libnitrokey/version.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018 Nitrokey UG
+ *
+ * This file is part of libnitrokey.
+ *
+ * libnitrokey is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ *
+ * libnitrokey is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnitrokey. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+ */
+
+#ifndef LIBNITROKEY_VERSION_H
+#define LIBNITROKEY_VERSION_H
+
+namespace nitrokey {
+    unsigned int get_major_library_version();
+
+    unsigned int get_minor_library_version();
+
+    const char* get_library_version();
+}
+
+#endif
diff --git a/libnitrokey-v3.3/log.cc b/libnitrokey-v3.4/log.cc
index 06acee7..06acee7 100644
--- a/libnitrokey-v3.3/log.cc
+++ b/libnitrokey-v3.4/log.cc
diff --git a/libnitrokey-v3.3/misc.cc b/libnitrokey-v3.4/misc.cc
index 59185f3..59185f3 100644
--- a/libnitrokey-v3.3/misc.cc
+++ b/libnitrokey-v3.4/misc.cc
diff --git a/libnitrokey-v3.4/version.cc.in b/libnitrokey-v3.4/version.cc.in
new file mode 100644
index 0000000..0eae647
--- /dev/null
+++ b/libnitrokey-v3.4/version.cc.in
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018 Nitrokey UG
+ *
+ * This file is part of libnitrokey.
+ *
+ * libnitrokey is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ *
+ * libnitrokey is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnitrokey. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+ */
+
+#include "version.h"
+
+namespace nitrokey {
+    unsigned int get_major_library_version() {
+        return @PROJECT_VERSION_MAJOR@;
+    }
+
+    unsigned int get_minor_library_version() {
+        return @PROJECT_VERSION_MINOR@;
+    }
+
+    const char* get_library_version() {
+        return "@PROJECT_VERSION_GIT@";
+    }
+}
+
diff --git a/src/ffi.rs b/src/ffi.rs
index fc70e97..58879ad 100644
--- a/src/ffi.rs
+++ b/src/ffi.rs
@@ -1,11 +1,467 @@
 /* automatically generated by rust-bindgen, manually modified */
 
+/// Use, if no supported device is connected
+pub const NK_device_model_NK_DISCONNECTED: NK_device_model = 0;
 /// Nitrokey Pro.
-pub const NK_device_model_NK_PRO: NK_device_model = 0;
+pub const NK_device_model_NK_PRO: NK_device_model = 1;
 /// Nitrokey Storage.
-pub const NK_device_model_NK_STORAGE: NK_device_model = 1;
+pub const NK_device_model_NK_STORAGE: NK_device_model = 2;
 /// The Nitrokey device models supported by the API.
 pub type NK_device_model = u32;
+/// Stores the status of a Storage device.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct NK_storage_status {
+    /// Indicates whether the unencrypted volume is read-only.
+    pub unencrypted_volume_read_only: bool,
+    /// Indicates whether the unencrypted volume is active.
+    pub unencrypted_volume_active: bool,
+    /// Indicates whether the encrypted volume is read-only.
+    pub encrypted_volume_read_only: bool,
+    /// Indicates whether the encrypted volume is active.
+    pub encrypted_volume_active: bool,
+    /// Indicates whether the hidden volume is read-only.
+    pub hidden_volume_read_only: bool,
+    /// Indicates whether the hidden volume is active.
+    pub hidden_volume_active: bool,
+    /// The major firmware version, e. g. 0 in v0.40.
+    pub firmware_version_major: u8,
+    /// The minor firmware version, e. g. 40 in v0.40.
+    pub firmware_version_minor: u8,
+    /// Indicates whether the firmware is locked.
+    pub firmware_locked: bool,
+    /// The serial number of the SD card in the Storage stick.
+    pub serial_number_sd_card: u32,
+    /// The serial number of the smart card in the Storage stick.
+    pub serial_number_smart_card: u32,
+    /// The number of remaining login attempts for the user PIN.
+    pub user_retry_count: u8,
+    /// The number of remaining login attempts for the admin PIN.
+    pub admin_retry_count: u8,
+    /// Indicates whether a new SD card was found.
+    pub new_sd_card_found: bool,
+    /// Indicates whether the SD card is filled with random characters.
+    pub filled_with_random: bool,
+    /// Indicates whether the stick has been initialized by generating
+    /// the AES keys.
+    pub stick_initialized: bool,
+}
+#[test]
+fn bindgen_test_layout_NK_storage_status() {
+    assert_eq!(
+        ::std::mem::size_of::<NK_storage_status>(),
+        28usize,
+        concat!("Size of: ", stringify!(NK_storage_status))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NK_storage_status>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NK_storage_status))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).unencrypted_volume_read_only as *const _
+                as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(unencrypted_volume_read_only)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).unencrypted_volume_active as *const _
+                as usize
+        },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(unencrypted_volume_active)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).encrypted_volume_read_only as *const _
+                as usize
+        },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(encrypted_volume_read_only)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).encrypted_volume_active as *const _
+                as usize
+        },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(encrypted_volume_active)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).hidden_volume_read_only as *const _
+                as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(hidden_volume_read_only)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).hidden_volume_active as *const _ as usize
+        },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(hidden_volume_active)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).firmware_version_major as *const _
+                as usize
+        },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(firmware_version_major)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).firmware_version_minor as *const _
+                as usize
+        },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(firmware_version_minor)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).firmware_locked as *const _ as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(firmware_locked)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).serial_number_sd_card as *const _ as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(serial_number_sd_card)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).serial_number_smart_card as *const _
+                as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(serial_number_smart_card)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).user_retry_count as *const _ as usize
+        },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(user_retry_count)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).admin_retry_count as *const _ as usize
+        },
+        21usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(admin_retry_count)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).new_sd_card_found as *const _ as usize
+        },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(new_sd_card_found)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).filled_with_random as *const _ as usize
+        },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(filled_with_random)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_status>())).stick_initialized as *const _ as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_status),
+            "::",
+            stringify!(stick_initialized)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct NK_storage_ProductionTest {
+    pub FirmwareVersion_au8: [u8; 2usize],
+    pub FirmwareVersionInternal_u8: u8,
+    pub SD_Card_Size_u8: u8,
+    pub CPU_CardID_u32: u32,
+    pub SmartCardID_u32: u32,
+    pub SD_CardID_u32: u32,
+    pub SC_UserPwRetryCount: u8,
+    pub SC_AdminPwRetryCount: u8,
+    pub SD_Card_ManufacturingYear_u8: u8,
+    pub SD_Card_ManufacturingMonth_u8: u8,
+    pub SD_Card_OEM_u16: u16,
+    pub SD_WriteSpeed_u16: u16,
+    pub SD_Card_Manufacturer_u8: u8,
+}
+#[test]
+fn bindgen_test_layout_NK_storage_ProductionTest() {
+    assert_eq!(
+        ::std::mem::size_of::<NK_storage_ProductionTest>(),
+        28usize,
+        concat!("Size of: ", stringify!(NK_storage_ProductionTest))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NK_storage_ProductionTest>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NK_storage_ProductionTest))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).FirmwareVersion_au8 as *const _
+                as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(FirmwareVersion_au8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).FirmwareVersionInternal_u8
+                as *const _ as usize
+        },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(FirmwareVersionInternal_u8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_Card_Size_u8 as *const _
+                as usize
+        },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_Card_Size_u8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).CPU_CardID_u32 as *const _
+                as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(CPU_CardID_u32)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SmartCardID_u32 as *const _
+                as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SmartCardID_u32)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_CardID_u32 as *const _ as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_CardID_u32)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SC_UserPwRetryCount as *const _
+                as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SC_UserPwRetryCount)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SC_AdminPwRetryCount as *const _
+                as usize
+        },
+        17usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SC_AdminPwRetryCount)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_Card_ManufacturingYear_u8
+                as *const _ as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_Card_ManufacturingYear_u8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_Card_ManufacturingMonth_u8
+                as *const _ as usize
+        },
+        19usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_Card_ManufacturingMonth_u8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_Card_OEM_u16 as *const _
+                as usize
+        },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_Card_OEM_u16)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_WriteSpeed_u16 as *const _
+                as usize
+        },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_WriteSpeed_u16)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<NK_storage_ProductionTest>())).SD_Card_Manufacturer_u8
+                as *const _ as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NK_storage_ProductionTest),
+            "::",
+            stringify!(SD_Card_Manufacturer_u8)
+        )
+    );
+}
+extern "C" {
+    pub fn NK_get_storage_production_info(
+        out: *mut NK_storage_ProductionTest,
+    ) -> ::std::os::raw::c_int;
+}
 extern "C" {
     /// Set debug level of messages written on stderr
     /// @param state state=True - most messages, state=False - only errors level
@@ -17,6 +473,24 @@ extern "C" {
     pub fn NK_set_debug_level(level: ::std::os::raw::c_int);
 }
 extern "C" {
+    /// Get the major library version, e. g. the 3 in v3.2.
+    /// @return the major library version
+    pub fn NK_get_major_library_version() -> ::std::os::raw::c_uint;
+}
+extern "C" {
+    /// Get the minor library version, e. g. the 2 in v3.2.
+    /// @return the minor library version
+    pub fn NK_get_minor_library_version() -> ::std::os::raw::c_uint;
+}
+extern "C" {
+    /// Get the library version as a string.  This is the output of
+    /// `git describe --always` at compile time, for example "v3.3" or
+    /// "v3.3-19-gaee920b".
+    /// The return value is a string literal and must not be freed.
+    /// @return the library version as a string
+    pub fn NK_get_library_version() -> *const ::std::os::raw::c_char;
+}
+extern "C" {
     /// Connect to device of given model. Currently library can be connected only to one device at once.
     /// @param device_model char 'S': Nitrokey Storage, 'P': Nitrokey Pro
     /// @return 1 if connected, 0 if wrong model or cannot connect
@@ -39,14 +513,21 @@ extern "C" {
     pub fn NK_logout() -> ::std::os::raw::c_int;
 }
 extern "C" {
+    /// Query the model of the connected device.
+    /// Returns the model of the connected device or NK_DISCONNECTED.
+    ///
+    /// @return true if a device is connected and the out argument has been set
+    pub fn NK_get_device_model() -> NK_device_model;
+}
+extern "C" {
     /// Return the debug status string. Debug purposes.
     /// @return command processing error code
-    pub fn NK_status() -> *const ::std::os::raw::c_char;
+    pub fn NK_status() -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Return the device's serial number string in hex.
     /// @return string device's serial number in hex
-    pub fn NK_device_serial_number() -> *const ::std::os::raw::c_char;
+    pub fn NK_device_serial_number() -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get last command processing status. Useful for commands which returns the results of their own and could not return
@@ -61,8 +542,8 @@ extern "C" {
 }
 extern "C" {
     /// Authenticates the user on USER privilages with user_password and sets user's temporary password on device to user_temporary_password.
-    /// @param user_password char[25](Pro) current user password
-    /// @param user_temporary_password char[25](Pro) user temporary password to be set on device for further communication (authentication command)
+    /// @param user_password char[25] current user password
+    /// @param user_temporary_password char[25] user temporary password to be set on device for further communication (authentication command)
     /// @return command processing error code
     pub fn NK_user_authenticate(
         user_password: *const ::std::os::raw::c_char,
@@ -71,8 +552,8 @@ extern "C" {
 }
 extern "C" {
     /// Authenticates the user on ADMIN privilages with admin_password and sets user's temporary password on device to admin_temporary_password.
-    /// @param admin_password char[25](Pro) current administrator PIN
-    /// @param admin_temporary_password char[25](Pro) admin temporary password to be set on device for further communication (authentication command)
+    /// @param admin_password char[25] current administrator PIN
+    /// @param admin_temporary_password char[25] admin temporary password to be set on device for further communication (authentication command)
     /// @return command processing error code
     pub fn NK_first_authenticate(
         admin_password: *const ::std::os::raw::c_char,
@@ -81,21 +562,21 @@ extern "C" {
 }
 extern "C" {
     /// Execute a factory reset.
-    /// @param admin_password char[20](Pro) current administrator PIN
+    /// @param admin_password char[20] current administrator PIN
     /// @return command processing error code
     pub fn NK_factory_reset(admin_password: *const ::std::os::raw::c_char)
         -> ::std::os::raw::c_int;
 }
 extern "C" {
     /// Generates AES key on the device
-    /// @param admin_password char[20](Pro) current administrator PIN
+    /// @param admin_password char[20] current administrator PIN
     /// @return command processing error code
     pub fn NK_build_aes_key(admin_password: *const ::std::os::raw::c_char)
         -> ::std::os::raw::c_int;
 }
 extern "C" {
     /// Unlock user PIN locked after 3 incorrect codes tries.
-    /// @param admin_password char[20](Pro) current administrator PIN
+    /// @param admin_password char[20] current administrator PIN
     /// @return command processing error code
     pub fn NK_unlock_user_password(
         admin_password: *const ::std::os::raw::c_char,
@@ -135,13 +616,13 @@ extern "C" {
 extern "C" {
     /// Get name of given TOTP slot
     /// @param slot_number TOTP slot number, slot_number<15
-    /// @return char[20](Pro) the name of the slot
-    pub fn NK_get_totp_slot_name(slot_number: u8) -> *const ::std::os::raw::c_char;
+    /// @return char[20] the name of the slot
+    pub fn NK_get_totp_slot_name(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// @param slot_number HOTP slot number, slot_number<3
-    /// @return char[20](Pro) the name of the slot
-    pub fn NK_get_hotp_slot_name(slot_number: u8) -> *const ::std::os::raw::c_char;
+    /// @return char[20] the name of the slot
+    pub fn NK_get_hotp_slot_name(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Erase HOTP slot data from the device
@@ -165,15 +646,16 @@ extern "C" {
 }
 extern "C" {
     /// Write HOTP slot data to the device
-    /// @param slot_number HOTP slot number, slot_number<3
-    /// @param slot_name char[15](Pro) desired slot name
-    /// @param secret char[20](Pro) 160-bit secret
+    /// @param slot_number HOTP slot number, slot_number<3, 0-numbered
+    /// @param slot_name char[15] desired slot name. C string (requires ending '\0'; 16 bytes).
+    /// @param secret char[40] 160-bit or 320-bit (currently Pro v0.8 only) secret as a hex string. C string (requires ending '\0'; 41 bytes).
+    /// See NitrokeyManager::is_320_OTP_secret_supported.
     /// @param hotp_counter uint32_t starting value of HOTP counter
     /// @param use_8_digits should returned codes be 6 (false) or 8 digits (true)
     /// @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock
     /// @param use_tokenID @see token_ID
     /// @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section
-    /// @param temporary_password char[25](Pro) admin temporary password
+    /// @param temporary_password char[25] admin temporary password
     /// @return command processing error code
     pub fn NK_write_hotp_slot(
         slot_number: u8,
@@ -189,15 +671,16 @@ extern "C" {
 }
 extern "C" {
     /// Write TOTP slot data to the device
-    /// @param slot_number TOTP slot number, slot_number<15
-    /// @param slot_name char[15](Pro) desired slot name
-    /// @param secret char[20](Pro) 160-bit secret
+    /// @param slot_number TOTP slot number, slot_number<15, 0-numbered
+    /// @param slot_name char[15] desired slot name. C string (requires ending '\0'; 16 bytes).
+    /// @param secret char[40] 160-bit or 320-bit (currently Pro v0.8 only) secret as a hex string. C string (requires ending '\0'; 41 bytes).
+    /// See NitrokeyManager::is_320_OTP_secret_supported.
     /// @param time_window uint16_t time window for this TOTP
     /// @param use_8_digits should returned codes be 6 (false) or 8 digits (true)
     /// @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock
     /// @param use_tokenID @see token_ID
     /// @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section
-    /// @param temporary_password char[20](Pro) admin temporary password
+    /// @param temporary_password char[20] admin temporary password
     /// @return command processing error code
     pub fn NK_write_totp_slot(
         slot_number: u8,
@@ -215,40 +698,40 @@ extern "C" {
     /// Get HOTP code from the device
     /// @param slot_number HOTP slot number, slot_number<3
     /// @return HOTP code
-    pub fn NK_get_hotp_code(slot_number: u8) -> *const ::std::os::raw::c_char;
+    pub fn NK_get_hotp_code(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get HOTP code from the device (PIN protected)
     /// @param slot_number HOTP slot number, slot_number<3
-    /// @param user_temporary_password char[25](Pro) user temporary password if PIN protected OTP codes are enabled,
+    /// @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,
     /// otherwise should be set to empty string - ''
     /// @return HOTP code
     pub fn NK_get_hotp_code_PIN(
         slot_number: u8,
         user_temporary_password: *const ::std::os::raw::c_char,
-    ) -> *const ::std::os::raw::c_char;
+    ) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get TOTP code from the device
     /// @param slot_number TOTP slot number, slot_number<15
-    /// @param challenge TOTP challenge
-    /// @param last_totp_time last time
-    /// @param last_interval last interval
+    /// @param challenge TOTP challenge -- unused
+    /// @param last_totp_time last time -- unused
+    /// @param last_interval last interval --unused
     /// @return TOTP code
     pub fn NK_get_totp_code(
         slot_number: u8,
         challenge: u64,
         last_totp_time: u64,
         last_interval: u8,
-    ) -> *const ::std::os::raw::c_char;
+    ) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get TOTP code from the device (PIN protected)
     /// @param slot_number TOTP slot number, slot_number<15
-    /// @param challenge TOTP challenge
-    /// @param last_totp_time last time
-    /// @param last_interval last interval
-    /// @param user_temporary_password char[25](Pro) user temporary password if PIN protected OTP codes are enabled,
+    /// @param challenge TOTP challenge -- unused
+    /// @param last_totp_time last time -- unused
+    /// @param last_interval last interval -- unused
+    /// @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,
     /// otherwise should be set to empty string - ''
     /// @return TOTP code
     pub fn NK_get_totp_code_PIN(
@@ -257,7 +740,7 @@ extern "C" {
         last_totp_time: u64,
         last_interval: u8,
         user_temporary_password: *const ::std::os::raw::c_char,
-    ) -> *const ::std::os::raw::c_char;
+    ) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Set time on the device (for TOTP requests)
@@ -266,12 +749,23 @@ extern "C" {
     pub fn NK_totp_set_time(time: u64) -> ::std::os::raw::c_int;
 }
 extern "C" {
+    /// Set the device time used for TOTP to the given time.  Contrary to
+    /// {@code set_time(uint64_t)}, this command fails if {@code old_time}
+    /// &gt; {@code time} or if {@code old_time} is zero (where {@code
+    /// old_time} is the current time on the device).
+    ///
+    /// @param time new device time as Unix timestamp (seconds since
+    /// 1970-01-01)
+    /// @return command processing error code
+    pub fn NK_totp_set_time_soft(time: u64) -> ::std::os::raw::c_int;
+}
+extern "C" {
     pub fn NK_totp_get_time() -> ::std::os::raw::c_int;
 }
 extern "C" {
     /// Change administrator PIN
-    /// @param current_PIN char[25](Pro) current PIN
-    /// @param new_PIN char[25](Pro) new PIN
+    /// @param current_PIN char[25] current PIN
+    /// @param new_PIN char[25] new PIN
     /// @return command processing error code
     pub fn NK_change_admin_PIN(
         current_PIN: *const ::std::os::raw::c_char,
@@ -280,8 +774,8 @@ extern "C" {
 }
 extern "C" {
     /// Change user PIN
-    /// @param current_PIN char[25](Pro) current PIN
-    /// @param new_PIN char[25](Pro) new PIN
+    /// @param current_PIN char[25] current PIN
+    /// @param new_PIN char[25] new PIN
     /// @return command processing error code
     pub fn NK_change_user_PIN(
         current_PIN: *const ::std::os::raw::c_char,
@@ -300,7 +794,7 @@ extern "C" {
 }
 extern "C" {
     /// Enable password safe access
-    /// @param user_pin char[30](Pro) current user PIN
+    /// @param user_pin char[30] current user PIN
     /// @return command processing error code
     pub fn NK_enable_password_safe(
         user_pin: *const ::std::os::raw::c_char,
@@ -315,26 +809,26 @@ extern "C" {
     /// Get password safe slot name
     /// @param slot_number password safe slot number, slot_number<16
     /// @return slot name
-    pub fn NK_get_password_safe_slot_name(slot_number: u8) -> *const ::std::os::raw::c_char;
+    pub fn NK_get_password_safe_slot_name(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get password safe slot login
     /// @param slot_number password safe slot number, slot_number<16
     /// @return login from the PWS slot
-    pub fn NK_get_password_safe_slot_login(slot_number: u8) -> *const ::std::os::raw::c_char;
+    pub fn NK_get_password_safe_slot_login(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get the password safe slot password
     /// @param slot_number password safe slot number, slot_number<16
     /// @return password from the PWS slot
-    pub fn NK_get_password_safe_slot_password(slot_number: u8) -> *const ::std::os::raw::c_char;
+    pub fn NK_get_password_safe_slot_password(slot_number: u8) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Write password safe data to the slot
     /// @param slot_number password safe slot number, slot_number<16
-    /// @param slot_name char[11](Pro) name of the slot
-    /// @param slot_login char[32](Pro) login string
-    /// @param slot_password char[20](Pro) password string
+    /// @param slot_name char[11] name of the slot
+    /// @param slot_login char[32] login string
+    /// @param slot_password char[20] password string
     /// @return command processing error code
     pub fn NK_write_password_safe_slot(
         slot_number: u8,
@@ -561,14 +1055,24 @@ extern "C" {
     /// Get Storage stick status as string.
     /// Storage only
     /// @return string with devices attributes
-    pub fn NK_get_status_storage_as_string() -> *const ::std::os::raw::c_char;
+    pub fn NK_get_status_storage_as_string() -> *mut ::std::os::raw::c_char;
+}
+extern "C" {
+    /// Get the Storage stick status and return the command processing
+    /// error code.  If the code is zero, i. e. the command was successful,
+    /// the storage status is written to the output pointer's target.
+    /// The output pointer must not be null.
+    ///
+    /// @param out the output pointer for the storage status
+    /// @return command processing error code
+    pub fn NK_get_status_storage(out: *mut NK_storage_status) -> ::std::os::raw::c_int;
 }
 extern "C" {
     /// Get SD card usage attributes as string.
     /// Usable during hidden volumes creation.
     /// Storage only
     /// @return string with SD card usage attributes
-    pub fn NK_get_SD_usage_data_as_string() -> *const ::std::os::raw::c_char;
+    pub fn NK_get_SD_usage_data_as_string() -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Get progress value of current long operation.
@@ -590,7 +1094,7 @@ extern "C" {
     /// Storage only
     /// @example Example of returned data: '00005d19:dacc2cb4_p_0001:0010:02;000037c7:4cf12445_p_0001:000f:02;0001:000c:02'
     /// @return string delimited id's of connected devices
-    pub fn NK_list_devices_by_cpuID() -> *const ::std::os::raw::c_char;
+    pub fn NK_list_devices_by_cpuID() -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
     /// Connects to the device with given ID. ID's list could be created with NK_list_devices_by_cpuID.
@@ -601,3 +1105,8 @@ extern "C" {
     /// @return 1 on successful connection, 0 otherwise
     pub fn NK_connect_with_ID(id: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
 }
+extern "C" {
+    /// Blink red and green LED alternatively and infinitely (until device is reconnected).
+    /// @return command processing error code
+    pub fn NK_wink() -> ::std::os::raw::c_int;
+}