From bd5fd5d6cf42732c4a34c10d390d3596615e9a47 Mon Sep 17 00:00:00 2001
From: Szczepan Zalega <szczepan@nitrokey.com>
Date: Sat, 18 Feb 2017 17:03:16 +0100
Subject: Remove unnecessary extern keyword from C API

Signed-off-by: Szczepan Zalega <szczepan@nitrokey.com>
---
 NK_C_API.cc          | 121 +++++++++++++++++++++++++++++----------------------
 NK_C_API.h           | 120 ++++++++++++++++++++++++++++----------------------
 unittest/conftest.py |   4 +-
 3 files changed, 137 insertions(+), 108 deletions(-)

diff --git a/NK_C_API.cc b/NK_C_API.cc
index 0fde829..05102cc 100644
--- a/NK_C_API.cc
+++ b/NK_C_API.cc
@@ -76,15 +76,16 @@ uint8_t get_without_result(T func){
     return NK_last_command_status;
 }
 
+
 extern "C"
 {
-extern uint8_t NK_get_last_command_status(){
+NK_C_API uint8_t NK_get_last_command_status(){
     auto _copy = NK_last_command_status;
     NK_last_command_status = 0;
     return _copy;
 }
 
-extern int NK_login(const char *device_model) {
+NK_C_API int NK_login(const char *device_model) {
     auto m = NitrokeyManager::instance();
     try {
         NK_last_command_status = 0;
@@ -101,14 +102,14 @@ extern int NK_login(const char *device_model) {
     return 0;
 }
 
-extern int NK_logout() {
+NK_C_API int NK_logout() {
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         m->disconnect();
     });
 }
 
-extern int NK_first_authenticate(const char* admin_password, const char* admin_temporary_password){
+NK_C_API int NK_first_authenticate(const char* admin_password, const char* admin_temporary_password){
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         return m->first_authenticate(admin_password, admin_temporary_password);
@@ -116,34 +117,34 @@ extern int NK_first_authenticate(const char* admin_password, const char* admin_t
 }
 
 
-extern int NK_user_authenticate(const char* user_password, const char* user_temporary_password){
+NK_C_API int NK_user_authenticate(const char* user_password, const char* user_temporary_password){
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         m->user_authenticate(user_password, user_temporary_password);
     });
 }
 
-extern int NK_factory_reset(const char* admin_password){
+NK_C_API int NK_factory_reset(const char* admin_password){
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         m->factory_reset(admin_password);
     });
 }
-extern int NK_build_aes_key(const char* admin_password){
+NK_C_API int NK_build_aes_key(const char* admin_password){
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         m->build_aes_key(admin_password);
     });
 }
 
-extern int NK_unlock_user_password(const char *admin_password, const char *new_user_password) {
+NK_C_API int NK_unlock_user_password(const char *admin_password, const char *new_user_password) {
     auto m = NitrokeyManager::instance();
     return get_without_result( [&](){
         m->unlock_user_password(admin_password, new_user_password);
     });
 }
 
-extern int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock, bool enable_user_password,
+NK_C_API int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock, bool enable_user_password,
                            bool delete_user_password,
                            const char *admin_temporary_password) {
     auto m = NitrokeyManager::instance();
@@ -153,7 +154,7 @@ extern int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock
 }
 
 
-extern uint8_t* NK_read_config(){
+NK_C_API uint8_t* NK_read_config(){
     auto m = NitrokeyManager::instance();
     return get_with_array_result( [&](){
         auto v = m->read_config();
@@ -166,7 +167,7 @@ void clear_string(std::string &s){
     std::fill(s.begin(), s.end(), ' ');
 }
 
-extern const char * NK_status() {
+NK_C_API const char * NK_status() {
     auto m = NitrokeyManager::instance();
     return get_with_string_result([&](){
         string && s = m->get_status_as_string();
@@ -176,7 +177,7 @@ extern const char * NK_status() {
     });
 }
 
-extern const char * NK_device_serial_number(){
+NK_C_API const char * NK_device_serial_number(){
     auto m = NitrokeyManager::instance();
     return get_with_string_result([&](){
         string && s = m->get_serial_number();
@@ -186,23 +187,23 @@ extern const char * NK_device_serial_number(){
     });
 }
 
-extern uint32_t NK_get_hotp_code(uint8_t slot_number) {
+NK_C_API uint32_t NK_get_hotp_code(uint8_t slot_number) {
     return NK_get_hotp_code_PIN(slot_number, "");
 }
 
-extern uint32_t NK_get_hotp_code_PIN(uint8_t slot_number, const char* user_temporary_password){
+NK_C_API uint32_t NK_get_hotp_code_PIN(uint8_t slot_number, const char* user_temporary_password){
     auto m = NitrokeyManager::instance();
     return get_with_result([&](){
         return m->get_HOTP_code(slot_number, user_temporary_password);
     });
 }
 
-extern uint32_t NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
+NK_C_API uint32_t 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, "");
 }
 
-extern uint32_t NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time,
+NK_C_API uint32_t 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_result([&](){
@@ -210,21 +211,21 @@ extern uint32_t NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge, ui
     });
 }
 
-extern int NK_erase_hotp_slot(uint8_t slot_number, const char *temporary_password) {
+NK_C_API int NK_erase_hotp_slot(uint8_t slot_number, const char *temporary_password) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&]{
         m->erase_hotp_slot(slot_number, temporary_password);
     });
 }
 
-extern int NK_erase_totp_slot(uint8_t slot_number, const char *temporary_password) {
+NK_C_API int NK_erase_totp_slot(uint8_t slot_number, const char *temporary_password) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&]{
         m->erase_totp_slot(slot_number, temporary_password);
     });
 }
 
-extern int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint64_t hotp_counter,
+NK_C_API int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint64_t hotp_counter,
                               bool use_8_digits, bool use_enter, bool use_tokenID, const char *token_ID,
                               const char *temporary_password) {
     auto m = NitrokeyManager::instance();
@@ -234,7 +235,7 @@ extern int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const
     });
 }
 
-extern int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint16_t time_window,
+NK_C_API int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint16_t time_window,
                               bool use_8_digits, bool use_enter, bool use_tokenID, const char *token_ID,
                               const char *temporary_password) {
     auto m = NitrokeyManager::instance();
@@ -244,14 +245,14 @@ extern int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const
     });
 }
 
-extern const char* NK_get_totp_slot_name(uint8_t slot_number){
+NK_C_API const 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;
     });
 }
-extern const char* NK_get_hotp_slot_name(uint8_t slot_number){
+NK_C_API const 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);
@@ -259,46 +260,46 @@ extern const char* NK_get_hotp_slot_name(uint8_t slot_number){
     });
 }
 
-extern void NK_set_debug(bool state){
+NK_C_API void NK_set_debug(bool state){
     auto m = NitrokeyManager::instance();
     m->set_debug(state);
 }
 
-extern int NK_totp_set_time(uint64_t time){
+NK_C_API int NK_totp_set_time(uint64_t time){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->set_time(time);
     });
 }
 
-extern int NK_totp_get_time(){
+NK_C_API int NK_totp_get_time(){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
       m->get_time(0); // FIXME check how that should work
     });
 }
 
-extern int NK_change_admin_PIN(char *current_PIN, char *new_PIN){
+NK_C_API int NK_change_admin_PIN(char *current_PIN, char *new_PIN){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->change_admin_PIN(current_PIN, new_PIN);
     });
 }
 
-extern int NK_change_user_PIN(char *current_PIN, char *new_PIN){
+NK_C_API int NK_change_user_PIN(char *current_PIN, char *new_PIN){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->change_user_PIN(current_PIN, new_PIN);
     });
 }
 
-extern int NK_enable_password_safe(const char *user_pin){
+NK_C_API int NK_enable_password_safe(const char *user_pin){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->enable_password_safe(user_pin);
     });
 }
-extern uint8_t * NK_get_password_safe_slot_status(){
+NK_C_API uint8_t * NK_get_password_safe_slot_status(){
     auto m = NitrokeyManager::instance();
     return get_with_array_result( [&](){
         auto slot_status = m->get_password_safe_slot_status();
@@ -307,47 +308,47 @@ extern uint8_t * NK_get_password_safe_slot_status(){
 
 }
 
-extern uint8_t NK_get_user_retry_count(){
+NK_C_API uint8_t NK_get_user_retry_count(){
     auto m = NitrokeyManager::instance();
     return get_with_result([&](){
         return m->get_user_retry_count();
     });
 }
 
-extern uint8_t NK_get_admin_retry_count(){
+NK_C_API uint8_t NK_get_admin_retry_count(){
     auto m = NitrokeyManager::instance();
     return get_with_result([&](){
         return m->get_admin_retry_count();
     });
 }
 
-extern int NK_lock_device(){
+NK_C_API int NK_lock_device(){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->lock_device();
     });
 }
 
-extern const char *NK_get_password_safe_slot_name(uint8_t slot_number) {
+NK_C_API const 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);
     });
 }
 
-extern const char *NK_get_password_safe_slot_login(uint8_t slot_number) {
+NK_C_API const 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);
     });
 }
-extern const char *NK_get_password_safe_slot_password(uint8_t slot_number) {
+NK_C_API const 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);
     });
 }
-extern int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_name, const char *slot_login,
+NK_C_API int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_name, const char *slot_login,
                                        const char *slot_password) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
@@ -355,21 +356,21 @@ extern int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_nam
     });
 }
 
-extern int NK_erase_password_safe_slot(uint8_t slot_number) {
+NK_C_API int NK_erase_password_safe_slot(uint8_t slot_number) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->erase_password_safe_slot(slot_number);
     });
 }
 
-extern int NK_is_AES_supported(const char *user_password) {
+NK_C_API int NK_is_AES_supported(const char *user_password) {
     auto m = NitrokeyManager::instance();
     return get_with_result([&](){
        return (uint8_t) m->is_AES_supported(user_password);
     });
 }
 
-extern int NK_login_auto() {
+NK_C_API int NK_login_auto() {
     auto m = NitrokeyManager::instance();
     return get_with_result([&](){
         return (uint8_t) m->connect();
@@ -378,28 +379,42 @@ extern int NK_login_auto() {
 
 // storage commands
 
-extern int NK_send_startup(uint64_t seconds_from_epoch){
+NK_C_API int NK_send_startup(uint64_t seconds_from_epoch){
   auto m = NitrokeyManager::instance();
   return get_without_result([&](){
       m->send_startup(seconds_from_epoch);
   });
 }
 
-extern int NK_unlock_encrypted_volume(const char* user_pin){
+NK_C_API int NK_unlock_encrypted_volume(const char* user_pin){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->unlock_encrypted_volume(user_pin);
     });
 }
 
-extern int NK_unlock_hidden_volume(const char* hidden_volume_password){
+NK_C_API int NK_lock_encrypted_volume(){
+    auto m = NitrokeyManager::instance();
+    return get_without_result([&](){
+        m->lock_encrypted_volume();
+    });
+}
+
+NK_C_API int NK_unlock_hidden_volume(const char* hidden_volume_password){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->unlock_hidden_volume(hidden_volume_password);
     });
 }
 
-extern int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8_t end_percent,
+NK_C_API int NK_lock_hidden_volume(){
+    auto m = NitrokeyManager::instance();
+    return get_without_result([&](){
+        m->lock_hidden_volume();
+    });
+}
+
+NK_C_API int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8_t end_percent,
                                    const char *hidden_volume_password){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
@@ -408,42 +423,42 @@ extern int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8
     });
 }
 
-extern int NK_set_unencrypted_read_only(const char* user_pin){
+NK_C_API int NK_set_unencrypted_read_only(const char* user_pin){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->set_unencrypted_read_only(user_pin);
     });
 }
 
-extern int NK_set_unencrypted_read_write(const char* user_pin){
+NK_C_API int NK_set_unencrypted_read_write(const char* user_pin){
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->set_unencrypted_read_write(user_pin);
     });
 }
 
-extern int NK_export_firmware(const char* admin_pin) {
+NK_C_API int NK_export_firmware(const char* admin_pin) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->export_firmware(admin_pin) ;
     });
 }
 
-extern int NK_clear_new_sd_card_warning(const char* admin_pin) {
+NK_C_API int NK_clear_new_sd_card_warning(const char* admin_pin) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->clear_new_sd_card_warning(admin_pin);
     });
 }
 
-extern int NK_fill_SD_card_with_random_data(const char* admin_pin) {
+NK_C_API int NK_fill_SD_card_with_random_data(const char* admin_pin) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
         m->fill_SD_card_with_random_data(admin_pin);
     });
 }
 
-extern int NK_change_update_password(const char* current_update_password,
+NK_C_API int NK_change_update_password(const char* current_update_password,
                                      const char* new_update_password) {
     auto m = NitrokeyManager::instance();
     return get_without_result([&](){
@@ -451,28 +466,28 @@ extern int NK_change_update_password(const char* current_update_password,
     });
 }
 
-extern const char* NK_get_status_storage_as_string() {
+NK_C_API const char* NK_get_status_storage_as_string() {
   auto m = NitrokeyManager::instance();
   return get_with_string_result([&](){
       return m->get_status_storage_as_string();
   });
 }
 
-extern const char* NK_get_SD_usage_data_as_string() {
+NK_C_API const 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();
   });
 }
 
-extern int NK_get_progress_bar_value() {
+NK_C_API int NK_get_progress_bar_value() {
   auto m = NitrokeyManager::instance();
   return get_with_result([&](){
       return m->get_progress_bar_value();
   });
 }
 
-extern int NK_get_major_firmware_version(){
+NK_C_API int NK_get_major_firmware_version(){
   auto m = NitrokeyManager::instance();
   return get_with_result([&](){
       return m->get_minor_firmware_version();
diff --git a/NK_C_API.h b/NK_C_API.h
index 7f01900..dd31287 100644
--- a/NK_C_API.h
+++ b/NK_C_API.h
@@ -6,57 +6,59 @@
 #include "include/NitrokeyManager.h"
 #include "include/inttypes.h"
 
+#define NK_C_API
+
 extern "C"
 {
 /**
  * Set debug level of messages written on stderr
  * @param state state=True - all messages, state=False - only errors level
  */
-extern void NK_set_debug(bool state);
+NK_C_API void NK_set_debug(bool state);
 
 /**
  * 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
  */
-extern int NK_login(const char *device_model);
+NK_C_API int NK_login(const char *device_model);
 
 /**
  * Connect to first available device, starting checking from Pro 1st to Storage 2nd.
  * @return 1 if connected, 0 if wrong model or cannot connect
  */
-extern int NK_login_auto();
+NK_C_API int NK_login_auto();
 
 /**
  * Disconnect from the device.
  * @return command processing error code
  */
-extern int NK_logout();
+NK_C_API int NK_logout();
 
 /**
  * Return the debug status string. Debug purposes.
  * @return command processing error code
  */
-extern const char * NK_status();
+NK_C_API const char * NK_status();
 
 /**
  * Return the device's serial number string in hex.
  * @return string device's serial number in hex
  */
-extern const char * NK_device_serial_number();
+NK_C_API const char * NK_device_serial_number();
 
 /**
  * Get last command processing status. Useful for commands which returns the results of their own and could not return
  * an error code.
  * @return previous command processing error code
  */
-extern uint8_t NK_get_last_command_status();
+NK_C_API uint8_t NK_get_last_command_status();
 
 /**
  * Lock device - cancel any user device unlocking.
  * @return command processing error code
  */
-extern int NK_lock_device();
+NK_C_API int NK_lock_device();
 
 /**
  * Authenticates the user on USER privilages with user_password and sets user's temporary password on device to user_temporary_password.
@@ -64,7 +66,7 @@ extern int NK_lock_device();
  * @param user_temporary_password char[25](Pro) user temporary password to be set on device for further communication (authentication command)
  * @return command processing error code
  */
-extern int NK_user_authenticate(const char* user_password, const char* user_temporary_password);
+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.
@@ -72,28 +74,28 @@ extern int NK_user_authenticate(const char* user_password, const char* user_temp
  * @param admin_temporary_password char[25](Pro) admin temporary password to be set on device for further communication (authentication command)
  * @return command processing error code
  */
-extern int NK_first_authenticate(const char* admin_password, const char* admin_temporary_password);
+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
  * @return command processing error code
  */
-extern int NK_factory_reset(const char* admin_password);
+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
  * @return command processing error code
  */
-extern int NK_build_aes_key(const char* admin_password);
+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
  * @return command processing error code
  */
-extern int NK_unlock_user_password(const char *admin_password, const char *new_user_password);
+NK_C_API int NK_unlock_user_password(const char *admin_password, const char *new_user_password);
 
 /**
  * Write general config to the device
@@ -106,7 +108,7 @@ extern int NK_unlock_user_password(const char *admin_password, const char *new_u
  * @param admin_temporary_password current admin temporary password
  * @return command processing error code
  */
-extern int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock,
+NK_C_API int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock,
                            bool enable_user_password, bool delete_user_password, const char *admin_temporary_password);
 
 /**
@@ -120,7 +122,7 @@ extern int NK_write_config(uint8_t numlock, uint8_t capslock, uint8_t scrolllock
               uint8_t delete_user_password;
 
  */
-extern uint8_t* NK_read_config();
+NK_C_API uint8_t* NK_read_config();
 
 //OTP
 
@@ -129,14 +131,14 @@ extern uint8_t* NK_read_config();
  * @param slot_number TOTP slot number, slot_number<15
  * @return char[20](Pro) the name of the slot
  */
-extern const char * NK_get_totp_slot_name(uint8_t slot_number);
+NK_C_API const 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
  */
-extern const char * NK_get_hotp_slot_name(uint8_t slot_number);
+NK_C_API const char * NK_get_hotp_slot_name(uint8_t slot_number);
 
 /**
  * Erase HOTP slot data from the device
@@ -144,7 +146,7 @@ extern const char * NK_get_hotp_slot_name(uint8_t slot_number);
  * @param temporary_password admin temporary password
  * @return command processing error code
  */
-extern int NK_erase_hotp_slot(uint8_t slot_number, const char *temporary_password);
+NK_C_API int NK_erase_hotp_slot(uint8_t slot_number, const char *temporary_password);
 
 /**
  * Erase TOTP slot data from the device
@@ -152,7 +154,7 @@ extern int NK_erase_hotp_slot(uint8_t slot_number, const char *temporary_passwor
  * @param temporary_password admin temporary password
  * @return command processing error code
  */
-extern int NK_erase_totp_slot(uint8_t slot_number, const char *temporary_password);
+NK_C_API int NK_erase_totp_slot(uint8_t slot_number, const char *temporary_password);
 
 /**
  * Write HOTP slot data to the device
@@ -167,7 +169,7 @@ extern int NK_erase_totp_slot(uint8_t slot_number, const char *temporary_passwor
  * @param temporary_password char[25](Pro) admin temporary password
  * @return command processing error code
  */
-extern int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint64_t hotp_counter,
+NK_C_API int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint64_t hotp_counter,
                               bool use_8_digits, bool use_enter, bool use_tokenID, const char *token_ID,
                               const char *temporary_password);
 
@@ -184,7 +186,7 @@ extern int NK_write_hotp_slot(uint8_t slot_number, const char *slot_name, const
  * @param temporary_password char[20](Pro) admin temporary password
  * @return command processing error code
  */
-extern int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint16_t time_window,
+NK_C_API int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const char *secret, uint16_t time_window,
                               bool use_8_digits, bool use_enter, bool use_tokenID, const char *token_ID,
                               const char *temporary_password);
 
@@ -193,7 +195,7 @@ extern int NK_write_totp_slot(uint8_t slot_number, const char *slot_name, const
  * @param slot_number HOTP slot number, slot_number<3
  * @return HOTP code
  */
-extern uint32_t NK_get_hotp_code(uint8_t slot_number);
+NK_C_API uint32_t NK_get_hotp_code(uint8_t slot_number);
 
 /**
  * Get HOTP code from the device (PIN protected)
@@ -202,7 +204,7 @@ extern uint32_t NK_get_hotp_code(uint8_t slot_number);
  * otherwise should be set to empty string - ''
  * @return HOTP code
  */
-extern uint32_t NK_get_hotp_code_PIN(uint8_t slot_number, const char* user_temporary_password);
+NK_C_API uint32_t NK_get_hotp_code_PIN(uint8_t slot_number, const char* user_temporary_password);
 
 /**
  * Get TOTP code from the device
@@ -212,7 +214,7 @@ extern uint32_t NK_get_hotp_code_PIN(uint8_t slot_number, const char* user_tempo
  * @param last_interval last interval
  * @return TOTP code
  */
-extern uint32_t NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64_t last_totp_time, uint8_t last_interval);
+NK_C_API uint32_t 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)
@@ -224,7 +226,7 @@ extern uint32_t NK_get_totp_code(uint8_t slot_number, uint64_t challenge, uint64
  * otherwise should be set to empty string - ''
  * @return TOTP code
  */
-extern uint32_t NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge,
+NK_C_API uint32_t 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);
 
 /**
@@ -232,9 +234,9 @@ extern uint32_t NK_get_totp_code_PIN(uint8_t slot_number, uint64_t challenge,
  * @param time seconds in unix epoch (from 01.01.1970)
  * @return command processing error code
  */
-extern int NK_totp_set_time(uint64_t time);
+NK_C_API int NK_totp_set_time(uint64_t time);
 
-extern int NK_totp_get_time();
+NK_C_API int NK_totp_get_time();
 //passwords
 /**
  * Change administrator PIN
@@ -242,7 +244,7 @@ extern int NK_totp_get_time();
  * @param new_PIN char[25](Pro) new PIN
  * @return command processing error code
  */
-extern int NK_change_admin_PIN(char *current_PIN, char *new_PIN);
+NK_C_API int NK_change_admin_PIN(char *current_PIN, char *new_PIN);
 
 /**
  * Change user PIN
@@ -250,20 +252,20 @@ extern int NK_change_admin_PIN(char *current_PIN, char *new_PIN);
  * @param new_PIN char[25](Pro) new PIN
  * @return command processing error code
 */
-extern int NK_change_user_PIN(char *current_PIN, char *new_PIN);
+NK_C_API int NK_change_user_PIN(char *current_PIN, char *new_PIN);
 
 
 /**
  * Get retry count of user PIN
  * @return user PIN retry count
  */
-extern uint8_t NK_get_user_retry_count();
+NK_C_API uint8_t NK_get_user_retry_count();
 
 /**
  * Get retry count of admin PIN
  * @return admin PIN retry count
  */
-extern uint8_t NK_get_admin_retry_count();
+NK_C_API uint8_t NK_get_admin_retry_count();
 //password safe
 
 /**
@@ -271,34 +273,34 @@ extern uint8_t NK_get_admin_retry_count();
  * @param user_pin char[30](Pro) current user PIN
  * @return command processing error code
  */
-extern int NK_enable_password_safe(const char *user_pin);
+NK_C_API int NK_enable_password_safe(const char *user_pin);
 
 /**
  * Get password safe slots' status
  * @return uint8_t[16] slot statuses - each byte represents one slot with 0 (not programmed) and 1 (programmed)
  */
-extern uint8_t * NK_get_password_safe_slot_status();
+NK_C_API uint8_t * NK_get_password_safe_slot_status();
 
 /**
  * Get password safe slot name
  * @param slot_number password safe slot number, slot_number<16
  * @return slot name
  */
-extern const char *NK_get_password_safe_slot_name(uint8_t slot_number);
+NK_C_API const 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
  */
-extern const char *NK_get_password_safe_slot_login(uint8_t slot_number);
+NK_C_API const 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
  */
-extern const char *NK_get_password_safe_slot_password(uint8_t slot_number);
+NK_C_API const char *NK_get_password_safe_slot_password(uint8_t slot_number);
 
 /**
  * Write password safe data to the slot
@@ -308,7 +310,7 @@ extern const char *NK_get_password_safe_slot_password(uint8_t slot_number);
  * @param slot_password char[20](Pro) password string
  * @return command processing error code
  */
-extern int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_name,
+NK_C_API int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_name,
                                        const char *slot_login, const char *slot_password);
 
 /**
@@ -316,19 +318,19 @@ extern int NK_write_password_safe_slot(uint8_t slot_number, const char *slot_nam
  * @param slot_number password safe slot number, slot_number<16
  * @return command processing error code
  */
-extern int NK_erase_password_safe_slot(uint8_t slot_number);
+NK_C_API int NK_erase_password_safe_slot(uint8_t slot_number);
 
 /**
  * Check whether AES is supported by the device
  * @return 0 for no and 1 for yes
  */
-extern int NK_is_AES_supported(const char *user_password);
+NK_C_API int NK_is_AES_supported(const char *user_password);
 
 /**
  * Get device's major firmware version
  * @return 7,8 for Pro and major for Storage
  */
-extern int NK_get_major_firmware_version();
+NK_C_API int NK_get_major_firmware_version();
 
 
 
@@ -340,7 +342,7 @@ extern int NK_get_major_firmware_version();
  * Storage only
  * @param seconds_from_epoch date and time expressed in seconds
  */
-extern int NK_send_startup(uint64_t seconds_from_epoch);
+NK_C_API int NK_send_startup(uint64_t seconds_from_epoch);
 
 /**
  * Unlock encrypted volume.
@@ -348,7 +350,13 @@ extern int NK_send_startup(uint64_t seconds_from_epoch);
  * @param user_pin user pin 20 characters
  * @return command processing error code
  */
-extern int NK_unlock_encrypted_volume(const char* user_pin);
+NK_C_API int NK_unlock_encrypted_volume(const char* user_pin);
+
+/**
+ * Locks encrypted volume
+ * @return command processing error code
+ */
+NK_C_API int NK_lock_encrypted_volume();
 
 /**
  * Unlock hidden volume and lock encrypted volume.
@@ -357,7 +365,13 @@ extern int NK_unlock_encrypted_volume(const char* user_pin);
  * @param hidden_volume_password 20 characters
  * @return command processing error code
  */
-extern int NK_unlock_hidden_volume(const char* hidden_volume_password);
+NK_C_API int NK_unlock_hidden_volume(const char* hidden_volume_password);
+
+/**
+ * Locks hidden volume
+ * @return command processing error code
+ */
+NK_C_API int NK_lock_hidden_volume();
 
 /**
  * Create hidden volume.
@@ -369,7 +383,7 @@ extern int NK_unlock_hidden_volume(const char* hidden_volume_password);
  * @param hidden_volume_password 20 characters
  * @return command processing error code
  */
-extern int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8_t end_percent,
+NK_C_API int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8_t end_percent,
                                    const char *hidden_volume_password);
 
 /**
@@ -380,7 +394,7 @@ extern int NK_create_hidden_volume(uint8_t slot_nr, uint8_t start_percent, uint8
  * @param user_pin 20 characters
  * @return command processing error code
  */
-extern int NK_set_unencrypted_read_only(const char* user_pin);
+NK_C_API int NK_set_unencrypted_read_only(const char* user_pin);
 
 /**
  * Make unencrypted volume read-write.
@@ -390,7 +404,7 @@ extern int NK_set_unencrypted_read_only(const char* user_pin);
  * @param user_pin 20 characters
  * @return command processing error code
  */
-extern int NK_set_unencrypted_read_write(const char* user_pin);
+NK_C_API int NK_set_unencrypted_read_write(const char* user_pin);
 
 /**
  * Exports device's firmware to unencrypted volume.
@@ -398,7 +412,7 @@ extern int NK_set_unencrypted_read_write(const char* user_pin);
  * @param admin_pin 20 characters
  * @return command processing error code
  */
-extern int NK_export_firmware(const char* admin_pin) ;
+NK_C_API int NK_export_firmware(const char* admin_pin) ;
 
 /**
  * Clear new SD card notification. It is set after factory reset.
@@ -406,7 +420,7 @@ extern int NK_export_firmware(const char* admin_pin) ;
  * @param admin_pin 20 characters
  * @return command processing error code
  */
-extern int NK_clear_new_sd_card_warning(const char* admin_pin) ;
+NK_C_API int NK_clear_new_sd_card_warning(const char* admin_pin) ;
 
 /**
  * Fill SD card with random data.
@@ -415,7 +429,7 @@ extern int NK_clear_new_sd_card_warning(const char* admin_pin) ;
  * @param admin_pin 20 characters
  * @return command processing error code
  */
-extern int NK_fill_SD_card_with_random_data(const char* admin_pin) ;
+NK_C_API int NK_fill_SD_card_with_random_data(const char* admin_pin) ;
 
 /**
  * Change update password.
@@ -426,7 +440,7 @@ extern int NK_fill_SD_card_with_random_data(const char* admin_pin) ;
  * @param new_update_password 20 characters
  * @return command processing error code
  */
-extern int NK_change_update_password(const char* current_update_password,
+NK_C_API int NK_change_update_password(const char* current_update_password,
                                  const char* new_update_password);
 
 /**
@@ -434,7 +448,7 @@ extern int NK_change_update_password(const char* current_update_password,
  * Storage only
  * @return string with devices attributes
  */
-extern const char* NK_get_status_storage_as_string();
+NK_C_API const char* NK_get_status_storage_as_string();
 
 /**
  * Get SD card usage attributes as string.
@@ -442,14 +456,14 @@ extern const char* NK_get_status_storage_as_string();
  * Storage only
  * @return string with SD card usage attributes
  */
-extern const char* NK_get_SD_usage_data_as_string();
+NK_C_API const char* NK_get_SD_usage_data_as_string();
 
 /**
  * Get progress value of current long operation.
  * Storage only
  * @return int in range 0-100 or -1 if device is not busy
  */
-extern int NK_get_progress_bar_value();
+NK_C_API int NK_get_progress_bar_value();
 
 }
 
diff --git a/unittest/conftest.py b/unittest/conftest.py
index 88bf7d0..f43f153 100644
--- a/unittest/conftest.py
+++ b/unittest/conftest.py
@@ -22,8 +22,8 @@ def C(request):
 
     a = iter(declarations)
     for declaration in a:
-        if declaration.startswith('extern') and not '"C"' in declaration:
-            declaration = declaration.replace('extern', '').strip()
+        if declaration.startswith('NK_C_API'):
+            declaration = declaration.replace('NK_C_API', '').strip()
             while not ';' in declaration:
                 declaration += (next(a)).strip()
             print(declaration)
-- 
cgit v1.2.1