diff --git a/Cargo.toml b/Cargo.toml
index dedff91..7553092 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,3 +6,5 @@ edition = "2018"
license = "BSD"
[dependencies]
+libc = "0.2"
+zeroize = "1"
diff --git a/src/error.rs b/src/error.rs
index b24ac6c..e8e5d7a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,3 +1,6 @@
+// Adapted from yubico-piv-tool:
+//
+//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -25,72 +28,105 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#[derive(Clone, Copy)]
+use std::fmt;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(i32)]
-pub enum Enum2 {
- YKPIV_OK = 0i32,
- YKPIV_MEMORY_ERROR = -1i32,
- YKPIV_PCSC_ERROR = -2i32,
- YKPIV_SIZE_ERROR = -3i32,
- YKPIV_APPLET_ERROR = -4i32,
- YKPIV_AUTHENTICATION_ERROR = -5i32,
- YKPIV_RANDOMNESS_ERROR = -6i32,
- YKPIV_GENERIC_ERROR = -7i32,
- YKPIV_KEY_ERROR = -8i32,
- YKPIV_PARSE_ERROR = -9i32,
- YKPIV_WRONG_PIN = -10i32,
- YKPIV_INVALID_OBJECT = -11i32,
- YKPIV_ALGORITHM_ERROR = -12i32,
- YKPIV_PIN_LOCKED = -13i32,
- YKPIV_ARGUMENT_ERROR = -14i32,
- YKPIV_RANGE_ERROR = -15i32,
- YKPIV_NOT_SUPPORTED = -16i32,
+#[allow(non_camel_case_types)]
+pub enum ErrorKind {
+ YKPIV_OK = 0,
+ YKPIV_MEMORY_ERROR = -1,
+ YKPIV_PCSC_ERROR = -2,
+ YKPIV_SIZE_ERROR = -3,
+ YKPIV_APPLET_ERROR = -4,
+ YKPIV_AUTHENTICATION_ERROR = -5,
+ YKPIV_RANDOMNESS_ERROR = -6,
+ YKPIV_GENERIC_ERROR = -7,
+ YKPIV_KEY_ERROR = -8,
+ YKPIV_PARSE_ERROR = -9,
+ YKPIV_WRONG_PIN = -10,
+ YKPIV_INVALID_OBJECT = -11,
+ YKPIV_ALGORITHM_ERROR = -12,
+ YKPIV_PIN_LOCKED = -13,
+ YKPIV_ARGUMENT_ERROR = -14,
+ YKPIV_RANGE_ERROR = -15,
+ YKPIV_NOT_SUPPORTED = -16,
}
+impl ErrorKind {
+ /// Name of the error
+ pub fn name(self) -> &'static str {
+ match self {
+ ErrorKind::YKPIV_OK => "YKPIV_OK",
+ ErrorKind::YKPIV_MEMORY_ERROR => "YKPIV_MEMORY_ERROR",
+ ErrorKind::YKPIV_PCSC_ERROR => "YKPIV_PCSC_ERROR",
+ ErrorKind::YKPIV_SIZE_ERROR => "YKPIV_SIZE_ERROR",
+ ErrorKind::YKPIV_APPLET_ERROR => "YKPIV_APPLET_ERROR",
+ ErrorKind::YKPIV_AUTHENTICATION_ERROR => "YKPIV_AUTHENTICATION_ERROR",
+ ErrorKind::YKPIV_RANDOMNESS_ERROR => "YKPIV_RANDOMNESS_ERROR",
+ ErrorKind::YKPIV_GENERIC_ERROR => "YKPIV_GENERIC_ERROR",
+ ErrorKind::YKPIV_KEY_ERROR => "YKPIV_KEY_ERROR",
+ ErrorKind::YKPIV_PARSE_ERROR => "YKPIV_PARSE_ERROR",
+ ErrorKind::YKPIV_WRONG_PIN => "YKPIV_WRONG_PIN",
+ ErrorKind::YKPIV_INVALID_OBJECT => "YKPIV_INVALID_OBJECT",
+ ErrorKind::YKPIV_ALGORITHM_ERROR => "YKPIV_ALGORITHM_ERROR",
+ ErrorKind::YKPIV_PIN_LOCKED => "YKPIV_PIN_LOCKED",
+ ErrorKind::YKPIV_ARGUMENT_ERROR => "YKPIV_ARGUMENT_ERROR",
+ ErrorKind::YKPIV_RANGE_ERROR => "YKPIV_RANGE_ERROR",
+ ErrorKind::YKPIV_NOT_SUPPORTED => "YKPIV_NOT_SUPPORTED",
+ }
+ }
+
+ /// Error message
+ pub fn msg(self) -> &'static str {
+ match self {
+ ErrorKind::YKPIV_OK => "OK",
+ ErrorKind::YKPIV_MEMORY_ERROR => "memory error",
+ ErrorKind::YKPIV_PCSC_ERROR => "PCSC error",
+ ErrorKind::YKPIV_SIZE_ERROR => "size error",
+ ErrorKind::YKPIV_APPLET_ERROR => "applet error",
+ ErrorKind::YKPIV_AUTHENTICATION_ERROR => "authentication error",
+ ErrorKind::YKPIV_RANDOMNESS_ERROR => "randomness error",
+ ErrorKind::YKPIV_GENERIC_ERROR => "generic error",
+ ErrorKind::YKPIV_KEY_ERROR => "key error",
+ ErrorKind::YKPIV_PARSE_ERROR => "parse error",
+ ErrorKind::YKPIV_WRONG_PIN => "wrong pin",
+ ErrorKind::YKPIV_INVALID_OBJECT => "invalid object",
+ ErrorKind::YKPIV_ALGORITHM_ERROR => "algorithm error",
+ ErrorKind::YKPIV_PIN_LOCKED => "PIN locked",
+ ErrorKind::YKPIV_ARGUMENT_ERROR => "argument error",
+ ErrorKind::YKPIV_RANGE_ERROR => "range error",
+ ErrorKind::YKPIV_NOT_SUPPORTED => "not supported",
+ }
+ }
+}
+
+impl fmt::Display for ErrorKind {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str(self.msg())
+ }
+}
+
+impl std::error::Error for ErrorKind {}
+
#[derive(Copy)]
#[repr(C)]
-pub struct Struct1 {
- pub rc: Enum2,
+pub struct Error {
+ pub rc: ErrorKind,
pub name: *const u8,
pub description: *const u8,
}
-impl Clone for Struct1 {
+impl Clone for Error {
fn clone(&self) -> Self {
*self
}
}
-static mut errors: *const Struct1 = Enum2::YKPIV_OK as (*const Struct1);
-
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_strerror(mut err: Enum2) -> *const u8 {
- static mut unknown: *const u8 = (*b"Unknown ykpiv error\0").as_ptr();
- let mut p: *const u8;
- if -(err as (i32)) < 0i32
- || -(err as (i32))
- >= ::std::mem::size_of::<*const Struct1>()
- .wrapping_div(::std::mem::size_of::()) as (i32)
- {
- unknown
- } else {
- p = (*errors.offset(-(err as (i32)) as (isize))).description;
- if p.is_null() {
- p = unknown;
- }
- p
- }
+pub fn ykpiv_strerror(err: ErrorKind) -> &'static str {
+ err.msg()
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_strerror_name(mut err: Enum2) -> *const u8 {
- if -(err as (i32)) < 0i32
- || -(err as (i32))
- >= ::std::mem::size_of::<*const Struct1>()
- .wrapping_div(::std::mem::size_of::()) as (i32)
- {
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- } else {
- (*errors.offset(-(err as (i32)) as (isize))).name
- }
+pub fn ykpiv_strerror_name(err: ErrorKind) -> &'static str {
+ err.name()
}
diff --git a/src/internal.rs b/src/internal.rs
index cbd76c0..264d1f6 100644
--- a/src/internal.rs
+++ b/src/internal.rs
@@ -1,3 +1,6 @@
+// Adapted from yubico-piv-tool:
+//
+//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -25,6 +28,12 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+use libc::{
+ c_char, c_int, fclose, feof, fgets, fopen, free, getenv, malloc, memcpy, memset, strcasecmp,
+ strcmp, strlen,
+};
+use std::ptr;
+
extern "C" {
fn DES_ecb3_encrypt(
input: *mut [u8; 8],
@@ -48,39 +57,13 @@ extern "C" {
fn RAND_bytes(buf: *mut u8, num: i32) -> i32;
static mut _DefaultRuneLocale: Struct1;
fn __maskrune(arg1: i32, arg2: usize) -> i32;
- fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32;
fn __tolower(arg1: i32) -> i32;
fn __toupper(arg1: i32) -> i32;
- fn fclose(arg1: *mut __sFILE) -> i32;
- fn feof(arg1: *mut __sFILE) -> i32;
- fn fgets(arg1: *mut u8, arg2: i32, arg3: *mut __sFILE) -> *mut u8;
- fn fopen(__filename: *const u8, __mode: *const u8) -> *mut __sFILE;
- fn free(arg1: *mut ::std::os::raw::c_void);
- fn getenv(arg1: *const u8) -> *mut u8;
- fn malloc(__size: usize) -> *mut ::std::os::raw::c_void;
- fn memcpy(
- __dst: *mut ::std::os::raw::c_void,
- __src: *const ::std::os::raw::c_void,
- __n: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memset(
- __b: *mut ::std::os::raw::c_void,
- __c: i32,
- __len: usize,
- ) -> *mut ::std::os::raw::c_void;
fn snprintf(__str: *mut u8, __size: usize, __format: *const u8, ...) -> i32;
fn sscanf(arg1: *const u8, arg2: *const u8, ...) -> i32;
- fn strcasecmp(arg1: *const u8, arg2: *const u8) -> i32;
- fn strcmp(__s1: *const u8, __s2: *const u8) -> i32;
- fn strlen(__s: *const u8) -> usize;
}
-enum Union6 {}
-
-enum __sFILEX {}
-
-#[no_mangle]
-pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 {
+pub fn isascii(mut _c: i32) -> i32 {
(_c & !0x7fi32 == 0i32) as (i32)
}
@@ -151,8 +134,7 @@ impl Clone for Struct1 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __istype(mut _c: i32, mut _f: usize) -> i32 {
if isascii(_c) != 0 {
!(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32)
} else {
@@ -160,8 +142,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
if _c < 0i32 || _c >= 256i32 {
0i32
} else {
@@ -169,8 +150,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
+pub fn __wcwidth(mut _c: i32) -> i32 {
let mut _x: u32;
if _c == 0i32 {
0i32
@@ -186,113 +166,91 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 {
+pub fn isalnum(mut _c: i32) -> i32 {
__istype(_c, (0x100isize | 0x400isize) as (usize))
}
-#[no_mangle]
-pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 {
+pub fn isalpha(mut _c: i32) -> i32 {
__istype(_c, 0x100usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 {
+pub fn isblank(mut _c: i32) -> i32 {
__istype(_c, 0x20000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 {
+pub fn iscntrl(mut _c: i32) -> i32 {
__istype(_c, 0x200usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 {
+pub fn isdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 {
+pub fn isgraph(mut _c: i32) -> i32 {
__istype(_c, 0x800usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn islower(mut _c: i32) -> i32 {
+pub fn islower(mut _c: i32) -> i32 {
__istype(_c, 0x1000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 {
+pub fn isprint(mut _c: i32) -> i32 {
__istype(_c, 0x40000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 {
+pub fn ispunct(mut _c: i32) -> i32 {
__istype(_c, 0x2000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 {
+pub fn isspace(mut _c: i32) -> i32 {
__istype(_c, 0x4000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 {
+pub fn isupper(mut _c: i32) -> i32 {
__istype(_c, 0x8000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 {
+pub fn isxdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 {
+pub fn toascii(mut _c: i32) -> i32 {
_c & 0x7fi32
}
-#[no_mangle]
-pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 {
+pub fn tolower(mut _c: i32) -> i32 {
__tolower(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 {
+pub fn toupper(mut _c: i32) -> i32 {
__toupper(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 {
+pub fn digittoint(mut _c: i32) -> i32 {
__maskrune(_c, 0xfusize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 {
+pub fn ishexnumber(mut _c: i32) -> i32 {
__istype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 {
+pub fn isideogram(mut _c: i32) -> i32 {
__istype(_c, 0x80000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 {
+pub fn isnumber(mut _c: i32) -> i32 {
__istype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 {
+pub fn isphonogram(mut _c: i32) -> i32 {
__istype(_c, 0x200000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 {
+pub fn isrune(mut _c: i32) -> i32 {
__istype(_c, 0xfffffff0usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 {
+pub fn isspecial(mut _c: i32) -> i32 {
__istype(_c, 0x100000usize)
}
@@ -309,65 +267,11 @@ impl Clone for __sbuf {
}
}
-#[derive(Copy)]
-#[repr(C)]
-pub struct __sFILE {
- pub _p: *mut u8,
- pub _r: i32,
- pub _w: i32,
- pub _flags: i16,
- pub _file: i16,
- pub _bf: __sbuf,
- pub _lbfsize: i32,
- pub _cookie: *mut ::std::os::raw::c_void,
- pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32,
- pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32,
- pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize,
- pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32,
- pub _ub: __sbuf,
- pub _extra: *mut __sFILEX,
- pub _ur: i32,
- pub _ubuf: [u8; 3],
- pub _nbuf: [u8; 1],
- pub _lb: __sbuf,
- pub _blksize: i32,
- pub _offset: isize,
-}
-
-impl Clone for __sFILE {
- fn clone(&self) -> Self {
- *self
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 {
- if {
- (*_p)._w = (*_p)._w - 1;
- (*_p)._w
- } >= 0i32
- || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32))
- {
- ({
- let _rhs = _c;
- let _lhs = &mut *{
- let _old = (*_p)._p;
- (*_p)._p = (*_p)._p.offset(1isize);
- _old
- };
- *_lhs = _rhs as (u8);
- *_lhs
- }) as (i32)
- } else {
- __swbuf(_c, _p)
- }
-}
-
-#[no_mangle]
pub static mut szLOG_SOURCE: *const u8 = (*b"YubiKey PIV Library\0").as_ptr();
#[derive(Clone, Copy)]
#[repr(i32)]
+#[allow(non_camel_case_types)]
pub enum Enum5 {
DES_OK = 0i32,
DES_INVALID_PARAMETER = -1i32,
@@ -379,7 +283,7 @@ pub enum Enum5 {
#[derive(Copy)]
#[repr(C)]
pub struct DES_ks {
- pub ks: [Union6; 16],
+ pub ks: [u8; 16],
}
impl Clone for DES_ks {
@@ -390,24 +294,23 @@ impl Clone for DES_ks {
#[derive(Copy)]
#[repr(C)]
-pub struct des_key {
+pub struct DesKey {
pub ks1: DES_ks,
pub ks2: DES_ks,
pub ks3: DES_ks,
}
-impl Clone for des_key {
+impl Clone for DesKey {
fn clone(&self) -> Self {
*self
}
}
-#[no_mangle]
-pub unsafe extern "C" fn des_import_key(
+pub fn des_import_key(
type_: i32,
mut keyraw: *const u8,
keyrawlen: usize,
- mut key: *mut *mut des_key,
+ mut key: *mut *mut DesKey,
) -> Enum5 {
let mut _currentBlock;
let mut rc: Enum5 = Enum5::DES_OK;
@@ -430,7 +333,7 @@ pub unsafe extern "C" fn des_import_key(
rc = Enum5::DES_INVALID_PARAMETER;
_currentBlock = 15;
} else if {
- *key = malloc(::std::mem::size_of::()) as (*mut des_key);
+ *key = malloc(::std::mem::size_of::()) as (*mut DesKey);
*key
}
.is_null()
@@ -441,7 +344,7 @@ pub unsafe extern "C" fn des_import_key(
memset(
*key as (*mut ::std::os::raw::c_void),
0i32,
- ::std::mem::size_of::(),
+ ::std::mem::size_of::(),
);
memcpy(
key_tmp.as_mut_ptr() as (*mut ::std::os::raw::c_void),
@@ -480,23 +383,21 @@ pub unsafe extern "C" fn des_import_key(
if _currentBlock == 15 {
if !key.is_null() {
des_destroy_key(*key);
- *key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut des_key);
+ *key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut DesKey);
}
}
rc
}
-#[no_mangle]
-pub unsafe extern "C" fn des_destroy_key(mut key: *mut des_key) -> Enum5 {
+pub fn des_destroy_key(mut key: *mut DesKey) -> Enum5 {
if !key.is_null() {
free(key as (*mut ::std::os::raw::c_void));
}
Enum5::DES_OK
}
-#[no_mangle]
-pub unsafe extern "C" fn des_encrypt(
- mut key: *mut des_key,
+pub fn des_encrypt(
+ mut key: *mut DesKey,
mut in_: *const u8,
inlen: usize,
mut out: *mut u8,
@@ -518,9 +419,8 @@ pub unsafe extern "C" fn des_encrypt(
rc
}
-#[no_mangle]
-pub unsafe extern "C" fn des_decrypt(
- mut key: *mut des_key,
+pub fn des_decrypt(
+ mut key: *mut DesKey,
mut in_: *const u8,
inlen: usize,
mut out: *mut u8,
@@ -542,21 +442,20 @@ pub unsafe extern "C" fn des_decrypt(
rc
}
-#[no_mangle]
-pub unsafe extern "C" fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool {
+pub fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool {
cb_key;
DES_is_weak_key(key as (*mut [u8; 8])) != 0
}
#[derive(Clone, Copy)]
#[repr(i32)]
+#[allow(non_camel_case_types)]
pub enum Enum7 {
PRNG_OK = 0i32,
PRNG_GENERAL_ERROR = -1i32,
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 {
+pub fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 {
let mut rc: Enum7 = Enum7::PRNG_OK;
if -1i32 == RAND_bytes(buffer, cb_req as (i32)) {
rc = Enum7::PRNG_GENERAL_ERROR;
@@ -566,13 +465,13 @@ pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize
#[derive(Clone, Copy)]
#[repr(i32)]
+#[allow(non_camel_case_types)]
pub enum Enum8 {
PKCS5_OK = 0i32,
PKCS5_GENERAL_ERROR = -1i32,
}
-#[no_mangle]
-pub unsafe extern "C" fn pkcs5_pbkdf2_sha1(
+pub fn pkcs5_pbkdf2_sha1(
mut password: *const u8,
cb_password: usize,
mut salt: *const u8,
@@ -594,14 +493,13 @@ pub unsafe extern "C" fn pkcs5_pbkdf2_sha1(
rc
}
-#[no_mangle]
-pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 {
- let mut psz_head: *mut u8 = sz;
- let mut psz_tail: *mut u8 = sz
- .offset(strlen(sz as (*const u8)) as (isize))
+pub fn _strip_ws(mut sz: *mut c_char) -> *mut c_char {
+ let mut psz_head: *mut c_char = sz;
+ let mut psz_tail: *mut c_char = sz
+ .offset(strlen(sz as *const c_char) as (isize))
.offset(-1isize);
'loop1: loop {
- if isspace(*psz_head as (i32)) == 0 {
+ if isspace(*psz_head as i32) == 0 {
break;
}
psz_head = psz_head.offset(1isize);
@@ -614,150 +512,150 @@ pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 {
let _old = psz_tail;
psz_tail = psz_tail.offset(-1isize);
_old
- } = b'\0';
+ } = 0;
}
psz_head
}
-#[derive(Clone, Copy)]
-#[repr(i32)]
-pub enum _setting_source_t {
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum SettingSource {
SETTING_SOURCE_USER,
SETTING_SOURCE_ADMIN,
SETTING_SOURCE_DEFAULT,
}
#[derive(Copy)]
-#[repr(C)]
-pub struct _setting_bool_t {
+pub struct SettingBool {
pub value: bool,
- pub source: _setting_source_t,
+ pub source: SettingSource,
}
-impl Clone for _setting_bool_t {
+impl Clone for SettingBool {
fn clone(&self) -> Self {
*self
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _get_bool_config(mut sz_setting: *const u8) -> _setting_bool_t {
- let mut _currentBlock;
- let mut setting: _setting_bool_t = _setting_bool_t {
+pub unsafe fn _get_bool_config(mut sz_setting: *const c_char) -> SettingBool {
+ let mut setting: SettingBool = SettingBool {
value: false,
- source: _setting_source_t::SETTING_SOURCE_DEFAULT,
+ source: SettingSource::SETTING_SOURCE_DEFAULT,
};
- let mut sz_line: [u8; 256];
- let mut psz_name: *mut u8 = 0i32 as (*mut u8);
- let mut psz_value: *mut u8 = 0i32 as (*mut u8);
+ let mut sz_line = [0u8; 256];
+ let mut psz_name: *mut c_char = ptr::null_mut();
+ let mut psz_value: *mut c_char = ptr::null_mut();
let mut sz_name = [0u8; 256];
let mut sz_value = [0u8; 256];
- let mut pf: *mut __sFILE = 0i32 as (*mut __sFILE);
- if !{
- pf = fopen(
- (*b"/etc/yubico/yubikeypiv.conf\0").as_ptr(),
- (*b"r\0").as_ptr(),
- );
- pf
+
+ let mut pf = unsafe {
+ fopen(
+ b"/etc/yubico/yubikeypiv.conf\0".as_ptr() as *const c_char,
+ b"r\0".as_ptr() as *const c_char,
+ )
+ };
+
+ if pf.is_null() {
+ return setting;
}
- .is_null()
- {
- _currentBlock = 1;
- } else {
- _currentBlock = 10;
- }
- 'loop1: loop {
- if _currentBlock == 1 {
- if feof(pf) == 0 {
- if fgets(
- sz_line.as_mut_ptr(),
- ::std::mem::size_of::<[u8; 256]>() as (i32),
- pf,
- )
- .is_null()
- {
- _currentBlock = 1;
- continue;
- }
- if sz_line[0usize] as (i32) == b'#' as (i32) {
- _currentBlock = 1;
- continue;
- }
- if sz_line[0usize] as (i32) == b'\r' as (i32) {
- _currentBlock = 1;
- continue;
- }
- if sz_line[0usize] as (i32) == b'\n' as (i32) {
- _currentBlock = 1;
- continue;
- }
- if !(sscanf(
- sz_line.as_mut_ptr() as (*const u8),
- (*b"%255[^=]=%255s\0").as_ptr(),
- sz_name.as_mut_ptr(),
- sz_value.as_mut_ptr(),
- ) == 2i32)
- {
- _currentBlock = 1;
- continue;
- }
- psz_name = _strip_ws(sz_name.as_mut_ptr());
- if !(strcasecmp(psz_name as (*const u8), sz_setting) == 0) {
- _currentBlock = 1;
- continue;
- }
- psz_value = _strip_ws(sz_value.as_mut_ptr());
- setting.source = _setting_source_t::SETTING_SOURCE_ADMIN;
- setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0
- || strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0;
- }
- fclose(pf);
- _currentBlock = 10;
- } else {
- return setting;
+
+ while feof(pf) == 0 {
+ if fgets(
+ sz_line.as_mut_ptr() as *mut c_char,
+ sz_line.len() as c_int,
+ pf,
+ )
+ .is_null()
+ {
+ continue;
}
+
+ if sz_line[0] == b'#' {
+ continue;
+ }
+
+ if sz_line[0] == b'\r' {
+ continue;
+ }
+
+ if sz_line[0] == b'\n' {
+ continue;
+ }
+
+ if !(sscanf(
+ sz_line.as_mut_ptr(),
+ (*b"%255[^=]=%255s\0").as_ptr(),
+ sz_name.as_mut_ptr(),
+ sz_value.as_mut_ptr(),
+ ) == 2)
+ {
+ continue;
+ }
+
+ psz_name = _strip_ws(sz_name.as_mut_ptr() as *mut c_char);
+
+ if !(strcasecmp(psz_name as *const c_char, sz_setting as *const c_char) == 0) {
+ continue;
+ }
+
+ psz_value = _strip_ws(sz_value.as_mut_ptr() as *mut c_char);
+ setting.source = SettingSource::SETTING_SOURCE_ADMIN;
+ setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0
+ || strcasecmp(
+ psz_value as *const c_char,
+ b"true\0".as_ptr() as *const c_char,
+ ) == 0;
}
+
+ fclose(pf);
+ setting
}
-#[no_mangle]
-pub unsafe extern "C" fn _get_bool_env(mut sz_setting: *const u8) -> _setting_bool_t {
- let mut setting: _setting_bool_t = _setting_bool_t {
+pub fn _get_bool_env(mut sz_setting: *const c_char) -> SettingBool {
+ let mut setting: SettingBool = SettingBool {
value: false,
- source: _setting_source_t::SETTING_SOURCE_DEFAULT,
+ source: SettingSource::SETTING_SOURCE_DEFAULT,
};
- let mut psz_value: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut psz_value: *mut c_char = ptr::null_mut();
let mut sz_name = [0u8; 256];
+
snprintf(
sz_name.as_mut_ptr(),
::std::mem::size_of::<[u8; 256]>().wrapping_sub(1usize),
- (*b"%s%s\0").as_ptr(),
- (*b"YUBIKEY_PIV_\0").as_ptr(),
+ b"%s%s\0".as_ptr(),
+ b"YUBIKEY_PIV_\0".as_ptr(),
sz_setting,
);
- psz_value = getenv(sz_name.as_mut_ptr() as (*const u8));
+
+ psz_value = getenv(sz_name.as_mut_ptr() as *const c_char);
+
if !psz_value.is_null() {
- setting.source = _setting_source_t::SETTING_SOURCE_USER;
- setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0
- || strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0;
+ setting.source = SettingSource::SETTING_SOURCE_USER;
+ setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0
+ || strcasecmp(
+ psz_value as *const c_char,
+ b"true\0".as_ptr() as *const c_char,
+ ) == 0;
}
+
setting
}
-#[no_mangle]
-pub unsafe extern "C" fn setting_get_bool(
- mut sz_setting: *const u8,
- mut def: bool,
-) -> _setting_bool_t {
- let mut setting: _setting_bool_t = _setting_bool_t {
+pub fn setting_get_bool(mut sz_setting: *const c_char, mut def: bool) -> SettingBool {
+ let mut setting: SettingBool = SettingBool {
value: def,
- source: _setting_source_t::SETTING_SOURCE_DEFAULT,
+ source: SettingSource::SETTING_SOURCE_DEFAULT,
};
+
setting = _get_bool_config(sz_setting);
- if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) {
+
+ if setting.source == SettingSource::SETTING_SOURCE_DEFAULT {
setting = _get_bool_env(sz_setting);
}
- if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) {
+
+ if setting.source == SettingSource::SETTING_SOURCE_DEFAULT {
setting.value = def;
}
+
setting
}
diff --git a/src/lib.rs b/src/lib.rs
index 820acde..4f01133 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,6 @@
+// Adapted from yubico-piv-tool:
+//
+//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -28,13 +31,22 @@
pub mod error;
pub mod internal;
pub mod util;
-pub mod version;
+
+use self::{error::ErrorKind, internal::DesKey};
+use std::{convert::TryInto, ffi::CStr, mem, os::raw::c_void, ptr};
+use zeroize::Zeroize;
+
+use crate::error::ykpiv_strerror;
+use libc::{
+ c_char, calloc, free, malloc, memcmp, memcpy, memmove, memset, realloc, strchr, strlen,
+ strncasecmp, strnlen,
+};
extern "C" {
fn SCardBeginTransaction(hCard: i32) -> i32;
fn SCardConnect(
hContext: i32,
- szReader: *const u8,
+ szReader: *const c_char,
dwShareMode: u32,
dwPreferredProtocols: u32,
phCard: *mut i32,
@@ -44,15 +56,15 @@ extern "C" {
fn SCardEndTransaction(hCard: i32, dwDisposition: u32) -> i32;
fn SCardEstablishContext(
dwScope: u32,
- pvReserved1: *const ::std::os::raw::c_void,
- pvReserved2: *const ::std::os::raw::c_void,
+ pvReserved1: *const c_void,
+ pvReserved2: *const c_void,
phContext: *mut i32,
) -> i32;
fn SCardIsValidContext(hContext: i32) -> i32;
fn SCardListReaders(
hContext: i32,
- mszGroups: *const u8,
- mszReaders: *mut u8,
+ mszGroups: *const c_char,
+ mszReaders: *mut c_char,
pcchReaders: *mut u32,
) -> i32;
fn SCardReconnect(
@@ -74,14 +86,11 @@ extern "C" {
) -> i32;
static mut _DefaultRuneLocale: Struct1;
fn __maskrune(arg1: i32, arg2: usize) -> i32;
- static mut __stderrp: *mut __sFILE;
- fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32;
fn __tolower(arg1: i32) -> i32;
fn __toupper(arg1: i32) -> i32;
- fn calloc(__count: usize, __size: usize) -> *mut ::std::os::raw::c_void;
- fn des_destroy_key(key: *mut des_key) -> Enum6;
+ fn des_destroy_key(key: *mut DesKey) -> Enum6;
fn des_encrypt(
- key: *mut des_key,
+ key: *mut DesKey,
in_: *const u8,
inlen: usize,
out: *mut u8,
@@ -91,46 +100,116 @@ extern "C" {
type_: i32,
keyraw: *const u8,
keyrawlen: usize,
- key: *mut *mut des_key,
+ key: *mut *mut DesKey,
) -> Enum6;
- fn fprintf(arg1: *mut __sFILE, arg2: *const u8, ...) -> i32;
- fn free(arg1: *mut ::std::os::raw::c_void);
- fn memcmp(
- __s1: *const ::std::os::raw::c_void,
- __s2: *const ::std::os::raw::c_void,
- __n: usize,
- ) -> i32;
- fn memcpy(
- __dst: *mut ::std::os::raw::c_void,
- __src: *const ::std::os::raw::c_void,
- __n: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memmove(
- __dst: *mut ::std::os::raw::c_void,
- __src: *const ::std::os::raw::c_void,
- __len: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memset(
- __b: *mut ::std::os::raw::c_void,
- __c: i32,
- __len: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memset_s(__s: *mut ::std::os::raw::c_void, __smax: usize, __c: i32, __n: usize) -> i32;
- fn realloc(__ptr: *mut ::std::os::raw::c_void, __size: usize) -> *mut ::std::os::raw::c_void;
+ fn memset_s(__s: *mut c_void, __smax: usize, __c: i32, __n: usize) -> i32;
fn snprintf(__str: *mut u8, __size: usize, __format: *const u8, ...) -> i32;
- fn strchr(__s: *const u8, __c: i32) -> *mut u8;
- fn strlen(__s: *const u8) -> usize;
- fn strncasecmp(arg1: *const u8, arg2: *const u8, arg3: usize) -> i32;
- fn strnlen(__s1: *const u8, __n: usize) -> usize;
fn yk_des_is_weak_key(key: *const u8, cb_key: usize) -> bool;
- fn ykpiv_strerror(err: Enum5) -> *const u8;
}
-enum __sFILEX {}
+pub const DES_TYPE_3DES: u8 = 1;
-enum des_key {}
+pub const DES_LEN_DES: usize = 8;
+pub const DES_LEN_3DES: usize = DES_LEN_DES * 3;
-enum u_APDU {}
+pub const YKPIV_ALGO_TAG: u8 = 0x80;
+pub const YKPIV_ALGO_3DES: u8 = 0x03;
+pub const YKPIV_ALGO_RSA1024: u8 = 0x06;
+pub const YKPIV_ALGO_RSA2048: u8 = 0x07;
+pub const YKPIV_ALGO_ECCP256: u8 = 0x11;
+pub const YKPIV_ALGO_ECCP384: u8 = 0x14;
+
+pub const YKPIV_KEY_AUTHENTICATION: u8 = 0x9a;
+pub const YKPIV_KEY_CARDMGM: u8 = 0x9b;
+pub const YKPIV_KEY_SIGNATURE: u8 = 0x9c;
+pub const YKPIV_KEY_KEYMGM: u8 = 0x9d;
+pub const YKPIV_KEY_CARDAUTH: u8 = 0x9e;
+pub const YKPIV_KEY_RETIRED1: u8 = 0x82;
+pub const YKPIV_KEY_RETIRED2: u8 = 0x83;
+pub const YKPIV_KEY_RETIRED3: u8 = 0x84;
+pub const YKPIV_KEY_RETIRED4: u8 = 0x85;
+pub const YKPIV_KEY_RETIRED5: u8 = 0x86;
+pub const YKPIV_KEY_RETIRED6: u8 = 0x87;
+pub const YKPIV_KEY_RETIRED7: u8 = 0x88;
+pub const YKPIV_KEY_RETIRED8: u8 = 0x89;
+pub const YKPIV_KEY_RETIRED9: u8 = 0x8a;
+pub const YKPIV_KEY_RETIRED10: u8 = 0x8b;
+pub const YKPIV_KEY_RETIRED11: u8 = 0x8c;
+pub const YKPIV_KEY_RETIRED12: u8 = 0x8d;
+pub const YKPIV_KEY_RETIRED13: u8 = 0x8e;
+pub const YKPIV_KEY_RETIRED14: u8 = 0x8f;
+pub const YKPIV_KEY_RETIRED15: u8 = 0x90;
+pub const YKPIV_KEY_RETIRED16: u8 = 0x91;
+pub const YKPIV_KEY_RETIRED17: u8 = 0x92;
+pub const YKPIV_KEY_RETIRED18: u8 = 0x93;
+pub const YKPIV_KEY_RETIRED19: u8 = 0x94;
+pub const YKPIV_KEY_RETIRED20: u8 = 0x95;
+pub const YKPIV_KEY_ATTESTATION: u8 = 0xf9;
+
+pub const YKPIV_INS_VERIFY: u8 = 0x20;
+pub const YKPIV_INS_CHANGE_REFERENCE: u8 = 0x24;
+pub const YKPIV_INS_RESET_RETRY: u8 = 0x2c;
+pub const YKPIV_INS_GENERATE_ASYMMETRIC: u8 = 0x47;
+pub const YKPIV_INS_AUTHENTICATE: u8 = 0x87;
+pub const YKPIV_INS_GET_DATA: u8 = 0xcb;
+pub const YKPIV_INS_PUT_DATA: u8 = 0xdb;
+pub const YKPIV_INS_SELECT_APPLICATION: u8 = 0xa4;
+pub const YKPIV_INS_GET_RESPONSE_APDU: u8 = 0xc0;
+
+// Yubico vendor specific instructions
+pub const YKPIV_INS_SET_MGMKEY: u8 = 0xff;
+pub const YKPIV_INS_IMPORT_KEY: u8 = 0xfe;
+pub const YKPIV_INS_GET_VERSION: u8 = 0xfd;
+pub const YKPIV_INS_RESET: u8 = 0xfb;
+pub const YKPIV_INS_SET_PIN_RETRIES: u8 = 0xfa;
+pub const YKPIV_INS_ATTEST: u8 = 0xf9;
+pub const YKPIV_INS_GET_SERIAL: u8 = 0xf8;
+
+/// Application Protocol Data Unit
+#[derive(Clone)]
+pub struct APDU {
+ /// Instruction class - indicates the type of command, e.g. interindustry or proprietary
+ pub cla: u8,
+
+ /// Instruction code - indicates the specific command, e.g. "write data"
+ pub ins: u8,
+
+ /// Instruction parameter 1 for the command, e.g. offset into file at which to write the data
+ pub p1: u8,
+
+ /// Instruction parameter 2 for the command
+ pub p2: u8,
+
+ /// Length of command - encodes the number of bytes of command data to follow
+ pub lc: u8,
+
+ /// Command data
+ pub data: [u8; 255],
+}
+
+impl Default for APDU {
+ fn default() -> Self {
+ Self {
+ cla: 0,
+ ins: 0,
+ p1: 0,
+ p2: 0,
+ lc: 0,
+ data: [0u8; 255],
+ }
+ }
+}
+
+impl Zeroize for APDU {
+ fn zeroize(&mut self) {
+ self.cla.zeroize();
+ self.ins.zeroize();
+ self.p1.zeroize();
+ self.p2.zeroize();
+ self.lc.zeroize();
+ self.data.zeroize();
+ }
+}
#[derive(Copy)]
#[repr(C)]
@@ -145,62 +224,7 @@ impl Clone for __sbuf {
}
}
-#[derive(Copy)]
-#[repr(C)]
-pub struct __sFILE {
- pub _p: *mut u8,
- pub _r: i32,
- pub _w: i32,
- pub _flags: i16,
- pub _file: i16,
- pub _bf: __sbuf,
- pub _lbfsize: i32,
- pub _cookie: *mut ::std::os::raw::c_void,
- pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32,
- pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32,
- pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize,
- pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32,
- pub _ub: __sbuf,
- pub _extra: *mut __sFILEX,
- pub _ur: i32,
- pub _ubuf: [u8; 3],
- pub _nbuf: [u8; 1],
- pub _lb: __sbuf,
- pub _blksize: i32,
- pub _offset: isize,
-}
-
-impl Clone for __sFILE {
- fn clone(&self) -> Self {
- *self
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 {
- if {
- (*_p)._w = (*_p)._w - 1;
- (*_p)._w
- } >= 0i32
- || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32))
- {
- ({
- let _rhs = _c;
- let _lhs = &mut *{
- let _old = (*_p)._p;
- (*_p)._p = (*_p)._p.offset(1isize);
- _old
- };
- *_lhs = _rhs as (u8);
- *_lhs
- }) as (i32)
- } else {
- __swbuf(_c, _p)
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 {
+pub fn isascii(mut _c: i32) -> i32 {
(_c & !0x7fi32 == 0i32) as (i32)
}
@@ -250,8 +274,8 @@ impl Clone for Struct4 {
pub struct Struct1 {
pub __magic: [u8; 8],
pub __encoding: [u8; 32],
- pub __sgetrune: unsafe extern "C" fn(*const u8, usize, *mut *const u8) -> i32,
- pub __sputrune: unsafe extern "C" fn(i32, *mut u8, usize, *mut *mut u8) -> i32,
+ pub __sgetrune: unsafe fn(*const u8, usize, *mut *const u8) -> i32,
+ pub __sputrune: unsafe fn(i32, *mut u8, usize, *mut *mut u8) -> i32,
pub __invalid_rune: i32,
pub __runetype: [u32; 256],
pub __maplower: [i32; 256],
@@ -259,7 +283,7 @@ pub struct Struct1 {
pub __runetype_ext: Struct2,
pub __maplower_ext: Struct2,
pub __mapupper_ext: Struct2,
- pub __variable: *mut ::std::os::raw::c_void,
+ pub __variable: *mut c_void,
pub __variable_len: i32,
pub __ncharclasses: i32,
pub __charclasses: *mut Struct4,
@@ -271,8 +295,7 @@ impl Clone for Struct1 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __istype(mut _c: i32, mut _f: usize) -> i32 {
if isascii(_c) != 0 {
!(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32)
} else {
@@ -280,8 +303,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
if _c < 0i32 || _c >= 256i32 {
0i32
} else {
@@ -289,8 +311,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
+pub fn __wcwidth(mut _c: i32) -> i32 {
let mut _x: u32;
if _c == 0i32 {
0i32
@@ -306,113 +327,91 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 {
+pub fn isalnum(mut _c: i32) -> i32 {
__istype(_c, (0x100isize | 0x400isize) as (usize))
}
-#[no_mangle]
-pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 {
+pub fn isalpha(mut _c: i32) -> i32 {
__istype(_c, 0x100usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 {
+pub fn isblank(mut _c: i32) -> i32 {
__istype(_c, 0x20000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 {
+pub fn iscntrl(mut _c: i32) -> i32 {
__istype(_c, 0x200usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 {
+pub fn isdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 {
+pub fn isgraph(mut _c: i32) -> i32 {
__istype(_c, 0x800usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn islower(mut _c: i32) -> i32 {
+pub fn islower(mut _c: i32) -> i32 {
__istype(_c, 0x1000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 {
+pub fn isprint(mut _c: i32) -> i32 {
__istype(_c, 0x40000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 {
+pub fn ispunct(mut _c: i32) -> i32 {
__istype(_c, 0x2000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 {
+pub fn isspace(mut _c: i32) -> i32 {
__istype(_c, 0x4000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 {
+pub fn isupper(mut _c: i32) -> i32 {
__istype(_c, 0x8000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 {
+pub fn isxdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 {
+pub fn toascii(mut _c: i32) -> i32 {
_c & 0x7fi32
}
-#[no_mangle]
-pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 {
+pub fn tolower(mut _c: i32) -> i32 {
__tolower(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 {
+pub fn toupper(mut _c: i32) -> i32 {
__toupper(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 {
+pub fn digittoint(mut _c: i32) -> i32 {
__maskrune(_c, 0xfusize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 {
+pub fn ishexnumber(mut _c: i32) -> i32 {
__istype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 {
+pub fn isideogram(mut _c: i32) -> i32 {
__istype(_c, 0x80000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 {
+pub fn isnumber(mut _c: i32) -> i32 {
__istype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 {
+pub fn isphonogram(mut _c: i32) -> i32 {
__istype(_c, 0x200000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 {
+pub fn isrune(mut _c: i32) -> i32 {
__istype(_c, 0xfffffff0usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 {
+pub fn isspecial(mut _c: i32) -> i32 {
__istype(_c, 0x100000usize)
}
@@ -421,15 +420,10 @@ static mut aid: *const u8 = 0xa0i32 as (*const u8);
#[derive(Copy)]
#[repr(C)]
pub struct ykpiv_allocator {
- pub pfn_alloc:
- unsafe extern "C" fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void,
- pub pfn_realloc: unsafe extern "C" fn(
- *mut ::std::os::raw::c_void,
- *mut ::std::os::raw::c_void,
- usize,
- ) -> *mut ::std::os::raw::c_void,
- pub pfn_free: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void),
- pub alloc_data: *mut ::std::os::raw::c_void,
+ pub pfn_alloc: unsafe fn(*mut c_void, usize) -> *mut c_void,
+ pub pfn_realloc: unsafe fn(*mut c_void, *mut c_void, usize) -> *mut c_void,
+ pub pfn_free: unsafe fn(*mut c_void, *mut c_void),
+ pub alloc_data: *mut c_void,
}
impl Clone for ykpiv_allocator {
@@ -438,37 +432,30 @@ impl Clone for ykpiv_allocator {
}
}
-unsafe extern "C" fn _default_alloc(
- mut data: *mut ::std::os::raw::c_void,
- mut cb: usize,
-) -> *mut ::std::os::raw::c_void {
+unsafe fn _default_alloc(mut data: *mut c_void, mut cb: usize) -> *mut c_void {
data;
calloc(cb, 1usize)
}
-unsafe extern "C" fn _default_realloc(
- mut data: *mut ::std::os::raw::c_void,
- mut p: *mut ::std::os::raw::c_void,
+unsafe fn _default_realloc(
+ mut data: *mut c_void,
+ mut p: *mut c_void,
mut cb: usize,
-) -> *mut ::std::os::raw::c_void {
+) -> *mut c_void {
data;
realloc(p, cb)
}
-unsafe extern "C" fn _default_free(
- mut data: *mut ::std::os::raw::c_void,
- mut p: *mut ::std::os::raw::c_void,
-) {
+unsafe fn _default_free(mut data: *mut c_void, mut p: *mut c_void) {
data;
free(p);
}
-#[no_mangle]
pub static mut _default_allocator: ykpiv_allocator = ykpiv_allocator {
pfn_alloc: _default_alloc,
pfn_realloc: _default_realloc,
pfn_free: _default_free,
- alloc_data: 0i32 as (*mut ::std::os::raw::c_void),
+ alloc_data: 0i32 as (*mut c_void),
};
#[derive(Copy)]
@@ -504,44 +491,7 @@ impl Clone for ykpiv_state {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_alloc(
- mut state: *mut ykpiv_state,
- mut size: usize,
-) -> *mut ::std::os::raw::c_void {
- if state.is_null() || (*state).allocator.pfn_alloc == 0 {
- 0i32 as (*mut ::std::os::raw::c_void)
- } else {
- ((*state).allocator.pfn_alloc)((*state).allocator.alloc_data, size)
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_realloc(
- mut state: *mut ykpiv_state,
- mut address: *mut ::std::os::raw::c_void,
- mut size: usize,
-) -> *mut ::std::os::raw::c_void {
- if state.is_null() || (*state).allocator.pfn_realloc == 0 {
- 0i32 as (*mut ::std::os::raw::c_void)
- } else {
- ((*state).allocator.pfn_realloc)((*state).allocator.alloc_data, address, size)
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_free(
- mut state: *mut ykpiv_state,
- mut data: *mut ::std::os::raw::c_void,
-) {
- if data.is_null() || state.is_null() || (*state).allocator.pfn_free == 0 {
- } else {
- ((*state).allocator.pfn_free)((*state).allocator.alloc_data, data);
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usize) -> u32 {
+pub fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usize) -> u32 {
if length < 0x80usize {
*{
let _old = buffer;
@@ -581,8 +531,7 @@ pub unsafe extern "C" fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usiz
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut usize) -> u32 {
+pub fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut usize) -> u32 {
if *buffer.offset(0isize) as (i32) < 0x81i32 {
*len = *buffer.offset(0isize) as (usize);
1u32
@@ -598,8 +547,7 @@ pub unsafe extern "C" fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len: usize) -> bool {
+pub fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len: usize) -> bool {
if *buffer.offset(0isize) as (i32) < 0x81i32 && (len > 0usize) {
true
} else if *buffer as (i32) & 0x7fi32 == 1i32 && (len > 1usize) {
@@ -611,68 +559,32 @@ pub unsafe extern "C" fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len:
}
}
-#[derive(Clone, Copy)]
-#[repr(i32)]
-pub enum Enum5 {
- YKPIV_OK = 0i32,
- YKPIV_MEMORY_ERROR = -1i32,
- YKPIV_PCSC_ERROR = -2i32,
- YKPIV_SIZE_ERROR = -3i32,
- YKPIV_APPLET_ERROR = -4i32,
- YKPIV_AUTHENTICATION_ERROR = -5i32,
- YKPIV_RANDOMNESS_ERROR = -6i32,
- YKPIV_GENERIC_ERROR = -7i32,
- YKPIV_KEY_ERROR = -8i32,
- YKPIV_PARSE_ERROR = -9i32,
- YKPIV_WRONG_PIN = -10i32,
- YKPIV_INVALID_OBJECT = -11i32,
- YKPIV_ALGORITHM_ERROR = -12i32,
- YKPIV_PIN_LOCKED = -13i32,
- YKPIV_ARGUMENT_ERROR = -14i32,
- YKPIV_RANGE_ERROR = -15i32,
- YKPIV_NOT_SUPPORTED = -16i32,
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_init_with_allocator(
+pub fn ykpiv_init_with_allocator(
mut state: *mut *mut ykpiv_state,
mut verbose: i32,
mut allocator: *const ykpiv_allocator,
-) -> Enum5 {
+) -> ErrorKind {
let mut s: *mut ykpiv_state;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*const ykpiv_allocator) == allocator
- || (*allocator).pfn_alloc == 0
- || (*allocator).pfn_realloc == 0
- || (*allocator).pfn_free == 0
- {
- Enum5::YKPIV_MEMORY_ERROR
+ if 0i32 as (*mut c_void) as (*mut *mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
- s = ((*allocator).pfn_alloc)(
- (*allocator).alloc_data,
- ::std::mem::size_of::(),
- ) as (*mut ykpiv_state);
- (if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == s {
- Enum5::YKPIV_MEMORY_ERROR
+ s = malloc(mem::size_of::()) as (*mut ykpiv_state);
+
+ (if 0i32 as (*mut c_void) as (*mut ykpiv_state) == s {
+ ErrorKind::YKPIV_MEMORY_ERROR
} else {
- memset(
- s as (*mut ::std::os::raw::c_void),
- 0i32,
- ::std::mem::size_of::(),
- );
- (*s).pin = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ memset(s as (*mut c_void), 0i32, mem::size_of::());
+ (*s).pin = 0i32 as (*mut c_void) as (*mut u8);
(*s).allocator = *allocator;
(*s).verbose = verbose;
(*s).context = -1i32;
*state = s;
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbose: i32) -> Enum5 {
+pub fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbose: i32) -> ErrorKind {
ykpiv_init_with_allocator(
state,
verbose,
@@ -680,31 +592,25 @@ pub unsafe extern "C" fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbos
)
}
-unsafe extern "C" fn _ykpiv_done(mut state: *mut ykpiv_state, mut disconnect: bool) -> Enum5 {
+unsafe fn _ykpiv_done(mut state: *mut ykpiv_state, mut disconnect: bool) -> ErrorKind {
if disconnect {
ykpiv_disconnect(state);
}
- _cache_pin(
- state,
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
- 0usize,
- );
- _ykpiv_free(state, state as (*mut ::std::os::raw::c_void));
- Enum5::YKPIV_OK
+
+ _cache_pin(state, ptr::null(), 0usize);
+ free(state as *mut c_void);
+ ErrorKind::YKPIV_OK
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_done_with_external_card(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn ykpiv_done_with_external_card(mut state: *mut ykpiv_state) -> ErrorKind {
_ykpiv_done(state, false)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_done(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn ykpiv_done(mut state: *mut ykpiv_state) -> ErrorKind {
_ykpiv_done(state, true)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> ErrorKind {
if (*state).card != 0 {
SCardDisconnect((*state).card, 0x1u32);
(*state).card = 0i32;
@@ -713,16 +619,15 @@ pub unsafe extern "C" fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> Enum5
SCardReleaseContext((*state).context);
(*state).context = -1i32;
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_select_application(mut state: *mut ykpiv_state) -> Enum5 {
- let mut apdu: u_APDU;
+pub fn _ykpiv_select_application(mut state: *mut ykpiv_state) -> ErrorKind {
+ let mut apdu: APDU;
let mut data: [u8; 255];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32);
let mut sw: i32;
- let mut res: Enum5 = Enum5::YKPIV_OK;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
// FIXME(tarcieri): translate APDU construction
/*
@@ -736,110 +641,92 @@ pub unsafe extern "C" fn _ykpiv_select_application(mut state: *mut ykpiv_state)
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
}
res
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed selecting application: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed selecting application: {:04x}", sw);
}
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
- res = _ykpiv_get_version(
- state,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_version_t),
- );
- if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ res = _ykpiv_get_version(state, 0i32 as (*mut c_void) as (*mut _ykpiv_version_t));
+ if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to retrieve version: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
- );
+ eprintln!("Failed to retrieve version: \'{}\'", ykpiv_strerror(res));
}
}
- res = _ykpiv_get_serial(
- state,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32),
- false,
- );
- if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ res = _ykpiv_get_serial(state, 0i32 as (*mut c_void) as (*mut u32), false);
+ if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to retrieve serial number: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed to retrieve serial number: \'{}\'",
+ ykpiv_strerror(res)
);
}
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
}
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_ensure_application_selected(mut state: *mut ykpiv_state) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn _ykpiv_ensure_application_selected(mut state: *mut ykpiv_state) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
state;
res
}
-unsafe extern "C" fn _ykpiv_connect(
+unsafe fn _ykpiv_connect(
mut state: *mut ykpiv_state,
mut context: usize,
mut card: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else if context != (*state).context as (usize)
&& (0x0i32 != SCardIsValidContext(context as (i32)))
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
if card != (*state).card as (usize) {
let mut reader: [u8; 3072];
- let mut reader_len: u32 = ::std::mem::size_of::<[u8; 3072]>() as (u32);
+ let mut reader_len: u32 = mem::size_of::<[u8; 3072]>() as (u32);
let mut atr: [u8; 33];
- let mut atr_len: u32 = ::std::mem::size_of::<[u8; 33]>() as (u32);
+ let mut atr_len: u32 = mem::size_of::<[u8; 33]>() as (u32);
if 0x0i32
!= SCardStatus(
card as (i32),
reader.as_mut_ptr(),
&mut reader_len as (*mut u32),
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32),
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32),
+ 0i32 as (*mut c_void) as (*mut u32),
+ 0i32 as (*mut c_void) as (*mut u32),
atr.as_mut_ptr(),
&mut atr_len as (*mut u32),
)
{
- return Enum5::YKPIV_PCSC_ERROR;
+ return ErrorKind::YKPIV_PCSC_ERROR;
} else {
- (*state).isNEO = ::std::mem::size_of::<[u8; 23]>().wrapping_sub(1usize)
+ (*state).isNEO = mem::size_of::<[u8; 23]>().wrapping_sub(1usize)
== atr_len as (usize)
&& (0i32
== memcmp(
(*b";\xFC\x13\0\0\x811\xFE\x15YubikeyNEOr3\xE1\0").as_ptr()
- as (*const ::std::os::raw::c_void),
- atr.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ as (*const c_void),
+ atr.as_mut_ptr() as (*const c_void),
atr_len as (usize),
));
}
@@ -850,33 +737,28 @@ unsafe extern "C" fn _ykpiv_connect(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_connect_with_external_card(
+pub fn ykpiv_connect_with_external_card(
mut state: *mut ykpiv_state,
mut context: usize,
mut card: usize,
-) -> Enum5 {
+) -> ErrorKind {
_ykpiv_connect(state, context, card)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_connect(
- mut state: *mut ykpiv_state,
- mut wanted: *const u8,
-) -> Enum5 {
+pub fn ykpiv_connect(mut state: *mut ykpiv_state, mut wanted: *const c_char) -> ErrorKind {
let mut _currentBlock;
let mut active_protocol: u32;
- let mut reader_buf: [u8; 2048];
- let mut num_readers: usize = ::std::mem::size_of::<[u8; 2048]>();
+ let mut reader_buf: [c_char; 2048];
+ let mut num_readers: usize = mem::size_of::<[u8; 2048]>();
let mut rc: isize;
- let mut reader_ptr: *mut u8;
+ let mut reader_ptr: *mut c_char;
let mut card: i32 = -1i32;
- let mut ret: Enum5 = ykpiv_list_readers(
+ let mut ret: ErrorKind = ykpiv_list_readers(
state,
reader_buf.as_mut_ptr(),
&mut num_readers as (*mut usize),
);
- if ret as (i32) != Enum5::YKPIV_OK as (i32) {
+ if ret as (i32) != ErrorKind::YKPIV_OK as (i32) {
ret
} else {
reader_ptr = reader_buf.as_mut_ptr();
@@ -886,14 +768,14 @@ pub unsafe extern "C" fn ykpiv_connect(
break;
}
if !wanted.is_null() {
- let mut ptr: *mut u8 = reader_ptr;
+ let mut ptr = reader_ptr as *const c_char;
let mut found: bool = false;
'loop10: loop {
- if strlen(ptr as (*const u8)) < strlen(wanted) {
+ if strlen(ptr) < strlen(wanted) {
_currentBlock = 14;
break;
}
- if strncasecmp(ptr as (*const u8), wanted, strlen(wanted)) == 0i32 {
+ if strncasecmp(ptr, wanted, strlen(wanted)) == 0i32 {
_currentBlock = 13;
break;
}
@@ -912,12 +794,10 @@ pub unsafe extern "C" fn ykpiv_connect(
}
if found as (i32) == 0i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"skipping reader \'%s\' since it doesn\'t match \'%s\'.\n\0")
- .as_ptr(),
- reader_ptr,
- wanted,
+ eprintln!(
+ "skipping reader \'{}\' since it doesn\'t match \'{}\'.",
+ CStr::from_ptr(reader_ptr).to_string_lossy(),
+ CStr::from_ptr(wanted).to_string_lossy()
);
_currentBlock = 26;
} else {
@@ -931,15 +811,14 @@ pub unsafe extern "C" fn ykpiv_connect(
}
if _currentBlock == 15 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"trying to connect to reader \'%s\'.\n\0").as_ptr(),
- reader_ptr,
+ eprintln!(
+ "trying to connect to reader \'{}\'.",
+ CStr::from_ptr(reader_ptr).to_string_lossy()
);
}
rc = SCardConnect(
(*state).context,
- reader_ptr as (*const u8),
+ reader_ptr as *const c_char,
0x2u32,
0x2u32,
&mut card as (*mut i32),
@@ -947,39 +826,34 @@ pub unsafe extern "C" fn ykpiv_connect(
) as (isize);
if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"SCardConnect failed, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("SCardConnect failed, rc={}", rc);
}
- } else if Enum5::YKPIV_OK as (i32)
+ } else if ErrorKind::YKPIV_OK as (i32)
== _ykpiv_connect(state, (*state).context as (usize), card as (usize)) as (i32)
{
_currentBlock = 19;
break;
}
}
- reader_ptr = reader_ptr
- .offset(strlen(reader_ptr as (*const u8)).wrapping_add(1usize) as (isize));
+ reader_ptr = reader_ptr.offset(strlen(reader_ptr).wrapping_add(1usize) as (isize));
}
(if _currentBlock == 3 {
(if *reader_ptr as (i32) == b'\0' as (i32) {
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"error: no usable reader found.\n\0").as_ptr());
+ eprintln!("error: no usable reader found.");
}
SCardReleaseContext((*state).context);
(*state).context = -1i32;
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
- } else if Enum5::YKPIV_OK as (i32) != {
+ } else if ErrorKind::YKPIV_OK as (i32) != {
ret = _ykpiv_begin_transaction(state);
ret
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
ret = _ykpiv_select_application(state);
_ykpiv_end_transaction(state);
@@ -988,49 +862,40 @@ pub unsafe extern "C" fn ykpiv_connect(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_list_readers(
+pub fn ykpiv_list_readers(
mut state: *mut ykpiv_state,
- mut readers: *mut u8,
+ mut readers: *mut c_char,
mut len: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut num_readers: u32 = 0u32;
let mut rc: isize;
if SCardIsValidContext((*state).context) != 0x0i32 {
rc = SCardEstablishContext(
0x2u32,
- 0i32 as (*mut ::std::os::raw::c_void) as (*const ::std::os::raw::c_void),
- 0i32 as (*mut ::std::os::raw::c_void) as (*const ::std::os::raw::c_void),
+ 0i32 as (*mut c_void) as (*const c_void),
+ 0i32 as (*mut c_void) as (*const c_void),
&mut (*state).context as (*mut i32),
) as (isize);
if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"error: SCardEstablishContext failed, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("error: SCardEstablishContext failed, rc={}", rc);
}
- return Enum5::YKPIV_PCSC_ERROR;
+ return ErrorKind::YKPIV_PCSC_ERROR;
}
}
rc = SCardListReaders(
(*state).context,
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
+ ptr::null(),
+ ptr::null_mut(),
&mut num_readers as (*mut u32),
) as (isize);
if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"error: SCardListReaders failed, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("error: SCardListReaders failed, rc={}", rc);
}
SCardReleaseContext((*state).context);
(*state).context = -1i32;
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
if num_readers as (usize) > *len {
num_readers = *len as (u32);
@@ -1039,38 +904,31 @@ pub unsafe extern "C" fn ykpiv_list_readers(
}
rc = SCardListReaders(
(*state).context,
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
+ ptr::null(),
readers,
&mut num_readers as (*mut u32),
) as (isize);
(if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"error: SCardListReaders failed, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("error: SCardListReaders failed, rc={}", rc);
}
SCardReleaseContext((*state).context);
(*state).context = -1i32;
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
*len = num_readers as (usize);
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
}
}
-unsafe extern "C" fn reconnect(mut state: *mut ykpiv_state) -> Enum5 {
+unsafe fn reconnect(mut state: *mut ykpiv_state) -> ErrorKind {
let mut active_protocol: u32 = 0u32;
let mut rc: isize;
- let mut res: Enum5;
+ let mut res: ErrorKind;
let mut tries: i32;
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"trying to reconnect to current reader.\n\0").as_ptr(),
- );
+ eprintln!("trying to reconnect to current reader.");
}
rc = SCardReconnect(
(*state).card,
@@ -1081,38 +939,37 @@ unsafe extern "C" fn reconnect(mut state: *mut ykpiv_state) -> Enum5 {
) as (isize);
if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"SCardReconnect failed, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("SCardReconnect failed, rc={}", rc);
}
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else if {
res = _ykpiv_select_application(state);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
res
} else if !(*state).pin.is_null() {
- ykpiv_verify(state, (*state).pin as (*const u8), &mut tries as (*mut i32))
+ ykpiv_verify(
+ state,
+ (*state).pin as *const c_char,
+ &mut tries as (*mut i32),
+ )
} else {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -> ErrorKind {
let mut rc: isize;
rc = SCardBeginTransaction((*state).card) as (isize);
if (rc as (usize) & 0xffffffffusize) as (isize) as (usize) == 0x80100068usize {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
if {
res = reconnect(state);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
return res;
} else {
@@ -1121,35 +978,25 @@ pub unsafe extern "C" fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -
}
if rc != 0x0isize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"error: Failed to begin pcsc transaction, rc=%08lx\n\0").as_ptr(),
- rc,
- );
+ eprintln!("error: Failed to begin pcsc transaction, rc={}", rc);
}
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_end_transaction(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn _ykpiv_end_transaction(mut state: *mut ykpiv_state) -> ErrorKind {
let mut rc: isize = SCardEndTransaction((*state).card, 0x0u32) as (isize);
if rc != 0x0isize && ((*state).verbose != 0) {
- fprintf(
- __stderrp,
- (*b"error: Failed to end pcsc transaction, rc=%08lx\n\0").as_ptr(),
- rc,
- );
- Enum5::YKPIV_PCSC_ERROR
+ eprintln!("error: Failed to end pcsc transaction, rc={}", rc);
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_transfer_data(
+pub fn _ykpiv_transfer_data(
mut state: *mut ykpiv_state,
mut templ: *const u8,
mut in_data: *const u8,
@@ -1157,47 +1004,48 @@ pub unsafe extern "C" fn _ykpiv_transfer_data(
mut out_data: *mut u8,
mut out_len: *mut usize,
mut sw: *mut i32,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut in_ptr: *const u8 = in_data;
let mut max_out: usize = *out_len;
- let mut res: Enum5;
+ let mut res: ErrorKind;
+ let mut recv_len: u32;
*out_len = 0usize;
'loop1: loop {
let mut this_size: usize = 0xffusize;
let mut data: [u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
- let mut apdu: u_APDU;
- // FIXME(tarcieri): translate APDU code
- /*
- memset(apdu.raw, 0, sizeof(apdu.raw));
- memcpy(apdu.raw, templ, 4);
- if(in_ptr + 0xff < in_data + in_len) {
- apdu.st.cla = 0x10;
+ recv_len = mem::size_of::<[u8; 261]>() as (u32);
+ let mut apdu = APDU::default();
+ apdu.cla = *templ;
+ apdu.ins = *templ.offset(1);
+ apdu.p1 = *templ.offset(2);
+ apdu.p2 = *templ.offset(3);
+
+ if in_ptr.offset(0xff) < in_data.offset(in_len) {
+ apdu.cla = 0x10;
} else {
- this_size = (size_t)((in_data + in_len) - in_ptr);
+ this_size = in_data.offset(in_len) as usize - in_ptr as usize;
}
- */
+
if (*state).verbose > 2i32 {
- fprintf(
- __stderrp,
- (*b"Going to send %lu bytes in this go.\n\0").as_ptr(),
- this_size,
- );
+ eprintln!("Going to send {} bytes in this go.", this_size);
}
- // FIXME(tarcieri): translate APDU code
- /*
- apdu.st.lc = (unsigned char)this_size;
- memcpy(apdu.st.data, in_ptr, this_size);
- */
+
+ apdu.lc = this_size.try_into().unwrap();
+ memcpy(
+ apdu.data.as_mut_ptr() as *mut c_void,
+ in_ptr as *const c_void,
+ this_size,
+ );
+
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
sw,
);
- if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
_currentBlock = 24;
break;
}
@@ -1215,8 +1063,8 @@ pub unsafe extern "C" fn _ykpiv_transfer_data(
}
if !out_data.is_null() {
memcpy(
- out_data as (*mut ::std::os::raw::c_void),
- data.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ out_data as (*mut c_void),
+ data.as_mut_ptr() as (*const c_void),
recv_len.wrapping_sub(2u32) as (usize),
);
out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize));
@@ -1234,29 +1082,25 @@ pub unsafe extern "C" fn _ykpiv_transfer_data(
_currentBlock = 24;
break;
}
- let mut apdu: u_APDU;
let mut data: [u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ recv_len = mem::size_of::<[u8; 261]>() as (u32);
if (*state).verbose > 2i32 {
- fprintf(
- __stderrp,
- (*b"The card indicates there is %d bytes more data for us.\n\0").as_ptr(),
- *sw & 0xffi32,
+ eprintln!(
+ "The card indicates there is {} bytes more data for us.",
+ *sw & 0xffi32
);
}
- // FIXME(tarcieri): translate APDU code
- /*
- memset(apdu.raw, 0, sizeof(apdu.raw));
- apdu.st.ins = YKPIV_INS_GET_RESPONSE_APDU;
- */
+
+ let mut apdu = APDU::default();
+ apdu.ins = YKPIV_INS_GET_RESPONSE_APDU;
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
sw,
);
- if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
_currentBlock = 24;
break;
}
@@ -1276,8 +1120,8 @@ pub unsafe extern "C" fn _ykpiv_transfer_data(
continue;
}
memcpy(
- out_data as (*mut ::std::os::raw::c_void),
- data.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ out_data as (*mut c_void),
+ data.as_mut_ptr() as (*const c_void),
recv_len.wrapping_sub(2u32) as (usize),
);
out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize));
@@ -1286,35 +1130,32 @@ pub unsafe extern "C" fn _ykpiv_transfer_data(
if _currentBlock == 24 {
} else {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Output buffer to small, wanted to write %lu, max was %lu.\0").as_ptr(),
+ eprintln!(
+ "Output buffer to small, wanted to write {}, max was {}.",
(*out_len)
.wrapping_add(recv_len as (usize))
.wrapping_sub(2usize),
- max_out,
+ max_out
);
}
- res = Enum5::YKPIV_SIZE_ERROR;
+ res = ErrorKind::YKPIV_SIZE_ERROR;
}
} else if _currentBlock == 21 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Output buffer to small, wanted to write %lu, max was %lu.\n\0").as_ptr(),
+ eprintln!(
+ "Output buffer to small, wanted to write {}, max was {}.",
(*out_len)
.wrapping_add(recv_len as (usize))
.wrapping_sub(2usize),
- max_out,
+ max_out
);
}
- res = Enum5::YKPIV_SIZE_ERROR;
+ res = ErrorKind::YKPIV_SIZE_ERROR;
}
res
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_transfer_data(
+pub fn ykpiv_transfer_data(
mut state: *mut ykpiv_state,
mut templ: *const u8,
mut in_data: *const u8,
@@ -1322,16 +1163,16 @@ pub unsafe extern "C" fn ykpiv_transfer_data(
mut out_data: *mut u8,
mut out_len: *mut usize,
mut sw: *mut i32,
-) -> Enum5 {
- let mut res: Enum5;
+) -> ErrorKind {
+ let mut res: ErrorKind;
if {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
*out_len = 0usize;
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
res = _ykpiv_transfer_data(state, templ, in_data, in_len, out_data, out_len, sw);
_ykpiv_end_transaction(state);
@@ -1339,30 +1180,25 @@ pub unsafe extern "C" fn ykpiv_transfer_data(
}
}
-unsafe extern "C" fn dump_hex(mut buf: *const u8, mut len: u32) {
+unsafe fn dump_hex(mut buf: *const u8, mut len: u32) {
let mut i: u32;
i = 0u32;
'loop1: loop {
if !(i < len) {
break;
}
- fprintf(
- __stderrp,
- (*b"%02x \0").as_ptr(),
- *buf.offset(i as (isize)) as (i32),
- );
+ eprintln!("{:02x} ", *buf.offset(i as (isize)) as (i32));
i = i.wrapping_add(1u32);
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _send_data(
+pub fn _send_data(
mut state: *mut ykpiv_state,
- mut apdu: *mut u_APDU,
+ mut apdu: *mut APDU,
mut data: *mut u8,
mut recv_len: *mut u32,
mut sw: *mut i32,
-) -> Enum5 {
+) -> ErrorKind {
let mut rc: isize;
// FIXME(tarcieri): `send_len` is NOT supposed to be 0. Translate C code
let mut send_len: u32 = 0u32; // (unsigned int)apdu->st.lc + 5;
@@ -1387,9 +1223,9 @@ pub unsafe extern "C" fn _send_data(
*recv_len = tmp_len;
if (*state).verbose > 1i32 {
- fprintf(__stderrp, (*b"< \0").as_ptr());
+ eprint!("< ");
dump_hex(data as (*const u8), *recv_len);
- fprintf(__stderrp, (*b"\n\0").as_ptr());
+ eprintln!();
}
if *recv_len >= 2u32 {
*sw = *data.offset((*recv_len).wrapping_sub(2u32) as (isize)) as (i32) << 8i32
@@ -1397,11 +1233,12 @@ pub unsafe extern "C" fn _send_data(
} else {
*sw = 0i32;
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
}
#[derive(Clone, Copy)]
#[repr(i32)]
+#[allow(non_camel_case_types)]
pub enum Enum6 {
DES_OK = 0i32,
DES_INVALID_PARAMETER = -1i32,
@@ -1410,35 +1247,31 @@ pub enum Enum6 {
DES_GENERAL_ERROR = -4i32,
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_authenticate(
- mut state: *mut ykpiv_state,
- mut key: *const u8,
-) -> Enum5 {
- let mut apdu: u_APDU;
+pub fn ykpiv_authenticate(mut state: *mut ykpiv_state, mut key: *const u8) -> ErrorKind {
+ let mut apdu: APDU;
let mut data: [u8; 261];
let mut challenge: [u8; 8];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32);
let mut sw: i32;
- let mut res: Enum5;
+ let mut res: ErrorKind;
let mut drc: Enum6 = Enum6::DES_OK;
- let mut mgm_key: *mut des_key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut des_key);
+ let mut mgm_key: *mut DesKey = 0i32 as (*mut c_void) as (*mut DesKey);
let mut out_len: usize = 0usize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) == key {
+ if 0i32 as (*mut c_void) as (*const u8) == key {
key = (*b"\x01\x02\x03\x04\x05\x06\x07\x08\x01\x02\x03\x04\x05\x06\x07\x08\x01\x02\x03\x04\x05\x06\x07\x08\0").as_ptr(
);
}
@@ -1447,10 +1280,10 @@ pub unsafe extern "C" fn ykpiv_authenticate(
1i32,
key,
(8i32 * 3i32) as (usize),
- &mut mgm_key as (*mut *mut des_key),
+ &mut mgm_key as (*mut *mut DesKey),
) as (i32)
{
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
} else {
// get a challenge from the card
// FIXME(tarcieri): Translate C code below
@@ -1522,25 +1355,25 @@ pub unsafe extern "C" fn ykpiv_authenticate(
}
*/
let mut response: [u8; 8];
- out_len = ::std::mem::size_of::<[u8; 8]>();
+ out_len = mem::size_of::<[u8; 8]>();
drc = des_encrypt(
mgm_key,
challenge.as_mut_ptr() as (*const u8),
- ::std::mem::size_of::<[u8; 8]>(),
+ mem::size_of::<[u8; 8]>(),
response.as_mut_ptr(),
&mut out_len as (*mut usize),
);
if drc as (i32) != Enum6::DES_OK as (i32) {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
} else if memcmp(
- response.as_mut_ptr() as (*const ::std::os::raw::c_void),
- data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void),
+ response.as_mut_ptr() as (*const c_void),
+ data.as_mut_ptr().offset(4isize) as (*const c_void),
8usize,
) == 0i32
{
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
}
}
}
@@ -1552,159 +1385,143 @@ pub unsafe extern "C" fn ykpiv_authenticate(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_set_mgmkey(
- mut state: *mut ykpiv_state,
- mut new_key: *const u8,
-) -> Enum5 {
+pub fn ykpiv_set_mgmkey(mut state: *mut ykpiv_state, mut new_key: *const u8) -> ErrorKind {
ykpiv_set_mgmkey2(state, new_key, 0u8)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_set_mgmkey2(
+pub fn ykpiv_set_mgmkey2(
mut state: *mut ykpiv_state,
mut new_key: *const u8,
touch: u8,
-) -> Enum5 {
- let mut apdu: u_APDU;
+) -> ErrorKind {
let mut data: [u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32);
let mut sw: i32;
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- if !(Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_ensure_application_selected(state);
- res
- } as (i32))
- {
- if yk_des_is_weak_key(new_key, (8i32 * 3i32) as (usize)) {
- if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Won\'t set new key \'\0").as_ptr());
- dump_hex(new_key, (8i32 * 3i32) as (u32));
- fprintf(
- __stderrp,
- (*b"\' since it\'s weak (with odd parity).\n\0").as_ptr(),
- );
- }
- res = Enum5::YKPIV_KEY_ERROR;
- // FIXME(tarcieri): Translate C code below (should go after else clause)
- /*
- memset(apdu.raw, 0, sizeof(apdu));
- apdu.st.ins = YKPIV_INS_SET_MGMKEY;
- apdu.st.p1 = 0xff;
- if (touch == 0) {
- apdu.st.p2 = 0xff;
- }
- else if (touch == 1) {
- apdu.st.p2 = 0xfe;
- }
- else {
- res = YKPIV_GENERIC_ERROR;
- goto Cleanup;
- }
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut apdu = APDU::default();
- apdu.st.lc = DES_LEN_3DES + 3;
- apdu.st.data[0] = YKPIV_ALGO_3DES;
- apdu.st.data[1] = YKPIV_KEY_CARDMGM;
- apdu.st.data[2] = DES_LEN_3DES;
- memcpy(apdu.st.data + 3, new_key, DES_LEN_3DES);
- */
- } else if !({
- res = _send_data(
- state,
- &mut apdu as (*mut u_APDU),
- data.as_mut_ptr(),
- &mut recv_len as (*mut u32),
- &mut sw as (*mut i32),
- );
- res
- } as (i32)
- != Enum5::YKPIV_OK as (i32))
- {
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ }
+
+ if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK {
+ if yk_des_is_weak_key(new_key, (8i32 * 3i32) as (usize)) {
+ if (*state).verbose != 0 {
+ // TODO(tarcieri): format string
+ eprint!("Won\'t set new key \'");
+ dump_hex(new_key, DES_LEN_3DES as u32);
+ eprintln!("\' since it\'s weak (with odd parity).");
+ }
+ res = ErrorKind::YKPIV_KEY_ERROR;
+ apdu.ins = YKPIV_INS_SET_MGMKEY;
+ apdu.p1 = 0xff;
+
+ apdu.p2 = match touch {
+ 0 => 0xff,
+ 1 => 0xfe,
+ _ => {
+ _ykpiv_end_transaction(state);
+ return ErrorKind::YKPIV_GENERIC_ERROR;
+ }
+ };
+
+ apdu.lc = DES_LEN_3DES as u8 + 3;
+ apdu.data[0] = YKPIV_ALGO_3DES;
+ apdu.data[1] = YKPIV_KEY_CARDMGM;
+ apdu.data[2] = DES_LEN_3DES as u8;
+ memcpy(
+ apdu.data.as_mut_ptr().offset(3) as *mut c_void,
+ new_key as *const c_void,
+ DES_LEN_3DES,
+ );
+ } else {
+ res = _send_data(
+ state,
+ &mut apdu as (*mut APDU),
+ data.as_mut_ptr(),
+ &mut recv_len as (*mut u32),
+ &mut sw as (*mut i32),
+ );
+
+ if res != ErrorKind::YKPIV_OK {
if !(sw == 0x9000i32) {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
}
}
}
- memset_s(
- &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::(),
- 0i32,
- ::std::mem::size_of::(),
- );
- _ykpiv_end_transaction(state);
- res
}
+
+ apdu.zeroize();
+ _ykpiv_end_transaction(state);
+ res
}
-static mut hex_translate: *mut u8 = (*b"0123456789abcdef\0").as_ptr() as (*mut u8);
+const HEX_TABLE: &[u8] = b"0123456789abcdef";
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_hex_decode(
+pub fn ykpiv_hex_decode(
mut hex_in: *const u8,
mut in_len: usize,
mut hex_out: *mut u8,
mut out_len: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut i: usize;
let mut first: bool = true;
- if *out_len < in_len.wrapping_div(2usize) {
- Enum5::YKPIV_SIZE_ERROR
- } else if in_len.wrapping_rem(2usize) != 0usize {
- Enum5::YKPIV_SIZE_ERROR
- } else {
- *out_len = in_len.wrapping_div(2usize);
- i = 0usize;
- 'loop3: loop {
- if !(i < in_len) {
- _currentBlock = 4;
- break;
- }
- let mut ind_ptr: *mut u8 = strchr(
- hex_translate as (*const u8),
- tolower(*{
- let _old = hex_in;
- hex_in = hex_in.offset(1isize);
- _old
- } as (i32)),
- );
- let mut index: i32 = 0i32;
- if ind_ptr.is_null() {
- _currentBlock = 6;
- break;
- }
- index = ((ind_ptr as (isize)).wrapping_sub(hex_translate as (isize))
- / ::std::mem::size_of::() as (isize)) as (i32);
- if first {
- *hex_out = (index << 4i32) as (u8);
- } else {
- let _rhs = index;
- let _lhs = &mut *{
- let _old = hex_out;
- hex_out = hex_out.offset(1isize);
- _old
- };
- *_lhs = (*_lhs as (i32) | _rhs) as (u8);
- }
- first = !first;
- i = i.wrapping_add(1usize);
+
+ if *out_len < in_len.wrapping_div(2) {
+ return ErrorKind::YKPIV_SIZE_ERROR;
+ }
+
+ if in_len.wrapping_rem(2) != 0 {
+ return ErrorKind::YKPIV_SIZE_ERROR;
+ }
+
+ *out_len = in_len.wrapping_div(2usize);
+ i = 0usize;
+
+ while i < in_len {
+ let mut ind_ptr: *mut c_char = strchr(
+ HEX_TABLE.as_ptr() as *const c_char,
+ tolower(*{
+ let _old = hex_in;
+ hex_in = hex_in.offset(1isize);
+ _old
+ } as (i32)),
+ );
+
+ if ind_ptr.is_null() {
+ _currentBlock = 6;
+ break;
}
- (if _currentBlock == 4 {
- Enum5::YKPIV_OK
+
+ let index = ind_ptr as usize - HEX_TABLE.as_ptr() as usize;
+
+ if first {
+ *hex_out = (index << 4i32) as (u8);
} else {
- Enum5::YKPIV_PARSE_ERROR
- })
+ let _rhs = index;
+
+ let _lhs = &mut *{
+ let _old = hex_out;
+ hex_out = hex_out.offset(1isize);
+ _old
+ };
+
+ *_lhs = (*_lhs as usize | _rhs) as (u8);
+ }
+
+ first = !first;
+ i = i.wrapping_add(1usize);
+ }
+
+ if _currentBlock == 4 {
+ ErrorKind::YKPIV_OK
+ } else {
+ ErrorKind::YKPIV_PARSE_ERROR
}
}
-unsafe extern "C" fn _general_authenticate(
+unsafe fn _general_authenticate(
mut state: *mut ykpiv_state,
mut sign_in: *const u8,
mut in_len: usize,
@@ -1713,18 +1530,18 @@ unsafe extern "C" fn _general_authenticate(
mut algorithm: u8,
mut key: u8,
mut decipher: bool,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut indata: [u8; 1024];
let mut dataptr: *mut u8 = indata.as_mut_ptr();
let mut data: [u8; 1024];
let mut templ: *mut u8 = 0i32 as (*mut u8);
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 1024]>();
+ let mut recv_len: usize = mem::size_of::<[u8; 1024]>();
let mut key_len: usize = 0usize;
let mut sw: i32 = 0i32;
let mut bytes: usize;
let mut len: usize = 0usize;
- let mut res: Enum5;
+ let mut res: ErrorKind;
if algorithm as (i32) == 0x14i32 {
_currentBlock = 12;
} else if algorithm as (i32) == 0x11i32 {
@@ -1735,14 +1552,14 @@ unsafe extern "C" fn _general_authenticate(
if algorithm as (i32) == 0x6i32 {
key_len = 128usize;
} else {
- return Enum5::YKPIV_ALGORITHM_ERROR;
+ return ErrorKind::YKPIV_ALGORITHM_ERROR;
}
}
if key_len == 0usize {
key_len = 256usize;
}
if in_len != key_len {
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else {
_currentBlock = 16;
}
@@ -1752,9 +1569,9 @@ unsafe extern "C" fn _general_authenticate(
key_len = 48usize;
}
if !decipher && (in_len > key_len) {
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else if decipher && (in_len != key_len.wrapping_mul(2usize).wrapping_add(1usize)) {
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
}
}
if in_len < 0x80usize {
@@ -1793,11 +1610,7 @@ unsafe extern "C" fn _general_authenticate(
0x81i32
} as (u8);
dataptr = dataptr.offset(_ykpiv_set_length(dataptr, in_len) as (isize));
- memcpy(
- dataptr as (*mut ::std::os::raw::c_void),
- sign_in as (*const ::std::os::raw::c_void),
- in_len,
- );
+ memcpy(dataptr as (*mut c_void), sign_in as (*const c_void), in_len);
dataptr = dataptr.offset(in_len as (isize));
if {
res = ykpiv_transfer_data(
@@ -1805,81 +1618,60 @@ unsafe extern "C" fn _general_authenticate(
templ as (*const u8),
indata.as_mut_ptr() as (*const u8),
(dataptr as (isize)).wrapping_sub(indata.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize),
+ / mem::size_of::() as (isize),
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Sign command failed to communicate.\n\0").as_ptr(),
- );
+ eprintln!("Sign command failed to communicate.");
}
res
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed sign command with code %x.\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed sign command with code {:x}.\n\0", sw);
}
(if sw == 0x6982i32 {
- Enum5::YKPIV_AUTHENTICATION_ERROR
+ ErrorKind::YKPIV_AUTHENTICATION_ERROR
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
} else if data[0usize] as (i32) != 0x7ci32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed parsing signature reply.\n\0").as_ptr(),
- );
+ eprintln!("Failed parsing signature reply.");
}
- Enum5::YKPIV_PARSE_ERROR
+ ErrorKind::YKPIV_PARSE_ERROR
} else {
dataptr = data.as_mut_ptr().offset(1isize);
- dataptr = dataptr
- .offset(_ykpiv_get_length(dataptr as (*const u8), &mut len as (*mut usize)) as (isize));
+ dataptr = dataptr.offset(_ykpiv_get_length(dataptr, &mut len as (*mut usize)) as (isize));
(if *dataptr as (i32) != 0x82i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed parsing signature reply.\n\0").as_ptr(),
- );
+ eprintln!("Failed parsing signature reply.");
}
- Enum5::YKPIV_PARSE_ERROR
+ ErrorKind::YKPIV_PARSE_ERROR
} else {
dataptr = dataptr.offset(1isize);
- dataptr = dataptr
- .offset(
- _ykpiv_get_length(dataptr as (*const u8), &mut len as (*mut usize)) as (isize),
- );
+ dataptr =
+ dataptr.offset(_ykpiv_get_length(dataptr, &mut len as (*mut usize)) as (isize));
(if len > *out_len {
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Wrong size on output buffer.\n\0").as_ptr());
+ eprintln!("Wrong size on output buffer.");
}
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
*out_len = len;
- memcpy(
- out as (*mut ::std::os::raw::c_void),
- dataptr as (*const ::std::os::raw::c_void),
- len,
- );
- Enum5::YKPIV_OK
+ memcpy(out as (*mut c_void), dataptr as (*const c_void), len);
+ ErrorKind::YKPIV_OK
})
})
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_sign_data(
+pub fn ykpiv_sign_data(
mut state: *mut ykpiv_state,
mut raw_in: *const u8,
mut in_len: usize,
@@ -1887,16 +1679,16 @@ pub unsafe extern "C" fn ykpiv_sign_data(
mut out_len: *mut usize,
mut algorithm: u8,
mut key: u8,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
res = _general_authenticate(
state, raw_in, in_len, sign_out, out_len, algorithm, key, false,
@@ -1906,8 +1698,7 @@ pub unsafe extern "C" fn ykpiv_sign_data(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_decipher_data(
+pub fn ykpiv_decipher_data(
mut state: *mut ykpiv_state,
mut in_: *const u8,
mut in_len: usize,
@@ -1915,16 +1706,16 @@ pub unsafe extern "C" fn ykpiv_decipher_data(
mut out_len: *mut usize,
mut algorithm: u8,
mut key: u8,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
res = _general_authenticate(state, in_, in_len, out, out_len, algorithm, key, true);
_ykpiv_end_transaction(state);
@@ -1932,26 +1723,26 @@ pub unsafe extern "C" fn ykpiv_decipher_data(
}
}
-unsafe extern "C" fn _ykpiv_get_version(
+unsafe fn _ykpiv_get_version(
mut state: *mut ykpiv_state,
mut p_version: *mut _ykpiv_version_t,
-) -> Enum5 {
- let mut apdu: u_APDU;
+) -> ErrorKind {
+ let mut apdu: APDU;
let mut data: [u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32);
let mut sw: i32;
- let mut res: Enum5;
+ let mut res: ErrorKind;
if state.is_null() {
- Enum5::YKPIV_ARGUMENT_ERROR
+ ErrorKind::YKPIV_ARGUMENT_ERROR
} else if (*state).ver.major != 0 || (*state).ver.minor != 0 || (*state).ver.patch != 0 {
if !p_version.is_null() {
memcpy(
- p_version as (*mut ::std::os::raw::c_void),
- &mut (*state).ver as (*mut _ykpiv_version_t) as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<_ykpiv_version_t>(),
+ p_version as (*mut c_void),
+ &mut (*state).ver as (*mut _ykpiv_version_t) as (*const c_void),
+ mem::size_of::<_ykpiv_version_t>(),
);
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
// get version from device
// FIXME(tarcieri): Translate C code below (should go after the else clause)
/*
@@ -1961,47 +1752,45 @@ unsafe extern "C" fn _ykpiv_get_version(
} else if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
res
} else {
if sw == 0x9000i32 {
if recv_len < 3u32 {
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else {
(*state).ver.major = data[0usize];
(*state).ver.minor = data[1usize];
(*state).ver.patch = data[2usize];
if !p_version.is_null() {
memcpy(
- p_version as (*mut ::std::os::raw::c_void),
- &mut (*state).ver as (*mut _ykpiv_version_t)
- as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<_ykpiv_version_t>(),
+ p_version as (*mut c_void),
+ &mut (*state).ver as (*mut _ykpiv_version_t) as (*const c_void),
+ mem::size_of::<_ykpiv_version_t>(),
);
}
}
} else {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
}
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_get_version(
+pub fn ykpiv_get_version(
mut state: *mut ykpiv_state,
mut version: *mut u8,
mut len: usize,
-) -> Enum5 {
- let mut res: Enum5;
+) -> ErrorKind {
+ let mut res: ErrorKind;
let mut result: i32 = 0i32;
let mut ver: _ykpiv_version_t = _ykpiv_version_t {
major: 0u8,
@@ -2012,21 +1801,21 @@ pub unsafe extern "C" fn ykpiv_get_version(
res = _ykpiv_begin_transaction(state);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
if !({
res = _ykpiv_ensure_application_selected(state);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32))
+ < ErrorKind::YKPIV_OK as (i32))
{
if {
res = _ykpiv_get_version(state, &mut ver as (*mut _ykpiv_version_t));
res
} as (i32)
- >= Enum5::YKPIV_OK as (i32)
+ >= ErrorKind::YKPIV_OK as (i32)
{
result = snprintf(
version,
@@ -2037,7 +1826,7 @@ pub unsafe extern "C" fn ykpiv_get_version(
ver.patch as (i32),
);
if result < 0i32 {
- res = Enum5::YKPIV_SIZE_ERROR;
+ res = ErrorKind::YKPIV_SIZE_ERROR;
}
}
}
@@ -2046,30 +1835,30 @@ pub unsafe extern "C" fn ykpiv_get_version(
}
}
-unsafe extern "C" fn _ykpiv_get_serial(
+unsafe fn _ykpiv_get_serial(
mut state: *mut ykpiv_state,
mut p_serial: *mut u32,
mut f_force: bool,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut apdu: u_APDU;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut apdu: APDU;
let mut yk_applet: *const u8 = 0xa0i32 as (*const u8);
let mut data: [u8; 255];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32);
let mut sw: i32;
- let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut p_temp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
if state.is_null() {
- Enum5::YKPIV_ARGUMENT_ERROR
+ ErrorKind::YKPIV_ARGUMENT_ERROR
} else if !f_force && ((*state).serial != 0u32) {
if !p_serial.is_null() {
*p_serial = (*state).serial;
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else {
if (*state).ver.major as (i32) < 5i32 {
let mut temp: [u8; 255];
- recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ recv_len = mem::size_of::<[u8; 255]>() as (u32);
// FIXME(tarcieri): Translate C code below
/*
memset(apdu.raw, 0, sizeof(apdu));
@@ -2081,20 +1870,19 @@ unsafe extern "C" fn _ykpiv_get_serial(
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
temp.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
_currentBlock = 37;
} else {
@@ -2102,16 +1890,12 @@ unsafe extern "C" fn _ykpiv_get_serial(
}
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed selecting yk application: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed selecting yk application: {:04x}", sw);
}
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
_currentBlock = 37;
} else {
- recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ recv_len = mem::size_of::<[u8; 255]>() as (u32);
// FIXME(tarcieri): Translate C code below
/*
memset(apdu.raw, 0, sizeof(apdu));
@@ -2122,20 +1906,19 @@ unsafe extern "C" fn _ykpiv_get_serial(
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
_currentBlock = 37;
} else {
@@ -2143,16 +1926,12 @@ unsafe extern "C" fn _ykpiv_get_serial(
}
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed retrieving serial number: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed retrieving serial number: {:04x}", sw);
}
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
_currentBlock = 37;
} else {
- recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ recv_len = mem::size_of::<[u8; 255]>() as (u32);
// FIXME(tarcieri): Translate C code below
/*
memset(apdu.raw, 0, sizeof(apdu));
@@ -2164,32 +1943,27 @@ unsafe extern "C" fn _ykpiv_get_serial(
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
temp.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
}
return res;
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed selecting application: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed selecting application: {:04x}", sw);
}
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
}
_currentBlock = 17;
}
@@ -2205,38 +1979,33 @@ unsafe extern "C" fn _ykpiv_get_serial(
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
}
return res;
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed retrieving serial number: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed retrieving serial number: {:04x}", sw);
}
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
}
_currentBlock = 17;
}
if _currentBlock == 17 {
if recv_len < 4u32 {
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else {
p_temp = &mut (*state).serial as (*mut u32) as (*mut u8);
*{
@@ -2268,25 +2037,21 @@ unsafe extern "C" fn _ykpiv_get_serial(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_get_serial(
- mut state: *mut ykpiv_state,
- mut p_serial: *mut u32,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_get_serial(mut state: *mut ykpiv_state, mut p_serial: *mut u32) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
if {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
if !({
res = _ykpiv_ensure_application_selected(state);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32))
+ != ErrorKind::YKPIV_OK as (i32))
{
res = _ykpiv_get_serial(state, p_serial, false);
}
@@ -2295,75 +2060,69 @@ pub unsafe extern "C" fn ykpiv_get_serial(
}
}
-unsafe extern "C" fn _cache_pin(
+unsafe fn _cache_pin(
mut state: *mut ykpiv_state,
- mut pin: *const u8,
+ mut pin: *const c_char,
mut len: usize,
-) -> Enum5 {
+) -> ErrorKind {
if state.is_null() {
- Enum5::YKPIV_ARGUMENT_ERROR
- } else if !pin.is_null() && ((*state).pin as (*const u8) == pin) {
- Enum5::YKPIV_OK
- } else {
- if !(*state).pin.is_null() {
- memset_s(
- (*state).pin as (*mut ::std::os::raw::c_void),
- strnlen((*state).pin as (*const u8), 8usize),
- 0i32,
- strnlen((*state).pin as (*const u8), 8usize),
- );
- _ykpiv_free(state, (*state).pin as (*mut ::std::os::raw::c_void));
- (*state).pin = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
- }
- if !pin.is_null() && (len > 0usize) {
- (*state).pin = _ykpiv_alloc(
- state,
- len.wrapping_mul(::std::mem::size_of::())
- .wrapping_add(1usize),
- ) as (*mut u8);
- if (*state).pin == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) {
- return Enum5::YKPIV_MEMORY_ERROR;
- } else {
- memcpy(
- (*state).pin as (*mut ::std::os::raw::c_void),
- pin as (*const ::std::os::raw::c_void),
- len,
- );
- *(*state).pin.offset(len as (isize)) = 0u8;
- }
- }
- Enum5::YKPIV_OK
+ return ErrorKind::YKPIV_ARGUMENT_ERROR;
}
+
+ if !pin.is_null() && ((*state).pin as *const c_char == pin) {
+ return ErrorKind::YKPIV_OK;
+ }
+
+ if !(*state).pin.is_null() {
+ memset_s(
+ (*state).pin as (*mut c_void),
+ strnlen((*state).pin as *const c_char, 8),
+ 0,
+ strnlen((*state).pin as *const c_char, 8),
+ );
+ free((*state).pin as (*mut c_void));
+ (*state).pin = ptr::null_mut();
+ }
+ if !pin.is_null() && (len > 0) {
+ (*state).pin = malloc(len + 1) as (*mut u8);
+ if (*state).pin == 0i32 as (*mut c_void) as (*mut u8) {
+ return ErrorKind::YKPIV_MEMORY_ERROR;
+ } else {
+ memcpy((*state).pin as (*mut c_void), pin as (*const c_void), len);
+ *(*state).pin.offset(len as (isize)) = 0u8;
+ }
+ }
+
+ ErrorKind::YKPIV_OK
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_verify(
+pub fn ykpiv_verify(
mut state: *mut ykpiv_state,
- mut pin: *const u8,
+ mut pin: *const c_char,
mut tries: *mut i32,
-) -> Enum5 {
+) -> ErrorKind {
ykpiv_verify_select(
state,
pin,
- if !pin.is_null() { strlen(pin) } else { 0usize },
+ if !pin.is_null() { strlen(pin) } else { 0 },
tries,
false,
)
}
-unsafe extern "C" fn _verify(
+unsafe fn _verify(
mut state: *mut ykpiv_state,
- mut pin: *const u8,
+ mut pin: *const c_char,
pin_len: usize,
mut tries: *mut i32,
-) -> Enum5 {
- let mut apdu: u_APDU;
+) -> ErrorKind {
+ let mut apdu: APDU;
let mut data: [u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32);
let mut sw: i32;
- let mut res: Enum5;
+ let mut res: ErrorKind;
if pin_len > 8usize {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
// FIXME(tarcieri): Translate C code below
/*
@@ -2381,18 +2140,18 @@ unsafe extern "C" fn _verify(
*/
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
memset_s(
- &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::(),
+ &mut apdu as (*mut APDU) as (*mut c_void),
+ mem::size_of::(),
0i32,
- ::std::mem::size_of::(),
+ mem::size_of::(),
);
- (if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ (if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
res
} else if sw == 0x9000i32 {
if !pin.is_null() && (pin_len != 0) {
@@ -2401,42 +2160,41 @@ unsafe extern "C" fn _verify(
if !tries.is_null() {
*tries = sw & 0xfi32;
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else if sw >> 8i32 == 0x63i32 {
if !tries.is_null() {
*tries = sw & 0xfi32;
}
- Enum5::YKPIV_WRONG_PIN
+ ErrorKind::YKPIV_WRONG_PIN
} else if sw == 0x6983i32 {
if !tries.is_null() {
*tries = 0i32;
}
- Enum5::YKPIV_WRONG_PIN
+ ErrorKind::YKPIV_WRONG_PIN
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_verify_select(
+pub fn ykpiv_verify_select(
mut state: *mut ykpiv_state,
- mut pin: *const u8,
+ mut pin: *const c_char,
pin_len: usize,
mut tries: *mut i32,
mut force_select: bool,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if Enum5::YKPIV_OK as (i32) != {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
if force_select {
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32)
@@ -2456,62 +2214,54 @@ pub unsafe extern "C" fn ykpiv_verify_select(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_get_pin_retries(
- mut state: *mut ykpiv_state,
- mut tries: *mut i32,
-) -> Enum5 {
- let mut res: Enum5;
- let mut ykrc: Enum5;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut i32) == tries
- {
- Enum5::YKPIV_ARGUMENT_ERROR
+pub fn ykpiv_get_pin_retries(mut state: *mut ykpiv_state, mut tries: *mut i32) -> ErrorKind {
+ let mut res: ErrorKind;
+ let mut ykrc: ErrorKind;
+
+ if state.is_null() || tries.is_null() {
+ return ErrorKind::YKPIV_ARGUMENT_ERROR;
+ }
+
+ res = _ykpiv_select_application(state);
+
+ if res != ErrorKind::YKPIV_OK {
+ return res;
+ }
+
+ ykrc = ykpiv_verify(state, ptr::null(), tries);
+
+ if ykrc == ErrorKind::YKPIV_WRONG_PIN {
+ ErrorKind::YKPIV_OK
} else {
- res = _ykpiv_select_application(state);
- (if res as (i32) != Enum5::YKPIV_OK as (i32) {
- res
- } else {
- ykrc = ykpiv_verify(
- state,
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
- tries,
- );
- (if ykrc as (i32) == Enum5::YKPIV_WRONG_PIN as (i32) {
- Enum5::YKPIV_OK as (i32)
- } else {
- ykrc as (i32)
- }) as (Enum5)
- })
+ ykrc
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_set_pin_retries(
+pub fn ykpiv_set_pin_retries(
mut state: *mut ykpiv_state,
mut pin_tries: i32,
mut puk_tries: i32,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut data: [u8; 255];
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>();
+ let mut recv_len: usize = mem::size_of::<[u8; 255]>();
let mut sw: i32 = 0i32;
if pin_tries == 0i32 || puk_tries == 0i32 {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else if pin_tries > 0xffi32 || puk_tries > 0xffi32 || pin_tries < 1i32 || puk_tries < 1i32 {
- Enum5::YKPIV_RANGE_ERROR
+ ErrorKind::YKPIV_RANGE_ERROR
} else {
*templ.offset(2isize) = pin_tries as (u8);
*templ.offset(3isize) = puk_tries as (u8);
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -2519,20 +2269,20 @@ pub unsafe extern "C" fn ykpiv_set_pin_retries(
res = ykpiv_transfer_data(
state,
templ as (*const u8),
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
+ 0i32 as (*mut c_void) as (*const u8),
0isize,
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
);
- if Enum5::YKPIV_OK as (i32) == res as (i32) {
+ if ErrorKind::YKPIV_OK as (i32) == res as (i32) {
if !(0x9000i32 == sw) {
if sw == 0x6983i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
} else if sw == 0x6982i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
} else {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
}
}
}
@@ -2543,25 +2293,25 @@ pub unsafe extern "C" fn ykpiv_set_pin_retries(
}
}
-unsafe extern "C" fn _ykpiv_change_pin(
+unsafe fn _ykpiv_change_pin(
mut state: *mut ykpiv_state,
mut action: i32,
- mut current_pin: *const u8,
+ mut current_pin: *const c_char,
mut current_pin_len: usize,
- mut new_pin: *const u8,
+ mut new_pin: *const c_char,
mut new_pin_len: usize,
mut tries: *mut i32,
-) -> Enum5 {
+) -> ErrorKind {
let mut sw: i32;
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut indata: [u8; 16];
let mut data: [u8; 255];
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>();
- let mut res: Enum5;
+ let mut recv_len: usize = mem::size_of::<[u8; 255]>();
+ let mut res: ErrorKind;
if current_pin_len > 8usize {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else if new_pin_len > 8usize {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
if action == 1i32 {
*templ.offset(1isize) = 0x2cu8;
@@ -2569,21 +2319,20 @@ unsafe extern "C" fn _ykpiv_change_pin(
*templ.offset(3isize) = 0x81u8;
}
memcpy(
- indata.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- current_pin as (*const ::std::os::raw::c_void),
+ indata.as_mut_ptr() as (*mut c_void),
+ current_pin as (*const c_void),
current_pin_len,
);
if current_pin_len < 8usize {
memset(
- indata.as_mut_ptr().offset(current_pin_len as (isize))
- as (*mut ::std::os::raw::c_void),
+ indata.as_mut_ptr().offset(current_pin_len as (isize)) as (*mut c_void),
0xffi32,
8usize.wrapping_sub(current_pin_len),
);
}
memcpy(
- indata.as_mut_ptr().offset(8isize) as (*mut ::std::os::raw::c_void),
- new_pin as (*const ::std::os::raw::c_void),
+ indata.as_mut_ptr().offset(8isize) as (*mut c_void),
+ new_pin as (*const c_void),
new_pin_len,
);
if new_pin_len < 8usize {
@@ -2591,8 +2340,7 @@ unsafe extern "C" fn _ykpiv_change_pin(
indata
.as_mut_ptr()
.offset(8isize)
- .offset(new_pin_len as (isize))
- as (*mut ::std::os::raw::c_void),
+ .offset(new_pin_len as (isize)) as (*mut c_void),
0xffi32,
8usize.wrapping_sub(new_pin_len),
);
@@ -2601,140 +2349,120 @@ unsafe extern "C" fn _ykpiv_change_pin(
state,
templ as (*const u8),
indata.as_mut_ptr() as (*const u8),
- ::std::mem::size_of::<[u8; 16]>() as (isize),
+ mem::size_of::<[u8; 16]>() as (isize),
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
);
memset_s(
- indata.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 16]>(),
+ indata.as_mut_ptr() as (*mut c_void),
+ mem::size_of::<[u8; 16]>(),
0i32,
- ::std::mem::size_of::<[u8; 16]>(),
+ mem::size_of::<[u8; 16]>(),
);
- (if res as (i32) != Enum5::YKPIV_OK as (i32) {
+ (if res as (i32) != ErrorKind::YKPIV_OK as (i32) {
res
} else if sw != 0x9000i32 {
(if sw >> 8i32 == 0x63i32 {
if !tries.is_null() {
*tries = sw & 0xfi32;
}
- Enum5::YKPIV_WRONG_PIN
+ ErrorKind::YKPIV_WRONG_PIN
} else if sw == 0x6983i32 {
- Enum5::YKPIV_PIN_LOCKED
+ ErrorKind::YKPIV_PIN_LOCKED
} else {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed changing pin, token response code: %x.\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed changing pin, token response code: {:x}.", sw);
}
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
} else {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_change_pin(
+pub fn ykpiv_change_pin(
mut state: *mut ykpiv_state,
- mut current_pin: *const u8,
+ mut current_pin: *const c_char,
mut current_pin_len: usize,
- mut new_pin: *const u8,
+ mut new_pin: *const c_char,
mut new_pin_len: usize,
mut tries: *mut i32,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR;
- if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- if !(Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_ensure_application_selected(state);
- res
- } as (i32))
- {
- res = _ykpiv_change_pin(
- state,
- 0i32,
- current_pin,
- current_pin_len,
- new_pin,
- new_pin_len,
- tries,
- );
- if res as (i32) == Enum5::YKPIV_OK as (i32)
- && (new_pin != 0i32 as (*mut ::std::os::raw::c_void) as (*const u8))
- {
- _cache_pin(state, new_pin, new_pin_len);
- }
- }
- _ykpiv_end_transaction(state);
- res
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_GENERIC_ERROR;
+
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
}
+
+ if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK {
+ res = _ykpiv_change_pin(
+ state,
+ 0i32,
+ current_pin,
+ current_pin_len,
+ new_pin,
+ new_pin_len,
+ tries,
+ );
+
+ if res == ErrorKind::YKPIV_OK && !new_pin.is_null() {
+ _cache_pin(state, new_pin, new_pin_len);
+ }
+ }
+
+ _ykpiv_end_transaction(state);
+ res
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_change_puk(
+pub fn ykpiv_change_puk(
mut state: *mut ykpiv_state,
- mut current_puk: *const u8,
+ mut current_puk: *const c_char,
mut current_puk_len: usize,
- mut new_puk: *const u8,
+ mut new_puk: *const c_char,
mut new_puk_len: usize,
mut tries: *mut i32,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR;
- if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- if !(Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_ensure_application_selected(state);
- res
- } as (i32))
- {
- res = _ykpiv_change_pin(
- state,
- 2i32,
- current_puk,
- current_puk_len,
- new_puk,
- new_puk_len,
- tries,
- );
- }
- _ykpiv_end_transaction(state);
- res
+) -> ErrorKind {
+ let mut res = ErrorKind::YKPIV_GENERIC_ERROR;
+
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
}
+
+ if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK {
+ res = _ykpiv_change_pin(
+ state,
+ 2,
+ current_puk,
+ current_puk_len,
+ new_puk,
+ new_puk_len,
+ tries,
+ );
+ }
+
+ _ykpiv_end_transaction(state);
+ res
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_unblock_pin(
+pub fn ykpiv_unblock_pin(
mut state: *mut ykpiv_state,
- mut puk: *const u8,
+ mut puk: *const c_char,
mut puk_len: usize,
- mut new_pin: *const u8,
+ mut new_pin: *const c_char,
mut new_pin_len: usize,
mut tries: *mut i32,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR;
- if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_GENERIC_ERROR;
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -2746,22 +2474,21 @@ pub unsafe extern "C" fn ykpiv_unblock_pin(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_fetch_object(
+pub fn ykpiv_fetch_object(
mut state: *mut ykpiv_state,
mut object_id: i32,
mut data: *mut u8,
mut len: *mut usize,
-) -> Enum5 {
- let mut res: Enum5;
- if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind;
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -2773,7 +2500,7 @@ pub unsafe extern "C" fn ykpiv_fetch_object(
}
}
-unsafe extern "C" fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut u8 {
+unsafe fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut u8 {
*{
let _old = buffer;
buffer = buffer.offset(1isize);
@@ -2815,35 +2542,34 @@ unsafe extern "C" fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut
buffer
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_fetch_object(
+pub fn _ykpiv_fetch_object(
mut state: *mut ykpiv_state,
mut object_id: i32,
mut data: *mut u8,
mut len: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut sw: i32;
let mut indata: [u8; 5];
let mut inptr: *mut u8 = indata.as_mut_ptr();
let mut templ: *mut u8 = 0i32 as (*mut u8);
- let mut res: Enum5;
+ let mut res: ErrorKind;
inptr = set_object(object_id, inptr);
- if inptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) {
- Enum5::YKPIV_INVALID_OBJECT
+ if inptr == 0i32 as (*mut c_void) as (*mut u8) {
+ ErrorKind::YKPIV_INVALID_OBJECT
} else if {
res = ykpiv_transfer_data(
state,
templ as (*const u8),
indata.as_mut_ptr() as (*const u8),
(inptr as (isize)).wrapping_sub(indata.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize),
+ / mem::size_of::() as (isize),
data,
len,
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
res
} else if sw == 0x9000i32 {
@@ -2855,56 +2581,53 @@ pub unsafe extern "C" fn _ykpiv_fetch_object(
(*len).wrapping_sub(1usize),
)
{
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
offs = _ykpiv_get_length(
data.offset(1isize) as (*const u8),
&mut outlen as (*mut usize),
);
(if offs == 0u32 {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else if outlen.wrapping_add(offs as (usize)).wrapping_add(1usize) != *len {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Invalid length indicated in object, total objlen is %lu, indicated length is %lu.\0").as_ptr(
- ),
+ eprintln!(
+ "Invalid length indicated in object, total objlen is {}, indicated length is {}.",
*len,
outlen
);
}
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
memmove(
- data as (*mut ::std::os::raw::c_void),
- data.offset(1isize).offset(offs as (isize)) as (*const ::std::os::raw::c_void),
+ data as (*mut c_void),
+ data.offset(1isize).offset(offs as (isize)) as (*const c_void),
outlen,
);
*len = outlen;
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
})
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_save_object(
+pub fn ykpiv_save_object(
mut state: *mut ykpiv_state,
mut object_id: i32,
mut indata: *mut u8,
mut len: usize,
-) -> Enum5 {
- let mut res: Enum5;
- if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind;
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -2916,25 +2639,24 @@ pub unsafe extern "C" fn ykpiv_save_object(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn _ykpiv_save_object(
+pub fn _ykpiv_save_object(
mut state: *mut ykpiv_state,
mut object_id: i32,
mut indata: *mut u8,
mut len: usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut data: [u8; 3072];
let mut dataptr: *mut u8 = data.as_mut_ptr();
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut sw: i32;
- let mut res: Enum5;
+ let mut res: ErrorKind;
let mut outlen: usize = 0usize;
- if len > ::std::mem::size_of::<[u8; 3072]>().wrapping_sub(9usize) {
- Enum5::YKPIV_SIZE_ERROR
+ if len > mem::size_of::<[u8; 3072]>().wrapping_sub(9usize) {
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
dataptr = set_object(object_id, dataptr);
- (if dataptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) {
- Enum5::YKPIV_INVALID_OBJECT
+ (if dataptr == 0i32 as (*mut c_void) as (*mut u8) {
+ ErrorKind::YKPIV_INVALID_OBJECT
} else {
*{
let _old = dataptr;
@@ -2942,11 +2664,7 @@ pub unsafe extern "C" fn _ykpiv_save_object(
_old
} = 0x53u8;
dataptr = dataptr.offset(_ykpiv_set_length(dataptr, len) as (isize));
- memcpy(
- dataptr as (*mut ::std::os::raw::c_void),
- indata as (*const ::std::os::raw::c_void),
- len,
- );
+ memcpy(dataptr as (*mut c_void), indata as (*const c_void), len);
dataptr = dataptr.offset(len as (isize));
(if {
res = _ykpiv_transfer_data(
@@ -2954,29 +2672,28 @@ pub unsafe extern "C" fn _ykpiv_save_object(
templ as (*const u8),
data.as_mut_ptr() as (*const u8),
(dataptr as (isize)).wrapping_sub(data.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize),
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
+ / mem::size_of::() as (isize),
+ 0i32 as (*mut c_void) as (*mut u8),
&mut outlen as (*mut usize),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32)
+ != ErrorKind::YKPIV_OK as (i32)
{
res
} else if 0x9000i32 == sw {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else if 0x6982i32 == sw {
- Enum5::YKPIV_AUTHENTICATION_ERROR
+ ErrorKind::YKPIV_AUTHENTICATION_ERROR
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
})
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_import_private_key(
+pub fn ykpiv_import_private_key(
mut state: *mut ykpiv_state,
key: u8,
mut algorithm: u8,
@@ -2994,13 +2711,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
mut ec_data_len: u8,
pin_policy: u8,
touch_policy: u8,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut key_data: [u8; 1024];
let mut in_ptr: *mut u8 = key_data.as_mut_ptr();
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut data: [u8; 256];
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 256]>();
+ let mut recv_len: usize = mem::size_of::<[u8; 256]>();
let mut elem_len: u32;
let mut sw: i32;
let mut params: [*const u8; 5];
@@ -3009,27 +2726,27 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
let mut n_params: u8;
let mut i: i32;
let mut param_tag: i32;
- let mut res: Enum5;
- if state == 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) {
- Enum5::YKPIV_GENERIC_ERROR
+ let mut res: ErrorKind;
+ if state == 0i32 as (*mut c_void) as (*mut ykpiv_state) {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else if key as (i32) == 0x9bi32
|| key as (i32) < 0x82i32
|| key as (i32) > 0x95i32 && (key as (i32) < 0x9ai32)
|| key as (i32) > 0x9ei32 && (key as (i32) != 0xf9i32)
{
- Enum5::YKPIV_KEY_ERROR
+ ErrorKind::YKPIV_KEY_ERROR
} else if pin_policy as (i32) != 0i32
&& (pin_policy as (i32) != 1i32)
&& (pin_policy as (i32) != 2i32)
&& (pin_policy as (i32) != 3i32)
{
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else if touch_policy as (i32) != 0i32
&& (touch_policy as (i32) != 1i32)
&& (touch_policy as (i32) != 2i32)
&& (touch_policy as (i32) != 3i32)
{
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32 {
if p_len
@@ -3037,9 +2754,9 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
.wrapping_add(dp_len)
.wrapping_add(dq_len)
.wrapping_add(qinv_len)
- >= ::std::mem::size_of::<[u8; 1024]>()
+ >= mem::size_of::<[u8; 1024]>()
{
- return Enum5::YKPIV_SIZE_ERROR;
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else {
if algorithm as (i32) == 0x6i32 {
elem_len = 64u32;
@@ -3047,13 +2764,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
if algorithm as (i32) == 0x7i32 {
elem_len = 128u32;
}
- if p == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- || q == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- || dp == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- || dq == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- || qinv == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
+ if p == 0i32 as (*mut c_void) as (*const u8)
+ || q == 0i32 as (*mut c_void) as (*const u8)
+ || dp == 0i32 as (*mut c_void) as (*const u8)
+ || dq == 0i32 as (*mut c_void) as (*const u8)
+ || qinv == 0i32 as (*mut c_void) as (*const u8)
{
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
} else {
params[0usize] = p;
lens[0usize] = p_len;
@@ -3070,8 +2787,8 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
}
}
} else if algorithm as (i32) == 0x11i32 || algorithm as (i32) == 0x14i32 {
- if ec_data_len as (usize) >= ::std::mem::size_of::<[u8; 1024]>() {
- return Enum5::YKPIV_SIZE_ERROR;
+ if ec_data_len as (usize) >= mem::size_of::<[u8; 1024]>() {
+ return ErrorKind::YKPIV_SIZE_ERROR;
} else {
if algorithm as (i32) == 0x11i32 {
elem_len = 32u32;
@@ -3079,8 +2796,8 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
if algorithm as (i32) == 0x14i32 {
elem_len = 48u32;
}
- if ec_data == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) {
- return Enum5::YKPIV_GENERIC_ERROR;
+ if ec_data == 0i32 as (*mut c_void) as (*const u8) {
+ return ErrorKind::YKPIV_GENERIC_ERROR;
} else {
params[0usize] = ec_data;
lens[0usize] = ec_data_len as (usize);
@@ -3089,7 +2806,7 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
}
}
} else {
- return Enum5::YKPIV_ALGORITHM_ERROR;
+ return ErrorKind::YKPIV_ALGORITHM_ERROR;
}
i = 0i32;
'loop24: loop {
@@ -3106,17 +2823,17 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
in_ptr = in_ptr.offset(_ykpiv_set_length(in_ptr, elem_len as (usize)) as (isize));
padding = (elem_len as (usize)).wrapping_sub(lens[i as (usize)]);
remaining = (key_data.as_mut_ptr() as (usize))
- .wrapping_add(::std::mem::size_of::<[u8; 1024]>())
+ .wrapping_add(mem::size_of::<[u8; 1024]>())
.wrapping_sub(in_ptr as (usize));
if padding > remaining {
_currentBlock = 39;
break;
}
- memset(in_ptr as (*mut ::std::os::raw::c_void), 0i32, padding);
+ memset(in_ptr as (*mut c_void), 0i32, padding);
in_ptr = in_ptr.offset(padding as (isize));
memcpy(
- in_ptr as (*mut ::std::os::raw::c_void),
- params[i as (usize)] as (*const ::std::os::raw::c_void),
+ in_ptr as (*mut c_void),
+ params[i as (usize)] as (*const c_void),
lens[i as (usize)],
);
in_ptr = in_ptr.offset(lens[i as (usize)] as (isize));
@@ -3157,13 +2874,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
_old
} = touch_policy;
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- return Enum5::YKPIV_PCSC_ERROR;
- } else if !(Enum5::YKPIV_OK as (i32) != {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ } else if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -3174,274 +2891,239 @@ pub unsafe extern "C" fn ykpiv_import_private_key(
templ as (*const u8),
key_data.as_mut_ptr() as (*const u8),
(in_ptr as (isize)).wrapping_sub(key_data.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize),
+ / mem::size_of::() as (isize),
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
);
res
} as (i32)
- != Enum5::YKPIV_OK as (i32))
+ != ErrorKind::YKPIV_OK as (i32))
{
if 0x9000i32 != sw {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
if sw == 0x6982i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
}
}
}
}
} else {
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
}
memset_s(
- key_data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 1024]>(),
+ key_data.as_mut_ptr() as (*mut c_void),
+ mem::size_of::<[u8; 1024]>(),
0i32,
- ::std::mem::size_of::<[u8; 1024]>(),
+ mem::size_of::<[u8; 1024]>(),
);
_ykpiv_end_transaction(state);
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_attest(
+pub fn ykpiv_attest(
mut state: *mut ykpiv_state,
key: u8,
mut data: *mut u8,
mut data_len: *mut usize,
-) -> Enum5 {
- let mut res: Enum5;
+) -> ErrorKind {
+ let mut res = ErrorKind::YKPIV_GENERIC_ERROR;
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut sw: i32;
let mut ul_data_len: usize;
- if state == 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state)
- || data == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8)
- || data_len == 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize)
- {
- Enum5::YKPIV_ARGUMENT_ERROR
- } else {
- ul_data_len = *data_len;
- (if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- if !(Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_ensure_application_selected(state);
- res
- } as (i32))
- {
- if !({
- res = ykpiv_transfer_data(
- state,
- templ as (*const u8),
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
- 0isize,
- data,
- &mut ul_data_len as (*mut usize),
- &mut sw as (*mut i32),
- );
- res
- } as (i32)
- != Enum5::YKPIV_OK as (i32))
- {
- if 0x9000i32 != sw {
- res = Enum5::YKPIV_GENERIC_ERROR;
- if 0x6d00i32 == sw {
- res = Enum5::YKPIV_NOT_SUPPORTED;
- }
- } else if *data.offset(0isize) as (i32) != 0x30i32 {
- res = Enum5::YKPIV_GENERIC_ERROR;
- } else {
- *data_len = ul_data_len;
- }
- }
- }
- _ykpiv_end_transaction(state);
- res
- })
+ if state.is_null() || data.is_null() || data_len.is_null() {
+ return ErrorKind::YKPIV_ARGUMENT_ERROR;
}
+
+ ul_data_len = *data_len;
+
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ }
+
+ if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK {
+ res = ykpiv_transfer_data(
+ state,
+ templ as (*const u8),
+ 0i32 as (*mut c_void) as (*const u8),
+ 0isize,
+ data,
+ &mut ul_data_len as (*mut usize),
+ &mut sw as (*mut i32),
+ );
+
+ if res == ErrorKind::YKPIV_OK {
+ if 0x9000i32 != sw {
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
+ if 0x6d00i32 == sw {
+ res = ErrorKind::YKPIV_NOT_SUPPORTED;
+ }
+ } else if *data as i32 != 0x30 {
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
+ } else {
+ *data_len = ul_data_len;
+ }
+ }
+ }
+
+ _ykpiv_end_transaction(state);
+ res
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_auth_getchallenge(
+pub fn ykpiv_auth_getchallenge(
mut state: *mut ykpiv_state,
mut challenge: *mut u8,
challenge_len: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut apdu: u_APDU = 0i32 as (u_APDU);
+) -> ErrorKind {
+ let mut res = ErrorKind::YKPIV_OK;
let mut data = [0u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32);
let mut sw: i32 = 0i32;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == challenge {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 8usize != challenge_len {
- Enum5::YKPIV_SIZE_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- if !(Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_ensure_application_selected(state);
- res
- } as (i32))
- {
- // get a challenge from the card
- // FIXME(tarcieri): Translate C code below
- /*
- memset(apdu.raw, 0, sizeof(apdu));
- apdu.st.ins = YKPIV_INS_AUTHENTICATE;
- apdu.st.p1 = YKPIV_ALGO_3DES; // triple des
- apdu.st.p2 = YKPIV_KEY_CARDMGM; // management key
- apdu.st.lc = 0x04;
- apdu.st.data[0] = 0x7c;
- apdu.st.data[1] = 0x02;
- apdu.st.data[2] = 0x81; //0x80;
- */
- if !({
- res = _send_data(
- state,
- &mut apdu as (*mut u_APDU),
- data.as_mut_ptr(),
- &mut recv_len as (*mut u32),
- &mut sw as (*mut i32),
+
+ if state.is_null() || challenge.is_null() {
+ return ErrorKind::YKPIV_GENERIC_ERROR;
+ }
+
+ if challenge_len != 8 {
+ return ErrorKind::YKPIV_SIZE_ERROR;
+ }
+
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ }
+
+ if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK {
+ let mut apdu = APDU::default();
+ apdu.ins = YKPIV_INS_AUTHENTICATE;
+ apdu.p1 = YKPIV_ALGO_3DES; // triple des
+ apdu.p2 = YKPIV_KEY_CARDMGM; // management key
+ apdu.lc = 0x04;
+ apdu.data[0] = 0x7c;
+ apdu.data[1] = 0x02;
+ apdu.data[2] = 0x81; //0x80;
+
+ res = _send_data(
+ state,
+ &mut apdu as (*mut APDU),
+ data.as_mut_ptr(),
+ &mut recv_len as (*mut u32),
+ &mut sw as (*mut i32),
+ );
+
+ if res != ErrorKind::YKPIV_OK {
+ if sw != 0x9000i32 {
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
+ } else {
+ memcpy(
+ challenge as (*mut c_void),
+ data.as_mut_ptr().offset(4isize) as (*const c_void),
+ 8usize,
);
- res
- } as (i32)
- != Enum5::YKPIV_OK as (i32))
- {
- if sw != 0x9000i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
- } else {
- memcpy(
- challenge as (*mut ::std::os::raw::c_void),
- data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void),
- 8usize,
- );
- }
}
}
- _ykpiv_end_transaction(state);
- res
}
+ _ykpiv_end_transaction(state);
+ res
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_auth_verifyresponse(
+pub fn ykpiv_auth_verifyresponse(
mut state: *mut ykpiv_state,
mut response: *mut u8,
response_len: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut apdu: u_APDU = 0i32 as (u_APDU);
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut data = [0u8; 261];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32);
+ let mut recv_len = data.len() as u32;
let mut sw: i32 = 0i32;
- // FIXME(tarcieri): dataptr should NOT be 0! Translate C code below
- let mut dataptr: *mut u8 = 0i32 as (*mut u8); // apdu.st.data
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == response {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 8usize != response_len {
- Enum5::YKPIV_SIZE_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
- res = _ykpiv_begin_transaction(state);
- res
- } as (i32)
- {
- Enum5::YKPIV_PCSC_ERROR
- } else {
- // send the response to the card and a challenge of our own.
- recv_len = ::std::mem::size_of::<[u8; 261]>() as (u32);
- // FIXME(tarcieri): Translate C code below
- /*
- memset(apdu.raw, 0, sizeof(apdu));
- apdu.st.ins = YKPIV_INS_AUTHENTICATE;
- apdu.st.p1 = YKPIV_ALGO_3DES; // triple des
- apdu.st.p2 = YKPIV_KEY_CARDMGM; // management key
- */
- *{
- let _old = dataptr;
- dataptr = dataptr.offset(1isize);
- _old
- } = 0x7cu8;
- *{
- let _old = dataptr;
- dataptr = dataptr.offset(1isize);
- _old
- } = 0xau8;
- *{
- let _old = dataptr;
- dataptr = dataptr.offset(1isize);
- _old
- } = 0x82u8;
- *{
- let _old = dataptr;
- dataptr = dataptr.offset(1isize);
- _old
- } = 8u8;
- memcpy(
- dataptr as (*mut ::std::os::raw::c_void),
- response as (*const ::std::os::raw::c_void),
- response_len,
- );
- dataptr = dataptr.offset(8isize);
- // FIXME(tarcieri): Translate C code below
- /* apdu.st.lc = (unsigned char)(dataptr - apdu.st.data); */
- if !({
- res = _send_data(
- state,
- &mut apdu as (*mut u_APDU),
- data.as_mut_ptr(),
- &mut recv_len as (*mut u32),
- &mut sw as (*mut i32),
- );
- res
- } as (i32)
- != Enum5::YKPIV_OK as (i32))
- {
- if sw != 0x9000i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
- }
- }
- memset_s(
- &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::(),
- 0i32,
- ::std::mem::size_of::(),
- );
- _ykpiv_end_transaction(state);
- res
+ let mut apdu = APDU::default();
+
+ let mut dataptr = apdu.data.as_mut_ptr();
+
+ if state.is_null() || response.is_null() {
+ return ErrorKind::YKPIV_GENERIC_ERROR;
}
+
+ if response_len != 8 {
+ return ErrorKind::YKPIV_SIZE_ERROR;
+ }
+
+ if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ }
+
+ // send the response to the card and a challenge of our own.
+ apdu.ins = YKPIV_INS_AUTHENTICATE;
+ apdu.p1 = YKPIV_ALGO_3DES; // triple des
+ apdu.p2 = YKPIV_KEY_CARDMGM; // management key
+
+ *{
+ let _old = dataptr;
+ dataptr = dataptr.offset(1isize);
+ _old
+ } = 0x7cu8;
+
+ *{
+ let _old = dataptr;
+ dataptr = dataptr.offset(1isize);
+ _old
+ } = 0xau8;
+
+ *{
+ let _old = dataptr;
+ dataptr = dataptr.offset(1isize);
+ _old
+ } = 0x82u8;
+
+ *{
+ let _old = dataptr;
+ dataptr = dataptr.offset(1isize);
+ _old
+ } = 8u8;
+
+ memcpy(
+ dataptr as *mut c_void,
+ response as *const c_void,
+ response_len,
+ );
+
+ dataptr = dataptr.offset(8isize);
+ apdu.lc = (dataptr as usize - apdu.data.as_ptr() as usize)
+ .try_into()
+ .unwrap();
+
+ res = _send_data(
+ state,
+ &mut apdu as (*mut APDU),
+ data.as_mut_ptr(),
+ &mut recv_len,
+ &mut sw,
+ );
+
+ if res == ErrorKind::YKPIV_OK && sw != 0x9000i32 {
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
+ }
+
+ apdu.zeroize();
+ _ykpiv_end_transaction(state);
+ res
}
static mut MGMT_AID: *const u8 = 0xa0i32 as (*const u8);
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut apdu: u_APDU;
+pub fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut apdu: APDU;
let mut data: [u8; 255];
- let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32);
+ let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32);
let mut sw: i32;
if state.is_null() {
- Enum5::YKPIV_ARGUMENT_ERROR
+ ErrorKind::YKPIV_ARGUMENT_ERROR
} else if {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
res
} else {
@@ -3456,31 +3138,26 @@ pub unsafe extern "C" fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state)
if {
res = _send_data(
state,
- &mut apdu as (*mut u_APDU),
+ &mut apdu as (*mut APDU),
data.as_mut_ptr(),
&mut recv_len as (*mut u32),
&mut sw as (*mut i32),
);
res
} as (i32)
- < Enum5::YKPIV_OK as (i32)
+ < ErrorKind::YKPIV_OK as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(),
- ykpiv_strerror(res),
+ eprintln!(
+ "Failed communicating with card: \'{}\'",
+ ykpiv_strerror(res)
);
}
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed selecting mgmt application: %04x\n\0").as_ptr(),
- sw,
- );
+ eprintln!("Failed selecting mgmt application: {:04x}", sw);
}
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
}
_ykpiv_end_transaction(state);
res
diff --git a/src/util.rs b/src/util.rs
index 4187752..aeea831 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,3 +1,6 @@
+// Adapted from yubico-piv-tool:
+//
+//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -25,38 +28,41 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#![allow(non_camel_case_types)]
+
+use crate::{
+ error::ErrorKind,
+ internal::{setting_get_bool, SettingBool, SettingSource},
+};
+use libc::{free, memcpy, memmove, time, time_t};
+use std::{ffi::CString, mem, os::raw::c_void};
+
extern "C" {
static mut _DefaultRuneLocale: Struct1;
fn __maskrune(arg1: i32, arg2: usize) -> i32;
- static mut __stderrp: *mut __sFILE;
- fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32;
fn __tolower(arg1: i32) -> i32;
fn __toupper(arg1: i32) -> i32;
- fn _ykpiv_alloc(state: *mut ykpiv_state, size: usize) -> *mut ::std::os::raw::c_void;
- fn _ykpiv_begin_transaction(state: *mut ykpiv_state) -> Enum5;
- fn _ykpiv_end_transaction(state: *mut ykpiv_state) -> Enum5;
- fn _ykpiv_ensure_application_selected(state: *mut ykpiv_state) -> Enum5;
+ fn _ykpiv_alloc(state: *mut ykpiv_state, size: usize) -> *mut c_void;
+ fn _ykpiv_begin_transaction(state: *mut ykpiv_state) -> ErrorKind;
+ fn _ykpiv_end_transaction(state: *mut ykpiv_state) -> ErrorKind;
+ fn _ykpiv_ensure_application_selected(state: *mut ykpiv_state) -> ErrorKind;
fn _ykpiv_fetch_object(
state: *mut ykpiv_state,
object_id: i32,
data: *mut u8,
len: *mut usize,
- ) -> Enum5;
- fn _ykpiv_free(state: *mut ykpiv_state, data: *mut ::std::os::raw::c_void);
+ ) -> ErrorKind;
+ fn _ykpiv_free(state: *mut ykpiv_state, data: *mut c_void);
fn _ykpiv_get_length(buffer: *const u8, len: *mut usize) -> u32;
fn _ykpiv_has_valid_length(buffer: *const u8, len: usize) -> bool;
fn _ykpiv_prng_generate(buffer: *mut u8, cb_req: usize) -> Enum7;
- fn _ykpiv_realloc(
- state: *mut ykpiv_state,
- address: *mut ::std::os::raw::c_void,
- size: usize,
- ) -> *mut ::std::os::raw::c_void;
+ fn _ykpiv_realloc(state: *mut ykpiv_state, address: *mut c_void, size: usize) -> *mut c_void;
fn _ykpiv_save_object(
state: *mut ykpiv_state,
object_id: i32,
indata: *mut u8,
len: usize,
- ) -> Enum5;
+ ) -> ErrorKind;
fn _ykpiv_set_length(buffer: *mut u8, length: usize) -> u32;
fn _ykpiv_transfer_data(
state: *mut ykpiv_state,
@@ -66,19 +72,8 @@ extern "C" {
out_data: *mut u8,
out_len: *mut usize,
sw: *mut i32,
- ) -> Enum5;
- fn fprintf(arg1: *mut __sFILE, arg2: *const u8, ...) -> i32;
- fn memcpy(
- __dst: *mut ::std::os::raw::c_void,
- __src: *const ::std::os::raw::c_void,
- __n: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memmove(
- __dst: *mut ::std::os::raw::c_void,
- __src: *const ::std::os::raw::c_void,
- __len: usize,
- ) -> *mut ::std::os::raw::c_void;
- fn memset_s(__s: *mut ::std::os::raw::c_void, __smax: usize, __c: i32, __n: usize) -> i32;
+ ) -> ErrorKind;
+ fn memset_s(__s: *mut c_void, __smax: usize, __c: i32, __n: usize) -> i32;
fn pkcs5_pbkdf2_sha1(
password: *const u8,
cb_password: usize,
@@ -88,8 +83,6 @@ extern "C" {
key: *const u8,
cb_key: usize,
) -> Enum11;
- fn setting_get_bool(sz_setting: *const u8, f_default: bool) -> _setting_bool_t;
- fn time(arg1: *mut isize) -> isize;
fn ykpiv_change_puk(
state: *mut ykpiv_state,
current_puk: *const u8,
@@ -97,8 +90,8 @@ extern "C" {
new_puk: *const u8,
new_puk_len: usize,
tries: *mut i32,
- ) -> Enum5;
- fn ykpiv_set_mgmkey(state: *mut ykpiv_state, new_key: *const u8) -> Enum5;
+ ) -> ErrorKind;
+ fn ykpiv_set_mgmkey(state: *mut ykpiv_state, new_key: *const u8) -> ErrorKind;
fn ykpiv_transfer_data(
state: *mut ykpiv_state,
templ: *const u8,
@@ -107,11 +100,9 @@ extern "C" {
out_data: *mut u8,
out_len: *mut usize,
sw: *mut i32,
- ) -> Enum5;
+ ) -> ErrorKind;
}
-enum __sFILEX {}
-
#[derive(Copy)]
#[repr(C)]
pub struct __sbuf {
@@ -125,62 +116,7 @@ impl Clone for __sbuf {
}
}
-#[derive(Copy)]
-#[repr(C)]
-pub struct __sFILE {
- pub _p: *mut u8,
- pub _r: i32,
- pub _w: i32,
- pub _flags: i16,
- pub _file: i16,
- pub _bf: __sbuf,
- pub _lbfsize: i32,
- pub _cookie: *mut ::std::os::raw::c_void,
- pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32,
- pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32,
- pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize,
- pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32,
- pub _ub: __sbuf,
- pub _extra: *mut __sFILEX,
- pub _ur: i32,
- pub _ubuf: [u8; 3],
- pub _nbuf: [u8; 1],
- pub _lb: __sbuf,
- pub _blksize: i32,
- pub _offset: isize,
-}
-
-impl Clone for __sFILE {
- fn clone(&self) -> Self {
- *self
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 {
- if {
- (*_p)._w = (*_p)._w - 1;
- (*_p)._w
- } >= 0i32
- || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32))
- {
- ({
- let _rhs = _c;
- let _lhs = &mut *{
- let _old = (*_p)._p;
- (*_p)._p = (*_p)._p.offset(1isize);
- _old
- };
- *_lhs = _rhs as (u8);
- *_lhs
- }) as (i32)
- } else {
- __swbuf(_c, _p)
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 {
+pub fn isascii(mut _c: i32) -> i32 {
(_c & !0x7fi32 == 0i32) as (i32)
}
@@ -230,8 +166,8 @@ impl Clone for Struct4 {
pub struct Struct1 {
pub __magic: [u8; 8],
pub __encoding: [u8; 32],
- pub __sgetrune: unsafe extern "C" fn(*const u8, usize, *mut *const u8) -> i32,
- pub __sputrune: unsafe extern "C" fn(i32, *mut u8, usize, *mut *mut u8) -> i32,
+ pub __sgetrune: unsafe fn(*const u8, usize, *mut *const u8) -> i32,
+ pub __sputrune: unsafe fn(i32, *mut u8, usize, *mut *mut u8) -> i32,
pub __invalid_rune: i32,
pub __runetype: [u32; 256],
pub __maplower: [i32; 256],
@@ -239,7 +175,7 @@ pub struct Struct1 {
pub __runetype_ext: Struct2,
pub __maplower_ext: Struct2,
pub __mapupper_ext: Struct2,
- pub __variable: *mut ::std::os::raw::c_void,
+ pub __variable: *mut c_void,
pub __variable_len: i32,
pub __ncharclasses: i32,
pub __charclasses: *mut Struct4,
@@ -251,8 +187,7 @@ impl Clone for Struct1 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __istype(mut _c: i32, mut _f: usize) -> i32 {
if isascii(_c) != 0 {
!(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32)
} else {
@@ -260,8 +195,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
+pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
if _c < 0i32 || _c >= 256i32 {
0i32
} else {
@@ -269,8 +203,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
+pub fn __wcwidth(mut _c: i32) -> i32 {
let mut _x: u32;
if _c == 0i32 {
0i32
@@ -286,144 +219,98 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 {
+pub fn isalnum(mut _c: i32) -> i32 {
__istype(_c, (0x100isize | 0x400isize) as (usize))
}
-#[no_mangle]
-pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 {
+pub fn isalpha(mut _c: i32) -> i32 {
__istype(_c, 0x100usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 {
+pub fn isblank(mut _c: i32) -> i32 {
__istype(_c, 0x20000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 {
+pub fn iscntrl(mut _c: i32) -> i32 {
__istype(_c, 0x200usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 {
+pub fn isdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 {
+pub fn isgraph(mut _c: i32) -> i32 {
__istype(_c, 0x800usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn islower(mut _c: i32) -> i32 {
+pub fn islower(mut _c: i32) -> i32 {
__istype(_c, 0x1000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 {
+pub fn isprint(mut _c: i32) -> i32 {
__istype(_c, 0x40000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 {
+pub fn ispunct(mut _c: i32) -> i32 {
__istype(_c, 0x2000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 {
+pub fn isspace(mut _c: i32) -> i32 {
__istype(_c, 0x4000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 {
+pub fn isupper(mut _c: i32) -> i32 {
__istype(_c, 0x8000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 {
+pub fn isxdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 {
+pub fn toascii(mut _c: i32) -> i32 {
_c & 0x7fi32
}
-#[no_mangle]
-pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 {
+pub fn tolower(mut _c: i32) -> i32 {
__tolower(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 {
+pub fn toupper(mut _c: i32) -> i32 {
__toupper(_c)
}
-#[no_mangle]
-pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 {
+pub fn digittoint(mut _c: i32) -> i32 {
__maskrune(_c, 0xfusize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 {
+pub fn ishexnumber(mut _c: i32) -> i32 {
__istype(_c, 0x10000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 {
+pub fn isideogram(mut _c: i32) -> i32 {
__istype(_c, 0x80000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 {
+pub fn isnumber(mut _c: i32) -> i32 {
__istype(_c, 0x400usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 {
+pub fn isphonogram(mut _c: i32) -> i32 {
__istype(_c, 0x200000usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 {
+pub fn isrune(mut _c: i32) -> i32 {
__istype(_c, 0xfffffff0usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 {
+pub fn isspecial(mut _c: i32) -> i32 {
__istype(_c, 0x100000usize)
}
-#[no_mangle]
pub static mut CHUID_TMPL: *const u8 = 0x30i32 as (*const u8);
-#[no_mangle]
pub static mut CCC_TMPL: *const u8 = 0xf0i32 as (*const u8);
-#[derive(Clone, Copy)]
-#[repr(i32)]
-pub enum Enum5 {
- YKPIV_OK = 0i32,
- YKPIV_MEMORY_ERROR = -1i32,
- YKPIV_PCSC_ERROR = -2i32,
- YKPIV_SIZE_ERROR = -3i32,
- YKPIV_APPLET_ERROR = -4i32,
- YKPIV_AUTHENTICATION_ERROR = -5i32,
- YKPIV_RANDOMNESS_ERROR = -6i32,
- YKPIV_GENERIC_ERROR = -7i32,
- YKPIV_KEY_ERROR = -8i32,
- YKPIV_PARSE_ERROR = -9i32,
- YKPIV_WRONG_PIN = -10i32,
- YKPIV_INVALID_OBJECT = -11i32,
- YKPIV_ALGORITHM_ERROR = -12i32,
- YKPIV_PIN_LOCKED = -13i32,
- YKPIV_ARGUMENT_ERROR = -14i32,
- YKPIV_RANGE_ERROR = -15i32,
- YKPIV_NOT_SUPPORTED = -16i32,
-}
-
#[derive(Copy)]
#[repr(C)]
pub struct Struct6 {
@@ -436,24 +323,20 @@ impl Clone for Struct6 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_get_cardid(
- mut state: *mut ykpiv_state,
- mut cardid: *mut Struct6,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_util_get_cardid(mut state: *mut ykpiv_state, mut cardid: *mut Struct6) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3063];
- let mut len: usize = ::std::mem::size_of::<[u8; 3063]>();
+ let mut len: usize = mem::size_of::<[u8; 3063]>();
if cardid.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -464,13 +347,13 @@ pub unsafe extern "C" fn ykpiv_util_get_cardid(
buf.as_mut_ptr(),
&mut len as (*mut usize),
);
- if Enum5::YKPIV_OK as (i32) == res as (i32) {
+ if ErrorKind::YKPIV_OK as (i32) == res as (i32) {
if len != 59usize {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
} else {
memcpy(
- (*cardid).data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- buf.as_mut_ptr().offset(29isize) as (*const ::std::os::raw::c_void),
+ (*cardid).data.as_mut_ptr() as (*mut c_void),
+ buf.as_mut_ptr().offset(29isize) as (*const c_void),
16usize,
);
}
@@ -488,52 +371,48 @@ pub enum Enum7 {
PRNG_GENERAL_ERROR = -1i32,
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_set_cardid(
- mut state: *mut ykpiv_state,
- mut cardid: *const Struct6,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_util_set_cardid(mut state: *mut ykpiv_state, mut cardid: *const Struct6) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut id: [u8; 16];
let mut buf: [u8; 59];
let mut len: usize = 0usize;
if state.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if cardid.is_null() {
if Enum7::PRNG_OK as (i32)
- != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 16]>()) as (i32)
+ != _ykpiv_prng_generate(id.as_mut_ptr(), mem::size_of::<[u8; 16]>()) as (i32)
{
- return Enum5::YKPIV_RANDOMNESS_ERROR;
+ return ErrorKind::YKPIV_RANDOMNESS_ERROR;
}
} else {
memcpy(
- id.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- (*cardid).data.as_mut_ptr() as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 16]>(),
+ id.as_mut_ptr() as (*mut c_void),
+ (*cardid).data.as_mut_ptr() as (*const c_void),
+ mem::size_of::<[u8; 16]>(),
);
}
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
memcpy(
- buf.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- CHUID_TMPL as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr() as (*mut c_void),
+ CHUID_TMPL as (*const c_void),
59usize,
);
memcpy(
- buf.as_mut_ptr().offset(29isize) as (*mut ::std::os::raw::c_void),
- id.as_mut_ptr() as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 16]>(),
+ buf.as_mut_ptr().offset(29isize) as (*mut c_void),
+ id.as_mut_ptr() as (*const c_void),
+ mem::size_of::<[u8; 16]>(),
);
len = 59usize;
res = _ykpiv_save_object(state, 0x5fc102i32, buf.as_mut_ptr(), len);
@@ -556,24 +435,20 @@ impl Clone for Struct8 {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_get_cccid(
- mut state: *mut ykpiv_state,
- mut ccc: *mut Struct8,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_util_get_cccid(mut state: *mut ykpiv_state, mut ccc: *mut Struct8) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3063];
- let mut len: usize = ::std::mem::size_of::<[u8; 3063]>();
+ let mut len: usize = mem::size_of::<[u8; 3063]>();
if ccc.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -584,13 +459,13 @@ pub unsafe extern "C" fn ykpiv_util_get_cccid(
buf.as_mut_ptr(),
&mut len as (*mut usize),
);
- if Enum5::YKPIV_OK as (i32) == res as (i32) {
+ if ErrorKind::YKPIV_OK as (i32) == res as (i32) {
if len != 51usize {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
} else {
memcpy(
- (*ccc).data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- buf.as_mut_ptr().offset(9isize) as (*const ::std::os::raw::c_void),
+ (*ccc).data.as_mut_ptr() as (*mut c_void),
+ buf.as_mut_ptr().offset(9isize) as (*const c_void),
14usize,
);
}
@@ -601,52 +476,48 @@ pub unsafe extern "C" fn ykpiv_util_get_cccid(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_set_cccid(
- mut state: *mut ykpiv_state,
- mut ccc: *const Struct8,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_util_set_cccid(mut state: *mut ykpiv_state, mut ccc: *const Struct8) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut id: [u8; 14];
let mut buf: [u8; 51];
let mut len: usize = 0usize;
if state.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if ccc.is_null() {
if Enum7::PRNG_OK as (i32)
- != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 14]>()) as (i32)
+ != _ykpiv_prng_generate(id.as_mut_ptr(), mem::size_of::<[u8; 14]>()) as (i32)
{
- return Enum5::YKPIV_RANDOMNESS_ERROR;
+ return ErrorKind::YKPIV_RANDOMNESS_ERROR;
}
} else {
memcpy(
- id.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- (*ccc).data.as_mut_ptr() as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 14]>(),
+ id.as_mut_ptr() as (*mut c_void),
+ (*ccc).data.as_mut_ptr() as (*const c_void),
+ mem::size_of::<[u8; 14]>(),
);
}
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
len = 51usize;
memcpy(
- buf.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- CCC_TMPL as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr() as (*mut c_void),
+ CCC_TMPL as (*const c_void),
len,
);
memcpy(
- buf.as_mut_ptr().offset(9isize) as (*mut ::std::os::raw::c_void),
- id.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr().offset(9isize) as (*mut c_void),
+ id.as_mut_ptr() as (*const c_void),
14usize,
);
res = _ykpiv_save_object(state, 0x5fc107i32, buf.as_mut_ptr(), len);
@@ -660,15 +531,10 @@ pub unsafe extern "C" fn ykpiv_util_set_cccid(
#[derive(Copy)]
#[repr(C)]
pub struct ykpiv_allocator {
- pub pfn_alloc:
- unsafe extern "C" fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void,
- pub pfn_realloc: unsafe extern "C" fn(
- *mut ::std::os::raw::c_void,
- *mut ::std::os::raw::c_void,
- usize,
- ) -> *mut ::std::os::raw::c_void,
- pub pfn_free: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void),
- pub alloc_data: *mut ::std::os::raw::c_void,
+ pub pfn_alloc: unsafe fn(*mut c_void, usize) -> *mut c_void,
+ pub pfn_realloc: unsafe fn(*mut c_void, *mut c_void, usize) -> *mut c_void,
+ pub pfn_free: unsafe fn(*mut c_void, *mut c_void),
+ pub alloc_data: *mut c_void,
}
impl Clone for ykpiv_allocator {
@@ -710,8 +576,7 @@ impl Clone for ykpiv_state {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_devicemodel(mut state: *mut ykpiv_state) -> u32 {
+pub fn ykpiv_util_devicemodel(mut state: *mut ykpiv_state) -> u32 {
if state.is_null() || (*state).context == 0 || (*state).context as (usize) == -1i32 as (usize) {
0x0u32
} else {
@@ -737,18 +602,17 @@ impl Clone for _ykpiv_key {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_list_keys(
+pub fn ykpiv_util_list_keys(
mut state: *mut ykpiv_state,
mut key_count: *mut u8,
mut data: *mut *mut _ykpiv_key,
mut data_len: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut pKey: *mut _ykpiv_key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_key);
- let mut pData: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
- let mut pTemp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut pKey: *mut _ykpiv_key = 0i32 as (*mut c_void) as (*mut _ykpiv_key);
+ let mut pData: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
+ let mut pTemp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cbData: usize = 0usize;
let mut offset: usize = 0usize;
let mut buf: [u8; 3072];
@@ -757,59 +621,59 @@ pub unsafe extern "C" fn ykpiv_util_list_keys(
let mut cbRealloc: usize = 0usize;
let CB_PAGE: usize = 4096usize;
let mut SLOTS: *const u8 = 0x9ai32 as (*const u8);
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut _ykpiv_key) == data
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == data_len
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == key_count
+ if 0i32 as (*mut c_void) as (*mut *mut _ykpiv_key) == data
+ || 0i32 as (*mut c_void) as (*mut usize) == data_len
+ || 0i32 as (*mut c_void) as (*mut u8) == key_count
{
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
*key_count = 0u8;
- *data = 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_key);
+ *data = 0i32 as (*mut c_void) as (*mut _ykpiv_key);
*data_len = 0usize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == {
+ if 0i32 as (*mut c_void) as (*mut u8) == {
pData = _ykpiv_alloc(state, CB_PAGE) as (*mut u8);
pData
} {
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
cbData = CB_PAGE;
i = 0usize;
'loop5: loop {
- if !(i < ::std::mem::size_of::<*const u8>()) {
+ if !(i < mem::size_of::<*const u8>()) {
_currentBlock = 6;
break;
}
- cbBuf = ::std::mem::size_of::<[u8; 3072]>();
+ cbBuf = mem::size_of::<[u8; 3072]>();
res = _read_certificate(
state,
*SLOTS.offset(i as (isize)),
buf.as_mut_ptr(),
&mut cbBuf as (*mut usize),
);
- if res as (i32) == Enum5::YKPIV_OK as (i32) && (cbBuf > 0usize) {
- cbRealloc = if ::std::mem::size_of::<_ykpiv_key>()
+ if res as (i32) == ErrorKind::YKPIV_OK as (i32) && (cbBuf > 0usize) {
+ cbRealloc = if mem::size_of::<_ykpiv_key>()
.wrapping_add(cbBuf)
.wrapping_sub(1usize)
> cbData.wrapping_sub(offset)
{
- (if ::std::mem::size_of::<_ykpiv_key>()
+ (if mem::size_of::<_ykpiv_key>()
.wrapping_add(cbBuf)
.wrapping_sub(1usize)
.wrapping_sub(cbData.wrapping_sub(offset))
> CB_PAGE
{
- ::std::mem::size_of::<_ykpiv_key>()
+ mem::size_of::<_ykpiv_key>()
.wrapping_add(cbBuf)
.wrapping_sub(1usize)
.wrapping_sub(cbData.wrapping_sub(offset))
@@ -823,7 +687,7 @@ pub unsafe extern "C" fn ykpiv_util_list_keys(
if {
pTemp = _ykpiv_realloc(
state,
- pData as (*mut ::std::os::raw::c_void),
+ pData as (*mut c_void),
cbData.wrapping_add(cbRealloc),
) as (*mut u8);
pTemp
@@ -834,19 +698,19 @@ pub unsafe extern "C" fn ykpiv_util_list_keys(
break;
}
pData = pTemp;
- pTemp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ pTemp = 0i32 as (*mut c_void) as (*mut u8);
}
cbData = cbData.wrapping_add(cbRealloc);
pKey = pData.offset(offset as (isize)) as (*mut _ykpiv_key);
(*pKey).slot = *SLOTS.offset(i as (isize));
(*pKey).cert_len = cbBuf as (u16);
memcpy(
- (*pKey).cert.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- buf.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ (*pKey).cert.as_mut_ptr() as (*mut c_void),
+ buf.as_mut_ptr() as (*const c_void),
cbBuf,
);
offset = offset.wrapping_add(
- ::std::mem::size_of::<_ykpiv_key>()
+ mem::size_of::<_ykpiv_key>()
.wrapping_add(cbBuf)
.wrapping_sub(1usize),
);
@@ -856,74 +720,66 @@ pub unsafe extern "C" fn ykpiv_util_list_keys(
}
if _currentBlock == 6 {
*data = pData as (*mut _ykpiv_key);
- pData = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ pData = 0i32 as (*mut c_void) as (*mut u8);
if !data_len.is_null() {
*data_len = offset;
}
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else {
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
}
}
}
if !pData.is_null() {
- _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void));
+ _ykpiv_free(state, pData as (*mut c_void));
}
_ykpiv_end_transaction(state);
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_free(
- mut state: *mut ykpiv_state,
- mut data: *mut ::std::os::raw::c_void,
-) -> Enum5 {
- if data.is_null() {
- Enum5::YKPIV_OK
- } else if state.is_null() || (*state).allocator.pfn_free == 0 {
- Enum5::YKPIV_GENERIC_ERROR
- } else {
- _ykpiv_free(state, data);
- Enum5::YKPIV_OK
+pub fn ykpiv_util_free(mut _state: *mut ykpiv_state, mut data: *mut c_void) -> ErrorKind {
+ if !data.is_null() {
+ free(data);
}
+
+ ErrorKind::YKPIV_OK
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_read_cert(
+pub fn ykpiv_util_read_cert(
mut state: *mut ykpiv_state,
mut slot: u8,
mut data: *mut *mut u8,
mut data_len: *mut usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3072];
- let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>();
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut u8) == data
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == data_len
+ let mut cbBuf: usize = mem::size_of::<[u8; 3072]>();
+ if 0i32 as (*mut c_void) as (*mut *mut u8) == data
+ || 0i32 as (*mut c_void) as (*mut usize) == data_len
{
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
*data = 0i32 as (*mut u8);
*data_len = 0usize;
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = _read_certificate(state, slot, buf.as_mut_ptr(), &mut cbBuf as (*mut usize));
res
} as (i32)
{
if cbBuf == 0usize {
- *data = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ *data = 0i32 as (*mut c_void) as (*mut u8);
*data_len = 0usize;
} else if {
*data = _ykpiv_alloc(state, cbBuf) as (*mut u8);
@@ -931,11 +787,11 @@ pub unsafe extern "C" fn ykpiv_util_read_cert(
}
.is_null()
{
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
memcpy(
- *data as (*mut ::std::os::raw::c_void),
- buf.as_mut_ptr() as (*const ::std::os::raw::c_void),
+ *data as (*mut c_void),
+ buf.as_mut_ptr() as (*const c_void),
cbBuf,
);
*data_len = cbBuf;
@@ -947,23 +803,22 @@ pub unsafe extern "C" fn ykpiv_util_read_cert(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_write_cert(
+pub fn ykpiv_util_write_cert(
mut state: *mut ykpiv_state,
mut slot: u8,
mut data: *mut u8,
mut data_len: usize,
mut certinfo: u8,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- if Enum5::YKPIV_OK as (i32) != {
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -975,41 +830,30 @@ pub unsafe extern "C" fn ykpiv_util_write_cert(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_delete_cert(
- mut state: *mut ykpiv_state,
- mut slot: u8,
-) -> Enum5 {
- ykpiv_util_write_cert(
- state,
- slot,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
- 0usize,
- 0u8,
- )
+pub fn ykpiv_util_delete_cert(mut state: *mut ykpiv_state, mut slot: u8) -> ErrorKind {
+ ykpiv_util_write_cert(state, slot, 0i32 as (*mut c_void) as (*mut u8), 0usize, 0u8)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut puk: *mut u8 = 0x30i32 as (*mut u8);
let mut tries: i32 = -1i32;
let mut data: [u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_item: usize = 0usize;
let mut flags: u8 = 0u8;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32)
@@ -1021,13 +865,13 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En
'loop3: loop {
if _currentBlock == 3 {
if tries != 0i32 {
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = ykpiv_change_puk(
state,
puk as (*const u8),
- ::std::mem::size_of::<*mut u8>(),
+ mem::size_of::<*mut u8>(),
puk as (*const u8),
- ::std::mem::size_of::<*mut u8>(),
+ mem::size_of::<*mut u8>(),
&mut tries as (*mut i32),
);
res
@@ -1038,16 +882,16 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En
*_lhs = (*_lhs as (i32) + _rhs) as (u8);
_currentBlock = 3;
} else {
- if !(Enum5::YKPIV_PIN_LOCKED as (i32) == res as (i32)) {
+ if !(ErrorKind::YKPIV_PIN_LOCKED as (i32) == res as (i32)) {
_currentBlock = 3;
continue;
}
tries = 0i32;
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
_currentBlock = 3;
}
} else {
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _read_metadata(
state,
0x80u8,
@@ -1055,7 +899,7 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En
&mut cb_data as (*mut usize),
) as (i32)
{
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -1064,41 +908,39 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En
&mut cb_item as (*mut usize),
) as (i32)
{
- if ::std::mem::size_of::() == cb_item {
+ if mem::size_of::() == cb_item {
memcpy(
- &mut flags as (*mut u8) as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
+ &mut flags as (*mut u8) as (*mut c_void),
+ p_item as (*const c_void),
cb_item,
);
} else if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"admin flags exist, but are incorrect size = %lu\0")
- .as_ptr(),
+ eprintln!(
+ "admin flags exist, but are incorrect size = {}",
cb_item,
);
}
}
}
flags = (flags as (i32) | 0x1i32) as (u8);
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
!= _set_metadata_item(
data.as_mut_ptr(),
&mut cb_data as (*mut usize),
3063usize,
0x81u8,
&mut flags as (*mut u8),
- ::std::mem::size_of::(),
+ mem::size_of::(),
) as (i32)
{
if (*state).verbose == 0 {
_currentBlock = 20;
continue;
}
- fprintf(__stderrp, (*b"could not set admin flags\0").as_ptr());
+ eprintln!("could not set admin flags");
_currentBlock = 20;
} else {
- if !(Enum5::YKPIV_OK as (i32)
+ if !(ErrorKind::YKPIV_OK as (i32)
!= _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data) as (i32))
{
_currentBlock = 20;
@@ -1108,7 +950,7 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En
_currentBlock = 20;
continue;
}
- fprintf(__stderrp, (*b"could not write admin metadata\0").as_ptr());
+ eprintln!("could not write admin metadata");
_currentBlock = 20;
}
}
@@ -1139,35 +981,34 @@ impl Clone for _ykpiv_container {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_read_mscmap(
+pub fn ykpiv_util_read_mscmap(
mut state: *mut ykpiv_state,
mut containers: *mut *mut _ykpiv_container,
mut n_containers: *mut usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3072];
- let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>();
+ let mut cbBuf: usize = mem::size_of::<[u8; 3072]>();
let mut len: usize = 0usize;
- let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut _ykpiv_container) == containers
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == n_containers
+ let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
+ if 0i32 as (*mut c_void) as (*mut *mut _ykpiv_container) == containers
+ || 0i32 as (*mut c_void) as (*mut usize) == n_containers
{
- res = Enum5::YKPIV_GENERIC_ERROR;
- } else if Enum5::YKPIV_OK as (i32) != {
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- return Enum5::YKPIV_PCSC_ERROR;
- } else if !(Enum5::YKPIV_OK as (i32) != {
+ return ErrorKind::YKPIV_PCSC_ERROR;
+ } else if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
*containers = 0i32 as (*mut _ykpiv_container);
*n_containers = 0usize;
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = _ykpiv_fetch_object(
state,
0x5fff10i32,
@@ -1179,7 +1020,7 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap(
{
ptr = buf.as_mut_ptr();
if cbBuf < 2usize {
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else if *{
let _old = ptr;
ptr = ptr.offset(1isize);
@@ -1194,23 +1035,18 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap(
if len
> cbBuf.wrapping_sub(
((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize))
- as (usize),
+ / mem::size_of::() as (isize)) as (usize),
)
{
- res = Enum5::YKPIV_OK;
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == {
+ res = ErrorKind::YKPIV_OK;
+ } else if 0i32 as (*mut c_void) as (*mut _ykpiv_container) == {
*containers = _ykpiv_alloc(state, len) as (*mut _ykpiv_container);
*containers
} {
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
- memcpy(
- *containers as (*mut ::std::os::raw::c_void),
- ptr as (*const ::std::os::raw::c_void),
- len,
- );
- *n_containers = len.wrapping_div(::std::mem::size_of::<_ykpiv_container>());
+ memcpy(*containers as (*mut c_void), ptr as (*const c_void), len);
+ *n_containers = len.wrapping_div(mem::size_of::<_ykpiv_container>());
}
}
}
@@ -1219,7 +1055,7 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap(
res
}
-unsafe extern "C" fn _obj_size_max(mut state: *mut ykpiv_state) -> usize {
+unsafe fn _obj_size_max(mut state: *mut ykpiv_state) -> usize {
(if !state.is_null() && (*state).isNEO {
2048i32 - 9i32
} else {
@@ -1227,41 +1063,40 @@ unsafe extern "C" fn _obj_size_max(mut state: *mut ykpiv_state) -> usize {
}) as (usize)
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_write_mscmap(
+pub fn ykpiv_util_write_mscmap(
mut state: *mut ykpiv_state,
mut containers: *mut _ykpiv_container,
mut n_containers: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3063];
let mut offset: usize = 0usize;
let mut req_len: usize = 0usize;
- let mut data_len: usize = n_containers.wrapping_mul(::std::mem::size_of::<_ykpiv_container>());
- if Enum5::YKPIV_OK as (i32) != {
+ let mut data_len: usize = n_containers.wrapping_mul(mem::size_of::<_ykpiv_container>());
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == containers
+ if 0i32 as (*mut c_void) as (*mut _ykpiv_container) == containers
|| 0usize == n_containers
{
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) != containers
+ if 0i32 as (*mut c_void) as (*mut _ykpiv_container) != containers
|| 0usize != n_containers
{
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
} else {
res = _ykpiv_save_object(
state,
0x5fff10i32,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
+ 0i32 as (*mut c_void) as (*mut u8),
0usize,
);
}
@@ -1270,7 +1105,7 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap(
.wrapping_add(_ykpiv_set_length(buf.as_mut_ptr(), data_len) as (usize))
.wrapping_add(data_len);
if req_len > _obj_size_max(state) {
- res = Enum5::YKPIV_SIZE_ERROR;
+ res = ErrorKind::YKPIV_SIZE_ERROR;
} else {
buf[{
let _old = offset;
@@ -1282,8 +1117,8 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap(
data_len,
) as (usize));
memcpy(
- buf.as_mut_ptr().offset(offset as (isize)) as (*mut ::std::os::raw::c_void),
- containers as (*mut u8) as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void),
+ containers as (*mut u8) as (*const c_void),
data_len,
);
offset = offset.wrapping_add(data_len);
@@ -1296,35 +1131,34 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_read_msroots(
+pub fn ykpiv_util_read_msroots(
mut state: *mut ykpiv_state,
mut data: *mut *mut u8,
mut data_len: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3072];
- let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>();
+ let mut cbBuf: usize = mem::size_of::<[u8; 3072]>();
let mut len: usize = 0usize;
- let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut object_id: i32 = 0i32;
let mut tag: u8 = 0u8;
- let mut pData: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
- let mut pTemp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut pData: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
+ let mut pTemp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cbData: usize = 0usize;
let mut cbRealloc: usize = 0usize;
let mut offset: usize = 0usize;
if data.is_null() || data_len.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -1332,11 +1166,11 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
*data = 0i32 as (*mut u8);
*data_len = 0usize;
cbData = _obj_size_max(state);
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == {
+ if 0i32 as (*mut c_void) as (*mut u8) == {
pData = _ykpiv_alloc(state, cbData) as (*mut u8);
pData
} {
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
object_id = 0x5fff11i32;
'loop5: loop {
@@ -1344,8 +1178,8 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
_currentBlock = 15;
break;
}
- cbBuf = ::std::mem::size_of::<[u8; 3072]>();
- if Enum5::YKPIV_OK as (i32) != {
+ cbBuf = mem::size_of::<[u8; 3072]>();
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_fetch_object(
state,
object_id,
@@ -1380,7 +1214,7 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
if len
> cbBuf.wrapping_sub(
((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize))
+ / mem::size_of::() as (isize))
as (usize),
)
{
@@ -1396,7 +1230,7 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
if {
pTemp = _ykpiv_realloc(
state,
- pData as (*mut ::std::os::raw::c_void),
+ pData as (*mut c_void),
cbData.wrapping_add(cbRealloc),
) as (*mut u8);
pTemp
@@ -1407,12 +1241,12 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
break;
}
pData = pTemp;
- pTemp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ pTemp = 0i32 as (*mut c_void) as (*mut u8);
}
cbData = cbData.wrapping_add(cbRealloc);
memcpy(
- pData.offset(offset as (isize)) as (*mut ::std::os::raw::c_void),
- ptr as (*const ::std::os::raw::c_void),
+ pData.offset(offset as (isize)) as (*mut c_void),
+ ptr as (*const c_void),
len,
);
offset = offset.wrapping_add(len);
@@ -1425,35 +1259,34 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots(
if _currentBlock == 21 {
} else if _currentBlock == 15 {
*data = pData;
- pData = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ pData = 0i32 as (*mut c_void) as (*mut u8);
*data_len = offset;
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else if _currentBlock == 16 {
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else if _currentBlock == 17 {
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else if _currentBlock == 18 {
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
} else {
- res = Enum5::YKPIV_OK;
+ res = ErrorKind::YKPIV_OK;
}
}
}
if !pData.is_null() {
- _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void));
+ _ykpiv_free(state, pData as (*mut c_void));
}
_ykpiv_end_transaction(state);
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_write_msroots(
+pub fn ykpiv_util_write_msroots(
mut state: *mut ykpiv_state,
mut data: *mut u8,
mut data_len: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf: [u8; 3063];
let mut offset: usize = 0usize;
let mut data_offset: usize = 0usize;
@@ -1461,27 +1294,26 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots(
let mut n_objs: usize = 0usize;
let mut i: u32 = 0u32;
let mut cb_obj_max: usize = _obj_size_max(state);
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == data || 0usize == data_len {
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) != data || 0usize != data_len
- {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ if 0i32 as (*mut c_void) as (*mut u8) == data || 0usize == data_len {
+ if 0i32 as (*mut c_void) as (*mut u8) != data || 0usize != data_len {
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
} else {
res = _ykpiv_save_object(
state,
0x5fff11i32,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
+ 0i32 as (*mut c_void) as (*mut u8),
0usize,
);
}
@@ -1490,7 +1322,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots(
.wrapping_div(cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize)))
.wrapping_add(1usize);
if n_objs > 5usize {
- res = Enum5::YKPIV_SIZE_ERROR;
+ res = ErrorKind::YKPIV_SIZE_ERROR;
} else {
i = 0u32;
'loop5: loop {
@@ -1519,9 +1351,8 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots(
data_chunk,
) as (usize));
memcpy(
- buf.as_mut_ptr().offset(offset as (isize))
- as (*mut ::std::os::raw::c_void),
- data.offset(data_offset as (isize)) as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void),
+ data.offset(data_offset as (isize)) as (*const c_void),
data_chunk,
);
offset = offset.wrapping_add(data_chunk);
@@ -1531,7 +1362,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots(
buf.as_mut_ptr(),
offset,
);
- if Enum5::YKPIV_OK as (i32) != res as (i32) {
+ if ErrorKind::YKPIV_OK as (i32) != res as (i32) {
break;
}
data_offset = data_offset.wrapping_add(data_chunk);
@@ -1545,29 +1376,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots(
}
}
-#[derive(Clone, Copy)]
-#[repr(i32)]
-pub enum _setting_source_t {
- SETTING_SOURCE_USER,
- SETTING_SOURCE_ADMIN,
- SETTING_SOURCE_DEFAULT,
-}
-
-#[derive(Copy)]
-#[repr(C)]
-pub struct _setting_bool_t {
- pub value: bool,
- pub source: _setting_source_t,
-}
-
-impl Clone for _setting_bool_t {
- fn clone(&self) -> Self {
- *self
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_generate_key(
+pub unsafe fn ykpiv_util_generate_key(
mut state: *mut ykpiv_state,
mut slot: u8,
mut algorithm: u8,
@@ -1579,45 +1388,35 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
mut exp_len: *mut usize,
mut point: *mut *mut u8,
mut point_len: *mut usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut in_data: [u8; 11];
let mut in_ptr: *mut u8 = in_data.as_mut_ptr();
let mut data: [u8; 1024];
let mut templ: *mut u8 = 0i32 as (*mut u8);
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 1024]>();
+ let mut recv_len: usize = mem::size_of::<[u8; 1024]>();
let mut sw: i32;
- let mut ptr_modulus: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut ptr_modulus: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_modulus: usize = 0usize;
- let mut ptr_exp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut ptr_exp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_exp: usize = 0usize;
- let mut ptr_point: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut ptr_point: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_point: usize = 0usize;
- let mut setting_roca = _setting_bool_t {
+ let mut setting_roca = SettingBool {
value: false,
- source: _setting_source_t::SETTING_SOURCE_DEFAULT,
+ source: SettingSource::SETTING_SOURCE_DEFAULT,
};
- let mut sz_setting_roca: *const u8 = (*b"Enable_Unsafe_Keygen_ROCA\0").as_ptr();
- let mut sz_roca_format
- : *const u8
- = (*b"YubiKey serial number %u is affected by vulnerability CVE-2017-15361 (ROCA) and should be replaced. On-chip key generation %s See YSA-2017-01 for additional information on device replacement and mitigation assistance.\n\0").as_ptr(
- );
- let mut sz_roca_allow_user: *const u8 =
- (*b"was permitted by an end-user configuration setting, but is not recommended.\0")
- .as_ptr();
- let mut sz_roca_allow_admin: *const u8 =
- (*b"was permitted by an administrator configuration setting, but is not recommended.\0")
- .as_ptr();
- let mut sz_roca_block_user: *const u8 =
- (*b"was blocked due to an end-user configuration setting.\0").as_ptr();
- let mut sz_roca_block_admin: *const u8 =
- (*b"was blocked due to an administrator configuration setting.\0").as_ptr();
- let mut sz_roca_default
- : *const u8
- = (*b"was permitted by default, but is not recommended. The default behavior will change in a future Yubico release.\0").as_ptr(
- );
+ let sz_setting_roca: &str = "Enable_Unsafe_Keygen_ROCA";
+ let sz_roca_allow_user: &str =
+ "was permitted by an end-user configuration setting, but is not recommended.";
+ let sz_roca_allow_admin: &str =
+ "was permitted by an administrator configuration setting, but is not recommended.";
+ let sz_roca_block_user: &str = "was blocked due to an end-user configuration setting.";
+ let sz_roca_block_admin: &str = "was blocked due to an administrator configuration setting.";
+ let sz_roca_default: &str = "was permitted by default, but is not recommended. The default behavior will change in a future Yubico release.";
+
if state.is_null() {
- Enum5::YKPIV_ARGUMENT_ERROR
+ ErrorKind::YKPIV_ARGUMENT_ERROR
} else {
if ykpiv_util_devicemodel(state) == (0x594b0000i32 | 0x34i32) as (u32)
&& (algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32)
@@ -1626,72 +1425,76 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
&& ((*state).ver.minor as (i32) < 3i32
|| (*state).ver.minor as (i32) == 3i32 && ((*state).ver.patch as (i32) < 5i32))
{
- let mut psz_msg: *const u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*const u8);
- setting_roca = setting_get_bool(sz_setting_roca, true);
+ let setting_name = CString::new(sz_setting_roca).unwrap();
+ setting_roca = setting_get_bool(setting_name.as_ptr(), true);
let switch9 = setting_roca.source;
- if switch9 as (i32) == _setting_source_t::SETTING_SOURCE_USER as (i32) {
- psz_msg = if setting_roca.value {
+
+ let psz_msg = if switch9 as (i32) == SettingSource::SETTING_SOURCE_USER as (i32) {
+ if setting_roca.value {
sz_roca_allow_user
} else {
sz_roca_block_user
- };
- } else if switch9 as (i32) == _setting_source_t::SETTING_SOURCE_ADMIN as (i32) {
- psz_msg = if setting_roca.value {
+ }
+ } else if switch9 as (i32) == SettingSource::SETTING_SOURCE_ADMIN as (i32) {
+ if setting_roca.value {
sz_roca_allow_admin
} else {
sz_roca_block_admin
- };
+ }
} else {
- psz_msg = sz_roca_default;
- }
- fprintf(__stderrp, sz_roca_format, (*state).serial, psz_msg);
+ sz_roca_default
+ };
+
+ eprintln!(
+ "YubiKey serial number {} is affected by vulnerability CVE-2017-15361 \
+ (ROCA) and should be replaced. On-chip key generation {} See \
+ YSA-2017-01 \
+ for additional information on device replacement and mitigation assistance",
+ (*state).serial,
+ psz_msg
+ );
+
if !setting_roca.value {
- return Enum5::YKPIV_NOT_SUPPORTED;
+ return ErrorKind::YKPIV_NOT_SUPPORTED;
}
}
}
if algorithm as (i32) == 0x14i32 || algorithm as (i32) == 0x11i32 {
if point.is_null() || point_len.is_null() {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Invalid output parameter for ECC algorithm\0").as_ptr(),
- );
+ eprintln!("Invalid output parameter for ECC algorithm",);
}
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
} else {
- *point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ *point = 0i32 as (*mut c_void) as (*mut u8);
*point_len = 0usize;
}
} else if algorithm as (i32) == 0x7i32 || algorithm as (i32) == 0x6i32 {
if modulus.is_null() || modulus_len.is_null() || exp.is_null() || exp_len.is_null() {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Invalid output parameter for RSA algorithm\0").as_ptr(),
- );
+ eprintln!("Invalid output parameter for RSA algorithm",);
}
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
} else {
- *modulus = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ *modulus = 0i32 as (*mut c_void) as (*mut u8);
*modulus_len = 0usize;
- *exp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ *exp = 0i32 as (*mut c_void) as (*mut u8);
*exp_len = 0usize;
}
} else {
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Invalid algorithm specified\0").as_ptr());
+ eprintln!("Invalid algorithm specified");
}
- return Enum5::YKPIV_GENERIC_ERROR;
+ return ErrorKind::YKPIV_GENERIC_ERROR;
}
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -1723,9 +1526,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
_old
} = algorithm;
if in_data[4usize] as (i32) == 0i32 {
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Unexpected algorithm.\n\0").as_ptr());
+ eprintln!("Unexpected algorithm.\n");
}
} else {
if pin_policy as (i32) != 0i32 {
@@ -1768,13 +1571,13 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
_old
} = touch_policy;
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_transfer_data(
state,
templ as (*const u8),
in_data.as_mut_ptr() as (*const u8),
(in_ptr as (isize)).wrapping_sub(in_data.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize),
+ / mem::size_of::() as (isize),
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
@@ -1783,46 +1586,37 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Failed to communicate.\n\0").as_ptr());
+ eprintln!("Failed to communicate.\n");
}
} else if sw != 0x9000i32 {
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Failed to generate new key (\0").as_ptr());
+ eprintln!("Failed to generate new key (");
}
if sw == 0x6b00i32 {
- res = Enum5::YKPIV_KEY_ERROR;
+ res = ErrorKind::YKPIV_KEY_ERROR;
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"incorrect slot)\n\0").as_ptr());
+ eprintln!("incorrect slot)\n");
}
} else if sw == 0x6a80i32 {
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
if (*state).verbose != 0 {
if pin_policy as (i32) != 0i32 {
- fprintf(
- __stderrp,
- (*b"pin policy not supported?)\n\0").as_ptr(),
- );
+ eprintln!("pin policy not supported?)\n",);
} else if touch_policy as (i32) != 0i32 {
- fprintf(
- __stderrp,
- (*b"touch policy not supported?)\n\0").as_ptr(),
- );
+ eprintln!("touch policy not supported?)\n",);
} else {
- fprintf(
- __stderrp,
- (*b"algorithm not supported?)\n\0").as_ptr(),
- );
+ eprintln!("algorithm not supported?)\n",);
}
}
} else if sw == 0x6982i32 {
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"not authenticated)\n\0").as_ptr());
+ eprintln!("not authenticated)");
}
} else {
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"error %x)\n\0").as_ptr(), sw);
+ eprintln!("error {:x})", sw);
}
}
} else if 0x6i32 == algorithm as (i32) || 0x7i32 == algorithm as (i32) {
@@ -1830,13 +1624,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
let mut len: usize = 0usize;
if *data_ptr as (i32) != 0x81i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to parse public key structure (modulus).\n\0")
- .as_ptr(),
- );
+ eprintln!("Failed to parse public key structure (modulus).");
}
- res = Enum5::YKPIV_PARSE_ERROR;
+ res = ErrorKind::YKPIV_PARSE_ERROR;
} else {
data_ptr = data_ptr.offset(1isize);
data_ptr = data_ptr.offset(_ykpiv_get_length(
@@ -1844,33 +1634,26 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
&mut len as (*mut usize),
) as (isize));
cb_modulus = len;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == {
+ if 0i32 as (*mut c_void) as (*mut u8) == {
ptr_modulus = _ykpiv_alloc(state, cb_modulus) as (*mut u8);
ptr_modulus
} {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to allocate memory for modulus.\n\0").as_ptr(),
- );
+ eprintln!("Failed to allocate memory for modulus.");
}
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
memcpy(
- ptr_modulus as (*mut ::std::os::raw::c_void),
- data_ptr as (*const ::std::os::raw::c_void),
+ ptr_modulus as (*mut c_void),
+ data_ptr as (*const c_void),
cb_modulus,
);
data_ptr = data_ptr.offset(len as (isize));
if *data_ptr as (i32) != 0x82i32 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to parse public key structure (public exponent).\n\0").as_ptr(
- )
- );
+ eprintln!("Failed to parse public key structure (public exponent).");
}
- res = Enum5::YKPIV_PARSE_ERROR;
+ res = ErrorKind::YKPIV_PARSE_ERROR;
} else {
data_ptr = data_ptr.offset(1isize);
data_ptr = data_ptr.offset(_ykpiv_get_length(
@@ -1879,31 +1662,27 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
)
as (isize));
cb_exp = len;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == {
+ if 0i32 as (*mut c_void) as (*mut u8) == {
ptr_exp = _ykpiv_alloc(state, cb_exp) as (*mut u8);
ptr_exp
} {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to allocate memory for public exponent.\n\0").as_ptr(
- )
- );
+ eprintln!(
+ "Failed to allocate memory for public exponent."
+ );
}
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
memcpy(
- ptr_exp as (*mut ::std::os::raw::c_void),
- data_ptr as (*const ::std::os::raw::c_void),
+ ptr_exp as (*mut c_void),
+ data_ptr as (*const c_void),
cb_exp,
);
*modulus = ptr_modulus;
- ptr_modulus =
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ ptr_modulus = 0i32 as (*mut c_void) as (*mut u8);
*modulus_len = cb_modulus;
*exp = ptr_exp;
- ptr_exp =
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ ptr_exp = 0i32 as (*mut c_void) as (*mut u8);
*exp_len = cb_exp;
}
}
@@ -1925,12 +1704,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
!= 0x86i32
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to parse public key structure.\n\0").as_ptr(),
- );
+ eprintln!("Failed to parse public key structure.\n",);
}
- res = Enum5::YKPIV_PARSE_ERROR;
+ res = ErrorKind::YKPIV_PARSE_ERROR;
} else if *{
let _old = data_ptr;
data_ptr = data_ptr.offset(1isize);
@@ -1939,50 +1715,46 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
!= len
{
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Unexpected length.\n\0").as_ptr());
+ eprintln!("Unexpected length.\n");
}
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
} else {
cb_point = len;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == {
+ if 0i32 as (*mut c_void) as (*mut u8) == {
ptr_point = _ykpiv_alloc(state, cb_point) as (*mut u8);
ptr_point
} {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"Failed to allocate memory for public point.\n\0")
- .as_ptr(),
- );
+ eprintln!("Failed to allocate memory for public point.");
}
- res = Enum5::YKPIV_MEMORY_ERROR;
+ res = ErrorKind::YKPIV_MEMORY_ERROR;
} else {
memcpy(
- ptr_point as (*mut ::std::os::raw::c_void),
- data_ptr as (*const ::std::os::raw::c_void),
+ ptr_point as (*mut c_void),
+ data_ptr as (*const c_void),
cb_point,
);
*point = ptr_point;
- ptr_point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ ptr_point = 0i32 as (*mut c_void) as (*mut u8);
*point_len = cb_point;
}
}
} else {
if (*state).verbose != 0 {
- fprintf(__stderrp, (*b"Wrong algorithm.\n\0").as_ptr());
+ eprintln!("Wrong algorithm.");
}
- res = Enum5::YKPIV_ALGORITHM_ERROR;
+ res = ErrorKind::YKPIV_ALGORITHM_ERROR;
}
}
}
if !ptr_modulus.is_null() {
- _ykpiv_free(state, modulus as (*mut ::std::os::raw::c_void));
+ _ykpiv_free(state, modulus as (*mut c_void));
}
if !ptr_exp.is_null() {
- _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void));
+ _ykpiv_free(state, ptr_exp as (*mut c_void));
}
if !ptr_point.is_null() {
- _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void));
+ _ykpiv_free(state, ptr_exp as (*mut c_void));
}
_ykpiv_end_transaction(state);
res
@@ -1992,6 +1764,7 @@ pub unsafe extern "C" fn ykpiv_util_generate_key(
#[derive(Clone, Copy)]
#[repr(i32)]
+#[allow(non_camel_case_types)]
pub enum Enum10 {
YKPIV_CONFIG_MGM_MANUAL = 0i32,
YKPIV_CONFIG_MGM_DERIVED = 1i32,
@@ -2014,39 +1787,38 @@ impl Clone for _ykpiv_config {
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_get_config(
+pub fn ykpiv_util_get_config(
mut state: *mut ykpiv_state,
mut config: *mut _ykpiv_config,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut data = [0u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_item: usize = 0usize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_config) == config {
- Enum5::YKPIV_GENERIC_ERROR
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if 0i32 as (*mut c_void) as (*mut _ykpiv_config) == config {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
(*config).protected_data_available = 0u8;
(*config).puk_blocked = 0u8;
(*config).puk_noblock_on_upgrade = 0u8;
(*config).pin_last_changed = 0u32;
(*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_MANUAL;
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _read_metadata(
state,
0x80u8,
@@ -2054,7 +1826,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
&mut cb_data as (*mut usize),
) as (i32)
{
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2070,7 +1842,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
(*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED;
}
}
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2081,17 +1853,13 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
{
if (*config).mgm_type as (i32) != Enum10::YKPIV_CONFIG_MGM_MANUAL as (i32) {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"conflicting types of mgm key administration configured\n\0").as_ptr(
- )
- );
+ eprintln!("conflicting types of mgm key administration configured");
}
} else {
(*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_DERIVED;
}
}
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2102,24 +1870,19 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
{
if 4usize != cb_item {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"pin timestamp in admin metadata is an invalid size\0")
- .as_ptr(),
- );
+ eprintln!("pin timestamp in admin metadata is an invalid size");
}
} else {
memcpy(
- &mut (*config).pin_last_changed as (*mut u32)
- as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
+ &mut (*config).pin_last_changed as (*mut u32) as (*mut c_void),
+ p_item as (*const c_void),
cb_item,
);
}
}
}
- cb_data = ::std::mem::size_of::<[u8; 3072]>();
- if Enum5::YKPIV_OK as (i32)
+ cb_data = mem::size_of::<[u8; 3072]>();
+ if ErrorKind::YKPIV_OK as (i32)
== _read_metadata(
state,
0x88u8,
@@ -2128,7 +1891,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
) as (i32)
{
(*config).protected_data_available = 1u8;
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2141,7 +1904,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
(*config).puk_noblock_on_upgrade = 1u8;
}
}
- if Enum5::YKPIV_OK as (i32)
+ if ErrorKind::YKPIV_OK as (i32)
== _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2154,10 +1917,8 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
!= Enum10::YKPIV_CONFIG_MGM_PROTECTED as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"conflicting types of mgm key administration configured - protected mgm exists\n\0").as_ptr(
- )
+ eprintln!(
+ "conflicting types of mgm key administration configured - protected mgm exists"
);
}
}
@@ -2171,28 +1932,27 @@ pub unsafe extern "C" fn ykpiv_util_get_config(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_state) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut ykrc: Enum5 = Enum5::YKPIV_OK;
+pub fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_state) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut ykrc: ErrorKind = ErrorKind::YKPIV_OK;
let mut data = [0u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut tnow: isize = 0isize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut tnow: time_t = 0;
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _read_metadata(
state,
0x80u8,
@@ -2204,37 +1964,29 @@ pub unsafe extern "C" fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_s
{
cb_data = 0usize;
}
- tnow = time(0i32 as (*mut ::std::os::raw::c_void) as (*mut isize));
- if Enum5::YKPIV_OK as (i32) != {
+ tnow = time(0 as *mut time_t);
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _set_metadata_item(
data.as_mut_ptr(),
&mut cb_data as (*mut usize),
3063usize,
0x83u8,
- &mut tnow as (*mut isize) as (*mut u8),
+ mem::transmute(&mut tnow),
4usize,
);
res
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not set pin timestamp, err = %d\n\0").as_ptr(),
- res as (i32),
- );
+ eprintln!("could not set pin timestamp, err = {}\n", res as (i32),);
}
- } else if Enum5::YKPIV_OK as (i32) != {
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data);
res
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not write admin data, err = %d\n\0").as_ptr(),
- res as (i32),
- );
+ eprintln!("could not write admin data, err = {}", res as (i32),);
}
}
}
@@ -2262,39 +2014,38 @@ pub enum Enum11 {
PKCS5_GENERAL_ERROR = -1i32,
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_get_derived_mgm(
+pub fn ykpiv_util_get_derived_mgm(
mut state: *mut ykpiv_state,
mut pin: *const u8,
pin_len: usize,
mut mgm: *mut _ykpiv_mgm,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut p5rc: Enum11 = Enum11::PKCS5_OK;
let mut data = [0u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_item: usize = 0usize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) == pin
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if 0i32 as (*mut c_void) as (*const u8) == pin
|| 0usize == pin_len
- || 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm
+ || 0i32 as (*mut c_void) as (*mut _ykpiv_mgm) == mgm
{
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = _read_metadata(
state,
0x80u8,
@@ -2304,7 +2055,7 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm(
res
} as (i32)
{
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2317,14 +2068,12 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm(
{
if cb_item != 16usize {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"derived mgm salt exists, but is incorrect size = %lu\n\0")
- .as_ptr(),
+ eprintln!(
+ "derived mgm salt exists, but is incorrect size = {}",
cb_item,
);
}
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
} else if Enum11::PKCS5_OK as (i32) != {
p5rc = pkcs5_pbkdf2_sha1(
pin,
@@ -2333,19 +2082,15 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm(
cb_item,
10000usize,
(*mgm).data.as_mut_ptr() as (*const u8),
- ::std::mem::size_of::<[u8; 24]>(),
+ mem::size_of::<[u8; 24]>(),
);
p5rc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"pbkdf2 failure, err = %d\n\0").as_ptr(),
- p5rc as (i32),
- );
+ eprintln!("pbkdf2 failure, err = {}", p5rc as (i32));
}
- res = Enum5::YKPIV_GENERIC_ERROR;
+ res = ErrorKind::YKPIV_GENERIC_ERROR;
}
}
}
@@ -2355,33 +2100,32 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm(
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_get_protected_mgm(
+pub fn ykpiv_util_get_protected_mgm(
mut state: *mut ykpiv_state,
mut mgm: *mut _ykpiv_mgm,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut data = [0u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_item: usize = 0usize;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm {
- Enum5::YKPIV_GENERIC_ERROR
- } else if Enum5::YKPIV_OK as (i32) != {
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if 0i32 as (*mut c_void) as (*mut _ykpiv_mgm) == mgm {
+ ErrorKind::YKPIV_GENERIC_ERROR
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- Enum5::YKPIV_PCSC_ERROR
+ ErrorKind::YKPIV_PCSC_ERROR
} else {
- if !(Enum5::YKPIV_OK as (i32) != {
+ if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
{
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _read_metadata(
state,
0x88u8,
@@ -2392,13 +2136,9 @@ pub unsafe extern "C" fn ykpiv_util_get_protected_mgm(
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not read protected data, err = %d\n\0").as_ptr(),
- res as (i32),
- );
+ eprintln!("could not read protected data, err = {}", res as (i32),);
}
- } else if Enum5::YKPIV_OK as (i32) != {
+ } else if ErrorKind::YKPIV_OK as (i32) != {
res = _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2410,72 +2150,69 @@ pub unsafe extern "C" fn ykpiv_util_get_protected_mgm(
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not read protected mgm from metadata, err = %d\n\0").as_ptr(),
+ eprintln!(
+ "could not read protected mgm from metadata, err = {}",
res as (i32),
);
}
- } else if cb_item != ::std::mem::size_of::<[u8; 24]>() {
+ } else if cb_item != mem::size_of::<[u8; 24]>() {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"protected data contains mgm, but is the wrong size = %lu\n\0").as_ptr(),
+ eprintln!(
+ "protected data contains mgm, but is the wrong size = {}",
cb_item,
);
}
- res = Enum5::YKPIV_AUTHENTICATION_ERROR;
+ res = ErrorKind::YKPIV_AUTHENTICATION_ERROR;
} else {
memcpy(
- (*mgm).data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
+ (*mgm).data.as_mut_ptr() as (*mut c_void),
+ p_item as (*const c_void),
cb_item,
);
}
}
memset_s(
- data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 3072]>(),
+ data.as_mut_ptr() as (*mut c_void),
+ mem::size_of::<[u8; 3072]>(),
0i32,
- ::std::mem::size_of::<[u8; 3072]>(),
+ mem::size_of::<[u8; 3072]>(),
);
_ykpiv_end_transaction(state);
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
+pub fn ykpiv_util_set_protected_mgm(
mut state: *mut ykpiv_state,
mut mgm: *mut _ykpiv_mgm,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut ykrc: Enum5 = Enum5::YKPIV_OK;
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut ykrc: ErrorKind = ErrorKind::YKPIV_OK;
let mut prngrc: Enum7 = Enum7::PRNG_OK;
let mut fGenerate: bool = false;
let mut mgm_key: [u8; 24];
let mut i: usize = 0usize;
let mut data = [0u8; 3072];
- let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>();
- let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut cb_data: usize = mem::size_of::<[u8; 3072]>();
+ let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_item: usize = 0usize;
let mut flags_1: u8 = 0u8;
- if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state {
- Enum5::YKPIV_GENERIC_ERROR
+ if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if mgm.is_null() {
fGenerate = true;
} else {
fGenerate = true;
memcpy(
- mgm_key.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- (*mgm).data.as_mut_ptr() as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 24]>(),
+ mgm_key.as_mut_ptr() as (*mut c_void),
+ (*mgm).data.as_mut_ptr() as (*const c_void),
+ mem::size_of::<[u8; 24]>(),
);
i = 0usize;
'loop3: loop {
- if !(i < ::std::mem::size_of::<[u8; 24]>()) {
+ if !(i < mem::size_of::<[u8; 24]>()) {
_currentBlock = 8;
break;
}
@@ -2490,13 +2227,13 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
fGenerate = false;
}
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_begin_transaction(state);
res
} as (i32)
{
- res = Enum5::YKPIV_PCSC_ERROR;
- } else if !(Enum5::YKPIV_OK as (i32) != {
+ res = ErrorKind::YKPIV_PCSC_ERROR;
+ } else if !(ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_ensure_application_selected(state);
res
} as (i32))
@@ -2504,10 +2241,8 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
'loop10: loop {
if fGenerate {
if Enum7::PRNG_OK as (i32) != {
- prngrc = _ykpiv_prng_generate(
- mgm_key.as_mut_ptr(),
- ::std::mem::size_of::<[u8; 24]>(),
- );
+ prngrc =
+ _ykpiv_prng_generate(mgm_key.as_mut_ptr(), mem::size_of::<[u8; 24]>());
prngrc
} as (i32)
{
@@ -2515,12 +2250,12 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
break;
}
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = ykpiv_set_mgmkey(state, mgm_key.as_mut_ptr() as (*const u8));
ykrc
} as (i32)
{
- if Enum5::YKPIV_KEY_ERROR as (i32) != ykrc as (i32) {
+ if ErrorKind::YKPIV_KEY_ERROR as (i32) != ykrc as (i32) {
_currentBlock = 44;
break;
}
@@ -2535,12 +2270,12 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
if _currentBlock == 16 {
if !mgm.is_null() {
memcpy(
- (*mgm).data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- mgm_key.as_mut_ptr() as (*const ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 24]>(),
+ (*mgm).data.as_mut_ptr() as (*mut c_void),
+ mgm_key.as_mut_ptr() as (*const c_void),
+ mem::size_of::<[u8; 24]>(),
);
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _read_metadata(
state,
0x88u8,
@@ -2552,39 +2287,31 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
{
cb_data = 0usize;
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _set_metadata_item(
data.as_mut_ptr(),
&mut cb_data as (*mut usize),
3063usize,
0x89u8,
mgm_key.as_mut_ptr(),
- ::std::mem::size_of::<[u8; 24]>(),
+ mem::size_of::<[u8; 24]>(),
);
ykrc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not set protected mgm item, err = %d\n\0").as_ptr(),
- ykrc as (i32),
- );
+ eprintln!("could not set protected mgm item, err = {}", ykrc as (i32),);
_currentBlock = 26;
} else {
_currentBlock = 26;
}
- } else if Enum5::YKPIV_OK as (i32) != {
+ } else if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _write_metadata(state, 0x88u8, data.as_mut_ptr(), cb_data);
ykrc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not write protected data, err = %d\n\0").as_ptr(),
- ykrc as (i32),
- );
+ eprintln!("could not write protected data, err = {}", ykrc as (i32),);
_currentBlock = 51;
} else {
_currentBlock = 51;
@@ -2594,8 +2321,8 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
}
if _currentBlock == 51 {
} else {
- cb_data = ::std::mem::size_of::<[u8; 3072]>();
- if Enum5::YKPIV_OK as (i32) != {
+ cb_data = mem::size_of::<[u8; 3072]>();
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _read_metadata(
state,
0x80u8,
@@ -2607,7 +2334,7 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
{
cb_data = 0usize;
} else {
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _get_metadata_item(
data.as_mut_ptr(),
cb_data,
@@ -2619,142 +2346,116 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm(
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"admin data exists, but flags are not present\n\0").as_ptr(),
- );
+ eprintln!("admin data exists, but flags are not present",);
}
}
- if cb_item == ::std::mem::size_of::() {
+ if cb_item == mem::size_of::() {
memcpy(
- &mut flags_1 as (*mut u8) as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
+ &mut flags_1 as (*mut u8) as (*mut c_void),
+ p_item as (*const c_void),
cb_item,
);
} else if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"admin data flags are an incorrect size = %lu\n\0").as_ptr(),
- cb_item,
- );
+ eprintln!("admin data flags are an incorrect size = {}", cb_item,);
}
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _set_metadata_item(
data.as_mut_ptr(),
&mut cb_data as (*mut usize),
3063usize,
0x82u8,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
+ 0i32 as (*mut c_void) as (*mut u8),
0usize,
);
ykrc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not unset derived mgm salt, err = %d\n\0").as_ptr(),
+ eprintln!(
+ "could not unset derived mgm salt, err = {}",
ykrc as (i32),
);
}
}
}
flags_1 = (flags_1 as (i32) | 0x2i32) as (u8);
- if Enum5::YKPIV_OK as (i32) != {
+ if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _set_metadata_item(
data.as_mut_ptr(),
&mut cb_data as (*mut usize),
3063usize,
0x81u8,
&mut flags_1 as (*mut u8),
- ::std::mem::size_of::(),
+ mem::size_of::(),
);
ykrc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not set admin flags item, err = %d\n\0").as_ptr(),
- ykrc as (i32),
- );
+ eprintln!("could not set admin flags item, err = {}", ykrc as (i32),);
}
- } else if Enum5::YKPIV_OK as (i32) != {
+ } else if ErrorKind::YKPIV_OK as (i32) != {
ykrc = _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data);
ykrc
} as (i32)
{
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not write admin data, err = %d\n\0").as_ptr(),
- ykrc as (i32),
- );
+ eprintln!("could not write admin data, err = {}", ykrc as (i32),);
}
}
}
} else if _currentBlock == 44 {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not set new derived mgm key, err = %d\n\0").as_ptr(),
- ykrc as (i32),
- );
+ eprintln!("could not set new derived mgm key, err = {}", ykrc as (i32),);
}
res = ykrc;
} else {
if (*state).verbose != 0 {
- fprintf(
- __stderrp,
- (*b"could not generate new mgm, err = %d\n\0").as_ptr(),
- prngrc as (i32),
- );
+ eprintln!("could not generate new mgm, err = {}", prngrc as (i32),);
}
- res = Enum5::YKPIV_RANDOMNESS_ERROR;
+ res = ErrorKind::YKPIV_RANDOMNESS_ERROR;
}
}
memset_s(
- data.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 3072]>(),
+ data.as_mut_ptr() as (*mut c_void),
+ mem::size_of::<[u8; 3072]>(),
0i32,
- ::std::mem::size_of::<[u8; 3072]>(),
+ mem::size_of::<[u8; 3072]>(),
);
memset_s(
- mgm_key.as_mut_ptr() as (*mut ::std::os::raw::c_void),
- ::std::mem::size_of::<[u8; 24]>(),
+ mgm_key.as_mut_ptr() as (*mut c_void),
+ mem::size_of::<[u8; 24]>(),
0i32,
- ::std::mem::size_of::<[u8; 24]>(),
+ mem::size_of::<[u8; 24]>(),
);
_ykpiv_end_transaction(state);
res
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_reset(mut state: *mut ykpiv_state) -> Enum5 {
+pub fn ykpiv_util_reset(mut state: *mut ykpiv_state) -> ErrorKind {
let mut templ: *mut u8 = 0i32 as (*mut u8);
let mut data: [u8; 255];
- let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>();
- let mut res: Enum5;
+ let mut recv_len: usize = mem::size_of::<[u8; 255]>();
+ let mut res: ErrorKind;
let mut sw: i32;
res = ykpiv_transfer_data(
state,
templ as (*const u8),
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8),
+ 0i32 as (*mut c_void) as (*const u8),
0isize,
data.as_mut_ptr(),
&mut recv_len as (*mut usize),
&mut sw as (*mut i32),
);
- if Enum5::YKPIV_OK as (i32) == res as (i32) && (0x9000i32 == sw) {
- Enum5::YKPIV_OK
+ if ErrorKind::YKPIV_OK as (i32) == res as (i32) && (0x9000i32 == sw) {
+ ErrorKind::YKPIV_OK
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
}
}
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_util_slot_object(mut slot: u8) -> u32 {
+pub fn ykpiv_util_slot_object(mut slot: u8) -> u32 {
let mut object_id: i32 = -1i32;
if slot as (i32) == 0xf9i32 {
object_id = 0x5fff01i32;
@@ -2772,20 +2473,20 @@ pub unsafe extern "C" fn ykpiv_util_slot_object(mut slot: u8) -> u32 {
object_id as (u32)
}
-unsafe extern "C" fn _read_certificate(
+unsafe fn _read_certificate(
mut state: *mut ykpiv_state,
mut slot: u8,
mut buf: *mut u8,
mut buf_len: *mut usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut object_id: i32 = ykpiv_util_slot_object(slot) as (i32);
let mut len: usize = 0usize;
if -1i32 == object_id {
- Enum5::YKPIV_INVALID_OBJECT
+ ErrorKind::YKPIV_INVALID_OBJECT
} else {
- if Enum5::YKPIV_OK as (i32) == {
+ if ErrorKind::YKPIV_OK as (i32) == {
res = _ykpiv_fetch_object(state, object_id, buf, buf_len);
res
} as (i32)
@@ -2793,7 +2494,7 @@ unsafe extern "C" fn _read_certificate(
ptr = buf;
if *buf_len < 2usize {
*buf_len = 0usize;
- return Enum5::YKPIV_OK;
+ return ErrorKind::YKPIV_OK;
} else if *{
let _old = ptr;
ptr = ptr.offset(1isize);
@@ -2807,18 +2508,13 @@ unsafe extern "C" fn _read_certificate(
if len
> (*buf_len).wrapping_sub(
((ptr as (isize)).wrapping_sub(buf as (isize))
- / ::std::mem::size_of::() as (isize))
- as (usize),
+ / mem::size_of::() as (isize)) as (usize),
)
{
*buf_len = 0usize;
- return Enum5::YKPIV_OK;
+ return ErrorKind::YKPIV_OK;
} else {
- memmove(
- buf as (*mut ::std::os::raw::c_void),
- ptr as (*const ::std::os::raw::c_void),
- len,
- );
+ memmove(buf as (*mut c_void), ptr as (*const c_void), len);
*buf_len = len;
}
}
@@ -2829,38 +2525,33 @@ unsafe extern "C" fn _read_certificate(
}
}
-unsafe extern "C" fn _write_certificate(
+unsafe fn _write_certificate(
mut state: *mut ykpiv_state,
mut slot: u8,
mut data: *mut u8,
mut data_len: usize,
mut certinfo: u8,
-) -> Enum5 {
+) -> ErrorKind {
let mut buf: [u8; 3063];
let mut object_id: i32 = ykpiv_util_slot_object(slot) as (i32);
let mut offset: usize = 0usize;
let mut req_len: usize = 0usize;
if -1i32 == object_id {
- Enum5::YKPIV_INVALID_OBJECT
- } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == data || 0usize == data_len {
- (if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) != data || 0usize != data_len {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_INVALID_OBJECT
+ } else if 0i32 as (*mut c_void) as (*mut u8) == data || 0usize == data_len {
+ (if 0i32 as (*mut c_void) as (*mut u8) != data || 0usize != data_len {
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
- _ykpiv_save_object(
- state,
- object_id,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
- 0usize,
- )
+ _ykpiv_save_object(state, object_id, 0i32 as (*mut c_void) as (*mut u8), 0usize)
})
} else {
req_len = (1i32 + 3i32 + 2i32) as (usize);
req_len = req_len.wrapping_add(_ykpiv_set_length(buf.as_mut_ptr(), data_len) as (usize));
req_len = req_len.wrapping_add(data_len);
(if req_len < data_len {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else if req_len > _obj_size_max(state) {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
} else {
buf[{
let _old = offset;
@@ -2872,8 +2563,8 @@ unsafe extern "C" fn _write_certificate(
data_len,
) as (usize));
memcpy(
- buf.as_mut_ptr().offset(offset as (isize)) as (*mut ::std::os::raw::c_void),
- data as (*const ::std::os::raw::c_void),
+ buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void),
+ data as (*const c_void),
data_len,
);
offset = offset.wrapping_add(data_len);
@@ -2911,21 +2602,21 @@ unsafe extern "C" fn _write_certificate(
}
}
-unsafe extern "C" fn _get_metadata_item(
+unsafe fn _get_metadata_item(
mut data: *mut u8,
mut cb_data: usize,
mut tag: u8,
mut pp_item: *mut *mut u8,
mut pcb_item: *mut usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut p_temp: *mut u8 = data;
let mut cb_temp: usize = 0usize;
let mut tag_temp: u8 = 0u8;
if data.is_null() || pp_item.is_null() || pcb_item.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
- *pp_item = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ *pp_item = 0i32 as (*mut c_void) as (*mut u8);
*pcb_item = 0usize;
'loop2: loop {
if !(p_temp < data.offset(cb_data as (isize))) {
@@ -2940,7 +2631,7 @@ unsafe extern "C" fn _get_metadata_item(
if !_ykpiv_has_valid_length(
p_temp as (*const u8),
((data.offset(cb_data as (isize)) as (isize)).wrapping_sub(p_temp as (isize))
- / ::std::mem::size_of::() as (isize)) as (usize),
+ / mem::size_of::() as (isize)) as (usize),
) {
_currentBlock = 9;
break;
@@ -2959,17 +2650,17 @@ unsafe extern "C" fn _get_metadata_item(
(if p_temp < data.offset(cb_data as (isize)) {
*pp_item = p_temp;
*pcb_item = cb_temp;
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
})
} else {
- Enum5::YKPIV_SIZE_ERROR
+ ErrorKind::YKPIV_SIZE_ERROR
})
}
}
-unsafe extern "C" fn _get_length_size(mut length: usize) -> i32 {
+unsafe fn _get_length_size(mut length: usize) -> i32 {
if length < 0x80usize {
1i32
} else if length < 0xffusize {
@@ -2979,23 +2670,23 @@ unsafe extern "C" fn _get_length_size(mut length: usize) -> i32 {
}
}
-unsafe extern "C" fn _set_metadata_item(
+unsafe fn _set_metadata_item(
mut data: *mut u8,
mut pcb_data: *mut usize,
mut cb_data_max: usize,
mut tag: u8,
mut p_item: *mut u8,
mut cb_item: usize,
-) -> Enum5 {
+) -> ErrorKind {
let mut _currentBlock;
let mut p_temp: *mut u8 = data;
let mut cb_temp: usize = 0usize;
let mut tag_temp: u8 = 0u8;
let mut cb_len: usize = 0usize;
- let mut p_next: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+ let mut p_next: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_moved: isize = 0isize;
if data.is_null() || pcb_data.is_null() {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
'loop1: loop {
if !(p_temp < data.offset(*pcb_data as (isize))) {
@@ -3018,12 +2709,12 @@ unsafe extern "C" fn _set_metadata_item(
}
(if _currentBlock == 2 {
(if cb_item == 0usize {
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
} else {
p_temp = data.offset(*pcb_data as (isize));
cb_len = _get_length_size(cb_item) as (usize);
(if (*pcb_data).wrapping_add(cb_len).wrapping_add(cb_item) > cb_data_max {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
*{
let _old = p_temp;
@@ -3031,23 +2722,15 @@ unsafe extern "C" fn _set_metadata_item(
_old
} = tag;
p_temp = p_temp.offset(_ykpiv_set_length(p_temp, cb_item) as (isize));
- memcpy(
- p_temp as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
- cb_item,
- );
+ memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item);
*pcb_data =
(*pcb_data).wrapping_add(1usize.wrapping_add(cb_len).wrapping_add(cb_item));
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
})
} else if cb_temp == cb_item {
- memcpy(
- p_temp as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
- cb_item,
- );
- Enum5::YKPIV_OK
+ memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item);
+ ErrorKind::YKPIV_OK
} else {
p_next = p_temp.offset(cb_temp as (isize));
cb_moved = cb_item as (isize) - cb_temp as (isize)
@@ -3058,63 +2741,58 @@ unsafe extern "C" fn _set_metadata_item(
} as (isize)
- cb_len as (isize));
(if (*pcb_data).wrapping_add(cb_moved as (usize)) > cb_data_max {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
memmove(
- p_next.offset(cb_moved) as (*mut ::std::os::raw::c_void),
- p_next as (*const ::std::os::raw::c_void),
+ p_next.offset(cb_moved) as (*mut c_void),
+ p_next as (*const c_void),
(*pcb_data).wrapping_sub(
((p_next as (isize)).wrapping_sub(data as (isize))
- / ::std::mem::size_of::() as (isize))
- as (usize),
+ / mem::size_of::() as (isize)) as (usize),
),
);
*pcb_data = (*pcb_data).wrapping_add(cb_moved as (usize));
if cb_item != 0usize {
p_temp = p_temp.offset(-(cb_len as (isize)));
p_temp = p_temp.offset(_ykpiv_set_length(p_temp, cb_item) as (isize));
- memcpy(
- p_temp as (*mut ::std::os::raw::c_void),
- p_item as (*const ::std::os::raw::c_void),
- cb_item,
- );
+ memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item);
}
- Enum5::YKPIV_OK
+ ErrorKind::YKPIV_OK
})
})
}
}
-unsafe extern "C" fn _read_metadata(
+unsafe fn _read_metadata(
mut state: *mut ykpiv_state,
mut tag: u8,
mut data: *mut u8,
mut pcb_data: *mut usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
- let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
+ let mut p_temp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8);
let mut cb_temp: usize = 0usize;
let mut obj_id: i32 = 0i32;
if data.is_null() || pcb_data.is_null() || 3072usize > *pcb_data {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if tag as (i32) == 0x88i32 {
obj_id = 0x5fc109i32;
} else if tag as (i32) == 0x80i32 {
obj_id = 0x5fff00i32;
} else {
- return Enum5::YKPIV_INVALID_OBJECT;
+ return ErrorKind::YKPIV_INVALID_OBJECT;
}
cb_temp = *pcb_data;
*pcb_data = 0usize;
- (if Enum5::YKPIV_OK as (i32) != {
+ (if ErrorKind::YKPIV_OK as (i32) != {
res = _ykpiv_fetch_object(state, obj_id, data, &mut cb_temp as (*mut usize));
res
} as (i32)
{
res
} else if cb_temp < 2usize {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
p_temp = data;
(if tag as (i32)
@@ -3124,59 +2802,49 @@ unsafe extern "C" fn _read_metadata(
_old
} as (i32)
{
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
p_temp =
p_temp.offset(_ykpiv_get_length(p_temp as (*const u8), pcb_data) as (isize));
(if *pcb_data
> cb_temp.wrapping_sub(
((p_temp as (isize)).wrapping_sub(data as (isize))
- / ::std::mem::size_of::() as (isize))
- as (usize),
+ / mem::size_of::() as (isize)) as (usize),
)
{
*pcb_data = 0usize;
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
- memmove(
- data as (*mut ::std::os::raw::c_void),
- p_temp as (*const ::std::os::raw::c_void),
- *pcb_data,
- );
- Enum5::YKPIV_OK
+ memmove(data as (*mut c_void), p_temp as (*const c_void), *pcb_data);
+ ErrorKind::YKPIV_OK
})
})
})
}
}
-unsafe extern "C" fn _write_metadata(
+unsafe fn _write_metadata(
mut state: *mut ykpiv_state,
mut tag: u8,
mut data: *mut u8,
mut cb_data: usize,
-) -> Enum5 {
- let mut res: Enum5 = Enum5::YKPIV_OK;
+) -> ErrorKind {
+ let mut res: ErrorKind = ErrorKind::YKPIV_OK;
let mut buf = [0u8; 3063];
let mut pTemp: *mut u8 = buf.as_mut_ptr();
let mut obj_id: i32 = 0i32;
if cb_data > _obj_size_max(state).wrapping_sub((2i32 + 2i32) as (usize)) {
- Enum5::YKPIV_GENERIC_ERROR
+ ErrorKind::YKPIV_GENERIC_ERROR
} else {
if tag as (i32) == 0x88i32 {
obj_id = 0x5fc109i32;
} else if tag as (i32) == 0x80i32 {
obj_id = 0x5fff00i32;
} else {
- return Enum5::YKPIV_INVALID_OBJECT;
+ return ErrorKind::YKPIV_INVALID_OBJECT;
}
if data.is_null() || 0usize == cb_data {
- res = _ykpiv_save_object(
- state,
- obj_id,
- 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8),
- 0usize,
- );
+ res = _ykpiv_save_object(state, obj_id, 0i32 as (*mut c_void) as (*mut u8), 0usize);
} else {
*{
let _old = pTemp;
@@ -3184,18 +2852,14 @@ unsafe extern "C" fn _write_metadata(
_old
} = tag;
pTemp = pTemp.offset(_ykpiv_set_length(pTemp, cb_data) as (isize));
- memcpy(
- pTemp as (*mut ::std::os::raw::c_void),
- data as (*const ::std::os::raw::c_void),
- cb_data,
- );
+ memcpy(pTemp as (*mut c_void), data as (*const c_void), cb_data);
pTemp = pTemp.offset(cb_data as (isize));
res = _ykpiv_save_object(
state,
obj_id,
buf.as_mut_ptr(),
((pTemp as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize))
- / ::std::mem::size_of::() as (isize)) as (usize),
+ / mem::size_of::() as (isize)) as (usize),
);
}
res
diff --git a/src/version.rs b/src/version.rs
deleted file mode 100644
index 0994608..0000000
--- a/src/version.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright (c) 2014-2016 Yubico AB
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-extern "C" {
- fn strcmp(__s1: *const u8, __s2: *const u8) -> i32;
- fn strcspn(__s: *const u8, __charset: *const u8) -> usize;
- fn strncmp(__s1: *const u8, __s2: *const u8, __n: usize) -> i32;
- fn strspn(__s: *const u8, __charset: *const u8) -> usize;
-}
-
-unsafe extern "C" fn my_strverscmp(mut s1: *const u8, mut s2: *const u8) -> i32 {
- let mut _currentBlock;
- static mut digits: *const u8 = (*b"0123456789\0").as_ptr();
- let mut p1: usize;
- let mut p2: usize;
- p1 = strcspn(s1, digits);
- p2 = strcspn(s2, digits);
- 'loop1: loop {
- if !(p1 == p2
- && (*s1.offset(p1 as (isize)) as (i32) != b'\0' as (i32))
- && (*s2.offset(p2 as (isize)) as (i32) != b'\0' as (i32)))
- {
- _currentBlock = 2;
- break;
- }
- let mut ret: i32;
- let mut lz1: i32;
- let mut lz2: i32;
- if {
- ret = strncmp(s1, s2, p1);
- ret
- } != 0i32
- {
- _currentBlock = 37;
- break;
- }
- s1 = s1.offset(p1 as (isize));
- s2 = s2.offset(p2 as (isize));
- lz1 = {
- lz2 = 0i32;
- lz2
- };
- if *s1 as (i32) == b'0' as (i32) {
- lz1 = 1i32;
- }
- if *s2 as (i32) == b'0' as (i32) {
- lz2 = 1i32;
- }
- if lz1 > lz2 {
- _currentBlock = 36;
- break;
- }
- if lz1 < lz2 {
- _currentBlock = 35;
- break;
- }
- if lz1 == 1i32 {
- _currentBlock = 11;
- } else {
- _currentBlock = 23;
- }
- 'loop11: loop {
- if _currentBlock == 11 {
- if *s1 as (i32) == b'0' as (i32) && (*s2 as (i32) == b'0' as (i32)) {
- s1 = s1.offset(1isize);
- s2 = s2.offset(1isize);
- _currentBlock = 11;
- } else {
- p1 = strspn(s1, digits);
- p2 = strspn(s2, digits);
- if p1 == 0usize && (p2 > 0usize) {
- _currentBlock = 33;
- break 'loop1;
- }
- if p2 == 0usize && (p1 > 0usize) {
- _currentBlock = 32;
- break 'loop1;
- }
- if *s1 as (i32) != *s2 as (i32)
- && (*s1 as (i32) != b'0' as (i32))
- && (*s2 as (i32) != b'0' as (i32))
- {
- if p1 < p2 {
- _currentBlock = 31;
- break 'loop1;
- }
- if p1 > p2 {
- _currentBlock = 30;
- break 'loop1;
- } else {
- _currentBlock = 23;
- }
- } else {
- if p1 < p2 {
- ret = strncmp(s1, s2, p1);
- } else if p1 > p2 {
- ret = strncmp(s1, s2, p2);
- }
- if ret != 0i32 {
- _currentBlock = 20;
- break 'loop1;
- } else {
- _currentBlock = 23;
- }
- }
- }
- } else {
- p1 = strspn(s1, digits);
- p2 = strspn(s2, digits);
- if p1 < p2 {
- _currentBlock = 29;
- break 'loop1;
- } else {
- break;
- }
- }
- }
- if p1 > p2 {
- _currentBlock = 28;
- break;
- }
- if {
- ret = strncmp(s1, s2, p1);
- ret
- } != 0i32
- {
- _currentBlock = 27;
- break;
- }
- s1 = s1.offset(p1 as (isize));
- s2 = s2.offset(p2 as (isize));
- p1 = strcspn(s1, digits);
- p2 = strcspn(s2, digits);
- }
- if _currentBlock == 2 {
- strcmp(s1, s2)
- } else if _currentBlock == 20 {
- ret
- } else if _currentBlock == 27 {
- ret
- } else if _currentBlock == 28 {
- 1i32
- } else if _currentBlock == 29 {
- -1i32
- } else if _currentBlock == 30 {
- -1i32
- } else if _currentBlock == 31 {
- 1i32
- } else if _currentBlock == 32 {
- -1i32
- } else if _currentBlock == 33 {
- 1i32
- } else if _currentBlock == 35 {
- 1i32
- } else if _currentBlock == 36 {
- -1i32
- } else {
- ret
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn ykpiv_check_version(mut req_version: *const u8) -> *const u8 {
- if req_version.is_null() || my_strverscmp(req_version, (*b"@VERSION@\0").as_ptr()) <= 0i32 {
- (*b"@VERSION@\0").as_ptr()
- } else {
- 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
- }
-}