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 ++++++++++++++++++++++++++++++++++--------------------------
 1 file changed, 68 insertions(+), 53 deletions(-)

(limited to 'NK_C_API.cc')

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();
-- 
cgit v1.2.1