~ireas/nitrokey-sys-rs

86060cb94dea683aa767fe98171577f7a083c4df — Robin Krahl 2 months ago 8695e2c + 72f6d7e master
Merge branch 'release-v3.6.0'
43 files changed, 1065 insertions(+), 1094 deletions(-)

A .builds/archlinux.yml
M .gitignore
M CHANGELOG.md
M Cargo.toml
A Makefile
M README.md
M build.rs
R libnitrokey-v3.5/{DeviceCommunicationExceptions.cpp => DeviceCommunicationExceptions.cpp}
R libnitrokey-v3.5/{LICENSE => LICENSE}
R libnitrokey-v3.5/{NK_C_API.cc => NK_C_API.cc}
R libnitrokey-v3.5/{NK_C_API.h => NK_C_API.h}
R libnitrokey-v3.5/{NitrokeyManager.cc => NitrokeyManager.cc}
R libnitrokey-v3.5/{README.md => README.md}
R libnitrokey-v3.5/{command_id.cc => command_id.cc}
R libnitrokey-v3.5/{device.cc => device.cc}
R libnitrokey-v3.5/libnitrokey/{CommandFailedException.h => CommandFailedException.h}
R libnitrokey-v3.5/libnitrokey/{DeviceCommunicationExceptions.h => DeviceCommunicationExceptions.h}
R libnitrokey-v3.5/libnitrokey/{LibraryException.h => LibraryException.h}
R libnitrokey-v3.5/libnitrokey/{LongOperationInProgressException.h => LongOperationInProgressException.h}
R libnitrokey-v3.5/libnitrokey/{NitrokeyManager.h => NitrokeyManager.h}
R libnitrokey-v3.5/libnitrokey/{command.h => command.h}
R libnitrokey-v3.5/libnitrokey/{command_id.h => command_id.h}
R libnitrokey-v3.5/libnitrokey/{cxx_semantics.h => cxx_semantics.h}
R libnitrokey-v3.5/libnitrokey/{deprecated.h => deprecated.h}
R libnitrokey-v3.5/libnitrokey/{device.h => device.h}
R libnitrokey-v3.5/libnitrokey/{device_proto.h => device_proto.h}
R libnitrokey-v3.5/libnitrokey/{dissect.h => dissect.h}
R libnitrokey-v3.5/libnitrokey/hidapi/{hidapi.h => hidapi.h}
R libnitrokey-v3.5/libnitrokey/{log.h => log.h}
R libnitrokey-v3.5/libnitrokey/{misc.h => misc.h}
R libnitrokey-v3.5/libnitrokey/{stick10_commands.h => stick10_commands.h}
R libnitrokey-v3.5/libnitrokey/{stick10_commands_0.8.h => stick10_commands_0.8.h}
R libnitrokey-v3.5/libnitrokey/{stick20_commands.h => stick20_commands.h}
R libnitrokey-v3.5/libnitrokey/{version.h => version.h}
R libnitrokey-v3.5/{log.cc => log.cc}
R libnitrokey-v3.5/{misc.cc => misc.cc}
R libnitrokey-v3.5/{version.cc => version.cc}
R libnitrokey-v3.5/{version.cc.in => version.cc.in}
A patches/deprecated.diff
A patches/remove-uint.diff
A patches/series
M src/ffi.rs
M src/lib.rs
A .builds/archlinux.yml => .builds/archlinux.yml +36 -0
@@ 0,0 1,36 @@
# Copyright (C) 2020 Robin Krahl <robin.krahl@ireas.org>
# SPDX-License-Identifier: CC0-1.0
image: archlinux
packages:
  - clang
  - gcc
  - gnupg
  - hidapi
  - rust
sources:
  - https://git.sr.ht/~ireas/nitrokey-sys-rs
tasks:
  - version: |
      rustc -V
  - verify: |
      cd nitrokey-sys-rs
      curl -s "https://pgp.ireas.org/0x6D533958F070C57C.txt" | gpg --import
      git verify-commit HEAD || [ `git config user.email` == "builds@sr.ht" ]
  - build: |
      cd nitrokey-sys-rs
      cargo build --release
      cargo build --release --features bindgen
  - test: |
      cd nitrokey-sys-rs
      cargo test
      cargo test --features bindgen
  - clippy: |
      cd nitrokey-sys-rs
      cargo clippy -- -D warnings
  - format: |
      cd nitrokey-sys-rs
      cargo fmt -- --check
triggers:
  - action: email
    condition: failure
    to: robin.krahl@ireas.org

M .gitignore => .gitignore +2 -0
@@ 2,3 2,5 @@
/target
**/*.rs.bk
Cargo.lock
.pc
patches/*~

M CHANGELOG.md => CHANGELOG.md +22 -0
@@ 1,3 1,25 @@
# v3.6.0 (2020-09-25)
- Derive `Debug` for all structs generated by `bindgen`.
- Implement `std::fmt::Display` instead of `std::string::ToString` for the
  `Version` enum in `build.rs`.
- Do not include layout tests in the generated bindings.
- Add `bindgen` feature that re-generates the bindings during the build,
  including layout tests.
- Update to libnitrokey 3.6, causing all following changes.
- New constants:
  - `NK_device_model_NK_LIBREM` (`NK_device_model` enum)
- New structures:
  - `NK_config`
- New functions:
  - `NK_device_serial_number_as_u32`
  - `NK_write_config_struct`
  - `NK_free_config`
  - `NK_read_config_struct`
  - `NK_free_password_safe_slot_status`
- Deprecated functions:
  - `NK_set_unencrypted_read_only`
  - `NK_set_unencrypted_read_write`

# v3.5.0 (2019-07-04)
- Mark deprecated functions using the `deprecated` attribute.
- Update to libnitrokey 3.5, causing all following changes.

M Cargo.toml => Cargo.toml +6 -2
@@ 1,10 1,10 @@
[package]
name = "nitrokey-sys"
version = "3.5.0"
version = "3.6.0"
authors = ["Robin Krahl <robin.krahl@ireas.org>"]
edition = "2018"
homepage = "https://code.ireas.org/nitrokey-rs/"
repository = "https://git.ireas.org/nitrokey-sys-rs/"
repository = "https://git.sr.ht/~ireas/nitrokey-sys-rs"
description = "Low-level bindings to libnitrokey for communication with Nitrokey devices"
categories = ["external-ffi-bindings"]
license = "LGPL-3.0"


@@ 13,4 13,8 @@ build = "build.rs"
readme = "README.md"

[build-dependencies]
bindgen = { version = "0.55.1", optional = true, default-features = false }
cc = "1.0"

[features]
default = []

A Makefile => Makefile +25 -0
@@ 0,0 1,25 @@
BINDGEN ?= bindgen
LIBNITROKEY ?= $(wildcard libnitrokey-v*)

src/ffi.rs: ${LIBNITROKEY}/NK_C_API.h
	quilt pop -af || true
	# always keep options in sync with build.rs
	${BINDGEN} \
		--whitelist-function "NK_.*" \
		--whitelist-var "NK_.*" \
		--whitelist-var "MAXIMUM_STR_REPLY_LENGTH" \
		--with-derive-default \
		--no-layout-tests \
		--output "$@" \
		"$<" \
		-- "-I${LIBNITROKEY}/libnitrokey"
	quilt push -a --refresh

.PHONY: verify-bindings
verify-bindings:
	@git diff --exit-code src/ffi.rs || \
		(echo "This test can only be executed on a clean working tree"; exit 1)
	@$(MAKE) --always-make src/ffi.rs > /dev/null
	@git diff --exit-code src/ffi.rs && \
		(echo "The generated bindings have been verified successfully!") || \
		(echo "Error: The generated bindings differ from the pre-generated bindings!"; exit 1)

M README.md => README.md +23 -2
@@ 15,21 15,42 @@ crate, it links directly against `libnitrokey` instead of building it from
source.  In this case, `libnitrokey` must be available in the library search
path.

Per default, this crate uses bindings that have been generated using Rust’s
`x86_64-unknown-linux-gnu` target.  To the best of our knowledge, these
bindings are platform-independent.  If you want to generate the bindings,
including layout tests, specifically for your platform during the build,
activate the `bindgen` feature.  In this case, you will also need `clang` and
`libclang` in the default search path.

Alternatively, you can execute `make verify-bindings` to compare the
pre-generated bindings with the bindings that `bindgen` generates for your
platform.  This check only works on a clean Git working tree and requires the
`bindgen` binary, `git` and `quilt`.

## Versioning

The major and minor version of the `nitrokey-sys` crate map to the major and
minor version of `libnitrokey`.  The `nitrokey-sys` patch version may be
increased independently.

## Contributing

Contributions to this project are welcome!  Please submit patches to the
mailing list [~ireas/nitrokey-rs-dev@lists.sr.ht][] ([archive][]) using the
`[PATCH nitrokey-sys-rs]` subject prefix.  For more information, see the
[Contributing Guide][].

## Contact

For bug reports, patches, feature requests or other messages, please send a
mail to [nitrokey-rs-dev@ireas.org][].
mail to the mailing list [~ireas/nitrokey-rs-dev@lists.sr.ht][] ([archive][]).

## License

This project as well as `libnitrokey` are licensed under the [LGPL-3.0][].

[`libnitrokey`]: https://github.com/nitrokey/libnitrokey
[nitrokey-rs-dev@ireas.org]: mailto:nitrokey-rs-dev@ireas.org
[~ireas/nitrokey-rs-dev@lists.sr.ht]: mailto:~ireas/nitrokey-rs-dev@lists.sr.ht
[archive]: https://lists.sr.ht/~ireas/nitrokey-rs-dev
[Contributing Guide]: https://man.sr.ht/~ireas/guides/contributing.md
[LGPL-3.0]: https://opensource.org/licenses/lgpl-3.0.html

M build.rs => build.rs +40 -7
@@ 1,9 1,9 @@
use std::env;
use std::fmt;
use std::fs;
use std::io;
use std::io::{Read, Write};
use std::path;
use std::string;

use cc;



@@ 14,18 14,19 @@ struct Version {
    patch: Option<u32>,
}

impl string::ToString for Version {
    fn to_string(&self) -> String {
        match self.patch {
            Some(patch) => format!("v{}.{}.{}", self.major, self.minor, patch),
            None => format!("v{}.{}", self.major, self.minor),
impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "v{}.{}", self.major, self.minor)?;
        if let Some(patch) = self.patch {
            write!(f, ".{}", patch)?;
        }
        Ok(())
    }
}

const LIBNITROKEY_VERSION: Version = Version {
    major: 3,
    minor: 5,
    minor: 6,
    patch: None,
};



@@ 53,6 54,35 @@ fn prepare_version_source(
    Ok(out)
}

#[cfg(feature = "bindgen")]
fn generate_bindings(library_path: &path::Path, out_path: &path::Path) {
    let header_path = library_path.join("NK_C_API.h");
    let header_str = header_path
        .to_str()
        .expect("Header path contains invalid UTF-8");

    let include_path = library_path.join("libnitrokey");
    let include_str = include_path
        .to_str()
        .expect("Include path contains invalid UTF-8");

    println!("cargo:rerun-if-changed={}", header_str);

    // always keep options in sync with Makefile
    let bindings = bindgen::Builder::default()
        .header(header_str)
        .whitelist_function("NK_.*")
        .whitelist_var("NK_.*")
        .whitelist_var("MAXIMUM_STR_REPLY_LENGTH")
        .derive_default(true)
        .clang_arg(&format!("-I{}", include_str))
        .generate()
        .expect("Unable to generate bindings");
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Could not write bindings");
}

fn main() {
    if env::var("USE_SYSTEM_LIBNITROKEY").is_ok() {
        println!("cargo:rustc-link-lib=nitrokey");


@@ 77,6 107,9 @@ fn main() {
    let version_source = prepare_version_source(LIBNITROKEY_VERSION, &out_path, &library_path)
        .expect("Could not prepare the version source file");

    #[cfg(feature = "bindgen")]
    generate_bindings(library_path, &out_path);

    cc::Build::new()
        .cpp(true)
        .flag("-std=c++14")

R libnitrokey-v3.5/DeviceCommunicationExceptions.cpp => libnitrokey-v3.6/DeviceCommunicationExceptions.cpp +0 -0

R libnitrokey-v3.5/LICENSE => libnitrokey-v3.6/LICENSE +0 -0

R libnitrokey-v3.5/NK_C_API.cc => libnitrokey-v3.6/NK_C_API.cc +50 -1
@@ 158,6 158,9 @@ extern "C" {
                    case NK_STORAGE:
                        model_string = "S";
                        break;
                    case NK_LIBREM:
                        model_string = "L";
                        break;
                    case NK_DISCONNECTED:
                    default:
                        /* no such enum value -- return error code */


@@ 217,6 220,12 @@ extern "C" {
		});
	}

	NK_C_API int NK_write_config_struct(struct NK_config config,
		const char *admin_temporary_password) {
                return NK_write_config(config.numlock, config.capslock, config.scrolllock, config.enable_user_password,
                    config.disable_user_password, admin_temporary_password);
        }


	NK_C_API uint8_t* NK_read_config() {
		auto m = NitrokeyManager::instance();


@@ 226,6 235,25 @@ extern "C" {
		});
	}

        NK_C_API void NK_free_config(uint8_t* config) {
                delete[] config;
        }

	NK_C_API int NK_read_config_struct(struct NK_config* out) {
		if (out == nullptr) {
			return -1;
		}
		auto m = NitrokeyManager::instance();
		return get_without_result([&]() {
			auto v = m->read_config();
                        out->numlock = v[0];
                        out->capslock = v[1];
                        out->scrolllock = v[2];
                        out->enable_user_password = v[3];
                        out->disable_user_password = v[4];
		});
	}


	NK_C_API enum NK_device_model NK_get_device_model() {
		auto m = NitrokeyManager::instance();


@@ 236,6 264,8 @@ extern "C" {
				    return NK_PRO;
				case DeviceModel::STORAGE:
				    return NK_STORAGE;
				case DeviceModel::LIBREM:
				    return NK_LIBREM;
				default:
				    /* unknown or not connected device */
				    return NK_device_model::NK_DISCONNECTED;


@@ 299,6 329,13 @@ extern "C" {
		});
	}

	NK_C_API uint32_t NK_device_serial_number_as_u32() {
		auto m = NitrokeyManager::instance();
		return get_with_result([&]() {
                        return m->get_serial_number_as_u32();
		});
	}

	NK_C_API char * NK_get_hotp_code(uint8_t slot_number) {
		return NK_get_hotp_code_PIN(slot_number, "");
	}


@@ 448,6 485,10 @@ extern "C" {

	}

        NK_C_API void NK_free_password_safe_slot_status(uint8_t* status) {
                delete[] status;
        }

	NK_C_API uint8_t NK_get_user_retry_count() {
		auto m = NitrokeyManager::instance();
		return get_with_result([&]() {


@@ 563,6 604,9 @@ extern "C" {
		});
	}

  // deprecated, noop on v0.51 and older (excl. v0.49)
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	NK_C_API int NK_set_unencrypted_read_only(const char *user_pin) {
		auto m = NitrokeyManager::instance();
		return get_without_result([&]() {


@@ 570,12 614,14 @@ extern "C" {
		});
	}

	NK_C_API int NK_set_unencrypted_read_write(const char *user_pin) {
	// deprecated, noop on v0.51 and older (excl. v0.49)
  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);
		});
	}
#pragma GCC diagnostic pop

	NK_C_API int NK_set_unencrypted_read_only_admin(const char *admin_pin) {
		auto m = NitrokeyManager::instance();


@@ 791,6 837,9 @@ NK_C_API char* NK_get_SD_usage_data_as_string() {
		case DeviceModel::STORAGE:
			target->model = NK_STORAGE;
			break;
		case DeviceModel::LIBREM:
			target->model = NK_LIBREM;
			break;
		default:
			return false;
		}

R libnitrokey-v3.5/NK_C_API.h => libnitrokey-v3.6/NK_C_API.h +80 -4
@@ 67,6 67,9 @@
 *         case NK_STORAGE:
 *                 printf("a Nitrokey Storage");
 *                 break;
 *         case NK_LIBREM:
 *                 printf("a Librem Key");
 *                 break;
 *         default:
 *                 printf("an unsupported Nitrokey");
 *                 break;


@@ 111,7 114,11 @@ extern "C" {
            /**
             * Nitrokey Storage.
             */
            NK_STORAGE = 2
            NK_STORAGE = 2,
            /**
             * Librem Key.
             */
            NK_LIBREM = 3
        };

        /**


@@ 265,6 272,32 @@ extern "C" {
		uint8_t write_level_max;
	};

        /**
         * The general configuration of a Nitrokey device.
         */
        struct NK_config {
            /**
             * value in range [0-1] to send HOTP code from slot 'numlock' after double pressing numlock
             * or outside the range to disable this function
             */
            uint8_t numlock;
            /**
	     * similar to numlock but with capslock
             */
            uint8_t capslock;
            /**
	     * similar to numlock but with scrolllock
             */
            uint8_t scrolllock;
            /**
             * True to enable OTP PIN protection (require PIN each OTP code request)
             */
            bool enable_user_password;
            /**
             * Unused.
             */
            bool disable_user_password;
        };

   struct NK_storage_ProductionTest{
    uint8_t FirmwareVersion_au8[2];


@@ 327,7 360,7 @@ extern "C" {

	/**
	 * Connect to device of given model. Currently library can be connected only to one device at once.
	 * @param device_model NK_device_model: NK_PRO: Nitrokey Pro, NK_STORAGE: Nitrokey Storage
	 * @param device_model NK_device_model: NK_PRO: Nitrokey Pro, NK_STORAGE: Nitrokey Storage, NK_LIBREM: Librem Key
	 * @return 1 if connected, 0 if wrong model or cannot connect
	 */
        NK_C_API int NK_login_enum(enum NK_device_model device_model);


@@ 386,6 419,14 @@ extern "C" {
	NK_C_API char * NK_device_serial_number();

	/**
	 * Return the device's serial number string as an integer.  Use
         * NK_last_command_status to check for an error if this function
         * returns zero.
	 * @return device's serial number as an integer
	 */
	NK_C_API uint32_t NK_device_serial_number_as_u32();

	/**
	 * 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


@@ 450,7 491,16 @@ extern "C" {
		bool enable_user_password, bool delete_user_password, const char *admin_temporary_password);

	/**
	 * Write general config to the device
	 * @param config the configuration data
	 * @param admin_temporary_password current admin temporary password
	 * @return command processing error code
	 */
	NK_C_API int NK_write_config_struct(struct NK_config config, const char *admin_temporary_password);

	/**
	 * Get currently set config - status of function Numlock/Capslock/Scrollock OTP sending and is enabled PIN protected OTP
         * The return value must be freed using NK_free_config.
	 * @see NK_write_config
	 * @return  uint8_t general_config[5]:
	 *            uint8_t numlock;


@@ 462,6 512,21 @@ extern "C" {
	 */
	NK_C_API uint8_t* NK_read_config();

        /**
         * Free a value returned by NK_read_config.  May be called with a NULL
         * argument.
         */
        NK_C_API void NK_free_config(uint8_t* config);

	/**
	 * Get currently set config and write it to the given pointer.
         * @see NK_read_config
	 * @see NK_write_config_struct
         * @param out a pointer to the struct that should be written to
	 * @return command processing error code
	 */
	NK_C_API int NK_read_config_struct(struct NK_config* out);

	//OTP

	/**


@@ 634,10 699,17 @@ extern "C" {

	/**
	 * Get password safe slots' status
         * The return value must be freed using NK_free_password_safe_slot_status.
	 * @return uint8_t[16] slot statuses - each byte represents one slot with 0 (not programmed) and 1 (programmed)
	 */
	NK_C_API uint8_t * NK_get_password_safe_slot_status();

        /**
         * Free a value returned by NK_get_password_safe_slot_status.  May be
         * called with a NULL argument.
         */
        NK_C_API void NK_free_password_safe_slot_status(uint8_t* status);

	/**
	 * Get password safe slot name
	 * @param slot_number password safe slot number, slot_number<16


@@ 765,7 837,9 @@ extern "C" {
	 * @param user_pin 20 characters User PIN
	 * @return command processing error code
	 */
	NK_C_API int NK_set_unencrypted_read_only(const char *user_pin);
  //[[deprecated("Use NK_set_unencrypted_read_only_admin instead")]]
  DEPRECATED
  NK_C_API int NK_set_unencrypted_read_only(const char *user_pin);

	/**
	 * Make unencrypted volume read-write.


@@ 777,7 851,9 @@ extern "C" {
	 * @param user_pin 20 characters User PIN
	 * @return command processing error code
	 */
	NK_C_API int NK_set_unencrypted_read_write(const char *user_pin);
  //[[deprecated("Use NK_set_unencrypted_read_write_admin instead")]]
  DEPRECATED
  NK_C_API int NK_set_unencrypted_read_write(const char *user_pin);

	/**
	 * Make unencrypted volume read-only.

R libnitrokey-v3.5/NitrokeyManager.cc => libnitrokey-v3.6/NitrokeyManager.cc +41 -7
@@ 217,7 217,12 @@ using nitrokey::misc::strcpyT;
            }
        }

        auto info_ptr = hid_enumerate(NITROKEY_VID, 0);
	auto vendor_id = NITROKEY_VID;
        auto info_ptr = hid_enumerate(vendor_id, 0);
	if (!info_ptr) {
	  vendor_id = PURISM_VID;
	  info_ptr = hid_enumerate(vendor_id, 0);
	}
        auto first_info_ptr = info_ptr;
        if (!info_ptr)
          return false;


@@ 225,7 230,7 @@ using nitrokey::misc::strcpyT;
        misc::Option<DeviceModel> model;
        while (info_ptr && !model.has_value()) {
            if (path == std::string(info_ptr->path)) {
                model = product_id_to_model(info_ptr->product_id);
                model = product_id_to_model(info_ptr->vendor_id, info_ptr->product_id);
            }
            info_ptr = info_ptr->next;
        }


@@ 254,7 259,8 @@ 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>() };
        vector< shared_ptr<Device> > devices = { make_shared<Stick10>(), make_shared<Stick20>(),
						 make_shared<LibremKey>() };
        bool connected = false;
        for( auto & d : devices ){
            if (d->connect()){


@@ 290,6 296,9 @@ using nitrokey::misc::strcpyT;
            case 'S':
                device = make_shared<Stick20>();
                break;
            case 'L':
                device = make_shared<LibremKey>();
                break;
            default:
                throw std::runtime_error("Unknown model");
        }


@@ 305,6 314,9 @@ using nitrokey::misc::strcpyT;
            case device::DeviceModel::STORAGE:
                model_string = "S";
                break;
            case device::DeviceModel::LIBREM:
                model_string = "L";
                break;
            default:
                throw std::runtime_error("Unknown model");
        }


@@ 380,22 392,36 @@ using nitrokey::misc::strcpyT;


    string NitrokeyManager::get_serial_number() {
        if (device == nullptr) { return ""; };
      try {
        auto serial_number = this->get_serial_number_as_u32();
        if (serial_number == 0) {
          return "NA";
        } else {
          return nitrokey::misc::toHex(serial_number);
        }
      } catch (DeviceNotConnected& e) {
        return "";
      }
    }

    uint32_t NitrokeyManager::get_serial_number_as_u32() {
        if (device == nullptr) { throw DeviceNotConnected("device not connected"); }
      switch (device->get_device_model()) {
        case DeviceModel::LIBREM:
        case DeviceModel::PRO: {
          auto response = GetStatus::CommandTransaction::run(device);
          return nitrokey::misc::toHex(response.data().card_serial_u32);
          return response.data().card_serial_u32;
        }
          break;

        case DeviceModel::STORAGE:
        {
          auto response = stick20::GetDeviceStatus::CommandTransaction::run(device);
          return nitrokey::misc::toHex(response.data().ActiveSmartCardID_u32);
          return response.data().ActiveSmartCardID_u32;
        }
          break;
      }
      return "NA";
      return 0;
    }

    stick10::GetStatus::ResponsePayload NitrokeyManager::get_status(){


@@ 552,6 578,7 @@ using nitrokey::misc::strcpyT;
      strcpyT(payload.slot_name, slot_name);
      strcpyT(payload.slot_token_id, token_ID);
      switch (device->get_device_model() ){
        case DeviceModel::LIBREM:
        case DeviceModel::PRO: {
          payload.slot_counter = hotp_counter;
          break;


@@ 713,6 740,7 @@ using nitrokey::misc::strcpyT;
    template <typename ProCommand, PasswordKind StoKind>
    void NitrokeyManager::change_PIN_general(const char *current_PIN, const char *new_PIN) {
        switch (device->get_device_model()){
            case DeviceModel::LIBREM:
            case DeviceModel::PRO:
            {
                auto p = get_payload<ProCommand>();


@@ 834,6 862,7 @@ using nitrokey::misc::strcpyT;

    void NitrokeyManager::build_aes_key(const char *admin_password) {
        switch (device->get_device_model()) {
            case DeviceModel::LIBREM:
            case DeviceModel::PRO: {
                auto p = get_payload<BuildAESKey>();
                strcpyT(p.admin_password, admin_password);


@@ 858,6 887,7 @@ using nitrokey::misc::strcpyT;

    void NitrokeyManager::unlock_user_password(const char *admin_password, const char *new_user_password) {
      switch (device->get_device_model()){
        case DeviceModel::LIBREM:
        case DeviceModel::PRO: {
          auto p = get_payload<stick10::UnlockUserPassword>();
          strcpyT(p.admin_password, admin_password);


@@ 907,6 937,7 @@ using nitrokey::misc::strcpyT;
      //authorization command is supported for versions equal or below:
        auto m = std::unordered_map<DeviceModel , int, EnumClassHash>({
                                               {DeviceModel::PRO, 7},
                                               {DeviceModel::LIBREM, 7},
                                               {DeviceModel::STORAGE, 53},
         });
        return get_minor_firmware_version() <= m[device->get_device_model()];


@@ 916,6 947,7 @@ using nitrokey::misc::strcpyT;
        // 320 bit OTP secret is supported by version bigger or equal to:
        auto m = std::unordered_map<DeviceModel , int, EnumClassHash>({
                                               {DeviceModel::PRO, 8},
                                               {DeviceModel::LIBREM, 8},
                                               {DeviceModel::STORAGE, 54},
         });
        return get_minor_firmware_version() >= m[device->get_device_model()];


@@ 940,6 972,7 @@ using nitrokey::misc::strcpyT;

    uint8_t NitrokeyManager::get_minor_firmware_version(){
      switch(device->get_device_model()){
        case DeviceModel::LIBREM:
        case DeviceModel::PRO:{
          auto status_p = GetStatus::CommandTransaction::run(device);
          return status_p.data().firmware_version_st.minor; //7 or 8


@@ 956,6 989,7 @@ using nitrokey::misc::strcpyT;
    }
    uint8_t NitrokeyManager::get_major_firmware_version(){
      switch(device->get_device_model()){
        case DeviceModel::LIBREM:
        case DeviceModel::PRO:{
          auto status_p = GetStatus::CommandTransaction::run(device);
          return status_p.data().firmware_version_st.major; //0

R libnitrokey-v3.5/README.md => libnitrokey-v3.6/README.md +83 -0
@@ 91,6 91,7 @@ To use libnitrokey with Python a [CFFI](http://cffi.readthedocs.io/en/latest/ove
pip install --user cffi # for python 2.x
pip3 install cffi # for python 3.x
```
## Python2
Just import it, read the C API header and it is done! You have access to the library. Here is an example (in Python 2) printing HOTP code for Pro or Storage device, assuming it is run in root directory [(full example)](python_bindings_example.py):
```python
#!/usr/bin/env python2


@@ 158,6 159,88 @@ print('Getting HOTP code from Nitrokey device: ')
print(hotp_slot_code)
libnitrokey.NK_logout()  # disconnect device
```
In case  no devices are connected, a friendly message will be printed.
All available functions for C and Python are listed in [NK_C_API.h](NK_C_API.h). Please check `Documentation` section below.

## Python3
Just import it, read the C API header and it is done! You have access to the library. Here is an example (in Python 3) printing HOTP code for Pro or Storage device, assuming it is run in root directory [(full example)](python3_bindings_example.py):
```python
#!/usr/bin/env python3
import cffi

ffi = cffi.FFI()
get_string = ffi.string

def get_library():
    fp = 'NK_C_API.h'  # path to C API header

    declarations = []
    with open(fp, 'r') as f:
        declarations = f.readlines()

    cnt = 0
    a = iter(declarations)
    for declaration in a:
        if declaration.strip().startswith('NK_C_API'):
            declaration = declaration.replace('NK_C_API', '').strip()
            while ';' not in declaration:
                declaration += (next(a)).strip()
            # print(declaration)
            ffi.cdef(declaration, override=True)
            cnt +=1
    print('Imported {} declarations'.format(cnt))


    C = None
    import os, sys
    path_build = os.path.join(".", "build")
    paths = [
            os.environ.get('LIBNK_PATH', None),
            os.path.join(path_build,"libnitrokey.so"),
            os.path.join(path_build,"libnitrokey.dylib"),
            os.path.join(path_build,"libnitrokey.dll"),
            os.path.join(path_build,"nitrokey.dll"),
    ]
    for p in paths:
        if not p: continue
        print("Trying " +p)
        p = os.path.abspath(p)
        if os.path.exists(p):
            print("Found: "+p)
            C = ffi.dlopen(p)
            break
        else:
            print("File does not exist: " + p)
    if not C:
        print("No library file found")
        sys.exit(1)

    return C


def get_hotp_code(lib, i):
    return lib.NK_get_hotp_code(i)

def connect_device(lib):
	# lib.NK_login('S'.encode('ascii'))  # connect only to Nitrokey Storage device
	# lib.NK_login('P'.encode('ascii'))  # connect only to Nitrokey Pro device
	device_connected = lib.NK_login_auto()  # connect to any Nitrokey Stick
	if device_connected:
		print('Connected to Nitrokey device!')
	else:
	    print('Could not connect to Nitrokey device!')
	    exit()

libnitrokey = get_library()
libnitrokey.NK_set_debug(False)  # do not show debug messages (log library only)

connect_device(libnitrokey)

hotp_slot_code = get_hotp_code(libnitrokey, 1)
print('Getting HOTP code from Nitrokey device: ')
print(ffi.string(hotp_slot_code).decode('ascii'))
libnitrokey.NK_logout()  # disconnect device
```

In case  no devices are connected, a friendly message will be printed.
All available functions for C and Python are listed in [NK_C_API.h](NK_C_API.h). Please check `Documentation` section below.

R libnitrokey-v3.5/command_id.cc => libnitrokey-v3.6/command_id.cc +3 -0
@@ 26,6 26,9 @@ namespace nitrokey {
namespace proto {

const char *commandid_to_string(CommandID id) {
#ifdef NO_LOG
  return "";
#endif
  switch (id) {
    case CommandID::GET_STATUS:
      return "GET_STATUS";

R libnitrokey-v3.5/device.cc => libnitrokey-v3.6/device.cc +65 -19
@@ 45,14 45,33 @@ const uint16_t nitrokey::device::NITROKEY_VID = 0x20a0;
const uint16_t nitrokey::device::NITROKEY_PRO_PID = 0x4108;
const uint16_t nitrokey::device::NITROKEY_STORAGE_PID = 0x4109;

const uint16_t nitrokey::device::PURISM_VID = 0x316d;
const uint16_t nitrokey::device::LIBREM_KEY_PID = 0x4c4b;

Option<DeviceModel> nitrokey::device::product_id_to_model(uint16_t product_id) {
  switch (product_id) {
    return product_id_to_model(NITROKEY_VID, product_id);
}

Option<DeviceModel> nitrokey::device::product_id_to_model(uint16_t vendor_id, uint16_t product_id) {
  switch (vendor_id) {
  case NITROKEY_VID:
    switch (product_id) {
    case NITROKEY_PRO_PID:
      return DeviceModel::PRO;
    case NITROKEY_STORAGE_PID:
      return DeviceModel::STORAGE;
    default:
      return {};
    }
  case PURISM_VID:
    switch (product_id) {
    case LIBREM_KEY_PID:
      return DeviceModel::LIBREM;
    default:
      return {};
    }
  default:
    return {};
  }
}



@@ 67,6 86,9 @@ std::ostream& nitrokey::device::operator<<(std::ostream& stream, DeviceModel mod
    case DeviceModel::STORAGE:
      stream << "Storage";
      break;
    case DeviceModel::LIBREM:
      stream << "Librem";
      break;
    default:
      stream << "Unknown";
      break;


@@ 99,7 121,9 @@ bool Device::disconnect() {
}

bool Device::_disconnect() {
  LOG(std::string(__FUNCTION__) + std::string(m_model == DeviceModel::PRO ? "PRO" : "STORAGE"), Loglevel::DEBUG_L2);
  LOG(std::string(__FUNCTION__) +
      std::string(m_model == DeviceModel::PRO ? "PRO" : (m_model == DeviceModel::STORAGE ? "STORAGE" : "LIBREM")),
      Loglevel::DEBUG_L2);
  LOG(std::string(__FUNCTION__) +  std::string(" *IN* "), Loglevel::DEBUG_L2);

  if(mp_devhandle == nullptr) {


@@ 204,27 228,36 @@ int Device::recv(void *packet) {
  return status;
}

std::vector<DeviceInfo> Device::enumerate(){
  auto pInfo = hid_enumerate(NITROKEY_VID, 0);
  auto pInfo_ = pInfo;
  std::vector<DeviceInfo> res;
  while (pInfo != nullptr){
    auto deviceModel = product_id_to_model(pInfo->product_id);
    if (deviceModel.has_value()) {
      std::string path(pInfo->path);
      std::wstring serialNumberW(pInfo->serial_number);
      std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
      std::string serialNumber = converter.to_bytes(serialNumberW);
      DeviceInfo info = { deviceModel.value(), path, serialNumber };
      res.push_back(info);
namespace {
  void add_vendor_devices(std::vector<DeviceInfo>& res, uint16_t vendor_id){
    auto pInfo = hid_enumerate(vendor_id, 0);
    auto pInfo_ = pInfo;
    while (pInfo != nullptr){
      if (pInfo->path == nullptr || pInfo->serial_number == nullptr) {
      continue;
    }
    auto deviceModel = product_id_to_model(vendor_id, pInfo->product_id);
      if (deviceModel.has_value()) {
	std::string path(pInfo->path);
	std::wstring serialNumberW(pInfo->serial_number);
	std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
	std::string serialNumber = converter.to_bytes(serialNumberW);
	DeviceInfo info = { deviceModel.value(), path, serialNumber };
	res.push_back(info);
      }
      pInfo = pInfo->next;
    }
    pInfo = pInfo->next;
  }

  if (pInfo_ != nullptr){
    hid_free_enumeration(pInfo_);
    if (pInfo_ != nullptr){
      hid_free_enumeration(pInfo_);
    }
  }
}

std::vector<DeviceInfo> Device::enumerate(){
  std::vector<DeviceInfo> res;
  ::add_vendor_devices(res, NITROKEY_VID);
  ::add_vendor_devices(res, PURISM_VID);
  return res;
}



@@ 234,6 267,8 @@ std::shared_ptr<Device> Device::create(DeviceModel model) {
      return std::make_shared<Stick10>();
    case DeviceModel::STORAGE:
      return std::make_shared<Stick20>();
    case DeviceModel::LIBREM:
      return std::make_shared<LibremKey>();
    default:
      return {};
  }


@@ 305,9 340,20 @@ Stick20::Stick20():
    setDefaultDelay();
  }


LibremKey::LibremKey():
  Device(PURISM_VID, LIBREM_KEY_PID, DeviceModel::LIBREM, 100ms, 5, 100ms)
  {
    setDefaultDelay();
  }

#include <sstream>
#define p(x) ss << #x << " " << x << ", ";
std::string Device::ErrorCounters::get_as_string() {
#ifdef NO_LOG
  return "";
#endif

  std::stringstream ss;
  p(total_comm_runs);
  p(communication_successful);

R libnitrokey-v3.5/libnitrokey/CommandFailedException.h => libnitrokey-v3.6/libnitrokey/CommandFailedException.h +0 -0

R libnitrokey-v3.5/libnitrokey/DeviceCommunicationExceptions.h => libnitrokey-v3.6/libnitrokey/DeviceCommunicationExceptions.h +0 -0

R libnitrokey-v3.5/libnitrokey/LibraryException.h => libnitrokey-v3.6/libnitrokey/LibraryException.h +0 -0

R libnitrokey-v3.5/libnitrokey/LongOperationInProgressException.h => libnitrokey-v3.6/libnitrokey/LongOperationInProgressException.h +0 -0

R libnitrokey-v3.5/libnitrokey/NitrokeyManager.h => libnitrokey-v3.6/libnitrokey/NitrokeyManager.h +3 -0
@@ 104,6 104,7 @@ char * strndup(const char* str, size_t maxlen);
        stick10::GetStatus::ResponsePayload get_status();
        string get_status_as_string();
        string get_serial_number();
        uint32_t get_serial_number_as_u32();

        char * get_totp_slot_name(uint8_t slot_number);
        char * get_hotp_slot_name(uint8_t slot_number);


@@ 157,6 158,7 @@ char * strndup(const char* str, size_t maxlen);
         * Does nothing otherwise.
         * @param user_pin User PIN
         */
        [[deprecated("Use set_unencrypted_read_only_admin instead.")]]
        void set_unencrypted_read_only(const char *user_pin);

        /**


@@ 173,6 175,7 @@ char * strndup(const char* str, size_t maxlen);
         * Does nothing otherwise.
         * @param user_pin User PIN
         */
        [[deprecated("Use set_unencrypted_read_write_admin instead")]]
        void set_unencrypted_read_write(const char *user_pin);

        /**

R libnitrokey-v3.5/libnitrokey/command.h => libnitrokey-v3.6/libnitrokey/command.h +0 -0

R libnitrokey-v3.5/libnitrokey/command_id.h => libnitrokey-v3.6/libnitrokey/command_id.h +0 -0

R libnitrokey-v3.5/libnitrokey/cxx_semantics.h => libnitrokey-v3.6/libnitrokey/cxx_semantics.h +0 -0

R libnitrokey-v3.5/libnitrokey/deprecated.h => libnitrokey-v3.6/libnitrokey/deprecated.h +0 -0

R libnitrokey-v3.5/libnitrokey/device.h => libnitrokey-v3.6/libnitrokey/device.h +17 -1
@@ 50,7 50,8 @@ namespace device {

enum class DeviceModel{
    PRO,
    STORAGE
    STORAGE,
    LIBREM
};

std::ostream& operator<<(std::ostream& stream, DeviceModel model);


@@ 67,12 68,21 @@ extern const uint16_t NITROKEY_PRO_PID;
 * The USB product ID for the Nitrokey Storage.
 */
extern const uint16_t NITROKEY_STORAGE_PID;
/**
 * The USB vendor ID for Purism devices.
 */
extern const uint16_t PURISM_VID;
/**
 * The USB product ID for the Librem Key.
 */
extern const uint16_t LIBREM_KEY_PID;

/**
 * Convert the given USB product ID to a Nitrokey model.  If there is no model
 * with that ID, return an absent value.
 */
misc::Option<DeviceModel> product_id_to_model(uint16_t product_id);
misc::Option<DeviceModel> product_id_to_model(uint16_t vendor_id, uint16_t product_id);

/**
 * Information about a connected device.


@@ 219,6 229,12 @@ class Stick20 : public Device {
 public:
  Stick20();
};

class LibremKey : public Device {
 public:
  LibremKey();
};

}
}
#endif

R libnitrokey-v3.5/libnitrokey/device_proto.h => libnitrokey-v3.6/libnitrokey/device_proto.h +1 -1
@@ 249,7 249,7 @@ namespace nitrokey {
              }
              dev->m_counters.total_comm_runs++;

              int status;
              int status = 0;
              OutgoingPacket outp;
              ResponsePacket resp;


R libnitrokey-v3.5/libnitrokey/dissect.h => libnitrokey-v3.6/libnitrokey/dissect.h +0 -0

R libnitrokey-v3.5/libnitrokey/hidapi/hidapi.h => libnitrokey-v3.6/libnitrokey/hidapi/hidapi.h +0 -0

R libnitrokey-v3.5/libnitrokey/log.h => libnitrokey-v3.6/libnitrokey/log.h +1 -0
@@ 100,6 100,7 @@ namespace nitrokey {
#ifdef NO_LOG
#define LOG(string, level) while(false){}
#define LOGD(string) while(false){}
#define LOGD1(string) while(false){}
#else
#define LOG(string, level) nitrokey::log::Log::instance()((string), (level))
#define LOGD1(string) nitrokey::log::Log::instance()((string), (nitrokey::log::Loglevel::DEBUG_L1))

R libnitrokey-v3.5/libnitrokey/misc.h => libnitrokey-v3.6/libnitrokey/misc.h +0 -0

R libnitrokey-v3.5/libnitrokey/stick10_commands.h => libnitrokey-v3.6/libnitrokey/stick10_commands.h +0 -0

R libnitrokey-v3.5/libnitrokey/stick10_commands_0.8.h => libnitrokey-v3.6/libnitrokey/stick10_commands_0.8.h +0 -0

R libnitrokey-v3.5/libnitrokey/stick20_commands.h => libnitrokey-v3.6/libnitrokey/stick20_commands.h +0 -0

R libnitrokey-v3.5/libnitrokey/version.h => libnitrokey-v3.6/libnitrokey/version.h +0 -0

R libnitrokey-v3.5/log.cc => libnitrokey-v3.6/log.cc +0 -0

R libnitrokey-v3.5/misc.cc => libnitrokey-v3.6/misc.cc +0 -0

R libnitrokey-v3.5/version.cc => libnitrokey-v3.6/version.cc +0 -0

R libnitrokey-v3.5/version.cc.in => libnitrokey-v3.6/version.cc.in +0 -0

A patches/deprecated.diff => patches/deprecated.diff +46 -0
@@ 0,0 1,46 @@
Add deprecated attribute to depracted functions

bindgen does add the deprecated attribute to deprecated functions.  This patch
manually adds the attributes libnitrokey’s deprecated functions.
Index: nitrokey-sys-rs/src/ffi.rs
===================================================================
--- nitrokey-sys-rs.orig/src/ffi.rs
+++ nitrokey-sys-rs/src/ffi.rs
@@ -212,6 +212,7 @@ extern "C" {
     #[doc = " deprecated in favor of NK_get_status_as_string."]
     #[doc = " @return string representation of the status or an empty string"]
     #[doc = "         if the command failed"]
+    #[deprecated(since = "3.5.0", note = "use `NK_get_status_as_string` instead")]
     pub fn NK_status() -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
@@ -498,6 +499,7 @@ extern "C" {
     pub fn NK_totp_set_time_soft(time: u64) -> ::std::os::raw::c_int;
 }
 extern "C" {
+    #[deprecated(since = "3.4.0", note = "use `NK_totp_set_time_soft` instead")]
     pub fn NK_totp_get_time() -> ::std::os::raw::c_int;
 }
 extern "C" {
@@ -673,6 +675,10 @@ extern "C" {
     #[doc = " Storage only"]
     #[doc = " @param user_pin 20 characters User PIN"]
     #[doc = " @return command processing error code"]
+    #[deprecated(
+        since = "3.6.0",
+        note = "use `set_unencrypted_read_only_admin` instead"
+    )]
     pub fn NK_set_unencrypted_read_only(
         user_pin: *const ::std::os::raw::c_char,
     ) -> ::std::os::raw::c_int;
@@ -686,6 +692,10 @@ extern "C" {
     #[doc = " Storage only"]
     #[doc = " @param user_pin 20 characters User PIN"]
     #[doc = " @return command processing error code"]
+    #[deprecated(
+        since = "3.6.0",
+        note = "use `set_unencrypted_read_write_admin` instead"
+    )]
     pub fn NK_set_unencrypted_read_write(
         user_pin: *const ::std::os::raw::c_char,
     ) -> ::std::os::raw::c_int;

A patches/remove-uint.diff => patches/remove-uint.diff +21 -0
@@ 0,0 1,21 @@
Remove uint type definitions

While bindgen is able to replace the C uint types with the correct Rust types,
it still generates typedefs for __uint{8,16,32,64}_t [0].  We don’t need these
typedefs, so we remove them manually.

[0] https://github.com/rust-lang/rust-bindgen/issues/1663
Index: nitrokey-sys-rs/src/ffi.rs
===================================================================
--- nitrokey-sys-rs.orig/src/ffi.rs
+++ nitrokey-sys-rs/src/ffi.rs
@@ -1,9 +1,5 @@
 /* automatically generated by rust-bindgen 0.55.1 */
 
-pub type __uint8_t = ::std::os::raw::c_uchar;
-pub type __uint16_t = ::std::os::raw::c_ushort;
-pub type __uint32_t = ::std::os::raw::c_uint;
-pub type __uint64_t = ::std::os::raw::c_ulong;
 extern "C" {
     pub static NK_PWS_SLOT_COUNT: u8;
 }

A patches/series => patches/series +2 -0
@@ 0,0 1,2 @@
deprecated.diff
remove-uint.diff

M src/ffi.rs => src/ffi.rs +491 -1049
@@ 1,501 1,131 @@
/* automatically generated by rust-bindgen, manually modified */
/* automatically generated by rust-bindgen 0.55.1 */

extern "C" {
    #[link_name = "\u{1}NK_PWS_SLOT_COUNT"]
    pub static mut NK_PWS_SLOT_COUNT: u8;
    pub static NK_PWS_SLOT_COUNT: u8;
}
pub const MAXIMUM_STR_REPLY_LENGTH: ::std::os::raw::c_int = 8192;
/// Use, if no supported device is connected
#[doc = " Use, if no supported device is connected"]
pub const NK_device_model_NK_DISCONNECTED: NK_device_model = 0;
/// Nitrokey Pro.
#[doc = " Nitrokey Pro."]
pub const NK_device_model_NK_PRO: NK_device_model = 1;
/// Nitrokey Storage.
#[doc = " Nitrokey Storage."]
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;
/// The connection info for a Nitrokey device as a linked list.
#[doc = " Librem Key."]
pub const NK_device_model_NK_LIBREM: NK_device_model = 3;
#[doc = " The Nitrokey device models supported by the API."]
pub type NK_device_model = ::std::os::raw::c_uint;
#[doc = " The connection info for a Nitrokey device as a linked list."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct NK_device_info {
    /// The model of the Nitrokey device.
    #[doc = " The model of the Nitrokey device."]
    pub model: NK_device_model,
    /// The USB device path for NK_connect_with_path.
    #[doc = " The USB device path for NK_connect_with_path."]
    pub path: *mut ::std::os::raw::c_char,
    /// The serial number.
    #[doc = " The serial number."]
    pub serial_number: *mut ::std::os::raw::c_char,
    /// The pointer to the next element of the linked list or null
    /// if this is the last element in the list.
    #[doc = " The pointer to the next element of the linked list or null"]
    #[doc = " if this is the last element in the list."]
    pub next: *mut NK_device_info,
}
#[test]
fn bindgen_test_layout_NK_device_info() {
    assert_eq!(
        ::std::mem::size_of::<NK_device_info>(),
        32usize,
        concat!("Size of: ", stringify!(NK_device_info))
    );
    assert_eq!(
        ::std::mem::align_of::<NK_device_info>(),
        8usize,
        concat!("Alignment of ", stringify!(NK_device_info))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_device_info>())).model as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_device_info),
            "::",
            stringify!(model)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_device_info>())).path as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_device_info),
            "::",
            stringify!(path)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_device_info>())).serial_number as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_device_info),
            "::",
            stringify!(serial_number)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_device_info>())).next as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_device_info),
            "::",
            stringify!(next)
        )
    );
}
/// Stores the common device status for all Nitrokey devices.
impl Default for NK_device_info {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
#[doc = " Stores the common device status for all Nitrokey devices."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NK_status {
    /// The major firmware version, e. g. 0 in v0.40.
    #[doc = " 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.
    #[doc = " The minor firmware version, e. g. 40 in v0.40."]
    pub firmware_version_minor: u8,
    /// The serial number of the smart card.
    #[doc = " The serial number of the smart card."]
    pub serial_number_smart_card: u32,
    /// The HOTP slot to generate a password from if the numlock
    /// key is pressed twice (slot 0-1, or any other value to
    /// disable the function).
    #[doc = " The HOTP slot to generate a password from if the numlock"]
    #[doc = " key is pressed twice (slot 0-1, or any other value to"]
    #[doc = " disable the function)."]
    pub config_numlock: u8,
    /// The HOTP slot to generate a password from if the capslock
    /// key is pressed twice (slot 0-1, or any other value to
    /// disable the function).
    #[doc = " The HOTP slot to generate a password from if the capslock"]
    #[doc = " key is pressed twice (slot 0-1, or any other value to"]
    #[doc = " disable the function)."]
    pub config_capslock: u8,
    /// The HOTP slot to generate a password from if the scrolllock
    /// key is pressed twice (slot 0-1, or any other value to
    /// disable the function).
    #[doc = " The HOTP slot to generate a password from if the scrolllock"]
    #[doc = " key is pressed twice (slot 0-1, or any other value to"]
    #[doc = " disable the function)."]
    pub config_scrolllock: u8,
    /// Indicates whether the user password is required to generate
    /// an OTP value.
    #[doc = " Indicates whether the user password is required to generate"]
    #[doc = " an OTP value."]
    pub otp_user_password: bool,
}
#[test]
fn bindgen_test_layout_NK_status() {
    assert_eq!(
        ::std::mem::size_of::<NK_status>(),
        12usize,
        concat!("Size of: ", stringify!(NK_status))
    );
    assert_eq!(
        ::std::mem::align_of::<NK_status>(),
        4usize,
        concat!("Alignment of ", stringify!(NK_status))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<NK_status>())).firmware_version_major as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(firmware_version_major)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<NK_status>())).firmware_version_minor as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(firmware_version_minor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<NK_status>())).serial_number_smart_card as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(serial_number_smart_card)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_status>())).config_numlock as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(config_numlock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_status>())).config_capslock as *const _ as usize },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(config_capslock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_status>())).config_scrolllock as *const _ as usize },
        10usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(config_scrolllock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<NK_status>())).otp_user_password as *const _ as usize },
        11usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_status),
            "::",
            stringify!(otp_user_password)
        )
    );
}
/// Stores the status of a Storage device.
#[doc = " Stores the status of a Storage device."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NK_storage_status {
    /// Indicates whether the unencrypted volume is read-only.
    #[doc = " Indicates whether the unencrypted volume is read-only."]
    pub unencrypted_volume_read_only: bool,
    /// Indicates whether the unencrypted volume is active.
    #[doc = " Indicates whether the unencrypted volume is active."]
    pub unencrypted_volume_active: bool,
    /// Indicates whether the encrypted volume is read-only.
    #[doc = " Indicates whether the encrypted volume is read-only."]
    pub encrypted_volume_read_only: bool,
    /// Indicates whether the encrypted volume is active.
    #[doc = " Indicates whether the encrypted volume is active."]
    pub encrypted_volume_active: bool,
    /// Indicates whether the hidden volume is read-only.
    #[doc = " Indicates whether the hidden volume is read-only."]
    pub hidden_volume_read_only: bool,
    /// Indicates whether the hidden volume is active.
    #[doc = " Indicates whether the hidden volume is active."]
    pub hidden_volume_active: bool,
    /// The major firmware version, e. g. 0 in v0.40.
    #[doc = " 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.
    #[doc = " The minor firmware version, e. g. 40 in v0.40."]
    pub firmware_version_minor: u8,
    /// Indicates whether the firmware is locked.
    #[doc = " Indicates whether the firmware is locked."]
    pub firmware_locked: bool,
    /// The serial number of the SD card in the Storage stick.
    #[doc = " 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.
    #[doc = " 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.
    #[doc = " 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.
    #[doc = " The number of remaining login attempts for the admin PIN."]
    pub admin_retry_count: u8,
    /// Indicates whether a new SD card was found.
    #[doc = " Indicates whether a new SD card was found."]
    pub new_sd_card_found: bool,
    /// Indicates whether the SD card is filled with random characters.
    #[doc = " 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.
    #[doc = " Indicates whether the stick has been initialized by generating"]
    #[doc = " 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)
        )
    );
}
/// Data about the usage of the SD card.
#[doc = " Data about the usage of the SD card."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NK_SD_usage_data {
    /// The minimum write level, as a percentage of the total card
    /// size.
    #[doc = " The minimum write level, as a percentage of the total card"]
    #[doc = " size."]
    pub write_level_min: u8,
    /// The maximum write level, as a percentage of the total card
    /// size.
    #[doc = " The maximum write level, as a percentage of the total card"]
    #[doc = " size."]
    pub write_level_max: u8,
}
#[test]
fn bindgen_test_layout_NK_SD_usage_data() {
    assert_eq!(
        ::std::mem::size_of::<NK_SD_usage_data>(),
        2usize,
        concat!("Size of: ", stringify!(NK_SD_usage_data))
    );
    assert_eq!(
        ::std::mem::align_of::<NK_SD_usage_data>(),
        1usize,
        concat!("Alignment of ", stringify!(NK_SD_usage_data))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<NK_SD_usage_data>())).write_level_min as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_SD_usage_data),
            "::",
            stringify!(write_level_min)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<NK_SD_usage_data>())).write_level_max as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(NK_SD_usage_data),
            "::",
            stringify!(write_level_max)
        )
    );
#[doc = " The general configuration of a Nitrokey device."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NK_config {
    #[doc = " value in range [0-1] to send HOTP code from slot 'numlock' after double pressing numlock"]
    #[doc = " or outside the range to disable this function"]
    pub numlock: u8,
    #[doc = " similar to numlock but with capslock"]
    pub capslock: u8,
    #[doc = " similar to numlock but with scrolllock"]
    pub scrolllock: u8,
    #[doc = " True to enable OTP PIN protection (require PIN each OTP code request)"]
    pub enable_user_password: bool,
    #[doc = " Unused."]
    pub disable_user_password: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NK_storage_ProductionTest {
    pub FirmwareVersion_au8: [u8; 2usize],
    pub FirmwareVersionInternal_u8: u8,


@@ 511,342 141,168 @@ pub struct NK_storage_ProductionTest {
    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
    #[doc = " Set debug level of messages written on stderr"]
    #[doc = " @param state state=True - most messages, state=False - only errors level"]
    pub fn NK_set_debug(state: bool);
}
extern "C" {
    /// Set debug level of messages written on stderr
    /// @param level (int) 0-lowest verbosity, 5-highest verbosity
    #[doc = " Set debug level of messages written on stderr"]
    #[doc = " @param level (int) 0-lowest verbosity, 5-highest verbosity"]
    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
    #[doc = " Get the major library version, e. g. the 3 in v3.2."]
    #[doc = " @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
    #[doc = " Get the minor library version, e. g. the 2 in v3.2."]
    #[doc = " @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
    #[doc = " Get the library version as a string.  This is the output of"]
    #[doc = " `git describe --always` at compile time, for example \"v3.3\" or"]
    #[doc = " \"v3.3-19-gaee920b\"."]
    #[doc = " The return value is a string literal and must not be freed."]
    #[doc = " @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
    #[doc = " Connect to device of given model. Currently library can be connected only to one device at once."]
    #[doc = " @param device_model char 'S': Nitrokey Storage, 'P': Nitrokey Pro"]
    #[doc = " @return 1 if connected, 0 if wrong model or cannot connect"]
    pub fn NK_login(device_model: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Connect to device of given model. Currently library can be connected only to one device at once.
    /// @param device_model NK_device_model: NK_PRO: Nitrokey Pro, NK_STORAGE: Nitrokey Storage
    /// @return 1 if connected, 0 if wrong model or cannot connect
    #[doc = " Connect to device of given model. Currently library can be connected only to one device at once."]
    #[doc = " @param device_model NK_device_model: NK_PRO: Nitrokey Pro, NK_STORAGE: Nitrokey Storage, NK_LIBREM: Librem Key"]
    #[doc = " @return 1 if connected, 0 if wrong model or cannot connect"]
    pub fn NK_login_enum(device_model: NK_device_model) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Connect to first available device, starting checking from Pro 1st to Storage 2nd.
    /// @return 1 if connected, 0 if wrong model or cannot connect
    #[doc = " Connect to first available device, starting checking from Pro 1st to Storage 2nd."]
    #[doc = " @return 1 if connected, 0 if wrong model or cannot connect"]
    pub fn NK_login_auto() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Disconnect from the device.
    /// @return command processing error code
    #[doc = " Disconnect from the device."]
    #[doc = " @return command processing error code"]
    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
    #[doc = " Query the model of the connected device."]
    #[doc = " Returns the model of the connected device or NK_DISCONNECTED."]
    #[doc = ""]
    #[doc = " @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.  This function is
    /// deprecated in favor of NK_get_status_as_string.
    /// @return string representation of the status or an empty string
    /// if the command failed
    #[deprecated(since = "3.5.0", note="use `NK_get_status_as_string` instead")]
    #[doc = " Return the debug status string. Debug purposes.  This function is"]
    #[doc = " deprecated in favor of NK_get_status_as_string."]
    #[doc = " @return string representation of the status or an empty string"]
    #[doc = "         if the command failed"]
    #[deprecated(since = "3.5.0", note = "use `NK_get_status_as_string` instead")]
    pub fn NK_status() -> *mut ::std::os::raw::c_char;
}
extern "C" {
    /// Return the debug status string. Debug purposes.
    /// @return string representation of the status or an empty string
    /// if the command failed
    #[doc = " Return the debug status string. Debug purposes."]
    #[doc = " @return string representation of the status or an empty string"]
    #[doc = "         if the command failed"]
    pub fn NK_get_status_as_string() -> *mut ::std::os::raw::c_char;
}
extern "C" {
    /// Get the stick status common to all Nitrokey devices 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 status
    /// @return command processing error code
    #[doc = " Get the stick status common to all Nitrokey devices and return the"]
    #[doc = " command processing error code.  If the code is zero, i. e. the"]
    #[doc = " command was successful, the storage status is written to the output"]
    #[doc = " pointer's target.  The output pointer must not be null."]
    #[doc = ""]
    #[doc = " @param out the output pointer for the status"]
    #[doc = " @return command processing error code"]
    pub fn NK_get_status(out: *mut NK_status) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Return the device's serial number string in hex.
    /// @return string device's serial number in hex
    #[doc = " Return the device's serial number string in hex."]
    #[doc = " @return string device's serial number in hex"]
    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
    /// an error code.
    /// @return previous command processing error code
    #[doc = " Return the device's serial number string as an integer.  Use"]
    #[doc = " NK_last_command_status to check for an error if this function"]
    #[doc = " returns zero."]
    #[doc = " @return device's serial number as an integer"]
    pub fn NK_device_serial_number_as_u32() -> u32;
}
extern "C" {
    #[doc = " Get last command processing status. Useful for commands which returns the results of their own and could not return"]
    #[doc = " an error code."]
    #[doc = " @return previous command processing error code"]
    pub fn NK_get_last_command_status() -> u8;
}
extern "C" {
    /// Lock device - cancel any user device unlocking.
    /// @return command processing error code
    #[doc = " Lock device - cancel any user device unlocking."]
    #[doc = " @return command processing error code"]
    pub fn NK_lock_device() -> ::std::os::raw::c_int;
}
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] 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
    #[doc = " Authenticates the user on USER privilages with user_password and sets user's temporary password on device to user_temporary_password."]
    #[doc = " @param user_password char[25] current user password"]
    #[doc = " @param user_temporary_password char[25] user temporary password to be set on device for further communication (authentication command)"]
    #[doc = " @return command processing error code"]
    pub fn NK_user_authenticate(
        user_password: *const ::std::os::raw::c_char,
        user_temporary_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
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] 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
    #[doc = " Authenticates the user on ADMIN privilages with admin_password and sets user's temporary password on device to admin_temporary_password."]
    #[doc = " @param admin_password char[25] current administrator PIN"]
    #[doc = " @param admin_temporary_password char[25] admin temporary password to be set on device for further communication (authentication command)"]
    #[doc = " @return command processing error code"]
    pub fn NK_first_authenticate(
        admin_password: *const ::std::os::raw::c_char,
        admin_temporary_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Execute a factory reset.
    /// @param admin_password char[20] current administrator PIN
    /// @return command processing error code
    #[doc = " Execute a factory reset."]
    #[doc = " @param admin_password char[20] current administrator PIN"]
    #[doc = " @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] current administrator PIN
    /// @return command processing error code
    #[doc = " Generates AES key on the device"]
    #[doc = " @param admin_password char[20] current administrator PIN"]
    #[doc = " @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] current administrator PIN
    /// @return command processing error code
    #[doc = " Unlock user PIN locked after 3 incorrect codes tries."]
    #[doc = " @param admin_password char[20] current administrator PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_unlock_user_password(
        admin_password: *const ::std::os::raw::c_char,
        new_user_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Write general config to the device
    /// @param numlock set value in range [0-1] to send HOTP code from slot 'numlock' after double pressing numlock
    /// or outside the range to disable this function
    /// @param capslock similar to numlock but with capslock
    /// @param scrolllock similar to numlock but with scrolllock
    /// @param enable_user_password set True to enable OTP PIN protection (require PIN each OTP code request)
    /// @param delete_user_password (unused)
    /// @param admin_temporary_password current admin temporary password
    /// @return command processing error code
    #[doc = " Write general config to the device"]
    #[doc = " @param numlock set value in range [0-1] to send HOTP code from slot 'numlock' after double pressing numlock"]
    #[doc = " or outside the range to disable this function"]
    #[doc = " @param capslock similar to numlock but with capslock"]
    #[doc = " @param scrolllock similar to numlock but with scrolllock"]
    #[doc = " @param enable_user_password set True to enable OTP PIN protection (require PIN each OTP code request)"]
    #[doc = " @param delete_user_password (unused)"]
    #[doc = " @param admin_temporary_password current admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_write_config(
        numlock: u8,
        capslock: u8,


@@ 857,60 313,85 @@ extern "C" {
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get currently set config - status of function Numlock/Capslock/Scrollock OTP sending and is enabled PIN protected OTP
    /// @see NK_write_config
    /// @return  uint8_t general_config[5]:
    /// uint8_t numlock;
    /// uint8_t capslock;
    /// uint8_t scrolllock;
    /// uint8_t enable_user_password;
    /// uint8_t delete_user_password;
    #[doc = " Write general config to the device"]
    #[doc = " @param config the configuration data"]
    #[doc = " @param admin_temporary_password current admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_write_config_struct(
        config: NK_config,
        admin_temporary_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Get currently set config - status of function Numlock/Capslock/Scrollock OTP sending and is enabled PIN protected OTP"]
    #[doc = " The return value must be freed using NK_free_config."]
    #[doc = " @see NK_write_config"]
    #[doc = " @return  uint8_t general_config[5]:"]
    #[doc = "            uint8_t numlock;"]
    #[doc = "uint8_t capslock;"]
    #[doc = "uint8_t scrolllock;"]
    #[doc = "uint8_t enable_user_password;"]
    #[doc = "uint8_t delete_user_password;"]
    #[doc = ""]
    pub fn NK_read_config() -> *mut u8;
}
extern "C" {
    /// Get name of given TOTP slot
    /// @param slot_number TOTP slot number, slot_number<15
    /// @return char[20] the name of the slot
    #[doc = " Free a value returned by NK_read_config.  May be called with a NULL"]
    #[doc = " argument."]
    pub fn NK_free_config(config: *mut u8);
}
extern "C" {
    #[doc = " Get currently set config and write it to the given pointer."]
    #[doc = " @see NK_read_config"]
    #[doc = " @see NK_write_config_struct"]
    #[doc = " @param out a pointer to the struct that should be written to"]
    #[doc = " @return command processing error code"]
    pub fn NK_read_config_struct(out: *mut NK_config) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Get name of given TOTP slot"]
    #[doc = " @param slot_number TOTP slot number, slot_number<15"]
    #[doc = " @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] the name of the slot
    #[doc = " @param slot_number HOTP slot number, slot_number<3"]
    #[doc = " @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
    /// @param slot_number HOTP slot number, slot_number<3
    /// @param temporary_password admin temporary password
    /// @return command processing error code
    #[doc = " Erase HOTP slot data from the device"]
    #[doc = " @param slot_number HOTP slot number, slot_number<3"]
    #[doc = " @param temporary_password admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_erase_hotp_slot(
        slot_number: u8,
        temporary_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Erase TOTP slot data from the device
    /// @param slot_number TOTP slot number, slot_number<15
    /// @param temporary_password admin temporary password
    /// @return command processing error code
    #[doc = " Erase TOTP slot data from the device"]
    #[doc = " @param slot_number TOTP slot number, slot_number<15"]
    #[doc = " @param temporary_password admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_erase_totp_slot(
        slot_number: u8,
        temporary_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Write HOTP slot data to the device
    /// @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] admin temporary password
    /// @return command processing error code
    #[doc = " Write HOTP slot data to the device"]
    #[doc = " @param slot_number HOTP slot number, slot_number<3, 0-numbered"]
    #[doc = " @param slot_name char[15] desired slot name. C string (requires ending '\\0'; 16 bytes)."]
    #[doc = " @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)."]
    #[doc = " See NitrokeyManager::is_320_OTP_secret_supported."]
    #[doc = " @param hotp_counter uint32_t starting value of HOTP counter"]
    #[doc = " @param use_8_digits should returned codes be 6 (false) or 8 digits (true)"]
    #[doc = " @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock"]
    #[doc = " @param use_tokenID @see token_ID"]
    #[doc = " @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section"]
    #[doc = " @param temporary_password char[25] admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_write_hotp_slot(
        slot_number: u8,
        slot_name: *const ::std::os::raw::c_char,


@@ 924,18 405,18 @@ extern "C" {
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Write TOTP slot data to the device
    /// @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] admin temporary password
    /// @return command processing error code
    #[doc = " Write TOTP slot data to the device"]
    #[doc = " @param slot_number TOTP slot number, slot_number<15, 0-numbered"]
    #[doc = " @param slot_name char[15] desired slot name. C string (requires ending '\\0'; 16 bytes)."]
    #[doc = " @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)."]
    #[doc = " See NitrokeyManager::is_320_OTP_secret_supported."]
    #[doc = " @param time_window uint16_t time window for this TOTP"]
    #[doc = " @param use_8_digits should returned codes be 6 (false) or 8 digits (true)"]
    #[doc = " @param use_enter press ENTER key after sending OTP code using double-pressed scroll/num/capslock"]
    #[doc = " @param use_tokenID @see token_ID"]
    #[doc = " @param token_ID @see https://openauthentication.org/token-specs/, 'Class A' section"]
    #[doc = " @param temporary_password char[20] admin temporary password"]
    #[doc = " @return command processing error code"]
    pub fn NK_write_totp_slot(
        slot_number: u8,
        slot_name: *const ::std::os::raw::c_char,


@@ 949,29 430,29 @@ extern "C" {
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get HOTP code from the device
    /// @param slot_number HOTP slot number, slot_number<3
    /// @return HOTP code
    #[doc = " Get HOTP code from the device"]
    #[doc = " @param slot_number HOTP slot number, slot_number<3"]
    #[doc = " @return HOTP code"]
    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] user temporary password if PIN protected OTP codes are enabled,
    /// otherwise should be set to empty string - ''
    /// @return HOTP code
    #[doc = " Get HOTP code from the device (PIN protected)"]
    #[doc = " @param slot_number HOTP slot number, slot_number<3"]
    #[doc = " @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,"]
    #[doc = " otherwise should be set to empty string - ''"]
    #[doc = " @return HOTP code"]
    pub fn NK_get_hotp_code_PIN(
        slot_number: u8,
        user_temporary_password: *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 -- unused
    /// @param last_totp_time last time -- unused
    /// @param last_interval last interval --unused
    /// @return TOTP code
    #[doc = " Get TOTP code from the device"]
    #[doc = " @param slot_number TOTP slot number, slot_number<15"]
    #[doc = " @param challenge TOTP challenge -- unused"]
    #[doc = " @param last_totp_time last time -- unused"]
    #[doc = " @param last_interval last interval --unused"]
    #[doc = " @return TOTP code"]
    pub fn NK_get_totp_code(
        slot_number: u8,
        challenge: u64,


@@ 980,14 461,14 @@ extern "C" {
    ) -> *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 -- 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
    #[doc = " Get TOTP code from the device (PIN protected)"]
    #[doc = " @param slot_number TOTP slot number, slot_number<15"]
    #[doc = " @param challenge TOTP challenge -- unused"]
    #[doc = " @param last_totp_time last time -- unused"]
    #[doc = " @param last_interval last interval -- unused"]
    #[doc = " @param user_temporary_password char[25] user temporary password if PIN protected OTP codes are enabled,"]
    #[doc = " otherwise should be set to empty string - ''"]
    #[doc = " @return TOTP code"]
    pub fn NK_get_totp_code_PIN(
        slot_number: u8,
        challenge: u64,


@@ 997,94 478,100 @@ extern "C" {
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    /// Set time on the device (for TOTP requests)
    /// @param time seconds in unix epoch (from 01.01.1970)
    /// @return command processing error code
    #[doc = " Set time on the device (for TOTP requests)"]
    #[doc = " @param time seconds in unix epoch (from 01.01.1970)"]
    #[doc = " @return command processing error code"]
    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
    #[doc = " Set the device time used for TOTP to the given time.  Contrary to"]
    #[doc = " {@code set_time(uint64_t)}, this command fails if {@code old_time}"]
    #[doc = " &gt; {@code time} or if {@code old_time} is zero (where {@code"]
    #[doc = " old_time} is the current time on the device)."]
    #[doc = ""]
    #[doc = " @param time new device time as Unix timestamp (seconds since"]
    #[doc = "        1970-01-01)"]
    #[doc = " @return command processing error code"]
    pub fn NK_totp_set_time_soft(time: u64) -> ::std::os::raw::c_int;
}
extern "C" {
    #[deprecated(since = "3.4.0", note="use `NK_totp_set_time_soft` instead")]
    #[deprecated(since = "3.4.0", note = "use `NK_totp_set_time_soft` instead")]
    pub fn NK_totp_get_time() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Change administrator PIN
    /// @param current_PIN char[25] current PIN
    /// @param new_PIN char[25] new PIN
    /// @return command processing error code
    #[doc = " Change administrator PIN"]
    #[doc = " @param current_PIN char[25] current PIN"]
    #[doc = " @param new_PIN char[25] new PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_change_admin_PIN(
        current_PIN: *const ::std::os::raw::c_char,
        new_PIN: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Change user PIN
    /// @param current_PIN char[25] current PIN
    /// @param new_PIN char[25] new PIN
    /// @return command processing error code
    #[doc = " Change user PIN"]
    #[doc = " @param current_PIN char[25] current PIN"]
    #[doc = " @param new_PIN char[25] new PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_change_user_PIN(
        current_PIN: *const ::std::os::raw::c_char,
        new_PIN: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get retry count of user PIN
    /// @return user PIN retry count
    #[doc = " Get retry count of user PIN"]
    #[doc = " @return user PIN retry count"]
    pub fn NK_get_user_retry_count() -> u8;
}
extern "C" {
    /// Get retry count of admin PIN
    /// @return admin PIN retry count
    #[doc = " Get retry count of admin PIN"]
    #[doc = " @return admin PIN retry count"]
    pub fn NK_get_admin_retry_count() -> u8;
}
extern "C" {
    /// Enable password safe access
    /// @param user_pin char[30] current user PIN
    /// @return command processing error code
    #[doc = " Enable password safe access"]
    #[doc = " @param user_pin char[30] current user PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_enable_password_safe(
        user_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get password safe slots' status
    /// @return uint8_t[16] slot statuses - each byte represents one slot with 0 (not programmed) and 1 (programmed)
    #[doc = " Get password safe slots' status"]
    #[doc = " The return value must be freed using NK_free_password_safe_slot_status."]
    #[doc = " @return uint8_t[16] slot statuses - each byte represents one slot with 0 (not programmed) and 1 (programmed)"]
    pub fn NK_get_password_safe_slot_status() -> *mut u8;
}
extern "C" {
    /// Get password safe slot name
    /// @param slot_number password safe slot number, slot_number<16
    /// @return slot name
    #[doc = " Free a value returned by NK_get_password_safe_slot_status.  May be"]
    #[doc = " called with a NULL argument."]
    pub fn NK_free_password_safe_slot_status(status: *mut u8);
}
extern "C" {
    #[doc = " Get password safe slot name"]
    #[doc = " @param slot_number password safe slot number, slot_number<16"]
    #[doc = " @return slot name"]
    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
    #[doc = " Get password safe slot login"]
    #[doc = " @param slot_number password safe slot number, slot_number<16"]
    #[doc = " @return login from the PWS slot"]
    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
    #[doc = " Get the password safe slot password"]
    #[doc = " @param slot_number password safe slot number, slot_number<16"]
    #[doc = " @return password from the PWS slot"]
    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] name of the slot
    /// @param slot_login char[32] login string
    /// @param slot_password char[20] password string
    /// @return command processing error code
    #[doc = " Write password safe data to the slot"]
    #[doc = " @param slot_number password safe slot number, slot_number<16"]
    #[doc = " @param slot_name char[11] name of the slot"]
    #[doc = " @param slot_login char[32] login string"]
    #[doc = " @param slot_password char[20] password string"]
    #[doc = " @return command processing error code"]
    pub fn NK_write_password_safe_slot(
        slot_number: u8,
        slot_name: *const ::std::os::raw::c_char,


@@ 1093,81 580,81 @@ extern "C" {
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Erase the password safe slot from the device
    /// @param slot_number password safe slot number, slot_number<16
    /// @return command processing error code
    #[doc = " Erase the password safe slot from the device"]
    #[doc = " @param slot_number password safe slot number, slot_number<16"]
    #[doc = " @return command processing error code"]
    pub fn NK_erase_password_safe_slot(slot_number: u8) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Check whether AES is supported by the device
    /// @return 0 for no and 1 for yes
    #[doc = " Check whether AES is supported by the device"]
    #[doc = " @return 0 for no and 1 for yes"]
    pub fn NK_is_AES_supported(
        user_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get device's major firmware version
    /// @return major part of the version number (e.g. 0 from 0.48, 0 from 0.7 etc.)
    #[doc = " Get device's major firmware version"]
    #[doc = " @return major part of the version number (e.g. 0 from 0.48, 0 from 0.7 etc.)"]
    pub fn NK_get_major_firmware_version() -> u8;
}
extern "C" {
    /// Get device's minor firmware version
    /// @return minor part of the version number (e.g. 7 from 0.7, 48 from 0.48 etc.)
    #[doc = " Get device's minor firmware version"]
    #[doc = " @return minor part of the version number (e.g. 7 from 0.7, 48 from 0.48 etc.)"]
    pub fn NK_get_minor_firmware_version() -> u8;
}
extern "C" {
    /// Function to determine unencrypted volume PIN type
    /// @param minor_firmware_version
    /// @return Returns 1, if set unencrypted volume ro/rw pin type is User, 0 otherwise.
    #[doc = " Function to determine unencrypted volume PIN type"]
    #[doc = " @param minor_firmware_version"]
    #[doc = " @return Returns 1, if set unencrypted volume ro/rw pin type is User, 0 otherwise."]
    pub fn NK_set_unencrypted_volume_rorw_pin_type_user() -> ::std::os::raw::c_int;
}
extern "C" {
    /// This command is typically run to initiate
    /// communication with the device (altough not required).
    /// It sets time on device and returns its current status
    /// - a combination of set_time and get_status_storage commands
    /// Storage only
    /// @param seconds_from_epoch date and time expressed in seconds
    #[doc = " This command is typically run to initiate"]
    #[doc = " communication with the device (altough not required)."]
    #[doc = " It sets time on device and returns its current status"]
    #[doc = " - a combination of set_time and get_status_storage commands"]
    #[doc = " Storage only"]
    #[doc = " @param seconds_from_epoch date and time expressed in seconds"]
    pub fn NK_send_startup(seconds_from_epoch: u64) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Unlock encrypted volume.
    /// Storage only
    /// @param user_pin user pin 20 characters
    /// @return command processing error code
    #[doc = " Unlock encrypted volume."]
    #[doc = " Storage only"]
    #[doc = " @param user_pin user pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_unlock_encrypted_volume(
        user_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Locks encrypted volume
    /// @return command processing error code
    #[doc = " Locks encrypted volume"]
    #[doc = " @return command processing error code"]
    pub fn NK_lock_encrypted_volume() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Unlock hidden volume and lock encrypted volume.
    /// Requires encrypted volume to be unlocked.
    /// Storage only
    /// @param hidden_volume_password 20 characters
    /// @return command processing error code
    #[doc = " Unlock hidden volume and lock encrypted volume."]
    #[doc = " Requires encrypted volume to be unlocked."]
    #[doc = " Storage only"]
    #[doc = " @param hidden_volume_password 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_unlock_hidden_volume(
        hidden_volume_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Locks hidden volume
    /// @return command processing error code
    #[doc = " Locks hidden volume"]
    #[doc = " @return command processing error code"]
    pub fn NK_lock_hidden_volume() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Create hidden volume.
    /// Requires encrypted volume to be unlocked.
    /// Storage only
    /// @param slot_nr slot number in range 0-3
    /// @param start_percent volume begin expressed in percent of total available storage, int in range 0-99
    /// @param end_percent volume end expressed in percent of total available storage, int in range 1-100
    /// @param hidden_volume_password 20 characters
    /// @return command processing error code
    #[doc = " Create hidden volume."]
    #[doc = " Requires encrypted volume to be unlocked."]
    #[doc = " Storage only"]
    #[doc = " @param slot_nr slot number in range 0-3"]
    #[doc = " @param start_percent volume begin expressed in percent of total available storage, int in range 0-99"]
    #[doc = " @param end_percent volume end expressed in percent of total available storage, int in range 1-100"]
    #[doc = " @param hidden_volume_password 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_create_hidden_volume(
        slot_nr: u8,
        start_percent: u8,


@@ 1176,306 663,261 @@ extern "C" {
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make unencrypted volume read-only.
    /// Device hides unencrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Does nothing if firmware version is not matched
    /// Firmware range: Storage v0.50, v0.48 and below
    /// Storage only
    /// @param user_pin 20 characters User PIN
    /// @return command processing error code
    #[doc = " Make unencrypted volume read-only."]
    #[doc = " Device hides unencrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Does nothing if firmware version is not matched"]
    #[doc = " Firmware range: Storage v0.50, v0.48 and below"]
    #[doc = " Storage only"]
    #[doc = " @param user_pin 20 characters User PIN"]
    #[doc = " @return command processing error code"]
    #[deprecated(
        since = "3.6.0",
        note = "use `set_unencrypted_read_only_admin` instead"
    )]
    pub fn NK_set_unencrypted_read_only(
        user_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make unencrypted volume read-write.
    /// Device hides unencrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Does nothing if firmware version is not matched
    /// Firmware range: Storage v0.50, v0.48 and below
    /// Storage only
    /// @param user_pin 20 characters User PIN
    /// @return command processing error code
    #[doc = " Make unencrypted volume read-write."]
    #[doc = " Device hides unencrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Does nothing if firmware version is not matched"]
    #[doc = " Firmware range: Storage v0.50, v0.48 and below"]
    #[doc = " Storage only"]
    #[doc = " @param user_pin 20 characters User PIN"]
    #[doc = " @return command processing error code"]
    #[deprecated(
        since = "3.6.0",
        note = "use `set_unencrypted_read_write_admin` instead"
    )]
    pub fn NK_set_unencrypted_read_write(
        user_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make unencrypted volume read-only.
    /// Device hides unencrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Does nothing if firmware version is not matched
    /// Firmware range: Storage v0.49, v0.51+
    /// Storage only
    /// @param admin_pin 20 characters Admin PIN
    /// @return command processing error code
    #[doc = " Make unencrypted volume read-only."]
    #[doc = " Device hides unencrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Does nothing if firmware version is not matched"]
    #[doc = " Firmware range: Storage v0.49, v0.51+"]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters Admin PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_set_unencrypted_read_only_admin(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make unencrypted volume read-write.
    /// Device hides unencrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Does nothing if firmware version is not matched
    /// Firmware range: Storage v0.49, v0.51+
    /// Storage only
    /// @param admin_pin 20 characters Admin PIN
    /// @return command processing error code
    #[doc = " Make unencrypted volume read-write."]
    #[doc = " Device hides unencrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Does nothing if firmware version is not matched"]
    #[doc = " Firmware range: Storage v0.49, v0.51+"]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters Admin PIN"]
    #[doc = " @return command processing error code"]
    pub fn NK_set_unencrypted_read_write_admin(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make encrypted volume read-only.
    /// Device hides encrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Firmware range: v0.49 only, future (see firmware release notes)
    /// Storage only
    /// @param admin_pin 20 characters
    /// @return command processing error code
    #[doc = " Make encrypted volume read-only."]
    #[doc = " Device hides encrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Firmware range: v0.49 only, future (see firmware release notes)"]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_set_encrypted_read_only(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Make encrypted volume read-write.
    /// Device hides encrypted volume for a second therefore make sure
    /// buffers are flushed before running.
    /// Firmware range: v0.49 only, future (see firmware release notes)
    /// Storage only
    /// @param admin_pin 20 characters
    /// @return command processing error code
    #[doc = " Make encrypted volume read-write."]
    #[doc = " Device hides encrypted volume for a second therefore make sure"]
    #[doc = " buffers are flushed before running."]
    #[doc = " Firmware range: v0.49 only, future (see firmware release notes)"]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_set_encrypted_read_write(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Exports device's firmware to unencrypted volume.
    /// Storage only
    /// @param admin_pin 20 characters
    /// @return command processing error code
    #[doc = " Exports device's firmware to unencrypted volume."]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_export_firmware(admin_pin: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Clear new SD card notification. It is set after factory reset.
    /// Storage only
    /// @param admin_pin 20 characters
    /// @return command processing error code
    #[doc = " Clear new SD card notification. It is set after factory reset."]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_clear_new_sd_card_warning(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Fill SD card with random data.
    /// Should be done on first stick initialization after creating keys.
    /// Storage only
    /// @param admin_pin 20 characters
    /// @return command processing error code
    #[doc = " Fill SD card with random data."]
    #[doc = " Should be done on first stick initialization after creating keys."]
    #[doc = " Storage only"]
    #[doc = " @param admin_pin 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_fill_SD_card_with_random_data(
        admin_pin: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Change update password.
    /// Update password is used for entering update mode, where firmware
    /// could be uploaded using dfu-programmer or other means.
    /// Storage only
    /// @param current_update_password 20 characters
    /// @param new_update_password 20 characters
    /// @return command processing error code
    #[doc = " Change update password."]
    #[doc = " Update password is used for entering update mode, where firmware"]
    #[doc = " could be uploaded using dfu-programmer or other means."]
    #[doc = " Storage only"]
    #[doc = " @param current_update_password 20 characters"]
    #[doc = " @param new_update_password 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_change_update_password(
        current_update_password: *const ::std::os::raw::c_char,
        new_update_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Enter update mode. Needs update password.
    /// When device is in update mode it no longer accepts any HID commands until
    /// firmware is launched (regardless of being updated or not).
    /// Smartcard (through CCID interface) and its all volumes are not visible as well.
    /// Its VID and PID are changed to factory-default (03eb:2ff1 Atmel Corp.)
    /// to be detected by flashing software. Result of this command can be reversed
    /// by using 'launch' command.
    /// For dfu-programmer it would be: 'dfu-programmer at32uc3a3256s launch'.
    /// Storage only
    /// @param update_password 20 characters
    /// @return command processing error code
    #[doc = " Enter update mode. Needs update password."]
    #[doc = " When device is in update mode it no longer accepts any HID commands until"]
    #[doc = " firmware is launched (regardless of being updated or not)."]
    #[doc = " Smartcard (through CCID interface) and its all volumes are not visible as well."]
    #[doc = " Its VID and PID are changed to factory-default (03eb:2ff1 Atmel Corp.)"]
    #[doc = " to be detected by flashing software. Result of this command can be reversed"]
    #[doc = " by using 'launch' command."]
    #[doc = " For dfu-programmer it would be: 'dfu-programmer at32uc3a3256s launch'."]
    #[doc = " Storage only"]
    #[doc = " @param update_password 20 characters"]
    #[doc = " @return command processing error code"]
    pub fn NK_enable_firmware_update(
        update_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Get Storage stick status as string.
    /// Storage only
    /// @return string with devices attributes
    #[doc = " Get Storage stick status as string."]
    #[doc = " Storage only"]
    #[doc = " @return string with devices attributes"]
    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
    #[doc = " Get the Storage stick status and return the command processing"]
    #[doc = " error code.  If the code is zero, i. e. the command was successful,"]
    #[doc = " the storage status is written to the output pointer's target."]
    #[doc = " The output pointer must not be null."]
    #[doc = ""]
    #[doc = " @param out the output pointer for the storage status"]
    #[doc = " @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. Usable during hidden volumes creation.
    /// If the command was successful (return value 0), the usage data is
    /// written to the output pointer’s target.  The output pointer must
    /// not be null.
    /// Storage only
    /// @param out the output pointer for the usage data
    /// @return command processing error code
    #[doc = " Get SD card usage attributes. Usable during hidden volumes creation."]
    #[doc = " If the command was successful (return value 0), the usage data is"]
    #[doc = " written to the output pointer\u{2019}s target.  The output pointer must"]
    #[doc = " not be null."]
    #[doc = " Storage only"]
    #[doc = " @param out the output pointer for the usage data"]
    #[doc = " @return command processing error code"]
    pub fn NK_get_SD_usage_data(out: *mut NK_SD_usage_data) -> ::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
    #[doc = " Get SD card usage attributes as string."]
    #[doc = " Usable during hidden volumes creation."]
    #[doc = " Storage only"]
    #[doc = " @return string with SD card usage attributes"]
    pub fn NK_get_SD_usage_data_as_string() -> *mut ::std::os::raw::c_char;
}
extern "C" {
    /// Get progress value of current long operation.
    /// Storage only
    /// @return int in range 0-100 or -1 if device is not busy or -2 if an
    /// error occured
    #[doc = " Get progress value of current long operation."]
    #[doc = " Storage only"]
    #[doc = " @return int in range 0-100 or -1 if device is not busy or -2 if an"]
    #[doc = "         error occured"]
    pub fn NK_get_progress_bar_value() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Returns a list of connected devices' id's, delimited by ';' character. Empty string is returned on no device found.
    /// Each ID could consist of:
    /// 1. SC_id:SD_id_p_path (about 40 bytes)
    /// 2. path (about 10 bytes)
    /// where 'path' is USB path (bus:num), 'SC_id' is smartcard ID, 'SD_id' is storage card ID and
    /// '_p_' and ':' are field delimiters.
    /// Case 2 (USB path only) is used, when the device cannot be asked about its status data (e.g. during a long operation,
    /// like clearing SD card.
    /// Internally connects to all available devices and creates a map between ids and connection objects.
    /// Side effects: changes active device to last detected Storage device.
    /// 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
    #[doc = " Returns a list of connected devices' id's, delimited by ';' character. Empty string is returned on no device found."]
    #[doc = " Each ID could consist of:"]
    #[doc = " 1. SC_id:SD_id_p_path (about 40 bytes)"]
    #[doc = " 2. path (about 10 bytes)"]
    #[doc = " where 'path' is USB path (bus:num), 'SC_id' is smartcard ID, 'SD_id' is storage card ID and"]
    #[doc = " '_p_' and ':' are field delimiters."]
    #[doc = " Case 2 (USB path only) is used, when the device cannot be asked about its status data (e.g. during a long operation,"]
    #[doc = " like clearing SD card."]
    #[doc = " Internally connects to all available devices and creates a map between ids and connection objects."]
    #[doc = " Side effects: changes active device to last detected Storage device."]
    #[doc = " Storage only"]
    #[doc = " @example Example of returned data: '00005d19:dacc2cb4_p_0001:0010:02;000037c7:4cf12445_p_0001:000f:02;0001:000c:02'"]
    #[doc = " @return string delimited id's of connected devices"]
    pub fn NK_list_devices_by_cpuID() -> *mut ::std::os::raw::c_char;
}
extern "C" {
    /// Returns a linked list of all connected devices, or null if no devices
    /// are connected or an error occured.  The linked list must be freed by
    /// calling NK_free_device_info.
    /// @return a linked list of all connected devices
    #[doc = " Returns a linked list of all connected devices, or null if no devices"]
    #[doc = " are connected or an error occured.  The linked list must be freed by"]
    #[doc = " calling NK_free_device_info."]
    #[doc = " @return a linked list of all connected devices"]
    pub fn NK_list_devices() -> *mut NK_device_info;
}
extern "C" {
    /// Free a linked list returned by NK_list_devices.
    /// @param the linked list to free or null
    #[doc = " Free a linked list returned by NK_list_devices."]
    #[doc = " @param the linked list to free or null"]
    pub fn NK_free_device_info(device_info: *mut NK_device_info);
}
extern "C" {
    /// Connects to the device with given ID. ID's list could be created with NK_list_devices_by_cpuID.
    /// Requires calling to NK_list_devices_by_cpuID first. Connecting to arbitrary ID/USB path is not handled.
    /// On connection requests status from device and disconnects it / removes from map on connection failure.
    /// Storage only
    /// @param id Target device ID (example: '00005d19:dacc2cb4_p_0001:0010:02')
    /// @return 1 on successful connection, 0 otherwise
    #[doc = " Connects to the device with given ID. ID's list could be created with NK_list_devices_by_cpuID."]
    #[doc = " Requires calling to NK_list_devices_by_cpuID first. Connecting to arbitrary ID/USB path is not handled."]
    #[doc = " On connection requests status from device and disconnects it / removes from map on connection failure."]
    #[doc = " Storage only"]
    #[doc = " @param id Target device ID (example: '00005d19:dacc2cb4_p_0001:0010:02')"]
    #[doc = " @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" {
    /// Connects to a device with the given path.  The path is a USB device
    /// path as returned by hidapi.
    /// @param path the device path
    /// @return 1 on successful connection, 0 otherwise
    #[doc = " Connects to a device with the given path.  The path is a USB device"]
    #[doc = " path as returned by hidapi."]
    #[doc = " @param path the device path"]
    #[doc = " @return 1 on successful connection, 0 otherwise"]
    pub fn NK_connect_with_path(path: *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
    #[doc = " Blink red and green LED alternatively and infinitely (until device is reconnected)."]
    #[doc = " @return command processing error code"]
    pub fn NK_wink() -> ::std::os::raw::c_int;
}
extern "C" {
    /// Enable update mode on Nitrokey Pro.
    /// Supported from v0.11.
    /// @param update_password 20 bytes update password
    /// @return command processing error code
    #[doc = " Enable update mode on Nitrokey Pro."]
    #[doc = " Supported from v0.11."]
    #[doc = " @param update_password 20 bytes update password"]
    #[doc = " @return command processing error code"]
    pub fn NK_enable_firmware_update_pro(
        update_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    /// Change update-mode password on Nitrokey Pro.
    /// Supported from v0.11.
    /// @param current_firmware_password 20 bytes update password
    /// @param new_firmware_password 20 bytes update password
    /// @return command processing error code
    #[doc = " Change update-mode password on Nitrokey Pro."]
    #[doc = " Supported from v0.11."]
    #[doc = " @param current_firmware_password 20 bytes update password"]
    #[doc = " @param new_firmware_password 20 bytes update password"]
    #[doc = " @return command processing error code"]
    pub fn NK_change_firmware_password_pro(
        current_firmware_password: *const ::std::os::raw::c_char,
        new_firmware_password: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ReadSlot_t {
    pub slot_name: [u8; 15usize],
    pub _slot_config: u8,
    pub slot_token_id: [u8; 13usize],
    pub slot_counter: u64,
}
#[test]
fn bindgen_test_layout_ReadSlot_t() {
    assert_eq!(
        ::std::mem::size_of::<ReadSlot_t>(),
        40usize,
        concat!("Size of: ", stringify!(ReadSlot_t))
    );
    assert_eq!(
        ::std::mem::align_of::<ReadSlot_t>(),
        8usize,
        concat!("Alignment of ", stringify!(ReadSlot_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ReadSlot_t>())).slot_name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ReadSlot_t),
            "::",
            stringify!(slot_name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ReadSlot_t>()))._slot_config as *const _ as usize },
        15usize,
        concat!(
            "Offset of field: ",
            stringify!(ReadSlot_t),
            "::",
            stringify!(_slot_config)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ReadSlot_t>())).slot_token_id as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ReadSlot_t),
            "::",
            stringify!(slot_token_id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ReadSlot_t>())).slot_counter as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ReadSlot_t),
            "::",
            stringify!(slot_counter)
        )
    );
}
extern "C" {
    pub fn NK_read_HOTP_slot(slot_num: u8, out: *mut ReadSlot_t) -> ::std::os::raw::c_int;
}

M src/lib.rs => src/lib.rs +7 -1
@@ 2,10 2,15 @@
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

#[cfg(not(feature = "bindgen"))]
mod ffi;

#[cfg(not(feature = "bindgen"))]
pub use crate::ffi::*;

#[cfg(feature = "bindgen")]
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

#[cfg(test)]
mod tests {
    use super::*;


@@ 22,8 27,9 @@ mod tests {
    fn login() {
        unsafe {
            // Unconnected
            assert_eq!(0, NK_login(CString::new("S").unwrap().as_ptr()));
            assert_eq!(0, NK_login(CString::new("L").unwrap().as_ptr()));
            assert_eq!(0, NK_login(CString::new("P").unwrap().as_ptr()));
            assert_eq!(0, NK_login(CString::new("S").unwrap().as_ptr()));
            // Unsupported model
            assert_eq!(0, NK_login(CString::new("T").unwrap().as_ptr()));
        }