diff --git a/src/error.rs b/src/error.rs index 51c17e5..b24ac6c 100644 --- a/src/error.rs +++ b/src/error.rs @@ -50,29 +50,28 @@ pub enum Enum2 { #[derive(Copy)] #[repr(C)] pub struct Struct1 { - pub rc : Enum2, - pub name : *const u8, - pub description : *const u8, + pub rc: Enum2, + pub name: *const u8, + pub description: *const u8, } impl Clone for Struct1 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } -static mut errors - : *const Struct1 - = Enum2::YKPIV_OK as (*const Struct1); +static mut errors: *const Struct1 = Enum2::YKPIV_OK as (*const Struct1); #[no_mangle] -pub unsafe extern 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) { +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; @@ -84,13 +83,12 @@ pub unsafe extern fn ykpiv_strerror(mut err : Enum2) -> *const u8 { } #[no_mangle] -pub unsafe extern 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) { +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 diff --git a/src/internal.rs b/src/internal.rs index aa470af..cbd76c0 100644 --- a/src/internal.rs +++ b/src/internal.rs @@ -25,343 +25,346 @@ // (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 { +extern "C" { fn DES_ecb3_encrypt( - input : *mut [u8; 8], - output : *mut [u8; 8], - ks1 : *mut DES_ks, - ks2 : *mut DES_ks, - ks3 : *mut DES_ks, - enc : i32 - ); - fn DES_is_weak_key(key : *mut [u8; 8]) -> i32; - fn DES_set_key_unchecked( - key : *mut [u8; 8], schedule : *mut DES_ks + input: *mut [u8; 8], + output: *mut [u8; 8], + ks1: *mut DES_ks, + ks2: *mut DES_ks, + ks3: *mut DES_ks, + enc: i32, ); + fn DES_is_weak_key(key: *mut [u8; 8]) -> i32; + fn DES_set_key_unchecked(key: *mut [u8; 8], schedule: *mut DES_ks); fn PKCS5_PBKDF2_HMAC_SHA1( - pass : *const u8, - passlen : i32, - salt : *const u8, - saltlen : i32, - iter : i32, - keylen : i32, - out : *mut u8 + pass: *const u8, + passlen: i32, + salt: *const u8, + saltlen: i32, + iter: i32, + keylen: i32, + out: *mut u8, ) -> i32; - 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 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 + __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 + __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; + 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 Union6 {} -enum __sFILEX { -} +enum __sFILEX {} #[no_mangle] -pub unsafe extern fn isascii(mut _c : i32) -> i32 { +pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 { (_c & !0x7fi32 == 0i32) as (i32) } #[derive(Copy)] #[repr(C)] pub struct Struct3 { - pub __min : i32, - pub __max : i32, - pub __map : i32, - pub __types : *mut u32, + pub __min: i32, + pub __max: i32, + pub __map: i32, + pub __types: *mut u32, } impl Clone for Struct3 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct2 { - pub __nranges : i32, - pub __ranges : *mut Struct3, + pub __nranges: i32, + pub __ranges: *mut Struct3, } impl Clone for Struct2 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct4 { - pub __name : [u8; 14], - pub __mask : u32, + pub __name: [u8; 14], + pub __mask: u32, } impl Clone for Struct4 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct1 { - pub __magic : [u8; 8], - pub __encoding : [u8; 32], - pub __sgetrune : unsafe extern fn(*const u8, usize, *mut *const u8) -> i32, - pub __sputrune : unsafe extern fn(i32, *mut u8, usize, *mut *mut u8) -> i32, - pub __invalid_rune : i32, - pub __runetype : [u32; 256], - pub __maplower : [i32; 256], - pub __mapupper : [i32; 256], - pub __runetype_ext : Struct2, - pub __maplower_ext : Struct2, - pub __mapupper_ext : Struct2, - pub __variable : *mut ::std::os::raw::c_void, - pub __variable_len : i32, - pub __ncharclasses : i32, - pub __charclasses : *mut Struct4, + 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 __invalid_rune: i32, + pub __runetype: [u32; 256], + pub __maplower: [i32; 256], + pub __mapupper: [i32; 256], + pub __runetype_ext: Struct2, + pub __maplower_ext: Struct2, + pub __mapupper_ext: Struct2, + pub __variable: *mut ::std::os::raw::c_void, + pub __variable_len: i32, + pub __ncharclasses: i32, + pub __charclasses: *mut Struct4, } impl Clone for Struct1 { - fn clone(&self) -> Self { *self } -} - -#[no_mangle] -pub unsafe extern 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 { - !(__maskrune(_c,_f) == 0) as (i32) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub unsafe extern fn __isctype(mut _c : i32, mut _f : usize) -> i32 { +pub unsafe extern "C" 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 { + !(__maskrune(_c, _f) == 0) as (i32) + } +} + +#[no_mangle] +pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { - !(_DefaultRuneLocale.__runetype[ - _c as (usize) - ] as (usize) & _f == 0) as (i32) + !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } } #[no_mangle] -pub unsafe extern fn __wcwidth(mut _c : i32) -> i32 { - let mut _x : u32; +pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { + let mut _x: u32; if _c == 0i32 { 0i32 } else { - _x = __maskrune(_c,0xe0000000usize | 0x40000usize) as (u32); + _x = __maskrune(_c, 0xe0000000usize | 0x40000usize) as (u32); (if _x as (usize) & 0xe0000000usize != 0usize { - ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) - } else if _x as (usize) & 0x40000usize != 0usize { - 1i32 - } else { - -1i32 - }) + ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) + } else if _x as (usize) & 0x40000usize != 0usize { + 1i32 + } else { + -1i32 + }) } } #[no_mangle] -pub unsafe extern fn isalnum(mut _c : i32) -> i32 { - __istype(_c,(0x100isize | 0x400isize) as (usize)) +pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { + __istype(_c, (0x100isize | 0x400isize) as (usize)) } #[no_mangle] -pub unsafe extern fn isalpha(mut _c : i32) -> i32 { - __istype(_c,0x100usize) +pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { + __istype(_c, 0x100usize) } #[no_mangle] -pub unsafe extern fn isblank(mut _c : i32) -> i32 { - __istype(_c,0x20000usize) +pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { + __istype(_c, 0x20000usize) } #[no_mangle] -pub unsafe extern fn iscntrl(mut _c : i32) -> i32 { - __istype(_c,0x200usize) +pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { + __istype(_c, 0x200usize) } #[no_mangle] -pub unsafe extern fn isdigit(mut _c : i32) -> i32 { - __isctype(_c,0x400usize) +pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x400usize) } #[no_mangle] -pub unsafe extern fn isgraph(mut _c : i32) -> i32 { - __istype(_c,0x800usize) +pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { + __istype(_c, 0x800usize) } #[no_mangle] -pub unsafe extern fn islower(mut _c : i32) -> i32 { - __istype(_c,0x1000usize) +pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { + __istype(_c, 0x1000usize) } #[no_mangle] -pub unsafe extern fn isprint(mut _c : i32) -> i32 { - __istype(_c,0x40000usize) +pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { + __istype(_c, 0x40000usize) } #[no_mangle] -pub unsafe extern fn ispunct(mut _c : i32) -> i32 { - __istype(_c,0x2000usize) +pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { + __istype(_c, 0x2000usize) } #[no_mangle] -pub unsafe extern fn isspace(mut _c : i32) -> i32 { - __istype(_c,0x4000usize) +pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { + __istype(_c, 0x4000usize) } #[no_mangle] -pub unsafe extern fn isupper(mut _c : i32) -> i32 { - __istype(_c,0x8000usize) +pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { + __istype(_c, 0x8000usize) } #[no_mangle] -pub unsafe extern fn isxdigit(mut _c : i32) -> i32 { - __isctype(_c,0x10000usize) +pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn toascii(mut _c : i32) -> i32 { _c & 0x7fi32 } - -#[no_mangle] -pub unsafe extern fn tolower(mut _c : i32) -> i32 { __tolower(_c) } - -#[no_mangle] -pub unsafe extern fn toupper(mut _c : i32) -> i32 { __toupper(_c) } - -#[no_mangle] -pub unsafe extern fn digittoint(mut _c : i32) -> i32 { - __maskrune(_c,0xfusize) +pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { + _c & 0x7fi32 } #[no_mangle] -pub unsafe extern fn ishexnumber(mut _c : i32) -> i32 { - __istype(_c,0x10000usize) +pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { + __tolower(_c) } #[no_mangle] -pub unsafe extern fn isideogram(mut _c : i32) -> i32 { - __istype(_c,0x80000usize) +pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { + __toupper(_c) } #[no_mangle] -pub unsafe extern fn isnumber(mut _c : i32) -> i32 { - __istype(_c,0x400usize) +pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { + __maskrune(_c, 0xfusize) } #[no_mangle] -pub unsafe extern fn isphonogram(mut _c : i32) -> i32 { - __istype(_c,0x200000usize) +pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { + __istype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn isrune(mut _c : i32) -> i32 { - __istype(_c,0xfffffff0usize) +pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { + __istype(_c, 0x80000usize) } #[no_mangle] -pub unsafe extern fn isspecial(mut _c : i32) -> i32 { - __istype(_c,0x100000usize) +pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { + __istype(_c, 0x400usize) +} + +#[no_mangle] +pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { + __istype(_c, 0x200000usize) +} + +#[no_mangle] +pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { + __istype(_c, 0xfffffff0usize) +} + +#[no_mangle] +pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 { + __istype(_c, 0x100000usize) } #[derive(Copy)] #[repr(C)] pub struct __sbuf { - pub _base : *mut u8, - pub _size : i32, + pub _base: *mut u8, + pub _size: i32, } impl Clone for __sbuf { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[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 fn(*mut ::std::os::raw::c_void) -> i32, - pub _read : unsafe extern fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek : unsafe extern fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write : unsafe extern 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, + 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 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) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub static mut szLOG_SOURCE - : *const u8 - = (*b"YubiKey PIV Library\0").as_ptr(); +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)] @@ -376,37 +379,41 @@ pub enum Enum5 { #[derive(Copy)] #[repr(C)] pub struct DES_ks { - pub ks : [Union6; 16], + pub ks: [Union6; 16], } impl Clone for DES_ks { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct des_key { - pub ks1 : DES_ks, - pub ks2 : DES_ks, - pub ks3 : DES_ks, + pub ks1: DES_ks, + pub ks2: DES_ks, + pub ks3: DES_ks, } impl Clone for des_key { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn des_import_key( - type_ : i32, - mut keyraw : *const u8, - keyrawlen : usize, - mut key : *mut *mut des_key +pub unsafe extern "C" fn des_import_key( + type_: i32, + mut keyraw: *const u8, + keyrawlen: usize, + mut key: *mut *mut des_key, ) -> Enum5 { let mut _currentBlock; - let mut rc : Enum5 = Enum5::DES_OK; - let mut cb_expectedkey : usize = (8i32 * 3i32) as (usize); - let mut key_tmp : [u8; 8]; - let mut cb_keysize : usize = 8usize; + let mut rc: Enum5 = Enum5::DES_OK; + let mut cb_expectedkey: usize = (8i32 * 3i32) as (usize); + let mut key_tmp: [u8; 8]; + let mut cb_keysize: usize = 8usize; if type_ == 1i32 { cb_expectedkey = (8i32 * 3i32) as (usize); cb_keysize = 8usize; @@ -423,48 +430,46 @@ pub unsafe extern fn des_import_key( rc = Enum5::DES_INVALID_PARAMETER; _currentBlock = 15; } else if { - *key = malloc(::std::mem::size_of::()) as (*mut des_key); - *key - }.is_null( - ) { + *key = malloc(::std::mem::size_of::()) as (*mut des_key); + *key + } + .is_null() + { rc = Enum5::DES_MEMORY_ERROR; _currentBlock = 15; } else { 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), keyraw as (*const ::std::os::raw::c_void), - cb_keysize + cb_keysize, ); DES_set_key_unchecked( &mut key_tmp as (*mut [u8; 8]), - &mut (**key).ks1 as (*mut DES_ks) + &mut (**key).ks1 as (*mut DES_ks), ); memcpy( key_tmp.as_mut_ptr() as (*mut ::std::os::raw::c_void), - keyraw.offset( - cb_keysize as (isize) - ) as (*const ::std::os::raw::c_void), - cb_keysize + keyraw.offset(cb_keysize as (isize)) as (*const ::std::os::raw::c_void), + cb_keysize, ); DES_set_key_unchecked( &mut key_tmp as (*mut [u8; 8]), - &mut (**key).ks2 as (*mut DES_ks) + &mut (**key).ks2 as (*mut DES_ks), ); memcpy( key_tmp.as_mut_ptr() as (*mut ::std::os::raw::c_void), - keyraw.offset( - 2usize.wrapping_mul(cb_keysize) as (isize) - ) as (*const ::std::os::raw::c_void), - cb_keysize + keyraw.offset(2usize.wrapping_mul(cb_keysize) as (isize)) + as (*const ::std::os::raw::c_void), + cb_keysize, ); DES_set_key_unchecked( &mut key_tmp as (*mut [u8; 8]), - &mut (**key).ks3 as (*mut DES_ks) + &mut (**key).ks3 as (*mut DES_ks), ); _currentBlock = 17; } @@ -482,7 +487,7 @@ pub unsafe extern fn des_import_key( } #[no_mangle] -pub unsafe extern fn des_destroy_key(mut key : *mut des_key) -> Enum5 { +pub unsafe extern "C" fn des_destroy_key(mut key: *mut des_key) -> Enum5 { if !key.is_null() { free(key as (*mut ::std::os::raw::c_void)); } @@ -490,16 +495,15 @@ pub unsafe extern fn des_destroy_key(mut key : *mut des_key) -> Enum5 { } #[no_mangle] -pub unsafe extern fn des_encrypt( - mut key : *mut des_key, - mut in_ : *const u8, - inlen : usize, - mut out : *mut u8, - mut outlen : *mut usize +pub unsafe extern "C" fn des_encrypt( + mut key: *mut des_key, + mut in_: *const u8, + inlen: usize, + mut out: *mut u8, + mut outlen: *mut usize, ) -> Enum5 { - let mut rc : Enum5 = Enum5::DES_OK; - if key.is_null() || outlen.is_null( - ) || *outlen < inlen || in_.is_null() || out.is_null() { + let mut rc: Enum5 = Enum5::DES_OK; + if key.is_null() || outlen.is_null() || *outlen < inlen || in_.is_null() || out.is_null() { rc = Enum5::DES_INVALID_PARAMETER; } else { DES_ecb3_encrypt( @@ -508,23 +512,22 @@ pub unsafe extern fn des_encrypt( &mut (*key).ks1 as (*mut DES_ks), &mut (*key).ks2 as (*mut DES_ks), &mut (*key).ks3 as (*mut DES_ks), - 1i32 + 1i32, ); } rc } #[no_mangle] -pub unsafe extern fn des_decrypt( - mut key : *mut des_key, - mut in_ : *const u8, - inlen : usize, - mut out : *mut u8, - mut outlen : *mut usize +pub unsafe extern "C" fn des_decrypt( + mut key: *mut des_key, + mut in_: *const u8, + inlen: usize, + mut out: *mut u8, + mut outlen: *mut usize, ) -> Enum5 { - let mut rc : Enum5 = Enum5::DES_OK; - if key.is_null() || outlen.is_null( - ) || *outlen < inlen || in_.is_null() || out.is_null() { + let mut rc: Enum5 = Enum5::DES_OK; + if key.is_null() || outlen.is_null() || *outlen < inlen || in_.is_null() || out.is_null() { rc = Enum5::DES_INVALID_PARAMETER; } else { DES_ecb3_encrypt( @@ -533,16 +536,14 @@ pub unsafe extern fn des_decrypt( &mut (*key).ks1 as (*mut DES_ks), &mut (*key).ks2 as (*mut DES_ks), &mut (*key).ks3 as (*mut DES_ks), - 0i32 + 0i32, ); } rc } #[no_mangle] -pub unsafe extern fn yk_des_is_weak_key( - mut key : *const u8, cb_key : usize -) -> bool { +pub unsafe extern "C" 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 } @@ -555,11 +556,9 @@ pub enum Enum7 { } #[no_mangle] -pub unsafe extern 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)) { +pub unsafe extern "C" 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; } rc @@ -573,16 +572,16 @@ pub enum Enum8 { } #[no_mangle] -pub unsafe extern fn pkcs5_pbkdf2_sha1( - mut password : *const u8, - cb_password : usize, - mut salt : *const u8, - cb_salt : usize, - mut iterations : usize, - mut key : *const u8, - cb_key : usize +pub unsafe extern "C" fn pkcs5_pbkdf2_sha1( + mut password: *const u8, + cb_password: usize, + mut salt: *const u8, + cb_salt: usize, + mut iterations: usize, + mut key: *const u8, + cb_key: usize, ) -> Enum8 { - let mut rc : Enum8 = Enum8::PKCS5_OK; + let mut rc: Enum8 = Enum8::PKCS5_OK; PKCS5_PBKDF2_HMAC_SHA1( password, cb_password as (i32), @@ -590,17 +589,17 @@ pub unsafe extern fn pkcs5_pbkdf2_sha1( cb_salt as (i32), iterations as (i32), cb_key as (i32), - key as (*mut u8) + key as (*mut u8), ); rc } #[no_mangle] -pub unsafe extern 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)).offset(-1isize); +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)) + .offset(-1isize); 'loop1: loop { if isspace(*psz_head as (i32)) == 0 { break; @@ -612,10 +611,10 @@ pub unsafe extern fn _strip_ws(mut sz : *mut u8) -> *mut u8 { break; } *{ - let _old = psz_tail; - psz_tail = psz_tail.offset(-1isize); - _old - } = b'\0'; + let _old = psz_tail; + psz_tail = psz_tail.offset(-1isize); + _old + } = b'\0'; } psz_head } @@ -631,39 +630,38 @@ pub enum _setting_source_t { #[derive(Copy)] #[repr(C)] pub struct _setting_bool_t { - pub value : bool, - pub source : _setting_source_t, + pub value: bool, + pub source: _setting_source_t, } impl Clone for _setting_bool_t { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn _get_bool_config( - mut sz_setting : *const u8 -) -> _setting_bool_t { +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 { - value: false, - source: _setting_source_t::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 setting: _setting_bool_t = _setting_bool_t { + value: false, + source: _setting_source_t::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_name = [0u8; 256]; let mut sz_value = [0u8; 256]; - let mut pf : *mut __sFILE = 0i32 as (*mut __sFILE); + 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 - }.is_null( - ) { + pf = fopen( + (*b"/etc/yubico/yubikeypiv.conf\0").as_ptr(), + (*b"r\0").as_ptr(), + ); + pf + } + .is_null() + { _currentBlock = 1; } else { _currentBlock = 10; @@ -672,11 +670,12 @@ pub unsafe extern fn _get_bool_config( 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( - ) { + sz_line.as_mut_ptr(), + ::std::mem::size_of::<[u8; 256]>() as (i32), + pf, + ) + .is_null() + { _currentBlock = 1; continue; } @@ -693,28 +692,24 @@ pub unsafe extern fn _get_bool_config( 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) { + 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) { + 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; + 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; @@ -725,50 +720,38 @@ pub unsafe extern fn _get_bool_config( } #[no_mangle] -pub unsafe extern fn _get_bool_env( - mut sz_setting : *const u8 -) -> _setting_bool_t { - let mut setting - : _setting_bool_t - = _setting_bool_t { - value: false, - source: _setting_source_t::SETTING_SOURCE_DEFAULT - }; - let mut psz_value - : *mut u8 - = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); +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 { + value: false, + source: _setting_source_t::SETTING_SOURCE_DEFAULT, + }; + let mut psz_value: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); 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(), - sz_setting + sz_setting, ); psz_value = getenv(sz_name.as_mut_ptr() as (*const u8)); 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.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 } #[no_mangle] -pub unsafe extern fn setting_get_bool( - mut sz_setting : *const u8, mut def : bool +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 { - value: def, - source: _setting_source_t::SETTING_SOURCE_DEFAULT - }; + let mut setting: _setting_bool_t = _setting_bool_t { + value: def, + source: _setting_source_t::SETTING_SOURCE_DEFAULT, + }; setting = _get_bool_config(sz_setting); if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) { setting = _get_bool_env(sz_setting); diff --git a/src/lib.rs b/src/lib.rs index d1e6eee..820acde 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -25,557 +25,564 @@ // (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 { - fn SCardBeginTransaction(hCard : i32) -> i32; +pub mod error; +pub mod internal; +pub mod util; +pub mod version; + +extern "C" { + fn SCardBeginTransaction(hCard: i32) -> i32; fn SCardConnect( - hContext : i32, - szReader : *const u8, - dwShareMode : u32, - dwPreferredProtocols : u32, - phCard : *mut i32, - pdwActiveProtocol : *mut u32 + hContext: i32, + szReader: *const u8, + dwShareMode: u32, + dwPreferredProtocols: u32, + phCard: *mut i32, + pdwActiveProtocol: *mut u32, ) -> i32; - fn SCardDisconnect(hCard : i32, dwDisposition : u32) -> i32; - fn SCardEndTransaction(hCard : i32, dwDisposition : u32) -> i32; + fn SCardDisconnect(hCard: i32, dwDisposition: u32) -> i32; + 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, - phContext : *mut i32 + dwScope: u32, + pvReserved1: *const ::std::os::raw::c_void, + pvReserved2: *const ::std::os::raw::c_void, + phContext: *mut i32, ) -> i32; - fn SCardIsValidContext(hContext : i32) -> i32; + fn SCardIsValidContext(hContext: i32) -> i32; fn SCardListReaders( - hContext : i32, - mszGroups : *const u8, - mszReaders : *mut u8, - pcchReaders : *mut u32 + hContext: i32, + mszGroups: *const u8, + mszReaders: *mut u8, + pcchReaders: *mut u32, ) -> i32; fn SCardReconnect( - hCard : i32, - dwShareMode : u32, - dwPreferredProtocols : u32, - dwInitialization : u32, - pdwActiveProtocol : *mut u32 + hCard: i32, + dwShareMode: u32, + dwPreferredProtocols: u32, + dwInitialization: u32, + pdwActiveProtocol: *mut u32, ) -> i32; - fn SCardReleaseContext(hContext : i32) -> i32; + fn SCardReleaseContext(hContext: i32) -> i32; fn SCardStatus( - hCard : i32, - mszReaderNames : *mut u8, - pcchReaderLen : *mut u32, - pdwState : *mut u32, - pdwProtocol : *mut u32, - pbAtr : *mut u8, - pcbAtrLen : *mut u32 + hCard: i32, + mszReaderNames: *mut u8, + pcchReaderLen: *mut u32, + pdwState: *mut u32, + pdwProtocol: *mut u32, + pbAtr: *mut u8, + pcbAtrLen: *mut u32, ) -> 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; + 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_encrypt( - key : *mut des_key, - in_ : *const u8, - inlen : usize, - out : *mut u8, - outlen : *mut usize + key: *mut des_key, + in_: *const u8, + inlen: usize, + out: *mut u8, + outlen: *mut usize, ) -> Enum6; fn des_import_key( - type_ : i32, - keyraw : *const u8, - keyrawlen : usize, - key : *mut *mut des_key + type_: i32, + keyraw: *const u8, + keyrawlen: usize, + key: *mut *mut des_key, ) -> Enum6; - fn fprintf(arg1 : *mut __sFILE, arg2 : *const u8, ...) -> i32; - fn free(arg1 : *mut ::std::os::raw::c_void); + 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 + __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 + __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 + __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 + __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 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; + 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 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 { -} +enum __sFILEX {} -enum des_key { -} +enum des_key {} -enum u_APDU { -} +enum u_APDU {} #[derive(Copy)] #[repr(C)] pub struct __sbuf { - pub _base : *mut u8, - pub _size : i32, + pub _base: *mut u8, + pub _size: i32, } impl Clone for __sbuf { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[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 fn(*mut ::std::os::raw::c_void) -> i32, - pub _read : unsafe extern fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek : unsafe extern fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write : unsafe extern 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, + 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 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) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub unsafe extern fn isascii(mut _c : i32) -> i32 { +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 { (_c & !0x7fi32 == 0i32) as (i32) } #[derive(Copy)] #[repr(C)] pub struct Struct3 { - pub __min : i32, - pub __max : i32, - pub __map : i32, - pub __types : *mut u32, + pub __min: i32, + pub __max: i32, + pub __map: i32, + pub __types: *mut u32, } impl Clone for Struct3 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct2 { - pub __nranges : i32, - pub __ranges : *mut Struct3, + pub __nranges: i32, + pub __ranges: *mut Struct3, } impl Clone for Struct2 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct4 { - pub __name : [u8; 14], - pub __mask : u32, + pub __name: [u8; 14], + pub __mask: u32, } impl Clone for Struct4 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct1 { - pub __magic : [u8; 8], - pub __encoding : [u8; 32], - pub __sgetrune : unsafe extern fn(*const u8, usize, *mut *const u8) -> i32, - pub __sputrune : unsafe extern fn(i32, *mut u8, usize, *mut *mut u8) -> i32, - pub __invalid_rune : i32, - pub __runetype : [u32; 256], - pub __maplower : [i32; 256], - pub __mapupper : [i32; 256], - pub __runetype_ext : Struct2, - pub __maplower_ext : Struct2, - pub __mapupper_ext : Struct2, - pub __variable : *mut ::std::os::raw::c_void, - pub __variable_len : i32, - pub __ncharclasses : i32, - pub __charclasses : *mut Struct4, + 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 __invalid_rune: i32, + pub __runetype: [u32; 256], + pub __maplower: [i32; 256], + pub __mapupper: [i32; 256], + pub __runetype_ext: Struct2, + pub __maplower_ext: Struct2, + pub __mapupper_ext: Struct2, + pub __variable: *mut ::std::os::raw::c_void, + pub __variable_len: i32, + pub __ncharclasses: i32, + pub __charclasses: *mut Struct4, } impl Clone for Struct1 { - fn clone(&self) -> Self { *self } -} - -#[no_mangle] -pub unsafe extern 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 { - !(__maskrune(_c,_f) == 0) as (i32) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub unsafe extern fn __isctype(mut _c : i32, mut _f : usize) -> i32 { +pub unsafe extern "C" 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 { + !(__maskrune(_c, _f) == 0) as (i32) + } +} + +#[no_mangle] +pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { - !(_DefaultRuneLocale.__runetype[ - _c as (usize) - ] as (usize) & _f == 0) as (i32) + !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } } #[no_mangle] -pub unsafe extern fn __wcwidth(mut _c : i32) -> i32 { - let mut _x : u32; +pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { + let mut _x: u32; if _c == 0i32 { 0i32 } else { - _x = __maskrune(_c,0xe0000000usize | 0x40000usize) as (u32); + _x = __maskrune(_c, 0xe0000000usize | 0x40000usize) as (u32); (if _x as (usize) & 0xe0000000usize != 0usize { - ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) - } else if _x as (usize) & 0x40000usize != 0usize { - 1i32 - } else { - -1i32 - }) + ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) + } else if _x as (usize) & 0x40000usize != 0usize { + 1i32 + } else { + -1i32 + }) } } #[no_mangle] -pub unsafe extern fn isalnum(mut _c : i32) -> i32 { - __istype(_c,(0x100isize | 0x400isize) as (usize)) +pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { + __istype(_c, (0x100isize | 0x400isize) as (usize)) } #[no_mangle] -pub unsafe extern fn isalpha(mut _c : i32) -> i32 { - __istype(_c,0x100usize) +pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { + __istype(_c, 0x100usize) } #[no_mangle] -pub unsafe extern fn isblank(mut _c : i32) -> i32 { - __istype(_c,0x20000usize) +pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { + __istype(_c, 0x20000usize) } #[no_mangle] -pub unsafe extern fn iscntrl(mut _c : i32) -> i32 { - __istype(_c,0x200usize) +pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { + __istype(_c, 0x200usize) } #[no_mangle] -pub unsafe extern fn isdigit(mut _c : i32) -> i32 { - __isctype(_c,0x400usize) +pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x400usize) } #[no_mangle] -pub unsafe extern fn isgraph(mut _c : i32) -> i32 { - __istype(_c,0x800usize) +pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { + __istype(_c, 0x800usize) } #[no_mangle] -pub unsafe extern fn islower(mut _c : i32) -> i32 { - __istype(_c,0x1000usize) +pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { + __istype(_c, 0x1000usize) } #[no_mangle] -pub unsafe extern fn isprint(mut _c : i32) -> i32 { - __istype(_c,0x40000usize) +pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { + __istype(_c, 0x40000usize) } #[no_mangle] -pub unsafe extern fn ispunct(mut _c : i32) -> i32 { - __istype(_c,0x2000usize) +pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { + __istype(_c, 0x2000usize) } #[no_mangle] -pub unsafe extern fn isspace(mut _c : i32) -> i32 { - __istype(_c,0x4000usize) +pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { + __istype(_c, 0x4000usize) } #[no_mangle] -pub unsafe extern fn isupper(mut _c : i32) -> i32 { - __istype(_c,0x8000usize) +pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { + __istype(_c, 0x8000usize) } #[no_mangle] -pub unsafe extern fn isxdigit(mut _c : i32) -> i32 { - __isctype(_c,0x10000usize) +pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn toascii(mut _c : i32) -> i32 { _c & 0x7fi32 } - -#[no_mangle] -pub unsafe extern fn tolower(mut _c : i32) -> i32 { __tolower(_c) } - -#[no_mangle] -pub unsafe extern fn toupper(mut _c : i32) -> i32 { __toupper(_c) } - -#[no_mangle] -pub unsafe extern fn digittoint(mut _c : i32) -> i32 { - __maskrune(_c,0xfusize) +pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { + _c & 0x7fi32 } #[no_mangle] -pub unsafe extern fn ishexnumber(mut _c : i32) -> i32 { - __istype(_c,0x10000usize) +pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { + __tolower(_c) } #[no_mangle] -pub unsafe extern fn isideogram(mut _c : i32) -> i32 { - __istype(_c,0x80000usize) +pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { + __toupper(_c) } #[no_mangle] -pub unsafe extern fn isnumber(mut _c : i32) -> i32 { - __istype(_c,0x400usize) +pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { + __maskrune(_c, 0xfusize) } #[no_mangle] -pub unsafe extern fn isphonogram(mut _c : i32) -> i32 { - __istype(_c,0x200000usize) +pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { + __istype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn isrune(mut _c : i32) -> i32 { - __istype(_c,0xfffffff0usize) +pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { + __istype(_c, 0x80000usize) } #[no_mangle] -pub unsafe extern fn isspecial(mut _c : i32) -> i32 { - __istype(_c,0x100000usize) +pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { + __istype(_c, 0x400usize) } -static mut aid : *const u8 = 0xa0i32 as (*const u8); +#[no_mangle] +pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { + __istype(_c, 0x200000usize) +} + +#[no_mangle] +pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { + __istype(_c, 0xfffffff0usize) +} + +#[no_mangle] +pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 { + __istype(_c, 0x100000usize) +} + +static mut aid: *const u8 = 0xa0i32 as (*const u8); #[derive(Copy)] #[repr(C)] pub struct ykpiv_allocator { - pub pfn_alloc : unsafe extern fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void, - pub pfn_realloc : unsafe extern 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 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 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, } impl Clone for ykpiv_allocator { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } -unsafe extern fn _default_alloc( - mut data : *mut ::std::os::raw::c_void, mut cb : usize +unsafe extern "C" fn _default_alloc( + mut data: *mut ::std::os::raw::c_void, + mut cb: usize, ) -> *mut ::std::os::raw::c_void { data; - calloc(cb,1usize) + calloc(cb, 1usize) } -unsafe extern fn _default_realloc( - mut data : *mut ::std::os::raw::c_void, - mut p : *mut ::std::os::raw::c_void, - mut cb : usize +unsafe extern "C" fn _default_realloc( + mut data: *mut ::std::os::raw::c_void, + mut p: *mut ::std::os::raw::c_void, + mut cb: usize, ) -> *mut ::std::os::raw::c_void { data; - realloc(p,cb) + realloc(p, cb) } -unsafe extern fn _default_free( - mut data : *mut ::std::os::raw::c_void, - mut p : *mut ::std::os::raw::c_void +unsafe extern "C" fn _default_free( + mut data: *mut ::std::os::raw::c_void, + mut p: *mut ::std::os::raw::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) - }; +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), +}; #[derive(Copy)] #[repr(C)] pub struct _ykpiv_version_t { - pub major : u8, - pub minor : u8, - pub patch : u8, + pub major: u8, + pub minor: u8, + pub patch: u8, } impl Clone for _ykpiv_version_t { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct ykpiv_state { - pub context : i32, - pub card : i32, - pub verbose : i32, - pub pin : *mut u8, - pub allocator : ykpiv_allocator, - pub isNEO : bool, - pub ver : _ykpiv_version_t, - pub serial : u32, + pub context: i32, + pub card: i32, + pub verbose: i32, + pub pin: *mut u8, + pub allocator: ykpiv_allocator, + pub isNEO: bool, + pub ver: _ykpiv_version_t, + pub serial: u32, } impl Clone for ykpiv_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn _ykpiv_alloc( - mut state : *mut ykpiv_state, mut size : usize +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) + ((*state).allocator.pfn_alloc)((*state).allocator.alloc_data, size) } } #[no_mangle] -pub unsafe extern fn _ykpiv_realloc( - mut state : *mut ykpiv_state, - mut address : *mut ::std::os::raw::c_void, - mut size : usize +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 - ) + ((*state).allocator.pfn_realloc)((*state).allocator.alloc_data, address, size) } } #[no_mangle] -pub unsafe extern 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 { +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); + ((*state).allocator.pfn_free)((*state).allocator.alloc_data, data); } } #[no_mangle] -pub unsafe extern fn _ykpiv_set_length( - mut buffer : *mut u8, mut length : usize -) -> u32 { +pub unsafe extern "C" fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usize) -> u32 { if length < 0x80usize { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = length as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = length as (u8); 1u32 } else if length < 0x100usize { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 0x81u8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 0x81u8; *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = length as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = length as (u8); 2u32 } else { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 0x82u8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 0x82u8; *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = (length >> 8i32 & 0xffusize) as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = (length >> 8i32 & 0xffusize) as (u8); *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = (length as (u8) as (i32) & 0xffi32) as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = (length as (u8) as (i32) & 0xffi32) as (u8); 3u32 } } #[no_mangle] -pub unsafe extern fn _ykpiv_get_length( - mut buffer : *const u8, mut len : *mut usize -) -> u32 { +pub unsafe extern "C" 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 @@ -583,10 +590,8 @@ pub unsafe extern fn _ykpiv_get_length( *len = *buffer.offset(1isize) as (usize); 2u32 } else if *buffer as (i32) & 0x7fi32 == 2i32 { - let mut tmp : usize = *buffer.offset(1isize) as (usize); - *len = (tmp << 8i32).wrapping_add( - *buffer.offset(2isize) as (usize) - ); + let mut tmp: usize = *buffer.offset(1isize) as (usize); + *len = (tmp << 8i32).wrapping_add(*buffer.offset(2isize) as (usize)); 3u32 } else { 0u32 @@ -594,9 +599,7 @@ pub unsafe extern fn _ykpiv_get_length( } #[no_mangle] -pub unsafe extern fn _ykpiv_has_valid_length( - mut buffer : *const u8, mut len : usize -) -> bool { +pub unsafe extern "C" 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) { @@ -631,85 +634,79 @@ pub enum Enum5 { } #[no_mangle] -pub unsafe extern fn ykpiv_init_with_allocator( - mut state : *mut *mut ykpiv_state, - mut verbose : i32, - mut allocator : *const ykpiv_allocator +pub unsafe extern "C" fn ykpiv_init_with_allocator( + mut state: *mut *mut ykpiv_state, + mut verbose: i32, + mut allocator: *const ykpiv_allocator, ) -> Enum5 { - let mut s : *mut ykpiv_state; + 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 { + } 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 } else { s = ((*allocator).pfn_alloc)( - (*allocator).alloc_data, - ::std::mem::size_of::() - ) as (*mut ykpiv_state); + (*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 - } 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); - (*s).allocator = *allocator; - (*s).verbose = verbose; - (*s).context = -1i32; - *state = s; - Enum5::YKPIV_OK - }) + Enum5::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); + (*s).allocator = *allocator; + (*s).verbose = verbose; + (*s).context = -1i32; + *state = s; + Enum5::YKPIV_OK + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_init( - mut state : *mut *mut ykpiv_state, mut verbose : i32 -) -> Enum5 { +pub unsafe extern "C" fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbose: i32) -> Enum5 { ykpiv_init_with_allocator( state, verbose, - &mut _default_allocator as (*mut ykpiv_allocator) as (*const ykpiv_allocator) + &mut _default_allocator as (*mut ykpiv_allocator) as (*const ykpiv_allocator), ) } -unsafe extern fn _ykpiv_done( - mut state : *mut ykpiv_state, mut disconnect : bool -) -> Enum5 { +unsafe extern "C" fn _ykpiv_done(mut state: *mut ykpiv_state, mut disconnect: bool) -> Enum5 { if disconnect { ykpiv_disconnect(state); } _cache_pin( state, 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - 0usize + 0usize, ); - _ykpiv_free(state,state as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, state as (*mut ::std::os::raw::c_void)); Enum5::YKPIV_OK } #[no_mangle] -pub unsafe extern fn ykpiv_done_with_external_card( - mut state : *mut ykpiv_state -) -> Enum5 { - _ykpiv_done(state,false) +pub unsafe extern "C" fn ykpiv_done_with_external_card(mut state: *mut ykpiv_state) -> Enum5 { + _ykpiv_done(state, false) } #[no_mangle] -pub unsafe extern fn ykpiv_done( - mut state : *mut ykpiv_state -) -> Enum5 { - _ykpiv_done(state,true) +pub unsafe extern "C" fn ykpiv_done(mut state: *mut ykpiv_state) -> Enum5 { + _ykpiv_done(state, true) } #[no_mangle] -pub unsafe extern fn ykpiv_disconnect( - mut state : *mut ykpiv_state -) -> Enum5 { +pub unsafe extern "C" fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> Enum5 { if (*state).card != 0 { - SCardDisconnect((*state).card,0x1u32); + SCardDisconnect((*state).card, 0x1u32); (*state).card = 0i32; } if SCardIsValidContext((*state).context) == 0x0i32 { @@ -720,16 +717,12 @@ pub unsafe extern fn ykpiv_disconnect( } #[no_mangle] -pub unsafe extern fn _ykpiv_select_application( - mut state : *mut ykpiv_state -) -> Enum5 { - let mut apdu : u_APDU; - let mut data : [u8; 255]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 255]>() as (u32); - let mut sw : i32; - let mut res : Enum5 = Enum5::YKPIV_OK; +pub unsafe extern "C" fn _ykpiv_select_application(mut state: *mut ykpiv_state) -> Enum5 { + let mut apdu: u_APDU; + let mut data: [u8; 255]; + let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32); + let mut sw: i32; + let mut res: Enum5 = Enum5::YKPIV_OK; // FIXME(tarcieri): translate APDU construction /* @@ -741,20 +734,22 @@ pub unsafe extern fn _ykpiv_select_application( */ 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) { + 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 (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } res @@ -763,35 +758,35 @@ pub unsafe extern fn _ykpiv_select_application( fprintf( __stderrp, (*b"Failed selecting application: %04x\n\0").as_ptr(), - sw + sw, ); } Enum5::YKPIV_GENERIC_ERROR } else { res = _ykpiv_get_version( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_version_t) - ); + state, + 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_version_t), + ); if res as (i32) != Enum5::YKPIV_OK as (i32) { if (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed to retrieve version: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } } res = _ykpiv_get_serial( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32), - false - ); + state, + 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32), + false, + ); if res as (i32) != Enum5::YKPIV_OK as (i32) { if (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed to retrieve serial number: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } res = Enum5::YKPIV_OK; @@ -801,52 +796,52 @@ pub unsafe extern fn _ykpiv_select_application( } #[no_mangle] -pub unsafe extern fn _ykpiv_ensure_application_selected( - mut state : *mut ykpiv_state -) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; +pub unsafe extern "C" fn _ykpiv_ensure_application_selected(mut state: *mut ykpiv_state) -> Enum5 { + let mut res: Enum5 = Enum5::YKPIV_OK; state; res } -unsafe extern fn _ykpiv_connect( - mut state : *mut ykpiv_state, mut context : usize, mut card : usize +unsafe extern "C" fn _ykpiv_connect( + mut state: *mut ykpiv_state, + mut context: usize, + mut card: usize, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; + 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 context != (*state).context as (usize) && (0x0i32 != SCardIsValidContext( - context as (i32) - )) { + } else if context != (*state).context as (usize) + && (0x0i32 != SCardIsValidContext(context as (i32))) + { Enum5::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 atr : [u8; 33]; - let mut atr_len : u32 = ::std::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), - atr.as_mut_ptr(), - &mut atr_len as (*mut u32) - ) { + let mut reader: [u8; 3072]; + let mut reader_len: u32 = ::std::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); + 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), + atr.as_mut_ptr(), + &mut atr_len as (*mut u32), + ) + { return Enum5::YKPIV_PCSC_ERROR; } else { - (*state).isNEO = ::std::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), - atr_len as (usize) - )); + (*state).isNEO = ::std::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), + atr_len as (usize), + )); } } (*state).context = context as (i32); @@ -856,30 +851,31 @@ unsafe extern fn _ykpiv_connect( } #[no_mangle] -pub unsafe extern fn ykpiv_connect_with_external_card( - mut state : *mut ykpiv_state, mut context : usize, mut card : usize +pub unsafe extern "C" fn ykpiv_connect_with_external_card( + mut state: *mut ykpiv_state, + mut context: usize, + mut card: usize, ) -> Enum5 { - _ykpiv_connect(state,context,card) + _ykpiv_connect(state, context, card) } #[no_mangle] -pub unsafe extern fn ykpiv_connect( - mut state : *mut ykpiv_state, mut wanted : *const u8 +pub unsafe extern "C" fn ykpiv_connect( + mut state: *mut ykpiv_state, + mut wanted: *const u8, ) -> Enum5 { 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 rc : isize; - let mut reader_ptr : *mut u8; - let mut card : i32 = -1i32; - let mut ret - : Enum5 - = ykpiv_list_readers( - state, - reader_buf.as_mut_ptr(), - &mut num_readers as (*mut usize) - ); + let mut active_protocol: u32; + let mut reader_buf: [u8; 2048]; + let mut num_readers: usize = ::std::mem::size_of::<[u8; 2048]>(); + let mut rc: isize; + let mut reader_ptr: *mut u8; + let mut card: i32 = -1i32; + let mut ret: Enum5 = ykpiv_list_readers( + state, + reader_buf.as_mut_ptr(), + &mut num_readers as (*mut usize), + ); if ret as (i32) != Enum5::YKPIV_OK as (i32) { ret } else { @@ -890,22 +886,23 @@ pub unsafe extern fn ykpiv_connect( break; } if !wanted.is_null() { - let mut ptr : *mut u8 = reader_ptr; - let mut found : bool = false; + let mut ptr: *mut u8 = reader_ptr; + let mut found: bool = false; 'loop10: loop { if strlen(ptr as (*const u8)) < strlen(wanted) { _currentBlock = 14; break; } - if strncasecmp(ptr as (*const u8),wanted,strlen(wanted)) == 0i32 { + if strncasecmp(ptr as (*const u8), wanted, strlen(wanted)) == 0i32 { _currentBlock = 13; break; } if *{ - let _old = ptr; - ptr = ptr.offset(1isize); - _old - } == 0 { + let _old = ptr; + ptr = ptr.offset(1isize); + _old + } == 0 + { _currentBlock = 14; break; } @@ -917,10 +914,10 @@ pub unsafe extern fn ykpiv_connect( if (*state).verbose != 0 { fprintf( __stderrp, - (*b"skipping reader \'%s\' since it doesn\'t match \'%s\'.\n\0").as_ptr( - ), + (*b"skipping reader \'%s\' since it doesn\'t match \'%s\'.\n\0") + .as_ptr(), reader_ptr, - wanted + wanted, ); _currentBlock = 26; } else { @@ -937,103 +934,98 @@ pub unsafe extern fn ykpiv_connect( fprintf( __stderrp, (*b"trying to connect to reader \'%s\'.\n\0").as_ptr(), - reader_ptr + reader_ptr, ); } rc = SCardConnect( - (*state).context, - reader_ptr as (*const u8), - 0x2u32, - 0x2u32, - &mut card as (*mut i32), - &mut active_protocol as (*mut u32) - ) as (isize); + (*state).context, + reader_ptr as (*const u8), + 0x2u32, + 0x2u32, + &mut card as (*mut i32), + &mut active_protocol as (*mut u32), + ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { fprintf( __stderrp, (*b"SCardConnect failed, rc=%08lx\n\0").as_ptr(), - rc + rc, ); } - } else if Enum5::YKPIV_OK as (i32) == _ykpiv_connect( - state, - (*state).context as (usize), - card as (usize) - ) as (i32) { + } else if Enum5::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 as (*const u8)).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() - ); - } - SCardReleaseContext((*state).context); - (*state).context = -1i32; - Enum5::YKPIV_PCSC_ERROR - } else { - Enum5::YKPIV_GENERIC_ERROR - }) - } else if Enum5::YKPIV_OK as (i32) != { - ret = _ykpiv_begin_transaction(state); - ret - } as (i32) { - Enum5::YKPIV_PCSC_ERROR - } else { - ret = _ykpiv_select_application(state); - _ykpiv_end_transaction(state); - ret - }) + (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()); + } + SCardReleaseContext((*state).context); + (*state).context = -1i32; + Enum5::YKPIV_PCSC_ERROR + } else { + Enum5::YKPIV_GENERIC_ERROR + }) + } else if Enum5::YKPIV_OK as (i32) != { + ret = _ykpiv_begin_transaction(state); + ret + } as (i32) + { + Enum5::YKPIV_PCSC_ERROR + } else { + ret = _ykpiv_select_application(state); + _ykpiv_end_transaction(state); + ret + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_list_readers( - mut state : *mut ykpiv_state, - mut readers : *mut u8, - mut len : *mut usize +pub unsafe extern "C" fn ykpiv_list_readers( + mut state: *mut ykpiv_state, + mut readers: *mut u8, + mut len: *mut usize, ) -> Enum5 { - let mut num_readers : u32 = 0u32; - let mut rc : isize; + 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), - &mut (*state).context as (*mut i32) - ) as (isize); + 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), + &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 + rc, ); } return Enum5::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), - &mut num_readers as (*mut u32) - ) as (isize); + (*state).context, + 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), + 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + &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 + rc, ); } SCardReleaseContext((*state).context); @@ -1046,84 +1038,82 @@ pub unsafe extern fn ykpiv_list_readers( *len = num_readers as (usize); } rc = SCardListReaders( - (*state).context, - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - readers, - &mut num_readers as (*mut u32) - ) as (isize); + (*state).context, + 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), + 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 - ); - } - SCardReleaseContext((*state).context); - (*state).context = -1i32; - Enum5::YKPIV_PCSC_ERROR - } else { - *len = num_readers as (usize); - Enum5::YKPIV_OK - }) + if (*state).verbose != 0 { + fprintf( + __stderrp, + (*b"error: SCardListReaders failed, rc=%08lx\n\0").as_ptr(), + rc, + ); + } + SCardReleaseContext((*state).context); + (*state).context = -1i32; + Enum5::YKPIV_PCSC_ERROR + } else { + *len = num_readers as (usize); + Enum5::YKPIV_OK + }) } } -unsafe extern fn reconnect(mut state : *mut ykpiv_state) -> Enum5 { - let mut active_protocol : u32 = 0u32; - let mut rc : isize; - let mut res : Enum5; - let mut tries : i32; +unsafe extern "C" fn reconnect(mut state: *mut ykpiv_state) -> Enum5 { + let mut active_protocol: u32 = 0u32; + let mut rc: isize; + let mut res: Enum5; + let mut tries: i32; if (*state).verbose != 0 { fprintf( __stderrp, - (*b"trying to reconnect to current reader.\n\0").as_ptr() + (*b"trying to reconnect to current reader.\n\0").as_ptr(), ); } rc = SCardReconnect( - (*state).card, - 0x2u32, - 0x2u32, - 0x1u32, - &mut active_protocol as (*mut u32) - ) as (isize); + (*state).card, + 0x2u32, + 0x2u32, + 0x1u32, + &mut active_protocol as (*mut u32), + ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { fprintf( __stderrp, (*b"SCardReconnect failed, rc=%08lx\n\0").as_ptr(), - rc + rc, ); } Enum5::YKPIV_PCSC_ERROR } else if { - res = _ykpiv_select_application(state); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + res = _ykpiv_select_application(state); + res + } as (i32) + != Enum5::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 u8), &mut tries as (*mut i32)) } else { Enum5::YKPIV_OK } } #[no_mangle] -pub unsafe extern fn _ykpiv_begin_transaction( - mut state : *mut ykpiv_state -) -> Enum5 { - let mut rc : isize; +pub unsafe extern "C" fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -> Enum5 { + 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: Enum5 = Enum5::YKPIV_OK; if { - res = reconnect(state); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + res = reconnect(state); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { return res; } else { rc = SCardBeginTransaction((*state).card) as (isize); @@ -1133,9 +1123,8 @@ pub unsafe extern fn _ykpiv_begin_transaction( if (*state).verbose != 0 { fprintf( __stderrp, - (*b"error: Failed to begin pcsc transaction, rc=%08lx\n\0").as_ptr( - ), - rc + (*b"error: Failed to begin pcsc transaction, rc=%08lx\n\0").as_ptr(), + rc, ); } Enum5::YKPIV_PCSC_ERROR @@ -1145,17 +1134,13 @@ pub unsafe extern fn _ykpiv_begin_transaction( } #[no_mangle] -pub unsafe extern fn _ykpiv_end_transaction( - mut state : *mut ykpiv_state -) -> Enum5 { - let mut rc - : isize - = SCardEndTransaction((*state).card,0x0u32) as (isize); +pub unsafe extern "C" fn _ykpiv_end_transaction(mut state: *mut ykpiv_state) -> Enum5 { + 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 + rc, ); Enum5::YKPIV_PCSC_ERROR } else { @@ -1164,27 +1149,25 @@ pub unsafe extern fn _ykpiv_end_transaction( } #[no_mangle] -pub unsafe extern fn _ykpiv_transfer_data( - mut state : *mut ykpiv_state, - mut templ : *const u8, - mut in_data : *const u8, - mut in_len : isize, - mut out_data : *mut u8, - mut out_len : *mut usize, - mut sw : *mut i32 +pub unsafe extern "C" fn _ykpiv_transfer_data( + mut state: *mut ykpiv_state, + mut templ: *const u8, + mut in_data: *const u8, + mut in_len: isize, + mut out_data: *mut u8, + mut out_len: *mut usize, + mut sw: *mut i32, ) -> Enum5 { let mut _currentBlock; - let mut in_ptr : *const u8 = in_data; - let mut max_out : usize = *out_len; - let mut res : Enum5; + let mut in_ptr: *const u8 = in_data; + let mut max_out: usize = *out_len; + let mut res: Enum5; *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; + 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)); @@ -1199,7 +1182,7 @@ pub unsafe extern fn _ykpiv_transfer_data( fprintf( __stderrp, (*b"Going to send %lu bytes in this go.\n\0").as_ptr(), - this_size + this_size, ); } // FIXME(tarcieri): translate APDU code @@ -1208,12 +1191,12 @@ pub unsafe extern fn _ykpiv_transfer_data( memcpy(apdu.st.data, in_ptr, this_size); */ res = _send_data( - state, - &mut apdu as (*mut u_APDU), - data.as_mut_ptr(), - &mut recv_len as (*mut u32), - sw - ); + state, + &mut apdu as (*mut u_APDU), + data.as_mut_ptr(), + &mut recv_len as (*mut u32), + sw, + ); if res as (i32) != Enum5::YKPIV_OK as (i32) { _currentBlock = 24; break; @@ -1222,9 +1205,11 @@ pub unsafe extern fn _ykpiv_transfer_data( _currentBlock = 24; break; } - if (*out_len).wrapping_add(recv_len as (usize)).wrapping_sub( - 2usize - ) > max_out { + if (*out_len) + .wrapping_add(recv_len as (usize)) + .wrapping_sub(2usize) + > max_out + { _currentBlock = 21; break; } @@ -1232,12 +1217,10 @@ pub unsafe extern fn _ykpiv_transfer_data( memcpy( out_data as (*mut ::std::os::raw::c_void), data.as_mut_ptr() as (*const ::std::os::raw::c_void), - recv_len.wrapping_sub(2u32) as (usize) + recv_len.wrapping_sub(2u32) as (usize), ); out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize)); - *out_len = (*out_len).wrapping_add( - recv_len.wrapping_sub(2u32) as (usize) - ); + *out_len = (*out_len).wrapping_add(recv_len.wrapping_sub(2u32) as (usize)); } in_ptr = in_ptr.offset(this_size as (isize)); if !(in_ptr < in_data.offset(in_len)) { @@ -1251,17 +1234,14 @@ pub unsafe extern 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); + let mut apdu: u_APDU; + let mut data: [u8; 261]; + let mut recv_len: u32 = ::std::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 + (*b"The card indicates there is %d bytes more data for us.\n\0").as_ptr(), + *sw & 0xffi32, ); } // FIXME(tarcieri): translate APDU code @@ -1270,12 +1250,12 @@ pub unsafe extern fn _ykpiv_transfer_data( apdu.st.ins = YKPIV_INS_GET_RESPONSE_APDU; */ res = _send_data( - state, - &mut apdu as (*mut u_APDU), - data.as_mut_ptr(), - &mut recv_len as (*mut u32), - sw - ); + state, + &mut apdu as (*mut u_APDU), + data.as_mut_ptr(), + &mut recv_len as (*mut u32), + sw, + ); if res as (i32) != Enum5::YKPIV_OK as (i32) { _currentBlock = 24; break; @@ -1284,9 +1264,11 @@ pub unsafe extern fn _ykpiv_transfer_data( _currentBlock = 24; break; } - if (*out_len).wrapping_add(recv_len as (usize)).wrapping_sub( - 2usize - ) > max_out { + if (*out_len) + .wrapping_add(recv_len as (usize)) + .wrapping_sub(2usize) + > max_out + { _currentBlock = 18; break; } @@ -1296,22 +1278,21 @@ pub unsafe extern fn _ykpiv_transfer_data( memcpy( out_data as (*mut ::std::os::raw::c_void), data.as_mut_ptr() as (*const ::std::os::raw::c_void), - recv_len.wrapping_sub(2u32) as (usize) + recv_len.wrapping_sub(2u32) as (usize), ); out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize)); - *out_len = (*out_len).wrapping_add( - recv_len.wrapping_sub(2u32) as (usize) - ); + *out_len = (*out_len).wrapping_add(recv_len.wrapping_sub(2u32) as (usize)); } 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( - ), - (*out_len).wrapping_add(recv_len as (usize)).wrapping_sub(2usize), - max_out + (*b"Output buffer to small, wanted to write %lu, max was %lu.\0").as_ptr(), + (*out_len) + .wrapping_add(recv_len as (usize)) + .wrapping_sub(2usize), + max_out, ); } res = Enum5::YKPIV_SIZE_ERROR; @@ -1320,10 +1301,11 @@ pub unsafe extern fn _ykpiv_transfer_data( if (*state).verbose != 0 { fprintf( __stderrp, - (*b"Output buffer to small, wanted to write %lu, max was %lu.\n\0").as_ptr( - ), - (*out_len).wrapping_add(recv_len as (usize)).wrapping_sub(2usize), - max_out + (*b"Output buffer to small, wanted to write %lu, max was %lu.\n\0").as_ptr(), + (*out_len) + .wrapping_add(recv_len as (usize)) + .wrapping_sub(2usize), + max_out, ); } res = Enum5::YKPIV_SIZE_ERROR; @@ -1332,39 +1314,33 @@ pub unsafe extern fn _ykpiv_transfer_data( } #[no_mangle] -pub unsafe extern fn ykpiv_transfer_data( - mut state : *mut ykpiv_state, - mut templ : *const u8, - mut in_data : *const u8, - mut in_len : isize, - mut out_data : *mut u8, - mut out_len : *mut usize, - mut sw : *mut i32 +pub unsafe extern "C" fn ykpiv_transfer_data( + mut state: *mut ykpiv_state, + mut templ: *const u8, + mut in_data: *const u8, + mut in_len: isize, + mut out_data: *mut u8, + mut out_len: *mut usize, + mut sw: *mut i32, ) -> Enum5 { - let mut res : Enum5; + let mut res: Enum5; if { - res = _ykpiv_begin_transaction(state); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { *out_len = 0usize; Enum5::YKPIV_PCSC_ERROR } else { - res = _ykpiv_transfer_data( - state, - templ, - in_data, - in_len, - out_data, - out_len, - sw - ); + res = _ykpiv_transfer_data(state, templ, in_data, in_len, out_data, out_len, sw); _ykpiv_end_transaction(state); res } } -unsafe extern fn dump_hex(mut buf : *const u8, mut len : u32) { - let mut i : u32; +unsafe extern "C" fn dump_hex(mut buf: *const u8, mut len: u32) { + let mut i: u32; i = 0u32; 'loop1: loop { if !(i < len) { @@ -1373,24 +1349,24 @@ unsafe extern fn dump_hex(mut buf : *const u8, mut len : u32) { fprintf( __stderrp, (*b"%02x \0").as_ptr(), - *buf.offset(i as (isize)) as (i32) + *buf.offset(i as (isize)) as (i32), ); i = i.wrapping_add(1u32); } } #[no_mangle] -pub unsafe extern fn _send_data( - mut state : *mut ykpiv_state, - mut apdu : *mut u_APDU, - mut data : *mut u8, - mut recv_len : *mut u32, - mut sw : *mut i32 +pub unsafe extern "C" fn _send_data( + mut state: *mut ykpiv_state, + mut apdu: *mut u_APDU, + mut data: *mut u8, + mut recv_len: *mut u32, + mut sw: *mut i32, ) -> Enum5 { - let mut rc : isize; + 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; - let mut tmp_len : u32 = *recv_len; + let mut send_len: u32 = 0u32; // (unsigned int)apdu->st.lc + 5; + let mut tmp_len: u32 = *recv_len; // FIXME(tarcieri): Translate C code below /* @@ -1411,16 +1387,13 @@ pub unsafe extern fn _send_data( *recv_len = tmp_len; if (*state).verbose > 1i32 { - fprintf(__stderrp,(*b"< \0").as_ptr()); - dump_hex(data as (*const u8),*recv_len); - fprintf(__stderrp,(*b"\n\0").as_ptr()); + fprintf(__stderrp, (*b"< \0").as_ptr()); + dump_hex(data as (*const u8), *recv_len); + fprintf(__stderrp, (*b"\n\0").as_ptr()); } if *recv_len >= 2u32 { - *sw = *data.offset( - (*recv_len).wrapping_sub(2u32) as (isize) - ) as (i32) << 8i32 | *data.offset( - (*recv_len).wrapping_sub(1u32) as (isize) - ) as (i32); + *sw = *data.offset((*recv_len).wrapping_sub(2u32) as (isize)) as (i32) << 8i32 + | *data.offset((*recv_len).wrapping_sub(1u32) as (isize)) as (i32); } else { *sw = 0i32; } @@ -1438,44 +1411,45 @@ pub enum Enum6 { } #[no_mangle] -pub unsafe extern fn ykpiv_authenticate( - mut state : *mut ykpiv_state, mut key : *const u8 +pub unsafe extern "C" fn ykpiv_authenticate( + mut state: *mut ykpiv_state, + mut key: *const u8, ) -> Enum5 { - let mut apdu : u_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 sw : i32; - let mut res : Enum5; - 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 out_len : usize = 0usize; + let mut apdu: u_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 sw: i32; + let mut res: Enum5; + 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 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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { if 0i32 as (*mut ::std::os::raw::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( ); } - if Enum6::DES_OK as (i32) != des_import_key( - 1i32, - key, - (8i32 * 3i32) as (usize), - &mut mgm_key as (*mut *mut des_key) - ) as (i32) { + if Enum6::DES_OK as (i32) + != des_import_key( + 1i32, + key, + (8i32 * 3i32) as (usize), + &mut mgm_key as (*mut *mut des_key), + ) as (i32) + { res = Enum5::YKPIV_ALGORITHM_ERROR; } else { // get a challenge from the card @@ -1547,24 +1521,23 @@ pub unsafe extern fn ykpiv_authenticate( } } */ - let mut response : [u8; 8]; + let mut response: [u8; 8]; out_len = ::std::mem::size_of::<[u8; 8]>(); drc = des_encrypt( - mgm_key, - challenge.as_mut_ptr() as (*const u8), - ::std::mem::size_of::<[u8; 8]>(), - response.as_mut_ptr(), - &mut out_len as (*mut usize) - ); + mgm_key, + challenge.as_mut_ptr() as (*const u8), + ::std::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; } 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), - 8usize - ) == 0i32 { + response.as_mut_ptr() as (*const ::std::os::raw::c_void), + data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void), + 8usize, + ) == 0i32 + { res = Enum5::YKPIV_OK; } else { res = Enum5::YKPIV_AUTHENTICATION_ERROR; @@ -1580,75 +1553,80 @@ pub unsafe extern fn ykpiv_authenticate( } #[no_mangle] -pub unsafe extern fn ykpiv_set_mgmkey( - mut state : *mut ykpiv_state, mut new_key : *const u8 +pub unsafe extern "C" fn ykpiv_set_mgmkey( + mut state: *mut ykpiv_state, + mut new_key: *const u8, ) -> Enum5 { - ykpiv_set_mgmkey2(state,new_key,0u8) + ykpiv_set_mgmkey2(state, new_key, 0u8) } #[no_mangle] -pub unsafe extern fn ykpiv_set_mgmkey2( - mut state : *mut ykpiv_state, mut new_key : *const u8, touch : u8 +pub unsafe extern "C" fn ykpiv_set_mgmkey2( + mut state: *mut ykpiv_state, + mut new_key: *const u8, + touch: u8, ) -> Enum5 { - let mut apdu : u_APDU; - let mut data : [u8; 261]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut sw : i32; - let mut res : Enum5 = Enum5::YKPIV_OK; + let mut apdu: u_APDU; + let mut data: [u8; 261]; + let mut recv_len: u32 = ::std::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) { + 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)) { + 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"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() + (*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; - } + // 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; + } - 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); - */ + 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)) { + 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_GENERIC_ERROR; } @@ -1658,27 +1636,25 @@ pub unsafe extern fn ykpiv_set_mgmkey2( &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void), ::std::mem::size_of::(), 0i32, - ::std::mem::size_of::() + ::std::mem::size_of::(), ); _ykpiv_end_transaction(state); res } } -static mut hex_translate - : *mut u8 - = (*b"0123456789abcdef\0").as_ptr() as (*mut u8); +static mut hex_translate: *mut u8 = (*b"0123456789abcdef\0").as_ptr() as (*mut u8); #[no_mangle] -pub unsafe extern fn ykpiv_hex_decode( - mut hex_in : *const u8, - mut in_len : usize, - mut hex_out : *mut u8, - mut out_len : *mut usize +pub unsafe extern "C" fn ykpiv_hex_decode( + mut hex_in: *const u8, + mut in_len: usize, + mut hex_out: *mut u8, + mut out_len: *mut usize, ) -> Enum5 { let mut _currentBlock; - let mut i : usize; - let mut first : bool = true; + 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 { @@ -1691,70 +1667,64 @@ pub unsafe extern fn ykpiv_hex_decode( _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; + 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); + 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 - }; + 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 _currentBlock == 4 { - Enum5::YKPIV_OK - } else { - Enum5::YKPIV_PARSE_ERROR - }) + Enum5::YKPIV_OK + } else { + Enum5::YKPIV_PARSE_ERROR + }) } } -unsafe extern fn _general_authenticate( - mut state : *mut ykpiv_state, - mut sign_in : *const u8, - mut in_len : usize, - mut out : *mut u8, - mut out_len : *mut usize, - mut algorithm : u8, - mut key : u8, - mut decipher : bool +unsafe extern "C" fn _general_authenticate( + mut state: *mut ykpiv_state, + mut sign_in: *const u8, + mut in_len: usize, + mut out: *mut u8, + mut out_len: *mut usize, + mut algorithm: u8, + mut key: u8, + mut decipher: bool, ) -> Enum5 { 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 key_len : usize = 0usize; - let mut sw : i32 = 0i32; - let mut bytes : usize; - let mut len : usize = 0usize; - let mut res : Enum5; + 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 key_len: usize = 0usize; + let mut sw: i32 = 0i32; + let mut bytes: usize; + let mut len: usize = 0usize; + let mut res: Enum5; if algorithm as (i32) == 0x14i32 { _currentBlock = 12; } else if algorithm as (i32) == 0x11i32 { @@ -1783,11 +1753,7 @@ unsafe extern fn _general_authenticate( } if !decipher && (in_len > key_len) { return Enum5::YKPIV_SIZE_ERROR; - } else if decipher && (in_len != key_len.wrapping_mul( - 2usize - ).wrapping_add( - 1usize - )) { + } else if decipher && (in_len != key_len.wrapping_mul(2usize).wrapping_add(1usize)) { return Enum5::YKPIV_SIZE_ERROR; } } @@ -1799,62 +1765,59 @@ unsafe extern fn _general_authenticate( bytes = 3usize; } *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0x7cu8; - dataptr = dataptr.offset( - _ykpiv_set_length( - dataptr, - in_len.wrapping_add(bytes).wrapping_add(3usize) - ) as (isize) - ); + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0x7cu8; + dataptr = dataptr + .offset( + _ykpiv_set_length(dataptr, in_len.wrapping_add(bytes).wrapping_add(3usize)) as (isize), + ); *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0x82u8; + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0x82u8; *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0x0u8; + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0x0u8; *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = if (algorithm as (i32) == 0x11i32 || algorithm as (i32) == 0x14i32) && decipher { - 0x85i32 - } else { - 0x81i32 - } as (u8); - dataptr = dataptr.offset( - _ykpiv_set_length(dataptr,in_len) as (isize) - ); + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = if (algorithm as (i32) == 0x11i32 || algorithm as (i32) == 0x14i32) && decipher { + 0x85i32 + } else { + 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 + in_len, ); dataptr = dataptr.offset(in_len as (isize)); if { - res = ykpiv_transfer_data( - state, - 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), - data.as_mut_ptr(), - &mut recv_len as (*mut usize), - &mut sw as (*mut i32) - ); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + res = ykpiv_transfer_data( + state, + 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), + data.as_mut_ptr(), + &mut recv_len as (*mut usize), + &mut sw as (*mut i32), + ); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, - (*b"Sign command failed to communicate.\n\0").as_ptr() + (*b"Sign command failed to communicate.\n\0").as_ptr(), ); } res @@ -1863,142 +1826,121 @@ unsafe extern fn _general_authenticate( fprintf( __stderrp, (*b"Failed sign command with code %x.\n\0").as_ptr(), - sw + sw, ); } (if sw == 0x6982i32 { - Enum5::YKPIV_AUTHENTICATION_ERROR - } else { - Enum5::YKPIV_GENERIC_ERROR - }) + Enum5::YKPIV_AUTHENTICATION_ERROR + } else { + Enum5::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() + (*b"Failed parsing signature reply.\n\0").as_ptr(), ); } Enum5::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 as (*const u8), &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() - ); - } - Enum5::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) - ); - (if len > *out_len { - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Wrong size on output buffer.\n\0").as_ptr()); - } - Enum5::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 - }) - }) + if (*state).verbose != 0 { + fprintf( + __stderrp, + (*b"Failed parsing signature reply.\n\0").as_ptr(), + ); + } + Enum5::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), + ); + (if len > *out_len { + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Wrong size on output buffer.\n\0").as_ptr()); + } + Enum5::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 + }) + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_sign_data( - mut state : *mut ykpiv_state, - mut raw_in : *const u8, - mut in_len : usize, - mut sign_out : *mut u8, - mut out_len : *mut usize, - mut algorithm : u8, - mut key : u8 +pub unsafe extern "C" fn ykpiv_sign_data( + mut state: *mut ykpiv_state, + mut raw_in: *const u8, + mut in_len: usize, + mut sign_out: *mut u8, + mut out_len: *mut usize, + mut algorithm: u8, + mut key: u8, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; + 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) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { Enum5::YKPIV_PCSC_ERROR } else { res = _general_authenticate( - state, - raw_in, - in_len, - sign_out, - out_len, - algorithm, - key, - false - ); + state, raw_in, in_len, sign_out, out_len, algorithm, key, false, + ); _ykpiv_end_transaction(state); res } } #[no_mangle] -pub unsafe extern fn ykpiv_decipher_data( - mut state : *mut ykpiv_state, - mut in_ : *const u8, - mut in_len : usize, - mut out : *mut u8, - mut out_len : *mut usize, - mut algorithm : u8, - mut key : u8 +pub unsafe extern "C" fn ykpiv_decipher_data( + mut state: *mut ykpiv_state, + mut in_: *const u8, + mut in_len: usize, + mut out: *mut u8, + mut out_len: *mut usize, + mut algorithm: u8, + mut key: u8, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; + 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) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { Enum5::YKPIV_PCSC_ERROR } else { - res = _general_authenticate( - state, - in_, - in_len, - out, - out_len, - algorithm, - key, - true - ); + res = _general_authenticate(state, in_, in_len, out, out_len, algorithm, key, true); _ykpiv_end_transaction(state); res } } -unsafe extern fn _ykpiv_get_version( - mut state : *mut ykpiv_state, mut p_version : *mut _ykpiv_version_t +unsafe extern "C" fn _ykpiv_get_version( + mut state: *mut ykpiv_state, + mut p_version: *mut _ykpiv_version_t, ) -> Enum5 { - let mut apdu : u_APDU; - let mut data : [u8; 261]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut sw : i32; - let mut res : Enum5; + let mut apdu: u_APDU; + let mut data: [u8; 261]; + let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut sw: i32; + let mut res: Enum5; if state.is_null() { Enum5::YKPIV_ARGUMENT_ERROR } else if (*state).ver.major != 0 || (*state).ver.minor != 0 || (*state).ver.patch != 0 { @@ -2006,26 +1948,28 @@ unsafe extern fn _ykpiv_get_version( 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>() + ::std::mem::size_of::<_ykpiv_version_t>(), ); } Enum5::YKPIV_OK - // get version from device - // FIXME(tarcieri): Translate C code below (should go after the else clause) - /* - memset(apdu.raw, 0, sizeof(apdu)); - apdu.st.ins = YKPIV_INS_GET_VERSION; - */ + // get version from device + // FIXME(tarcieri): Translate C code below (should go after the else clause) + /* + memset(apdu.raw, 0, sizeof(apdu)); + apdu.st.ins = YKPIV_INS_GET_VERSION; + */ } 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) { + 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) + { res } else { if sw == 0x9000i32 { @@ -2038,8 +1982,9 @@ unsafe extern fn _ykpiv_get_version( 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>() + &mut (*state).ver as (*mut _ykpiv_version_t) + as (*const ::std::os::raw::c_void), + ::std::mem::size_of::<_ykpiv_version_t>(), ); } } @@ -2051,41 +1996,46 @@ unsafe extern fn _ykpiv_get_version( } #[no_mangle] -pub unsafe extern fn ykpiv_get_version( - mut state : *mut ykpiv_state, - mut version : *mut u8, - mut len : usize +pub unsafe extern "C" fn ykpiv_get_version( + mut state: *mut ykpiv_state, + mut version: *mut u8, + mut len: usize, ) -> Enum5 { - let mut res : Enum5; - let mut result : i32 = 0i32; - let mut ver - : _ykpiv_version_t - = _ykpiv_version_t { major: 0u8, minor: 0u8, patch: 0u8 }; + let mut res: Enum5; + let mut result: i32 = 0i32; + let mut ver: _ykpiv_version_t = _ykpiv_version_t { + major: 0u8, + minor: 0u8, + patch: 0u8, + }; if { - res = _ykpiv_begin_transaction(state); - res - } as (i32) < Enum5::YKPIV_OK as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + < Enum5::YKPIV_OK as (i32) + { Enum5::YKPIV_PCSC_ERROR } else { if !({ - res = _ykpiv_ensure_application_selected(state); - res - } as (i32) < Enum5::YKPIV_OK as (i32)) { + res = _ykpiv_ensure_application_selected(state); + res + } as (i32) + < Enum5::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) { + res = _ykpiv_get_version(state, &mut ver as (*mut _ykpiv_version_t)); + res + } as (i32) + >= Enum5::YKPIV_OK as (i32) + { result = snprintf( - version, - len, - (*b"%d.%d.%d\0").as_ptr(), - ver.major as (i32), - ver.minor as (i32), - ver.patch as (i32) - ); + version, + len, + (*b"%d.%d.%d\0").as_ptr(), + ver.major as (i32), + ver.minor as (i32), + ver.patch as (i32), + ); if result < 0i32 { res = Enum5::YKPIV_SIZE_ERROR; } @@ -2096,23 +2046,19 @@ pub unsafe extern fn ykpiv_get_version( } } -unsafe extern fn _ykpiv_get_serial( - mut state : *mut ykpiv_state, - mut p_serial : *mut u32, - mut f_force : bool +unsafe extern "C" fn _ykpiv_get_serial( + mut state: *mut ykpiv_state, + mut p_serial: *mut u32, + mut f_force: bool, ) -> Enum5 { let mut _currentBlock; - let mut res : Enum5 = Enum5::YKPIV_OK; - let mut apdu : u_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 sw : i32; - let mut p_temp - : *mut u8 - = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut apdu: u_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 sw: i32; + let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); if state.is_null() { Enum5::YKPIV_ARGUMENT_ERROR } else if !f_force && ((*state).serial != 0u32) { @@ -2122,7 +2068,7 @@ unsafe extern fn _ykpiv_get_serial( Enum5::YKPIV_OK } else { if (*state).ver.major as (i32) < 5i32 { - let mut temp : [u8; 255]; + let mut temp: [u8; 255]; recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32); // FIXME(tarcieri): Translate C code below /* @@ -2133,20 +2079,22 @@ unsafe extern fn _ykpiv_get_serial( memcpy(apdu.st.data, yk_applet, sizeof(yk_applet)); */ if { - res = _send_data( - state, - &mut apdu as (*mut u_APDU), - temp.as_mut_ptr(), - &mut recv_len as (*mut u32), - &mut sw as (*mut i32) - ); - res - } as (i32) < Enum5::YKPIV_OK as (i32) { + res = _send_data( + state, + &mut apdu as (*mut u_APDU), + temp.as_mut_ptr(), + &mut recv_len as (*mut u32), + &mut sw as (*mut i32), + ); + res + } as (i32) + < Enum5::YKPIV_OK as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); _currentBlock = 37; } else { @@ -2157,7 +2105,7 @@ unsafe extern fn _ykpiv_get_serial( fprintf( __stderrp, (*b"Failed selecting yk application: %04x\n\0").as_ptr(), - sw + sw, ); } res = Enum5::YKPIV_GENERIC_ERROR; @@ -2172,20 +2120,22 @@ unsafe extern fn _ykpiv_get_serial( apdu.st.lc = 0x00; */ 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) { + 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 (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); _currentBlock = 37; } else { @@ -2196,7 +2146,7 @@ unsafe extern fn _ykpiv_get_serial( fprintf( __stderrp, (*b"Failed retrieving serial number: %04x\n\0").as_ptr(), - sw + sw, ); } res = Enum5::YKPIV_GENERIC_ERROR; @@ -2212,20 +2162,22 @@ unsafe extern fn _ykpiv_get_serial( memcpy(apdu.st.data, aid, sizeof(aid)); */ if { - res = _send_data( - state, - &mut apdu as (*mut u_APDU), - temp.as_mut_ptr(), - &mut recv_len as (*mut u32), - &mut sw as (*mut i32) - ); - res - } as (i32) < Enum5::YKPIV_OK as (i32) { + res = _send_data( + state, + &mut apdu as (*mut u_APDU), + temp.as_mut_ptr(), + &mut recv_len as (*mut u32), + &mut sw as (*mut i32), + ); + res + } as (i32) + < Enum5::YKPIV_OK as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } return res; @@ -2234,7 +2186,7 @@ unsafe extern fn _ykpiv_get_serial( fprintf( __stderrp, (*b"Failed selecting application: %04x\n\0").as_ptr(), - sw + sw, ); } return Enum5::YKPIV_GENERIC_ERROR; @@ -2251,20 +2203,22 @@ unsafe extern fn _ykpiv_get_serial( */ 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) { + 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 (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } return res; @@ -2273,7 +2227,7 @@ unsafe extern fn _ykpiv_get_serial( fprintf( __stderrp, (*b"Failed retrieving serial number: %04x\n\0").as_ptr(), - sw + sw, ); } return Enum5::YKPIV_GENERIC_ERROR; @@ -2286,25 +2240,25 @@ unsafe extern fn _ykpiv_get_serial( } else { p_temp = &mut (*state).serial as (*mut u32) as (*mut u8); *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - } = data[3usize]; + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + } = data[3usize]; *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - } = data[2usize]; + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + } = data[2usize]; *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - } = data[1usize]; + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + } = data[1usize]; *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - } = data[0usize]; + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + } = data[0usize]; if !p_serial.is_null() { *p_serial = (*state).serial; } @@ -2315,29 +2269,36 @@ unsafe extern fn _ykpiv_get_serial( } #[no_mangle] -pub unsafe extern fn ykpiv_get_serial( - mut state : *mut ykpiv_state, mut p_serial : *mut u32 +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; + let mut res: Enum5 = Enum5::YKPIV_OK; if { - res = _ykpiv_begin_transaction(state); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { Enum5::YKPIV_PCSC_ERROR } else { if !({ - res = _ykpiv_ensure_application_selected(state); - res - } as (i32) != Enum5::YKPIV_OK as (i32)) { - res = _ykpiv_get_serial(state,p_serial,false); + res = _ykpiv_ensure_application_selected(state); + res + } as (i32) + != Enum5::YKPIV_OK as (i32)) + { + res = _ykpiv_get_serial(state, p_serial, false); } _ykpiv_end_transaction(state); res } } -unsafe extern fn _cache_pin( - mut state : *mut ykpiv_state, mut pin : *const u8, mut len : usize +unsafe extern "C" fn _cache_pin( + mut state: *mut ykpiv_state, + mut pin: *const u8, + mut len: usize, ) -> Enum5 { if state.is_null() { Enum5::YKPIV_ARGUMENT_ERROR @@ -2347,25 +2308,26 @@ unsafe extern fn _cache_pin( if !(*state).pin.is_null() { memset_s( (*state).pin as (*mut ::std::os::raw::c_void), - strnlen((*state).pin as (*const u8),8usize), + strnlen((*state).pin as (*const u8), 8usize), 0i32, - strnlen((*state).pin as (*const u8),8usize) + strnlen((*state).pin as (*const u8), 8usize), ); - _ykpiv_free(state,(*state).pin as (*mut ::std::os::raw::c_void)); + _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); + 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 + len, ); *(*state).pin.offset(len as (isize)) = 0u8; } @@ -2375,33 +2337,31 @@ unsafe extern fn _cache_pin( } #[no_mangle] -pub unsafe extern fn ykpiv_verify( - mut state : *mut ykpiv_state, - mut pin : *const u8, - mut tries : *mut i32 +pub unsafe extern "C" fn ykpiv_verify( + mut state: *mut ykpiv_state, + mut pin: *const u8, + mut tries: *mut i32, ) -> Enum5 { ykpiv_verify_select( state, pin, if !pin.is_null() { strlen(pin) } else { 0usize }, tries, - false + false, ) } -unsafe extern fn _verify( - mut state : *mut ykpiv_state, - mut pin : *const u8, - pin_len : usize, - mut tries : *mut i32 +unsafe extern "C" fn _verify( + mut state: *mut ykpiv_state, + mut pin: *const u8, + pin_len: usize, + mut tries: *mut i32, ) -> Enum5 { - let mut apdu : u_APDU; - let mut data : [u8; 261]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut sw : i32; - let mut res : Enum5; + let mut apdu: u_APDU; + let mut data: [u8; 261]; + let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut sw: i32; + let mut res: Enum5; if pin_len > 8usize { Enum5::YKPIV_SIZE_ERROR } else { @@ -2420,65 +2380,67 @@ unsafe extern fn _verify( } */ 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) - ); + state, + &mut apdu as (*mut u_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::(), 0i32, - ::std::mem::size_of::() + ::std::mem::size_of::(), ); (if res as (i32) != Enum5::YKPIV_OK as (i32) { - res - } else if sw == 0x9000i32 { - if !pin.is_null() && (pin_len != 0) { - _cache_pin(state,pin,pin_len); - } - if !tries.is_null() { - *tries = sw & 0xfi32; - } - Enum5::YKPIV_OK - } else if sw >> 8i32 == 0x63i32 { - if !tries.is_null() { - *tries = sw & 0xfi32; - } - Enum5::YKPIV_WRONG_PIN - } else if sw == 0x6983i32 { - if !tries.is_null() { - *tries = 0i32; - } - Enum5::YKPIV_WRONG_PIN - } else { - Enum5::YKPIV_GENERIC_ERROR - }) + res + } else if sw == 0x9000i32 { + if !pin.is_null() && (pin_len != 0) { + _cache_pin(state, pin, pin_len); + } + if !tries.is_null() { + *tries = sw & 0xfi32; + } + Enum5::YKPIV_OK + } else if sw >> 8i32 == 0x63i32 { + if !tries.is_null() { + *tries = sw & 0xfi32; + } + Enum5::YKPIV_WRONG_PIN + } else if sw == 0x6983i32 { + if !tries.is_null() { + *tries = 0i32; + } + Enum5::YKPIV_WRONG_PIN + } else { + Enum5::YKPIV_GENERIC_ERROR + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_verify_select( - mut state : *mut ykpiv_state, - mut pin : *const u8, - pin_len : usize, - mut tries : *mut i32, - mut force_select : bool +pub unsafe extern "C" fn ykpiv_verify_select( + mut state: *mut ykpiv_state, + mut pin: *const u8, + pin_len: usize, + mut tries: *mut i32, + mut force_select: bool, ) -> Enum5 { let mut _currentBlock; - let mut res : Enum5 = Enum5::YKPIV_OK; + let mut res: Enum5 = Enum5::YKPIV_OK; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { Enum5::YKPIV_PCSC_ERROR } else { if force_select { if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32) { + res = _ykpiv_ensure_application_selected(state); + res + } as (i32) + { _currentBlock = 4; } else { _currentBlock = 3; @@ -2487,7 +2449,7 @@ pub unsafe extern fn ykpiv_verify_select( _currentBlock = 3; } if _currentBlock == 3 { - res = _verify(state,pin,pin_len,tries); + res = _verify(state, pin, pin_len, tries); } _ykpiv_end_transaction(state); res @@ -2495,43 +2457,46 @@ pub unsafe extern fn ykpiv_verify_select( } #[no_mangle] -pub unsafe extern fn ykpiv_get_pin_retries( - mut state : *mut ykpiv_state, mut tries : *mut i32 +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 { + 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 } 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) - }) + 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) + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_set_pin_retries( - mut state : *mut ykpiv_state, - mut pin_tries : i32, - mut puk_tries : i32 +pub unsafe extern "C" 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; - 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 sw : i32 = 0i32; + let mut res: Enum5 = Enum5::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 sw: i32 = 0i32; if pin_tries == 0i32 || puk_tries == 0i32 { Enum5::YKPIV_OK } else if pin_tries > 0xffi32 || puk_tries > 0xffi32 || pin_tries < 1i32 || puk_tries < 1i32 { @@ -2540,57 +2505,59 @@ pub unsafe extern fn ykpiv_set_pin_retries( *templ.offset(2isize) = pin_tries as (u8); *templ.offset(3isize) = puk_tries as (u8); (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_transfer_data( - state, - templ as (*const u8), - 0i32 as (*mut ::std::os::raw::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 !(0x9000i32 == sw) { - if sw == 0x6983i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; - } else if sw == 0x6982i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; - } else { - res = Enum5::YKPIV_GENERIC_ERROR; - } - } - } - } - _ykpiv_end_transaction(state); - res - }) + 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_transfer_data( + state, + templ as (*const u8), + 0i32 as (*mut ::std::os::raw::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 !(0x9000i32 == sw) { + if sw == 0x6983i32 { + res = Enum5::YKPIV_AUTHENTICATION_ERROR; + } else if sw == 0x6982i32 { + res = Enum5::YKPIV_AUTHENTICATION_ERROR; + } else { + res = Enum5::YKPIV_GENERIC_ERROR; + } + } + } + } + _ykpiv_end_transaction(state); + res + }) } } -unsafe extern fn _ykpiv_change_pin( - mut state : *mut ykpiv_state, - mut action : i32, - mut current_pin : *const u8, - mut current_pin_len : usize, - mut new_pin : *const u8, - mut new_pin_len : usize, - mut tries : *mut i32 +unsafe extern "C" fn _ykpiv_change_pin( + mut state: *mut ykpiv_state, + mut action: i32, + mut current_pin: *const u8, + mut current_pin_len: usize, + mut new_pin: *const u8, + mut new_pin_len: usize, + mut tries: *mut i32, ) -> Enum5 { - 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 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; if current_pin_len > 8usize { Enum5::YKPIV_SIZE_ERROR } else if new_pin_len > 8usize { @@ -2604,105 +2571,108 @@ unsafe extern fn _ykpiv_change_pin( memcpy( indata.as_mut_ptr() as (*mut ::std::os::raw::c_void), current_pin as (*const ::std::os::raw::c_void), - current_pin_len + 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 ::std::os::raw::c_void), 0xffi32, - 8usize.wrapping_sub(current_pin_len) + 8usize.wrapping_sub(current_pin_len), ); } memcpy( - indata.as_mut_ptr().offset( - 8isize - ) as (*mut ::std::os::raw::c_void), + indata.as_mut_ptr().offset(8isize) as (*mut ::std::os::raw::c_void), new_pin as (*const ::std::os::raw::c_void), - new_pin_len + new_pin_len, ); if new_pin_len < 8usize { memset( - indata.as_mut_ptr().offset(8isize).offset( - new_pin_len as (isize) - ) as (*mut ::std::os::raw::c_void), + indata + .as_mut_ptr() + .offset(8isize) + .offset(new_pin_len as (isize)) + as (*mut ::std::os::raw::c_void), 0xffi32, - 8usize.wrapping_sub(new_pin_len) + 8usize.wrapping_sub(new_pin_len), ); } res = ykpiv_transfer_data( - state, - templ as (*const u8), - indata.as_mut_ptr() as (*const u8), - ::std::mem::size_of::<[u8; 16]>() as (isize), - data.as_mut_ptr(), - &mut recv_len as (*mut usize), - &mut sw as (*mut i32) - ); + state, + templ as (*const u8), + indata.as_mut_ptr() as (*const u8), + ::std::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]>(), 0i32, - ::std::mem::size_of::<[u8; 16]>() + ::std::mem::size_of::<[u8; 16]>(), ); (if res as (i32) != Enum5::YKPIV_OK as (i32) { - res - } else if sw != 0x9000i32 { - (if sw >> 8i32 == 0x63i32 { - if !tries.is_null() { - *tries = sw & 0xfi32; - } - Enum5::YKPIV_WRONG_PIN - } else if sw == 0x6983i32 { - Enum5::YKPIV_PIN_LOCKED - } else { - if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed changing pin, token response code: %x.\n\0").as_ptr(), - sw - ); - } - Enum5::YKPIV_GENERIC_ERROR - }) - } else { - Enum5::YKPIV_OK - }) + res + } else if sw != 0x9000i32 { + (if sw >> 8i32 == 0x63i32 { + if !tries.is_null() { + *tries = sw & 0xfi32; + } + Enum5::YKPIV_WRONG_PIN + } else if sw == 0x6983i32 { + Enum5::YKPIV_PIN_LOCKED + } else { + if (*state).verbose != 0 { + fprintf( + __stderrp, + (*b"Failed changing pin, token response code: %x.\n\0").as_ptr(), + sw, + ); + } + Enum5::YKPIV_GENERIC_ERROR + }) + } else { + Enum5::YKPIV_OK + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_change_pin( - mut state : *mut ykpiv_state, - mut current_pin : *const u8, - mut current_pin_len : usize, - mut new_pin : *const u8, - mut new_pin_len : usize, - mut tries : *mut i32 +pub unsafe extern "C" fn ykpiv_change_pin( + mut state: *mut ykpiv_state, + mut current_pin: *const u8, + mut current_pin_len: usize, + mut new_pin: *const u8, + mut new_pin_len: usize, + mut tries: *mut i32, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_GENERIC_ERROR; + let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_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); + 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); @@ -2711,34 +2681,36 @@ pub unsafe extern fn ykpiv_change_pin( } #[no_mangle] -pub unsafe extern fn ykpiv_change_puk( - mut state : *mut ykpiv_state, - mut current_puk : *const u8, - mut current_puk_len : usize, - mut new_puk : *const u8, - mut new_puk_len : usize, - mut tries : *mut i32 +pub unsafe extern "C" fn ykpiv_change_puk( + mut state: *mut ykpiv_state, + mut current_puk: *const u8, + mut current_puk_len: usize, + mut new_puk: *const u8, + mut new_puk_len: usize, + mut tries: *mut i32, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_GENERIC_ERROR; + let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { res = _ykpiv_change_pin( - state, - 2i32, - current_puk, - current_puk_len, - new_puk, - new_puk_len, - tries - ); + state, + 2i32, + current_puk, + current_puk_len, + new_puk, + new_puk_len, + tries, + ); } _ykpiv_end_transaction(state); res @@ -2746,34 +2718,28 @@ pub unsafe extern fn ykpiv_change_puk( } #[no_mangle] -pub unsafe extern fn ykpiv_unblock_pin( - mut state : *mut ykpiv_state, - mut puk : *const u8, - mut puk_len : usize, - mut new_pin : *const u8, - mut new_pin_len : usize, - mut tries : *mut i32 +pub unsafe extern "C" fn ykpiv_unblock_pin( + mut state: *mut ykpiv_state, + mut puk: *const u8, + mut puk_len: usize, + mut new_pin: *const u8, + mut new_pin_len: usize, + mut tries: *mut i32, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_GENERIC_ERROR; + let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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, - 1i32, - puk, - puk_len, - new_pin, - new_pin_len, - tries - ); + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { + res = _ykpiv_change_pin(state, 1i32, puk, puk_len, new_pin, new_pin_len, tries); } _ykpiv_end_transaction(state); res @@ -2781,168 +2747,169 @@ pub unsafe extern fn ykpiv_unblock_pin( } #[no_mangle] -pub unsafe extern fn ykpiv_fetch_object( - mut state : *mut ykpiv_state, - mut object_id : i32, - mut data : *mut u8, - mut len : *mut usize +pub unsafe extern "C" 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; + let mut res: Enum5; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_fetch_object(state,object_id,data,len); + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { + res = _ykpiv_fetch_object(state, object_id, data, len); } _ykpiv_end_transaction(state); res } } -unsafe extern fn set_object( - mut object_id : i32, mut buffer : *mut u8 -) -> *mut u8 { +unsafe extern "C" fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut u8 { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 0x5cu8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 0x5cu8; if object_id == 0x7ei32 { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 1u8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 1u8; *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 0x7eu8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 0x7eu8; } else if object_id > 0xffffi32 && (object_id <= 0xffffffi32) { *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = 3u8; + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = 3u8; *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = (object_id >> 16i32 & 0xffi32) as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = (object_id >> 16i32 & 0xffi32) as (u8); *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = (object_id >> 8i32 & 0xffi32) as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = (object_id >> 8i32 & 0xffi32) as (u8); *{ - let _old = buffer; - buffer = buffer.offset(1isize); - _old - } = (object_id & 0xffi32) as (u8); + let _old = buffer; + buffer = buffer.offset(1isize); + _old + } = (object_id & 0xffi32) as (u8); } buffer } #[no_mangle] -pub unsafe extern fn _ykpiv_fetch_object( - mut state : *mut ykpiv_state, - mut object_id : i32, - mut data : *mut u8, - mut len : *mut usize +pub unsafe extern "C" fn _ykpiv_fetch_object( + mut state: *mut ykpiv_state, + mut object_id: i32, + mut data: *mut u8, + mut len: *mut usize, ) -> Enum5 { - 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; - inptr = set_object(object_id,inptr); + 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; + inptr = set_object(object_id, inptr); if inptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) { Enum5::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), - data, - len, - &mut sw as (*mut i32) - ); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { + 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), + data, + len, + &mut sw as (*mut i32), + ); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { res } else if sw == 0x9000i32 { - let mut outlen : usize = 0usize; - let mut offs : u32 = 0u32; - (if *len < 2usize || !_ykpiv_has_valid_length( - data.offset(1isize) as (*const u8), - (*len).wrapping_sub(1usize) - ) { - Enum5::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 - } else if outlen.wrapping_add(offs as (usize)).wrapping_add( - 1usize - ) != *len { - if (*state).verbose != 0 { - fprintf( + let mut outlen: usize = 0usize; + let mut offs: u32 = 0u32; + (if *len < 2usize + || !_ykpiv_has_valid_length( + data.offset(1isize) as (*const u8), + (*len).wrapping_sub(1usize), + ) + { + Enum5::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 + } 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( ), *len, outlen ); - } - Enum5::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), - outlen - ); - *len = outlen; - Enum5::YKPIV_OK - }) - }) + } + Enum5::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), + outlen, + ); + *len = outlen; + Enum5::YKPIV_OK + }) + }) } else { Enum5::YKPIV_GENERIC_ERROR } } #[no_mangle] -pub unsafe extern fn ykpiv_save_object( - mut state : *mut ykpiv_state, - mut object_id : i32, - mut indata : *mut u8, - mut len : usize +pub unsafe extern "C" 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; + let mut res: Enum5; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_save_object(state,object_id,indata,len); + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { + res = _ykpiv_save_object(state, object_id, indata, len); } _ykpiv_end_transaction(state); res @@ -2950,115 +2917,128 @@ pub unsafe extern fn ykpiv_save_object( } #[no_mangle] -pub unsafe extern fn _ykpiv_save_object( - mut state : *mut ykpiv_state, - mut object_id : i32, - mut indata : *mut u8, - mut len : usize +pub unsafe extern "C" fn _ykpiv_save_object( + mut state: *mut ykpiv_state, + mut object_id: i32, + mut indata: *mut u8, + mut len: usize, ) -> Enum5 { - 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 outlen : usize = 0usize; + 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 outlen: usize = 0usize; if len > ::std::mem::size_of::<[u8; 3072]>().wrapping_sub(9usize) { Enum5::YKPIV_SIZE_ERROR } else { - dataptr = set_object(object_id,dataptr); + dataptr = set_object(object_id, dataptr); (if dataptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) { - Enum5::YKPIV_INVALID_OBJECT - } else { - *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _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 - ); - dataptr = dataptr.offset(len as (isize)); - (if { - res = _ykpiv_transfer_data( - state, - 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), - &mut outlen as (*mut usize), - &mut sw as (*mut i32) - ); - res - } as (i32) != Enum5::YKPIV_OK as (i32) { - res - } else if 0x9000i32 == sw { - Enum5::YKPIV_OK - } else if 0x6982i32 == sw { - Enum5::YKPIV_AUTHENTICATION_ERROR - } else { - Enum5::YKPIV_GENERIC_ERROR - }) - }) + Enum5::YKPIV_INVALID_OBJECT + } else { + *{ + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _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, + ); + dataptr = dataptr.offset(len as (isize)); + (if { + res = _ykpiv_transfer_data( + state, + 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), + &mut outlen as (*mut usize), + &mut sw as (*mut i32), + ); + res + } as (i32) + != Enum5::YKPIV_OK as (i32) + { + res + } else if 0x9000i32 == sw { + Enum5::YKPIV_OK + } else if 0x6982i32 == sw { + Enum5::YKPIV_AUTHENTICATION_ERROR + } else { + Enum5::YKPIV_GENERIC_ERROR + }) + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_import_private_key( - mut state : *mut ykpiv_state, - key : u8, - mut algorithm : u8, - mut p : *const u8, - mut p_len : usize, - mut q : *const u8, - mut q_len : usize, - mut dp : *const u8, - mut dp_len : usize, - mut dq : *const u8, - mut dq_len : usize, - mut qinv : *const u8, - mut qinv_len : usize, - mut ec_data : *const u8, - mut ec_data_len : u8, - pin_policy : u8, - touch_policy : u8 +pub unsafe extern "C" fn ykpiv_import_private_key( + mut state: *mut ykpiv_state, + key: u8, + mut algorithm: u8, + mut p: *const u8, + mut p_len: usize, + mut q: *const u8, + mut q_len: usize, + mut dp: *const u8, + mut dp_len: usize, + mut dq: *const u8, + mut dq_len: usize, + mut qinv: *const u8, + mut qinv_len: usize, + mut ec_data: *const u8, + mut ec_data_len: u8, + pin_policy: u8, + touch_policy: u8, ) -> Enum5 { 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 elem_len : u32; - let mut sw : i32; - let mut params : [*const u8; 5]; - let mut lens : [usize; 5]; - let mut padding : usize; - let mut n_params : u8; - let mut i : i32; - let mut param_tag : i32; - let mut res : Enum5; + 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 elem_len: u32; + let mut sw: i32; + let mut params: [*const u8; 5]; + let mut lens: [usize; 5]; + let mut padding: usize; + 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 - } 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) { + } 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 - } else if pin_policy as (i32) != 0i32 && (pin_policy as (i32) != 1i32) && (pin_policy as (i32) != 2i32) && (pin_policy as (i32) != 3i32) { + } 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 - } else if touch_policy as (i32) != 0i32 && (touch_policy as (i32) != 1i32) && (touch_policy as (i32) != 2i32) && (touch_policy as (i32) != 3i32) { + } 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 } else { if algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32 { - if p_len.wrapping_add(q_len).wrapping_add(dp_len).wrapping_add( - dq_len - ).wrapping_add( - qinv_len - ) >= ::std::mem::size_of::<[u8; 1024]>() { + if p_len + .wrapping_add(q_len) + .wrapping_add(dp_len) + .wrapping_add(dq_len) + .wrapping_add(qinv_len) + >= ::std::mem::size_of::<[u8; 1024]>() + { return Enum5::YKPIV_SIZE_ERROR; } else { if algorithm as (i32) == 0x6i32 { @@ -3067,7 +3047,12 @@ pub unsafe extern 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 ::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) + { return Enum5::YKPIV_GENERIC_ERROR; } else { params[0usize] = p; @@ -3112,31 +3097,27 @@ pub unsafe extern fn ykpiv_import_private_key( _currentBlock = 25; break; } - let mut remaining : usize; + let mut remaining: usize; *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = (param_tag + i) as (u8); - in_ptr = in_ptr.offset( - _ykpiv_set_length(in_ptr,elem_len as (usize)) as (isize) - ); + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = (param_tag + i) as (u8); + 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_sub( - in_ptr as (usize) - ); + remaining = (key_data.as_mut_ptr() as (usize)) + .wrapping_add(::std::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 ::std::os::raw::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), - lens[i as (usize)] + lens[i as (usize)], ); in_ptr = in_ptr.offset(lens[i as (usize)] as (isize)); i = i + 1; @@ -3144,63 +3125,64 @@ pub unsafe extern fn ykpiv_import_private_key( if _currentBlock == 25 { if pin_policy as (i32) != 0i32 { *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0xaau8; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0xaau8; *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0x1u8; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0x1u8; *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = pin_policy; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = pin_policy; } if touch_policy as (i32) != 0i32 { *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0xabu8; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0xabu8; *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0x1u8; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0x1u8; *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = touch_policy; + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = touch_policy; } if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { return Enum5::YKPIV_PCSC_ERROR; } else if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected( - state - ); - res - } as (i32)) { + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { if !({ - res = ykpiv_transfer_data( - state, - 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), - data.as_mut_ptr(), - &mut recv_len as (*mut usize), - &mut sw as (*mut i32) - ); - res - } as (i32) != Enum5::YKPIV_OK as (i32)) { + res = ykpiv_transfer_data( + state, + 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), + data.as_mut_ptr(), + &mut recv_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 sw == 0x6982i32 { @@ -3216,7 +3198,7 @@ pub unsafe extern fn ykpiv_import_private_key( key_data.as_mut_ptr() as (*mut ::std::os::raw::c_void), ::std::mem::size_of::<[u8; 1024]>(), 0i32, - ::std::mem::size_of::<[u8; 1024]>() + ::std::mem::size_of::<[u8; 1024]>(), ); _ykpiv_end_transaction(state); res @@ -3224,73 +3206,78 @@ pub unsafe extern fn ykpiv_import_private_key( } #[no_mangle] -pub unsafe extern fn ykpiv_attest( - mut state : *mut ykpiv_state, - key : u8, - mut data : *mut u8, - mut data_len : *mut usize +pub unsafe extern "C" fn ykpiv_attest( + mut state: *mut ykpiv_state, + key: u8, + mut data: *mut u8, + mut data_len: *mut usize, ) -> Enum5 { - let mut res : Enum5; - 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) { + let mut res: Enum5; + 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 - }) + 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 + }) } } #[no_mangle] -pub unsafe extern fn ykpiv_auth_getchallenge( - mut state : *mut ykpiv_state, - mut challenge : *mut u8, - challenge_len : usize +pub unsafe extern "C" 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); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut apdu: u_APDU = 0i32 as (u_APDU); let mut data = [0u8; 261]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut sw : i32 = 0i32; + let mut recv_len: u32 = ::std::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 { @@ -3298,15 +3285,17 @@ pub unsafe extern fn ykpiv_auth_getchallenge( } else if 8usize != challenge_len { Enum5::YKPIV_SIZE_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { // get a challenge from the card // FIXME(tarcieri): Translate C code below /* @@ -3320,24 +3309,24 @@ pub unsafe extern fn ykpiv_auth_getchallenge( 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) - ); - res - } as (i32) != Enum5::YKPIV_OK as (i32)) { + 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; } else { memcpy( challenge as (*mut ::std::os::raw::c_void), - data.as_mut_ptr().offset( - 4isize - ) as (*const ::std::os::raw::c_void), - 8usize + data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void), + 8usize, ); } } @@ -3348,20 +3337,18 @@ pub unsafe extern fn ykpiv_auth_getchallenge( } #[no_mangle] -pub unsafe extern fn ykpiv_auth_verifyresponse( - mut state : *mut ykpiv_state, - mut response : *mut u8, - response_len : usize +pub unsafe extern "C" 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); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut apdu: u_APDU = 0i32 as (u_APDU); let mut data = [0u8; 261]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut sw : i32 = 0i32; + let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() 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 + 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 { @@ -3369,9 +3356,10 @@ pub unsafe extern fn ykpiv_auth_verifyresponse( } else if 8usize != response_len { Enum5::YKPIV_SIZE_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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. @@ -3384,43 +3372,45 @@ pub unsafe extern fn ykpiv_auth_verifyresponse( 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 + } = 0x7cu8; *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0xau8; + 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 + } = 0x82u8; *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 8u8; + 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 + 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)) { + 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; } @@ -3429,32 +3419,30 @@ pub unsafe extern fn ykpiv_auth_verifyresponse( &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void), ::std::mem::size_of::(), 0i32, - ::std::mem::size_of::() + ::std::mem::size_of::(), ); _ykpiv_end_transaction(state); res } } -static mut MGMT_AID : *const u8 = 0xa0i32 as (*const u8); +static mut MGMT_AID: *const u8 = 0xa0i32 as (*const u8); #[no_mangle] -pub unsafe extern fn ykpiv_auth_deauthenticate( - mut state : *mut ykpiv_state -) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; - let mut apdu : u_APDU; - let mut data : [u8; 255]; - let mut recv_len - : u32 - = ::std::mem::size_of::<[u8; 255]>() as (u32); - let mut sw : i32; +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; + let mut data: [u8; 255]; + let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32); + let mut sw: i32; if state.is_null() { Enum5::YKPIV_ARGUMENT_ERROR } else if { - res = _ykpiv_begin_transaction(state); - res - } as (i32) < Enum5::YKPIV_OK as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + < Enum5::YKPIV_OK as (i32) + { res } else { // FIXME(tarcieri): Translate C code below @@ -3466,20 +3454,22 @@ pub unsafe extern fn ykpiv_auth_deauthenticate( memcpy(apdu.st.data, MGMT_AID, sizeof(MGMT_AID)); */ 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) { + 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 (*state).verbose != 0 { fprintf( __stderrp, (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res) + ykpiv_strerror(res), ); } } else if sw != 0x9000i32 { @@ -3487,7 +3477,7 @@ pub unsafe extern fn ykpiv_auth_deauthenticate( fprintf( __stderrp, (*b"Failed selecting mgmt application: %04x\n\0").as_ptr(), - sw + sw, ); } res = Enum5::YKPIV_GENERIC_ERROR; diff --git a/src/util.rs b/src/util.rs index 2f6145b..4187752 100644 --- a/src/util.rs +++ b/src/util.rs @@ -25,387 +25,382 @@ // (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 { - 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; +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_fetch_object( - state : *mut ykpiv_state, - object_id : i32, - data : *mut u8, - len : *mut usize + 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 - ); - 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_free(state: *mut ykpiv_state, data: *mut ::std::os::raw::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 + state: *mut ykpiv_state, + address: *mut ::std::os::raw::c_void, + size: usize, ) -> *mut ::std::os::raw::c_void; fn _ykpiv_save_object( - state : *mut ykpiv_state, - object_id : i32, - indata : *mut u8, - len : usize + state: *mut ykpiv_state, + object_id: i32, + indata: *mut u8, + len: usize, ) -> Enum5; - fn _ykpiv_set_length(buffer : *mut u8, length : usize) -> u32; + fn _ykpiv_set_length(buffer: *mut u8, length: usize) -> u32; fn _ykpiv_transfer_data( - state : *mut ykpiv_state, - templ : *const u8, - in_data : *const u8, - in_len : isize, - out_data : *mut u8, - out_len : *mut usize, - sw : *mut i32 + state: *mut ykpiv_state, + templ: *const u8, + in_data: *const u8, + in_len: isize, + out_data: *mut u8, + out_len: *mut usize, + sw: *mut i32, ) -> Enum5; - fn fprintf(arg1 : *mut __sFILE, arg2 : *const u8, ...) -> i32; + 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 + __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 + __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; + fn memset_s(__s: *mut ::std::os::raw::c_void, __smax: usize, __c: i32, __n: usize) -> i32; fn pkcs5_pbkdf2_sha1( - password : *const u8, - cb_password : usize, - salt : *const u8, - cb_salt : usize, - iterations : usize, - key : *const u8, - cb_key : usize + password: *const u8, + cb_password: usize, + salt: *const u8, + cb_salt: usize, + iterations: usize, + 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 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, - current_puk_len : usize, - new_puk : *const u8, - new_puk_len : usize, - tries : *mut i32 - ) -> Enum5; - fn ykpiv_set_mgmkey( - state : *mut ykpiv_state, new_key : *const u8 + state: *mut ykpiv_state, + current_puk: *const u8, + current_puk_len: usize, + 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; fn ykpiv_transfer_data( - state : *mut ykpiv_state, - templ : *const u8, - in_data : *const u8, - in_len : isize, - out_data : *mut u8, - out_len : *mut usize, - sw : *mut i32 + state: *mut ykpiv_state, + templ: *const u8, + in_data: *const u8, + in_len: isize, + out_data: *mut u8, + out_len: *mut usize, + sw: *mut i32, ) -> Enum5; } -enum __sFILEX { -} +enum __sFILEX {} #[derive(Copy)] #[repr(C)] pub struct __sbuf { - pub _base : *mut u8, - pub _size : i32, + pub _base: *mut u8, + pub _size: i32, } impl Clone for __sbuf { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[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 fn(*mut ::std::os::raw::c_void) -> i32, - pub _read : unsafe extern fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek : unsafe extern fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write : unsafe extern 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, + 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 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) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub unsafe extern fn isascii(mut _c : i32) -> i32 { +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 { (_c & !0x7fi32 == 0i32) as (i32) } #[derive(Copy)] #[repr(C)] pub struct Struct3 { - pub __min : i32, - pub __max : i32, - pub __map : i32, - pub __types : *mut u32, + pub __min: i32, + pub __max: i32, + pub __map: i32, + pub __types: *mut u32, } impl Clone for Struct3 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct2 { - pub __nranges : i32, - pub __ranges : *mut Struct3, + pub __nranges: i32, + pub __ranges: *mut Struct3, } impl Clone for Struct2 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct4 { - pub __name : [u8; 14], - pub __mask : u32, + pub __name: [u8; 14], + pub __mask: u32, } impl Clone for Struct4 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct Struct1 { - pub __magic : [u8; 8], - pub __encoding : [u8; 32], - pub __sgetrune : unsafe extern fn(*const u8, usize, *mut *const u8) -> i32, - pub __sputrune : unsafe extern fn(i32, *mut u8, usize, *mut *mut u8) -> i32, - pub __invalid_rune : i32, - pub __runetype : [u32; 256], - pub __maplower : [i32; 256], - pub __mapupper : [i32; 256], - pub __runetype_ext : Struct2, - pub __maplower_ext : Struct2, - pub __mapupper_ext : Struct2, - pub __variable : *mut ::std::os::raw::c_void, - pub __variable_len : i32, - pub __ncharclasses : i32, - pub __charclasses : *mut Struct4, + 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 __invalid_rune: i32, + pub __runetype: [u32; 256], + pub __maplower: [i32; 256], + pub __mapupper: [i32; 256], + pub __runetype_ext: Struct2, + pub __maplower_ext: Struct2, + pub __mapupper_ext: Struct2, + pub __variable: *mut ::std::os::raw::c_void, + pub __variable_len: i32, + pub __ncharclasses: i32, + pub __charclasses: *mut Struct4, } impl Clone for Struct1 { - fn clone(&self) -> Self { *self } -} - -#[no_mangle] -pub unsafe extern 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 { - !(__maskrune(_c,_f) == 0) as (i32) + fn clone(&self) -> Self { + *self } } #[no_mangle] -pub unsafe extern fn __isctype(mut _c : i32, mut _f : usize) -> i32 { +pub unsafe extern "C" 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 { + !(__maskrune(_c, _f) == 0) as (i32) + } +} + +#[no_mangle] +pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { - !(_DefaultRuneLocale.__runetype[ - _c as (usize) - ] as (usize) & _f == 0) as (i32) + !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } } #[no_mangle] -pub unsafe extern fn __wcwidth(mut _c : i32) -> i32 { - let mut _x : u32; +pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { + let mut _x: u32; if _c == 0i32 { 0i32 } else { - _x = __maskrune(_c,0xe0000000usize | 0x40000usize) as (u32); + _x = __maskrune(_c, 0xe0000000usize | 0x40000usize) as (u32); (if _x as (usize) & 0xe0000000usize != 0usize { - ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) - } else if _x as (usize) & 0x40000usize != 0usize { - 1i32 - } else { - -1i32 - }) + ((_x as (usize) & 0xe0000000usize) >> 30i32) as (i32) + } else if _x as (usize) & 0x40000usize != 0usize { + 1i32 + } else { + -1i32 + }) } } #[no_mangle] -pub unsafe extern fn isalnum(mut _c : i32) -> i32 { - __istype(_c,(0x100isize | 0x400isize) as (usize)) +pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { + __istype(_c, (0x100isize | 0x400isize) as (usize)) } #[no_mangle] -pub unsafe extern fn isalpha(mut _c : i32) -> i32 { - __istype(_c,0x100usize) +pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { + __istype(_c, 0x100usize) } #[no_mangle] -pub unsafe extern fn isblank(mut _c : i32) -> i32 { - __istype(_c,0x20000usize) +pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { + __istype(_c, 0x20000usize) } #[no_mangle] -pub unsafe extern fn iscntrl(mut _c : i32) -> i32 { - __istype(_c,0x200usize) +pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { + __istype(_c, 0x200usize) } #[no_mangle] -pub unsafe extern fn isdigit(mut _c : i32) -> i32 { - __isctype(_c,0x400usize) +pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x400usize) } #[no_mangle] -pub unsafe extern fn isgraph(mut _c : i32) -> i32 { - __istype(_c,0x800usize) +pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { + __istype(_c, 0x800usize) } #[no_mangle] -pub unsafe extern fn islower(mut _c : i32) -> i32 { - __istype(_c,0x1000usize) +pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { + __istype(_c, 0x1000usize) } #[no_mangle] -pub unsafe extern fn isprint(mut _c : i32) -> i32 { - __istype(_c,0x40000usize) +pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { + __istype(_c, 0x40000usize) } #[no_mangle] -pub unsafe extern fn ispunct(mut _c : i32) -> i32 { - __istype(_c,0x2000usize) +pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { + __istype(_c, 0x2000usize) } #[no_mangle] -pub unsafe extern fn isspace(mut _c : i32) -> i32 { - __istype(_c,0x4000usize) +pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { + __istype(_c, 0x4000usize) } #[no_mangle] -pub unsafe extern fn isupper(mut _c : i32) -> i32 { - __istype(_c,0x8000usize) +pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { + __istype(_c, 0x8000usize) } #[no_mangle] -pub unsafe extern fn isxdigit(mut _c : i32) -> i32 { - __isctype(_c,0x10000usize) +pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { + __isctype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn toascii(mut _c : i32) -> i32 { _c & 0x7fi32 } - -#[no_mangle] -pub unsafe extern fn tolower(mut _c : i32) -> i32 { __tolower(_c) } - -#[no_mangle] -pub unsafe extern fn toupper(mut _c : i32) -> i32 { __toupper(_c) } - -#[no_mangle] -pub unsafe extern fn digittoint(mut _c : i32) -> i32 { - __maskrune(_c,0xfusize) +pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { + _c & 0x7fi32 } #[no_mangle] -pub unsafe extern fn ishexnumber(mut _c : i32) -> i32 { - __istype(_c,0x10000usize) +pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { + __tolower(_c) } #[no_mangle] -pub unsafe extern fn isideogram(mut _c : i32) -> i32 { - __istype(_c,0x80000usize) +pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { + __toupper(_c) } #[no_mangle] -pub unsafe extern fn isnumber(mut _c : i32) -> i32 { - __istype(_c,0x400usize) +pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { + __maskrune(_c, 0xfusize) } #[no_mangle] -pub unsafe extern fn isphonogram(mut _c : i32) -> i32 { - __istype(_c,0x200000usize) +pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { + __istype(_c, 0x10000usize) } #[no_mangle] -pub unsafe extern fn isrune(mut _c : i32) -> i32 { - __istype(_c,0xfffffff0usize) +pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { + __istype(_c, 0x80000usize) } #[no_mangle] -pub unsafe extern fn isspecial(mut _c : i32) -> i32 { - __istype(_c,0x100000usize) +pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { + __istype(_c, 0x400usize) } #[no_mangle] -pub static mut CHUID_TMPL : *const u8 = 0x30i32 as (*const u8); +pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { + __istype(_c, 0x200000usize) +} #[no_mangle] -pub static mut CCC_TMPL : *const u8 = 0xf0i32 as (*const u8); +pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { + __istype(_c, 0xfffffff0usize) +} + +#[no_mangle] +pub unsafe extern "C" 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)] @@ -432,48 +427,51 @@ pub enum Enum5 { #[derive(Copy)] #[repr(C)] pub struct Struct6 { - pub data : [u8; 16], + pub data: [u8; 16], } impl Clone for Struct6 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_get_cardid( - mut state : *mut ykpiv_state, mut cardid : *mut Struct6 +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; - let mut buf : [u8; 3063]; - let mut len : usize = ::std::mem::size_of::<[u8; 3063]>(); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut buf: [u8; 3063]; + let mut len: usize = ::std::mem::size_of::<[u8; 3063]>(); if cardid.is_null() { Enum5::YKPIV_GENERIC_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { res = _ykpiv_fetch_object( - state, - 0x5fc102i32, - buf.as_mut_ptr(), - &mut len as (*mut usize) - ); + state, + 0x5fc102i32, + buf.as_mut_ptr(), + &mut len as (*mut usize), + ); if Enum5::YKPIV_OK as (i32) == res as (i32) { if len != 59usize { res = Enum5::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), - 16usize + buf.as_mut_ptr().offset(29isize) as (*const ::std::os::raw::c_void), + 16usize, ); } } @@ -491,94 +489,101 @@ pub enum Enum7 { } #[no_mangle] -pub unsafe extern fn ykpiv_util_set_cardid( - mut state : *mut ykpiv_state, mut cardid : *const Struct6 +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; - let mut id : [u8; 16]; - let mut buf : [u8; 59]; - let mut len : usize = 0usize; + let mut res: Enum5 = Enum5::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 } 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) { + if Enum7::PRNG_OK as (i32) + != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 16]>()) as (i32) + { return Enum5::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]>() + ::std::mem::size_of::<[u8; 16]>(), ); } (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)) { - memcpy( - buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), - CHUID_TMPL as (*const ::std::os::raw::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]>() - ); - len = 59usize; - res = _ykpiv_save_object(state,0x5fc102i32,buf.as_mut_ptr(),len); - } - _ykpiv_end_transaction(state); - res - }) + 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)) + { + memcpy( + buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), + CHUID_TMPL as (*const ::std::os::raw::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]>(), + ); + len = 59usize; + res = _ykpiv_save_object(state, 0x5fc102i32, buf.as_mut_ptr(), len); + } + _ykpiv_end_transaction(state); + res + }) } } #[derive(Copy)] #[repr(C)] pub struct Struct8 { - pub data : [u8; 14], + pub data: [u8; 14], } impl Clone for Struct8 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_get_cccid( - mut state : *mut ykpiv_state, mut ccc : *mut Struct8 +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; - let mut buf : [u8; 3063]; - let mut len : usize = ::std::mem::size_of::<[u8; 3063]>(); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut buf: [u8; 3063]; + let mut len: usize = ::std::mem::size_of::<[u8; 3063]>(); if ccc.is_null() { Enum5::YKPIV_GENERIC_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { res = _ykpiv_fetch_object( - state, - 0x5fc107i32, - buf.as_mut_ptr(), - &mut len as (*mut usize) - ); + state, + 0x5fc107i32, + buf.as_mut_ptr(), + &mut len as (*mut usize), + ); if Enum5::YKPIV_OK as (i32) == res as (i32) { if len != 51usize { res = Enum5::YKPIV_GENERIC_ERROR; @@ -586,7 +591,7 @@ pub unsafe extern fn ykpiv_util_get_cccid( 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), - 14usize + 14usize, ); } } @@ -597,177 +602,185 @@ pub unsafe extern fn ykpiv_util_get_cccid( } #[no_mangle] -pub unsafe extern fn ykpiv_util_set_cccid( - mut state : *mut ykpiv_state, mut ccc : *const Struct8 +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; - let mut id : [u8; 14]; - let mut buf : [u8; 51]; - let mut len : usize = 0usize; + let mut res: Enum5 = Enum5::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 } 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) { + if Enum7::PRNG_OK as (i32) + != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 14]>()) as (i32) + { return Enum5::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]>() + ::std::mem::size_of::<[u8; 14]>(), ); } (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)) { - len = 51usize; - memcpy( - buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), - CCC_TMPL as (*const ::std::os::raw::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), - 14usize - ); - res = _ykpiv_save_object(state,0x5fc107i32,buf.as_mut_ptr(),len); - } - _ykpiv_end_transaction(state); - res - }) + 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)) + { + len = 51usize; + memcpy( + buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), + CCC_TMPL as (*const ::std::os::raw::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), + 14usize, + ); + res = _ykpiv_save_object(state, 0x5fc107i32, buf.as_mut_ptr(), len); + } + _ykpiv_end_transaction(state); + res + }) } } #[derive(Copy)] #[repr(C)] pub struct ykpiv_allocator { - pub pfn_alloc : unsafe extern fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void, - pub pfn_realloc : unsafe extern 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 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 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, } impl Clone for ykpiv_allocator { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct _ykpiv_version_t { - pub major : u8, - pub minor : u8, - pub patch : u8, + pub major: u8, + pub minor: u8, + pub patch: u8, } impl Clone for _ykpiv_version_t { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Copy)] #[repr(C)] pub struct ykpiv_state { - pub context : i32, - pub card : i32, - pub verbose : i32, - pub pin : *mut u8, - pub allocator : ykpiv_allocator, - pub isNEO : bool, - pub ver : _ykpiv_version_t, - pub serial : u32, + pub context: i32, + pub card: i32, + pub verbose: i32, + pub pin: *mut u8, + pub allocator: ykpiv_allocator, + pub isNEO: bool, + pub ver: _ykpiv_version_t, + pub serial: u32, } impl Clone for ykpiv_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_devicemodel( - mut state : *mut ykpiv_state -) -> u32 { - if state.is_null( - ) || (*state).context == 0 || (*state).context as (usize) == -1i32 as (usize) { +pub unsafe extern "C" 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 { (if (*state).isNEO { - 0x4e450000i32 | 0x7233i32 - } else { - 0x594b0000i32 | 0x34i32 - }) as (u32) + 0x4e450000i32 | 0x7233i32 + } else { + 0x594b0000i32 | 0x34i32 + }) as (u32) } } #[derive(Copy)] #[repr(C)] pub struct _ykpiv_key { - pub slot : u8, - pub cert_len : u16, - pub cert : [u8; 1], + pub slot: u8, + pub cert_len: u16, + pub cert: [u8; 1], } impl Clone for _ykpiv_key { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern 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 +pub unsafe extern "C" 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 { 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 cbData : usize = 0usize; - let mut offset : usize = 0usize; - let mut buf : [u8; 3072]; - let mut cbBuf : usize = 0usize; - let mut i : usize = 0usize; - 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 { + 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 cbData: usize = 0usize; + let mut offset: usize = 0usize; + let mut buf: [u8; 3072]; + let mut cbBuf: usize = 0usize; + let mut i: usize = 0usize; + 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 + { Enum5::YKPIV_GENERIC_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { *key_count = 0u8; *data = 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_key); *data_len = 0usize; if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { - pData = _ykpiv_alloc( - state, - CB_PAGE - ) as (*mut u8); - pData - } { + pData = _ykpiv_alloc(state, CB_PAGE) as (*mut u8); + pData + } { res = Enum5::YKPIV_MEMORY_ERROR; } else { cbData = CB_PAGE; @@ -779,47 +792,44 @@ pub unsafe extern fn ykpiv_util_list_keys( } cbBuf = ::std::mem::size_of::<[u8; 3072]>(); res = _read_certificate( - state, - *SLOTS.offset(i as (isize)), - buf.as_mut_ptr(), - &mut cbBuf as (*mut usize) - ); + 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>().wrapping_add( - cbBuf - ).wrapping_sub( - 1usize - ) > cbData.wrapping_sub(offset) { - (if ::std::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>().wrapping_add( - cbBuf - ).wrapping_sub( - 1usize - ).wrapping_sub( - cbData.wrapping_sub(offset) - ) - } else { - CB_PAGE - }) - } else { - 0usize - }; + cbRealloc = if ::std::mem::size_of::<_ykpiv_key>() + .wrapping_add(cbBuf) + .wrapping_sub(1usize) + > cbData.wrapping_sub(offset) + { + (if ::std::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>() + .wrapping_add(cbBuf) + .wrapping_sub(1usize) + .wrapping_sub(cbData.wrapping_sub(offset)) + } else { + CB_PAGE + }) + } else { + 0usize + }; if 0usize != cbRealloc { if { - pTemp = _ykpiv_realloc( - state, - pData as (*mut ::std::os::raw::c_void), - cbData.wrapping_add(cbRealloc) - ) as (*mut u8); - pTemp - }.is_null( - ) { + pTemp = _ykpiv_realloc( + state, + pData as (*mut ::std::os::raw::c_void), + cbData.wrapping_add(cbRealloc), + ) as (*mut u8); + pTemp + } + .is_null() + { _currentBlock = 15; break; } @@ -833,15 +843,13 @@ pub unsafe extern fn ykpiv_util_list_keys( memcpy( (*pKey).cert.as_mut_ptr() as (*mut ::std::os::raw::c_void), buf.as_mut_ptr() as (*const ::std::os::raw::c_void), - cbBuf + cbBuf, ); offset = offset.wrapping_add( - ::std::mem::size_of::<_ykpiv_key>().wrapping_add( - cbBuf - ).wrapping_sub( - 1usize - ) - ); + ::std::mem::size_of::<_ykpiv_key>() + .wrapping_add(cbBuf) + .wrapping_sub(1usize), + ); *key_count = (*key_count as (i32) + 1) as (u8); } i = i.wrapping_add(1usize); @@ -859,7 +867,7 @@ pub unsafe extern fn ykpiv_util_list_keys( } } if !pData.is_null() { - _ykpiv_free(state,pData as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void)); } _ykpiv_end_transaction(state); res @@ -867,67 +875,68 @@ pub unsafe extern fn ykpiv_util_list_keys( } #[no_mangle] -pub unsafe extern fn ykpiv_util_free( - mut state : *mut ykpiv_state, - mut data : *mut ::std::os::raw::c_void +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); + _ykpiv_free(state, data); Enum5::YKPIV_OK } } #[no_mangle] -pub unsafe extern fn ykpiv_util_read_cert( - mut state : *mut ykpiv_state, - mut slot : u8, - mut data : *mut *mut u8, - mut data_len : *mut usize +pub unsafe extern "C" 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; - 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 res: Enum5 = Enum5::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 + { Enum5::YKPIV_GENERIC_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { *data = 0i32 as (*mut u8); *data_len = 0usize; if Enum5::YKPIV_OK as (i32) == { - res = _read_certificate( - state, - slot, - buf.as_mut_ptr(), - &mut cbBuf as (*mut usize) - ); - res - } 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_len = 0usize; } else if { - *data = _ykpiv_alloc(state,cbBuf) as (*mut u8); - *data - }.is_null( - ) { + *data = _ykpiv_alloc(state, cbBuf) as (*mut u8); + *data + } + .is_null() + { res = Enum5::YKPIV_MEMORY_ERROR; } else { memcpy( *data as (*mut ::std::os::raw::c_void), buf.as_mut_ptr() as (*const ::std::os::raw::c_void), - cbBuf + cbBuf, ); *data_len = cbBuf; } @@ -939,25 +948,27 @@ pub unsafe extern fn ykpiv_util_read_cert( } #[no_mangle] -pub unsafe extern fn ykpiv_util_write_cert( - mut state : *mut ykpiv_state, - mut slot : u8, - mut data : *mut u8, - mut data_len : usize, - mut certinfo : u8 +pub unsafe extern "C" 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; + let mut res: Enum5 = Enum5::YKPIV_OK; if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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 = _write_certificate(state,slot,data,data_len,certinfo); + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { + res = _write_certificate(state, slot, data, data_len, certinfo); } _ykpiv_end_transaction(state); res @@ -965,45 +976,44 @@ pub unsafe extern fn ykpiv_util_write_cert( } #[no_mangle] -pub unsafe extern fn ykpiv_util_delete_cert( - mut state : *mut ykpiv_state, mut slot : u8 +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 + 0u8, ) } #[no_mangle] -pub unsafe extern fn ykpiv_util_block_puk( - mut state : *mut ykpiv_state -) -> Enum5 { +pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> Enum5 { let mut _currentBlock; - let mut res : Enum5 = Enum5::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_item : usize = 0usize; - let mut flags : u8 = 0u8; + let mut res: Enum5 = Enum5::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_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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32) + { _currentBlock = 20; } else { _currentBlock = 3; @@ -1012,16 +1022,17 @@ pub unsafe extern fn ykpiv_util_block_puk( if _currentBlock == 3 { if tries != 0i32 { if Enum5::YKPIV_OK as (i32) == { - res = ykpiv_change_puk( - state, - puk as (*const u8), - ::std::mem::size_of::<*mut u8>(), - puk as (*const u8), - ::std::mem::size_of::<*mut u8>(), - &mut tries as (*mut i32) - ); - res - } as (i32) { + res = ykpiv_change_puk( + state, + puk as (*const u8), + ::std::mem::size_of::<*mut u8>(), + puk as (*const u8), + ::std::mem::size_of::<*mut u8>(), + &mut tries as (*mut i32), + ); + res + } as (i32) + { let _rhs = 1; let _lhs = &mut *puk.offset(0isize); *_lhs = (*_lhs as (i32) + _rhs) as (u8); @@ -1036,57 +1047,60 @@ pub unsafe extern fn ykpiv_util_block_puk( _currentBlock = 3; } } else { - if Enum5::YKPIV_OK as (i32) == _read_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ) as (i32) { - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x81u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { + if Enum5::YKPIV_OK as (i32) + == _read_metadata( + state, + 0x80u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ) as (i32) + { + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x81u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { if ::std::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), - cb_item + cb_item, ); } else if (*state).verbose != 0 { fprintf( __stderrp, - (*b"admin flags exist, but are incorrect size = %lu\0").as_ptr( - ), - cb_item + (*b"admin flags exist, but are incorrect size = %lu\0") + .as_ptr(), + cb_item, ); } } } flags = (flags as (i32) | 0x1i32) as (u8); - if Enum5::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::() - ) as (i32) { + if Enum5::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::(), + ) as (i32) + { if (*state).verbose == 0 { _currentBlock = 20; continue; } - fprintf(__stderrp,(*b"could not set admin flags\0").as_ptr()); + fprintf(__stderrp, (*b"could not set admin flags\0").as_ptr()); _currentBlock = 20; } else { - if !(Enum5::YKPIV_OK as (i32) != _write_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - cb_data - ) as (i32)) { + if !(Enum5::YKPIV_OK as (i32) + != _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data) as (i32)) + { _currentBlock = 20; continue; } @@ -1094,7 +1108,7 @@ pub unsafe extern fn ykpiv_util_block_puk( _currentBlock = 20; continue; } - fprintf(__stderrp,(*b"could not write admin metadata\0").as_ptr()); + fprintf(__stderrp, (*b"could not write admin metadata\0").as_ptr()); _currentBlock = 20; } } @@ -1109,92 +1123,94 @@ pub unsafe extern fn ykpiv_util_block_puk( #[derive(Copy)] #[repr(C)] pub struct _ykpiv_container { - pub name : [i32; 40], - pub slot : u8, - pub key_spec : u8, - pub key_size_bits : u16, - pub flags : u8, - pub pin_id : u8, - pub associated_echd_container : u8, - pub cert_fingerprint : [u8; 20], + pub name: [i32; 40], + pub slot: u8, + pub key_spec: u8, + pub key_size_bits: u16, + pub flags: u8, + pub pin_id: u8, + pub associated_echd_container: u8, + pub cert_fingerprint: [u8; 20], } impl Clone for _ykpiv_container { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_read_mscmap( - mut state : *mut ykpiv_state, - mut containers : *mut *mut _ykpiv_container, - mut n_containers : *mut usize +pub unsafe extern "C" 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; - let mut buf : [u8; 3072]; - let mut cbBuf : usize = ::std::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 res: Enum5 = Enum5::YKPIV_OK; + let mut buf: [u8; 3072]; + let mut cbBuf: usize = ::std::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 + { res = Enum5::YKPIV_GENERIC_ERROR; } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { return Enum5::YKPIV_PCSC_ERROR; } else if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } 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) == { - res = _ykpiv_fetch_object( - state, - 0x5fff10i32, - buf.as_mut_ptr(), - &mut cbBuf as (*mut usize) - ); - res - } as (i32) { + res = _ykpiv_fetch_object( + state, + 0x5fff10i32, + buf.as_mut_ptr(), + &mut cbBuf as (*mut usize), + ); + res + } as (i32) + { ptr = buf.as_mut_ptr(); if cbBuf < 2usize { res = Enum5::YKPIV_OK; } else if *{ - let _old = ptr; - ptr = ptr.offset(1isize); - _old - } as (i32) == 0x81i32 { + let _old = ptr; + ptr = ptr.offset(1isize); + _old + } as (i32) + == 0x81i32 + { ptr = ptr.offset( - _ykpiv_get_length( - ptr as (*const u8), - &mut len as (*mut usize) - ) as (usize) as (isize) - ); - if len > cbBuf.wrapping_sub( - ((ptr as (isize)).wrapping_sub( - buf.as_mut_ptr() as (isize) - ) / ::std::mem::size_of::() as (isize)) as (usize) - ) { + _ykpiv_get_length(ptr as (*const u8), &mut len as (*mut usize)) as (usize) + as (isize), + ); + if len + > cbBuf.wrapping_sub( + ((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize)) + / ::std::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) == { - *containers = _ykpiv_alloc( - state, - len - ) as (*mut _ykpiv_container); - *containers - } { + *containers = _ykpiv_alloc(state, len) as (*mut _ykpiv_container); + *containers + } { res = Enum5::YKPIV_MEMORY_ERROR; } else { memcpy( *containers as (*mut ::std::os::raw::c_void), ptr as (*const ::std::os::raw::c_void), - len + len, ); - *n_containers = len.wrapping_div( - ::std::mem::size_of::<_ykpiv_container>() - ); + *n_containers = len.wrapping_div(::std::mem::size_of::<_ykpiv_container>()); } } } @@ -1203,88 +1219,75 @@ pub unsafe extern fn ykpiv_util_read_mscmap( res } -unsafe extern fn _obj_size_max( - mut state : *mut ykpiv_state -) -> usize { +unsafe extern "C" fn _obj_size_max(mut state: *mut ykpiv_state) -> usize { (if !state.is_null() && (*state).isNEO { - 2048i32 - 9i32 - } else { - 3063i32 - }) as (usize) + 2048i32 - 9i32 + } else { + 3063i32 + }) as (usize) } #[no_mangle] -pub unsafe extern fn ykpiv_util_write_mscmap( - mut state : *mut ykpiv_state, - mut containers : *mut _ykpiv_container, - mut n_containers : usize +pub unsafe extern "C" 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; - 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>() - ); + let mut res: Enum5 = Enum5::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) != { - res = _ykpiv_begin_transaction(state); - res - } 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 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == containers || 0usize == n_containers { - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) != containers || 0usize != n_containers { + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { + if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == containers + || 0usize == n_containers + { + if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) != containers + || 0usize != n_containers + { res = Enum5::YKPIV_GENERIC_ERROR; } else { res = _ykpiv_save_object( - state, - 0x5fff10i32, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize - ); + state, + 0x5fff10i32, + 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0usize, + ); } } else { - req_len = 1usize.wrapping_add( - _ykpiv_set_length(buf.as_mut_ptr(),data_len) as (usize) - ).wrapping_add( - data_len - ); + req_len = 1usize + .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; } else { - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0x81u8; - offset = offset.wrapping_add( - _ykpiv_set_length( - buf.as_mut_ptr().offset(offset as (isize)), - data_len - ) as (usize) - ); + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0x81u8; + offset = offset.wrapping_add(_ykpiv_set_length( + buf.as_mut_ptr().offset(offset as (isize)), + data_len, + ) as (usize)); memcpy( - buf.as_mut_ptr().offset( - offset as (isize) - ) as (*mut ::std::os::raw::c_void), + 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), - data_len + data_len, ); offset = offset.wrapping_add(data_len); - res = _ykpiv_save_object( - state, - 0x5fff10i32, - buf.as_mut_ptr(), - offset - ); + res = _ykpiv_save_object(state, 0x5fff10i32, buf.as_mut_ptr(), offset); } } } @@ -1294,52 +1297,45 @@ pub unsafe extern fn ykpiv_util_write_mscmap( } #[no_mangle] -pub unsafe extern fn ykpiv_util_read_msroots( - mut state : *mut ykpiv_state, - mut data : *mut *mut u8, - mut data_len : *mut usize +pub unsafe extern "C" fn ykpiv_util_read_msroots( + mut state: *mut ykpiv_state, + mut data: *mut *mut u8, + mut data_len: *mut usize, ) -> Enum5 { let mut _currentBlock; - let mut res : Enum5 = Enum5::YKPIV_OK; - let mut buf : [u8; 3072]; - let mut cbBuf : usize = ::std::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 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 cbData : usize = 0usize; - let mut cbRealloc : usize = 0usize; - let mut offset : usize = 0usize; + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut buf: [u8; 3072]; + let mut cbBuf: usize = ::std::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 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 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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { *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) == { - pData = _ykpiv_alloc( - state, - cbData - ) as (*mut u8); - pData - } { + pData = _ykpiv_alloc(state, cbData) as (*mut u8); + pData + } { res = Enum5::YKPIV_MEMORY_ERROR; } else { object_id = 0x5fff11i32; @@ -1350,14 +1346,15 @@ pub unsafe extern fn ykpiv_util_read_msroots( } cbBuf = ::std::mem::size_of::<[u8; 3072]>(); if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_fetch_object( - state, - object_id, - buf.as_mut_ptr(), - &mut cbBuf as (*mut usize) - ); - res - } as (i32) { + res = _ykpiv_fetch_object( + state, + object_id, + buf.as_mut_ptr(), + &mut cbBuf as (*mut usize), + ); + res + } as (i32) + { _currentBlock = 21; break; } @@ -1367,43 +1364,45 @@ pub unsafe extern fn ykpiv_util_read_msroots( break; } tag = *{ - let _old = ptr; - ptr = ptr.offset(1isize); - _old - }; - if 0x83i32 != tag as (i32) && (0x82i32 != tag as (i32)) || 0x5fff15i32 == object_id && (0x82i32 != tag as (i32)) { + let _old = ptr; + ptr = ptr.offset(1isize); + _old + }; + if 0x83i32 != tag as (i32) && (0x82i32 != tag as (i32)) + || 0x5fff15i32 == object_id && (0x82i32 != tag as (i32)) + { _currentBlock = 18; break; } ptr = ptr.offset( - _ykpiv_get_length( - ptr as (*const u8), - &mut len as (*mut usize) - ) as (isize) - ); - if len > cbBuf.wrapping_sub( - ((ptr as (isize)).wrapping_sub( - buf.as_mut_ptr() as (isize) - ) / ::std::mem::size_of::() as (isize)) as (usize) - ) { + _ykpiv_get_length(ptr as (*const u8), &mut len as (*mut usize)) as (isize), + ); + if len + > cbBuf.wrapping_sub( + ((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize)) + / ::std::mem::size_of::() as (isize)) + as (usize), + ) + { _currentBlock = 17; break; } cbRealloc = if len > cbData.wrapping_sub(offset) { - len.wrapping_sub(cbData.wrapping_sub(offset)) - } else { - 0usize - }; + len.wrapping_sub(cbData.wrapping_sub(offset)) + } else { + 0usize + }; if 0usize != cbRealloc { if { - pTemp = _ykpiv_realloc( - state, - pData as (*mut ::std::os::raw::c_void), - cbData.wrapping_add(cbRealloc) - ) as (*mut u8); - pTemp - }.is_null( - ) { + pTemp = _ykpiv_realloc( + state, + pData as (*mut ::std::os::raw::c_void), + cbData.wrapping_add(cbRealloc), + ) as (*mut u8); + pTemp + } + .is_null() + { _currentBlock = 16; break; } @@ -1414,7 +1413,7 @@ pub unsafe extern fn ykpiv_util_read_msroots( memcpy( pData.offset(offset as (isize)) as (*mut ::std::os::raw::c_void), ptr as (*const ::std::os::raw::c_void), - len + len, ); offset = offset.wrapping_add(len); if 0x82i32 == tag as (i32) { @@ -1441,7 +1440,7 @@ pub unsafe extern fn ykpiv_util_read_msroots( } } if !pData.is_null() { - _ykpiv_free(state,pData as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void)); } _ykpiv_end_transaction(state); res @@ -1449,46 +1448,47 @@ pub unsafe extern fn ykpiv_util_read_msroots( } #[no_mangle] -pub unsafe extern fn ykpiv_util_write_msroots( - mut state : *mut ykpiv_state, - mut data : *mut u8, - mut data_len : usize +pub unsafe extern "C" 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; - let mut buf : [u8; 3063]; - let mut offset : usize = 0usize; - let mut data_offset : usize = 0usize; - let mut data_chunk : usize = 0usize; - let mut n_objs : usize = 0usize; - let mut i : u32 = 0u32; - let mut cb_obj_max : usize = _obj_size_max(state); + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut buf: [u8; 3063]; + let mut offset: usize = 0usize; + let mut data_offset: usize = 0usize; + let mut data_chunk: usize = 0usize; + 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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_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 { + if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) != data || 0usize != data_len + { res = Enum5::YKPIV_GENERIC_ERROR; } else { res = _ykpiv_save_object( - state, - 0x5fff11i32, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize - ); + state, + 0x5fff11i32, + 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0usize, + ); } } else { - n_objs = data_len.wrapping_div( - cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize)) - ).wrapping_add( - 1usize - ); + n_objs = data_len + .wrapping_div(cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize))) + .wrapping_add(1usize); if n_objs > 5usize { res = Enum5::YKPIV_SIZE_ERROR; } else { @@ -1498,46 +1498,39 @@ pub unsafe extern fn ykpiv_util_write_msroots( break; } offset = 0usize; - data_chunk = if cb_obj_max.wrapping_sub( - (2i32 + 2i32) as (usize) - ) < data_len.wrapping_sub(data_offset) { - cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize)) - } else { - data_len.wrapping_sub(data_offset) - }; - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = if i as (usize) == n_objs.wrapping_sub(1usize) { - 0x82i32 - } else { - 0x83i32 - } as (u8); - offset = offset.wrapping_add( - _ykpiv_set_length( - buf.as_mut_ptr().offset(offset as (isize)), - data_chunk - ) as (usize) - ); + data_chunk = if cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize)) + < data_len.wrapping_sub(data_offset) + { + cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize)) + } else { + data_len.wrapping_sub(data_offset) + }; + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = if i as (usize) == n_objs.wrapping_sub(1usize) { + 0x82i32 + } else { + 0x83i32 + } as (u8); + offset = offset.wrapping_add(_ykpiv_set_length( + buf.as_mut_ptr().offset(offset as (isize)), + 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), - data_chunk + 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), + data_chunk, ); offset = offset.wrapping_add(data_chunk); res = _ykpiv_save_object( - state, - 0x5fff11u32.wrapping_add(i) as (i32), - buf.as_mut_ptr(), - offset - ); + state, + 0x5fff11u32.wrapping_add(i) as (i32), + buf.as_mut_ptr(), + offset, + ); if Enum5::YKPIV_OK as (i32) != res as (i32) { break; } @@ -1563,71 +1556,62 @@ pub enum _setting_source_t { #[derive(Copy)] #[repr(C)] pub struct _setting_bool_t { - pub value : bool, - pub source : _setting_source_t, + pub value: bool, + pub source: _setting_source_t, } impl Clone for _setting_bool_t { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_generate_key( - mut state : *mut ykpiv_state, - mut slot : u8, - mut algorithm : u8, - mut pin_policy : u8, - mut touch_policy : u8, - mut modulus : *mut *mut u8, - mut modulus_len : *mut usize, - mut exp : *mut *mut u8, - mut exp_len : *mut usize, - mut point : *mut *mut u8, - mut point_len : *mut usize +pub unsafe extern "C" fn ykpiv_util_generate_key( + mut state: *mut ykpiv_state, + mut slot: u8, + mut algorithm: u8, + mut pin_policy: u8, + mut touch_policy: u8, + mut modulus: *mut *mut u8, + mut modulus_len: *mut usize, + mut exp: *mut *mut u8, + mut exp_len: *mut usize, + mut point: *mut *mut u8, + mut point_len: *mut usize, ) -> Enum5 { - let mut res : Enum5 = Enum5::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 sw : i32; - let mut ptr_modulus - : *mut u8 - = 0i32 as (*mut ::std::os::raw::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 cb_exp : usize = 0usize; - let mut ptr_point - : *mut u8 - = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - let mut cb_point : usize = 0usize; - let mut setting_roca = _setting_bool_t { value: false, source: _setting_source_t::SETTING_SOURCE_DEFAULT }; - let mut sz_setting_roca - : *const u8 - = (*b"Enable_Unsafe_Keygen_ROCA\0").as_ptr(); + let mut res: Enum5 = Enum5::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 sw: i32; + let mut ptr_modulus: *mut u8 = 0i32 as (*mut ::std::os::raw::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 cb_exp: usize = 0usize; + let mut ptr_point: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_point: usize = 0usize; + let mut setting_roca = _setting_bool_t { + value: false, + source: _setting_source_t::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_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( @@ -1635,31 +1619,32 @@ pub unsafe extern fn ykpiv_util_generate_key( if state.is_null() { Enum5::YKPIV_ARGUMENT_ERROR } else { - if ykpiv_util_devicemodel( - state - ) == (0x594b0000i32 | 0x34i32) as (u32) && (algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32) { - if (*state).ver.major as (i32) == 4i32 && ((*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); + if ykpiv_util_devicemodel(state) == (0x594b0000i32 | 0x34i32) as (u32) + && (algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32) + { + if (*state).ver.major as (i32) == 4i32 + && ((*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 switch9 = setting_roca.source; if switch9 as (i32) == _setting_source_t::SETTING_SOURCE_USER as (i32) { psz_msg = if setting_roca.value { - sz_roca_allow_user - } else { - sz_roca_block_user - }; + 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 { - sz_roca_allow_admin - } else { - sz_roca_block_admin - }; + sz_roca_allow_admin + } else { + sz_roca_block_admin + }; } else { psz_msg = sz_roca_default; } - fprintf(__stderrp,sz_roca_format,(*state).serial,psz_msg); + fprintf(__stderrp, sz_roca_format, (*state).serial, psz_msg); if !setting_roca.value { return Enum5::YKPIV_NOT_SUPPORTED; } @@ -1670,7 +1655,7 @@ pub unsafe extern fn ykpiv_util_generate_key( if (*state).verbose != 0 { fprintf( __stderrp, - (*b"Invalid output parameter for ECC algorithm\0").as_ptr() + (*b"Invalid output parameter for ECC algorithm\0").as_ptr(), ); } return Enum5::YKPIV_GENERIC_ERROR; @@ -1679,12 +1664,11 @@ pub unsafe extern fn ykpiv_util_generate_key( *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 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() + (*b"Invalid output parameter for RSA algorithm\0").as_ptr(), ); } return Enum5::YKPIV_GENERIC_ERROR; @@ -1696,320 +1680,313 @@ pub unsafe extern fn ykpiv_util_generate_key( } } else { if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Invalid algorithm specified\0").as_ptr()); + fprintf(__stderrp, (*b"Invalid algorithm specified\0").as_ptr()); } return 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)) { - *templ.offset(3isize) = slot; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0xacu8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 3u8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0x80u8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 1u8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = algorithm; - if in_data[4usize] as (i32) == 0i32 { - res = Enum5::YKPIV_ALGORITHM_ERROR; - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Unexpected algorithm.\n\0").as_ptr()); - } - } else { - if pin_policy as (i32) != 0i32 { - let _rhs = 3i32; - let _lhs = &mut in_data[1usize]; - *_lhs = (*_lhs as (i32) + _rhs) as (u8); - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0xaau8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 1u8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = pin_policy; - } - if touch_policy as (i32) != 0i32 { - let _rhs = 3i32; - let _lhs = &mut in_data[1usize]; - *_lhs = (*_lhs as (i32) + _rhs) as (u8); - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 0xabu8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = 1u8; - *{ - let _old = in_ptr; - in_ptr = in_ptr.offset(1isize); - _old - } = touch_policy; - } - if Enum5::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), - data.as_mut_ptr(), - &mut recv_len as (*mut usize), - &mut sw as (*mut i32) - ); - res - } as (i32) { - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Failed to communicate.\n\0").as_ptr()); - } - } else if sw != 0x9000i32 { - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Failed to generate new key (\0").as_ptr()); - } - if sw == 0x6b00i32 { - res = Enum5::YKPIV_KEY_ERROR; - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"incorrect slot)\n\0").as_ptr()); - } - } else if sw == 0x6a80i32 { - res = Enum5::YKPIV_ALGORITHM_ERROR; - if (*state).verbose != 0 { - if pin_policy as (i32) != 0i32 { - fprintf( - __stderrp, - (*b"pin policy not supported?)\n\0").as_ptr() - ); - } else if touch_policy as (i32) != 0i32 { - fprintf( - __stderrp, - (*b"touch policy not supported?)\n\0").as_ptr() - ); - } else { - fprintf( - __stderrp, - (*b"algorithm not supported?)\n\0").as_ptr() - ); - } - } - } else if sw == 0x6982i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"not authenticated)\n\0").as_ptr()); - } - } else { - res = Enum5::YKPIV_GENERIC_ERROR; - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"error %x)\n\0").as_ptr(),sw); - } - } - } else if 0x6i32 == algorithm as (i32) || 0x7i32 == algorithm as (i32) { - let mut data_ptr : *mut u8 = data.as_mut_ptr().offset(5isize); - 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( - ) - ); - } - res = Enum5::YKPIV_PARSE_ERROR; - } else { - data_ptr = data_ptr.offset(1isize); - data_ptr = data_ptr.offset( - _ykpiv_get_length( - data_ptr as (*const u8), - &mut len as (*mut usize) - ) as (isize) - ); - cb_modulus = len; - if 0i32 as (*mut ::std::os::raw::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() - ); - } - res = Enum5::YKPIV_MEMORY_ERROR; - } else { - memcpy( - ptr_modulus as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), - cb_modulus - ); - data_ptr = data_ptr.offset(len as (isize)); - if *data_ptr as (i32) != 0x82i32 { - if (*state).verbose != 0 { - fprintf( + 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)) + { + *templ.offset(3isize) = slot; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0xacu8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 3u8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0x80u8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 1u8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = algorithm; + if in_data[4usize] as (i32) == 0i32 { + res = Enum5::YKPIV_ALGORITHM_ERROR; + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Unexpected algorithm.\n\0").as_ptr()); + } + } else { + if pin_policy as (i32) != 0i32 { + let _rhs = 3i32; + let _lhs = &mut in_data[1usize]; + *_lhs = (*_lhs as (i32) + _rhs) as (u8); + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0xaau8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 1u8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = pin_policy; + } + if touch_policy as (i32) != 0i32 { + let _rhs = 3i32; + let _lhs = &mut in_data[1usize]; + *_lhs = (*_lhs as (i32) + _rhs) as (u8); + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 0xabu8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = 1u8; + *{ + let _old = in_ptr; + in_ptr = in_ptr.offset(1isize); + _old + } = touch_policy; + } + if Enum5::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), + data.as_mut_ptr(), + &mut recv_len as (*mut usize), + &mut sw as (*mut i32), + ); + res + } as (i32) + { + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Failed to communicate.\n\0").as_ptr()); + } + } else if sw != 0x9000i32 { + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Failed to generate new key (\0").as_ptr()); + } + if sw == 0x6b00i32 { + res = Enum5::YKPIV_KEY_ERROR; + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"incorrect slot)\n\0").as_ptr()); + } + } else if sw == 0x6a80i32 { + res = Enum5::YKPIV_ALGORITHM_ERROR; + if (*state).verbose != 0 { + if pin_policy as (i32) != 0i32 { + fprintf( + __stderrp, + (*b"pin policy not supported?)\n\0").as_ptr(), + ); + } else if touch_policy as (i32) != 0i32 { + fprintf( + __stderrp, + (*b"touch policy not supported?)\n\0").as_ptr(), + ); + } else { + fprintf( + __stderrp, + (*b"algorithm not supported?)\n\0").as_ptr(), + ); + } + } + } else if sw == 0x6982i32 { + res = Enum5::YKPIV_AUTHENTICATION_ERROR; + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"not authenticated)\n\0").as_ptr()); + } + } else { + res = Enum5::YKPIV_GENERIC_ERROR; + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"error %x)\n\0").as_ptr(), sw); + } + } + } else if 0x6i32 == algorithm as (i32) || 0x7i32 == algorithm as (i32) { + let mut data_ptr: *mut u8 = data.as_mut_ptr().offset(5isize); + 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(), + ); + } + res = Enum5::YKPIV_PARSE_ERROR; + } else { + data_ptr = data_ptr.offset(1isize); + data_ptr = data_ptr.offset(_ykpiv_get_length( + data_ptr as (*const u8), + &mut len as (*mut usize), + ) as (isize)); + cb_modulus = len; + if 0i32 as (*mut ::std::os::raw::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(), + ); + } + res = Enum5::YKPIV_MEMORY_ERROR; + } else { + memcpy( + ptr_modulus as (*mut ::std::os::raw::c_void), + data_ptr as (*const ::std::os::raw::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( ) ); - } - res = Enum5::YKPIV_PARSE_ERROR; - } else { - data_ptr = data_ptr.offset(1isize); - data_ptr = data_ptr.offset( - _ykpiv_get_length( - data_ptr as (*const u8), - &mut len as (*mut usize) - ) as (isize) - ); - cb_exp = len; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { - ptr_exp = _ykpiv_alloc( - state, - cb_exp - ) as (*mut u8); - ptr_exp - } { - if (*state).verbose != 0 { - fprintf( + } + res = Enum5::YKPIV_PARSE_ERROR; + } else { + data_ptr = data_ptr.offset(1isize); + data_ptr = data_ptr.offset(_ykpiv_get_length( + data_ptr as (*const u8), + &mut len as (*mut usize), + ) + as (isize)); + cb_exp = len; + if 0i32 as (*mut ::std::os::raw::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( ) ); - } - res = Enum5::YKPIV_MEMORY_ERROR; - } else { - memcpy( - ptr_exp as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), - cb_exp - ); - *modulus = ptr_modulus; - ptr_modulus = 0i32 as (*mut ::std::os::raw::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); - *exp_len = cb_exp; - } - } - } - } - } else if 0x11i32 == algorithm as (i32) || 0x14i32 == algorithm as (i32) { - let mut data_ptr : *mut u8 = data.as_mut_ptr().offset(3isize); - let mut len : usize; - if 0x11i32 == algorithm as (i32) { - len = 65usize; - } else { - len = 97usize; - } - if *{ - let _old = data_ptr; - data_ptr = data_ptr.offset(1isize); - _old - } as (i32) != 0x86i32 { - if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to parse public key structure.\n\0").as_ptr() - ); - } - res = Enum5::YKPIV_PARSE_ERROR; - } else if *{ - let _old = data_ptr; - data_ptr = data_ptr.offset(1isize); - _old - } as (usize) != len { - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Unexpected length.\n\0").as_ptr()); - } - res = Enum5::YKPIV_ALGORITHM_ERROR; - } else { - cb_point = len; - if 0i32 as (*mut ::std::os::raw::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( - ) - ); - } - res = Enum5::YKPIV_MEMORY_ERROR; - } else { - memcpy( - ptr_point as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), - cb_point - ); - *point = ptr_point; - ptr_point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - *point_len = cb_point; - } - } - } else { - if (*state).verbose != 0 { - fprintf(__stderrp,(*b"Wrong algorithm.\n\0").as_ptr()); - } - res = Enum5::YKPIV_ALGORITHM_ERROR; - } - } - } - if !ptr_modulus.is_null() { - _ykpiv_free(state,modulus as (*mut ::std::os::raw::c_void)); - } - if !ptr_exp.is_null() { - _ykpiv_free(state,ptr_exp as (*mut ::std::os::raw::c_void)); - } - if !ptr_point.is_null() { - _ykpiv_free(state,ptr_exp as (*mut ::std::os::raw::c_void)); - } - _ykpiv_end_transaction(state); - res - }) + } + res = Enum5::YKPIV_MEMORY_ERROR; + } else { + memcpy( + ptr_exp as (*mut ::std::os::raw::c_void), + data_ptr as (*const ::std::os::raw::c_void), + cb_exp, + ); + *modulus = ptr_modulus; + ptr_modulus = + 0i32 as (*mut ::std::os::raw::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); + *exp_len = cb_exp; + } + } + } + } + } else if 0x11i32 == algorithm as (i32) || 0x14i32 == algorithm as (i32) { + let mut data_ptr: *mut u8 = data.as_mut_ptr().offset(3isize); + let mut len: usize; + if 0x11i32 == algorithm as (i32) { + len = 65usize; + } else { + len = 97usize; + } + if *{ + let _old = data_ptr; + data_ptr = data_ptr.offset(1isize); + _old + } as (i32) + != 0x86i32 + { + if (*state).verbose != 0 { + fprintf( + __stderrp, + (*b"Failed to parse public key structure.\n\0").as_ptr(), + ); + } + res = Enum5::YKPIV_PARSE_ERROR; + } else if *{ + let _old = data_ptr; + data_ptr = data_ptr.offset(1isize); + _old + } as (usize) + != len + { + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Unexpected length.\n\0").as_ptr()); + } + res = Enum5::YKPIV_ALGORITHM_ERROR; + } else { + cb_point = len; + if 0i32 as (*mut ::std::os::raw::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(), + ); + } + res = Enum5::YKPIV_MEMORY_ERROR; + } else { + memcpy( + ptr_point as (*mut ::std::os::raw::c_void), + data_ptr as (*const ::std::os::raw::c_void), + cb_point, + ); + *point = ptr_point; + ptr_point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *point_len = cb_point; + } + } + } else { + if (*state).verbose != 0 { + fprintf(__stderrp, (*b"Wrong algorithm.\n\0").as_ptr()); + } + res = Enum5::YKPIV_ALGORITHM_ERROR; + } + } + } + if !ptr_modulus.is_null() { + _ykpiv_free(state, modulus as (*mut ::std::os::raw::c_void)); + } + if !ptr_exp.is_null() { + _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void)); + } + if !ptr_point.is_null() { + _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void)); + } + _ykpiv_end_transaction(state); + res + }) } } @@ -2024,28 +2001,29 @@ pub enum Enum10 { #[derive(Copy)] #[repr(C)] pub struct _ykpiv_config { - pub protected_data_available : u8, - pub puk_blocked : u8, - pub puk_noblock_on_upgrade : u8, - pub pin_last_changed : u32, - pub mgm_type : Enum10, + pub protected_data_available: u8, + pub puk_blocked: u8, + pub puk_noblock_on_upgrade: u8, + pub pin_last_changed: u32, + pub mgm_type: Enum10, } impl Clone for _ykpiv_config { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[no_mangle] -pub unsafe extern fn ykpiv_util_get_config( - mut state : *mut ykpiv_state, mut config : *mut _ykpiv_config +pub unsafe extern "C" fn ykpiv_util_get_config( + mut state: *mut ykpiv_state, + mut config: *mut _ykpiv_config, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; + let mut res: Enum5 = Enum5::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_item : usize = 0usize; + 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_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 { @@ -2057,188 +2035,205 @@ pub unsafe extern fn ykpiv_util_get_config( (*config).pin_last_changed = 0u32; (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_MANUAL; (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 Enum5::YKPIV_OK as (i32) == _read_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ) as (i32) { - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x81u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { - if *p_item as (i32) & 0x1i32 != 0 { - (*config).puk_blocked = 1u8; - } - if *p_item as (i32) & 0x2i32 != 0 { - (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED; - } - } - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x82u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { - if (*config).mgm_type as (i32) != Enum10::YKPIV_CONFIG_MGM_MANUAL as (i32) { - if (*state).verbose != 0 { - fprintf( + 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 Enum5::YKPIV_OK as (i32) + == _read_metadata( + state, + 0x80u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ) as (i32) + { + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x81u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { + if *p_item as (i32) & 0x1i32 != 0 { + (*config).puk_blocked = 1u8; + } + if *p_item as (i32) & 0x2i32 != 0 { + (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED; + } + } + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x82u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { + 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( ) ); - } - } else { - (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_DERIVED; - } - } - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x83u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { - if 4usize != cb_item { - if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"pin timestamp in admin metadata is an invalid size\0").as_ptr( - ) - ); - } - } 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), - cb_item - ); - } - } - } - cb_data = ::std::mem::size_of::<[u8; 3072]>(); - if Enum5::YKPIV_OK as (i32) == _read_metadata( - state, - 0x88u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ) as (i32) { - (*config).protected_data_available = 1u8; - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x81u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { - if *p_item as (i32) & 0x1i32 != 0 { - (*config).puk_noblock_on_upgrade = 1u8; - } - } - if Enum5::YKPIV_OK as (i32) == _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x89u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ) as (i32) { - if (*config).mgm_type as (i32) != Enum10::YKPIV_CONFIG_MGM_PROTECTED as (i32) { - if (*state).verbose != 0 { - fprintf( + } + } else { + (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_DERIVED; + } + } + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x83u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { + if 4usize != cb_item { + if (*state).verbose != 0 { + fprintf( + __stderrp, + (*b"pin timestamp in admin metadata is an invalid size\0") + .as_ptr(), + ); + } + } 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), + cb_item, + ); + } + } + } + cb_data = ::std::mem::size_of::<[u8; 3072]>(); + if Enum5::YKPIV_OK as (i32) + == _read_metadata( + state, + 0x88u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ) as (i32) + { + (*config).protected_data_available = 1u8; + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x81u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { + if *p_item as (i32) & 0x1i32 != 0 { + (*config).puk_noblock_on_upgrade = 1u8; + } + } + if Enum5::YKPIV_OK as (i32) + == _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x89u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ) as (i32) + { + if (*config).mgm_type as (i32) + != 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( ) ); - } - } - (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED; - } - } - } - _ykpiv_end_transaction(state); - res - }) + } + } + (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED; + } + } + } + _ykpiv_end_transaction(state); + res + }) } } #[no_mangle] -pub unsafe extern 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 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; let mut data = [0u8; 3072]; - let mut cb_data : usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut tnow : isize = 0isize; + 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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { if Enum5::YKPIV_OK as (i32) != { - ykrc = _read_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ); - ykrc - } as (i32) { + ykrc = _read_metadata( + state, + 0x80u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ); + ykrc + } as (i32) + { cb_data = 0usize; } tnow = time(0i32 as (*mut ::std::os::raw::c_void) as (*mut isize)); if Enum5::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), - 4usize - ); - res - } 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), + 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) + res as (i32), ); } } else if Enum5::YKPIV_OK as (i32) != { - res = _write_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - cb_data - ); - res - } 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) + res as (i32), ); } } @@ -2251,11 +2246,13 @@ pub unsafe extern fn ykpiv_util_set_pin_last_changed( #[derive(Copy)] #[repr(C)] pub struct _ykpiv_mgm { - pub data : [u8; 24], + pub data: [u8; 24], } impl Clone for _ykpiv_mgm { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } #[derive(Clone, Copy)] @@ -2266,82 +2263,86 @@ pub enum Enum11 { } #[no_mangle] -pub unsafe extern fn ykpiv_util_get_derived_mgm( - mut state : *mut ykpiv_state, - mut pin : *const u8, - pin_len : usize, - mut mgm : *mut _ykpiv_mgm +pub unsafe extern "C" 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; - let mut p5rc : Enum11 = Enum11::PKCS5_OK; + let mut res: Enum5 = Enum5::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_item : usize = 0usize; + 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_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 || 0usize == pin_len || 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm { + } else if 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) == pin + || 0usize == pin_len + || 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm + { Enum5::YKPIV_GENERIC_ERROR } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { if Enum5::YKPIV_OK as (i32) == { - res = _read_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ); - res - } as (i32) { + res = _read_metadata( + state, + 0x80u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ); + res + } as (i32) + { if Enum5::YKPIV_OK as (i32) == { - res = _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x82u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ); - res - } as (i32) { + res = _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x82u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ); + res + } as (i32) + { if cb_item != 16usize { if (*state).verbose != 0 { fprintf( __stderrp, - (*b"derived mgm salt exists, but is incorrect size = %lu\n\0").as_ptr( - ), - cb_item + (*b"derived mgm salt exists, but is incorrect size = %lu\n\0") + .as_ptr(), + cb_item, ); } res = Enum5::YKPIV_GENERIC_ERROR; } else if Enum11::PKCS5_OK as (i32) != { - p5rc = pkcs5_pbkdf2_sha1( - pin, - pin_len, - p_item as (*const u8), - cb_item, - 10000usize, - (*mgm).data.as_mut_ptr( - ) as (*const u8), - ::std::mem::size_of::<[u8; 24]>( - ) - ); - p5rc - } as (i32) { + p5rc = pkcs5_pbkdf2_sha1( + pin, + pin_len, + p_item as (*const u8), + cb_item, + 10000usize, + (*mgm).data.as_mut_ptr() as (*const u8), + ::std::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) + p5rc as (i32), ); } res = Enum5::YKPIV_GENERIC_ERROR; @@ -2355,71 +2356,72 @@ pub unsafe extern fn ykpiv_util_get_derived_mgm( } #[no_mangle] -pub unsafe extern fn ykpiv_util_get_protected_mgm( - mut state : *mut ykpiv_state, mut mgm : *mut _ykpiv_mgm +pub unsafe extern "C" fn ykpiv_util_get_protected_mgm( + mut state: *mut ykpiv_state, + mut mgm: *mut _ykpiv_mgm, ) -> Enum5 { - let mut res : Enum5 = Enum5::YKPIV_OK; + let mut res: Enum5 = Enum5::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_item : usize = 0usize; + 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_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) != { - res = _ykpiv_begin_transaction(state); - res - } 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_ensure_application_selected(state); + res + } as (i32)) + { if Enum5::YKPIV_OK as (i32) != { - res = _read_metadata( - state, - 0x88u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ); - res - } as (i32) { + res = _read_metadata( + state, + 0x88u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ); + res + } as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, (*b"could not read protected data, err = %d\n\0").as_ptr(), - res as (i32) + res as (i32), ); } } else if Enum5::YKPIV_OK as (i32) != { - res = _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x89u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ); - res - } as (i32) { + res = _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x89u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ); + res + } as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, - (*b"could not read protected mgm from metadata, err = %d\n\0").as_ptr( - ), - res as (i32) + (*b"could not read protected mgm from metadata, err = %d\n\0").as_ptr(), + res as (i32), ); } } else if cb_item != ::std::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( - ), - cb_item + (*b"protected data contains mgm, but is the wrong size = %lu\n\0").as_ptr(), + cb_item, ); } res = Enum5::YKPIV_AUTHENTICATION_ERROR; @@ -2427,7 +2429,7 @@ pub unsafe extern fn ykpiv_util_get_protected_mgm( memcpy( (*mgm).data.as_mut_ptr() as (*mut ::std::os::raw::c_void), p_item as (*const ::std::os::raw::c_void), - cb_item + cb_item, ); } } @@ -2435,7 +2437,7 @@ pub unsafe extern fn ykpiv_util_get_protected_mgm( data.as_mut_ptr() as (*mut ::std::os::raw::c_void), ::std::mem::size_of::<[u8; 3072]>(), 0i32, - ::std::mem::size_of::<[u8; 3072]>() + ::std::mem::size_of::<[u8; 3072]>(), ); _ykpiv_end_transaction(state); res @@ -2443,23 +2445,22 @@ pub unsafe extern fn ykpiv_util_get_protected_mgm( } #[no_mangle] -pub unsafe extern fn ykpiv_util_set_protected_mgm( - mut state : *mut ykpiv_state, mut mgm : *mut _ykpiv_mgm +pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( + mut state: *mut ykpiv_state, + mut mgm: *mut _ykpiv_mgm, ) -> Enum5 { let mut _currentBlock; - let mut res : Enum5 = Enum5::YKPIV_OK; - let mut ykrc : Enum5 = Enum5::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 res: Enum5 = Enum5::YKPIV_OK; + let mut ykrc: Enum5 = Enum5::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_item : usize = 0usize; - let mut flags_1 : u8 = 0u8; + 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_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 } else { @@ -2470,7 +2471,7 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( 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]>() + ::std::mem::size_of::<[u8; 24]>(), ); i = 0usize; 'loop3: loop { @@ -2490,34 +2491,35 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( } } if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) { + res = _ykpiv_begin_transaction(state); + res + } as (i32) + { res = Enum5::YKPIV_PCSC_ERROR; } else if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) { + res = _ykpiv_ensure_application_selected(state); + res + } as (i32)) + { '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 - } as (i32) { + prngrc = _ykpiv_prng_generate( + mgm_key.as_mut_ptr(), + ::std::mem::size_of::<[u8; 24]>(), + ); + prngrc + } as (i32) + { _currentBlock = 47; break; } } if Enum5::YKPIV_OK as (i32) != { - ykrc = ykpiv_set_mgmkey( - state, - mgm_key.as_mut_ptr() as (*const u8) - ); - ykrc - } 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) { _currentBlock = 44; break; @@ -2535,55 +2537,53 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( 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]>() + ::std::mem::size_of::<[u8; 24]>(), ); } if Enum5::YKPIV_OK as (i32) != { - ykrc = _read_metadata( - state, - 0x88u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ); - ykrc - } as (i32) { + ykrc = _read_metadata( + state, + 0x88u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ); + ykrc + } as (i32) + { cb_data = 0usize; } if Enum5::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]>() - ); - ykrc - } 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]>(), + ); + 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) + ykrc as (i32), ); _currentBlock = 26; } else { _currentBlock = 26; } } else if Enum5::YKPIV_OK as (i32) != { - ykrc = _write_metadata( - state, - 0x88u8, - data.as_mut_ptr(), - cb_data - ); - ykrc - } 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) + ykrc as (i32), ); _currentBlock = 51; } else { @@ -2596,30 +2596,32 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( } else { cb_data = ::std::mem::size_of::<[u8; 3072]>(); if Enum5::YKPIV_OK as (i32) != { - ykrc = _read_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - &mut cb_data as (*mut usize) - ); - ykrc - } as (i32) { + ykrc = _read_metadata( + state, + 0x80u8, + data.as_mut_ptr(), + &mut cb_data as (*mut usize), + ); + ykrc + } as (i32) + { cb_data = 0usize; } else { if Enum5::YKPIV_OK as (i32) != { - ykrc = _get_metadata_item( - data.as_mut_ptr(), - cb_data, - 0x81u8, - &mut p_item as (*mut *mut u8), - &mut cb_item as (*mut usize) - ); - ykrc - } as (i32) { + ykrc = _get_metadata_item( + data.as_mut_ptr(), + cb_data, + 0x81u8, + &mut p_item as (*mut *mut u8), + &mut cb_item as (*mut usize), + ); + ykrc + } as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, - (*b"admin data exists, but flags are not present\n\0").as_ptr() + (*b"admin data exists, but flags are not present\n\0").as_ptr(), ); } } @@ -2627,68 +2629,66 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( memcpy( &mut flags_1 as (*mut u8) as (*mut ::std::os::raw::c_void), p_item as (*const ::std::os::raw::c_void), - cb_item + cb_item, ); } else if (*state).verbose != 0 { fprintf( __stderrp, (*b"admin data flags are an incorrect size = %lu\n\0").as_ptr(), - cb_item + cb_item, ); } if Enum5::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), - 0usize - ); - ykrc - } 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), + 0usize, + ); + ykrc + } as (i32) + { if (*state).verbose != 0 { fprintf( __stderrp, (*b"could not unset derived mgm salt, err = %d\n\0").as_ptr(), - ykrc as (i32) + ykrc as (i32), ); } } } flags_1 = (flags_1 as (i32) | 0x2i32) as (u8); if Enum5::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::() - ); - ykrc - } 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::(), + ); + 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) + ykrc as (i32), ); } } else if Enum5::YKPIV_OK as (i32) != { - ykrc = _write_metadata( - state, - 0x80u8, - data.as_mut_ptr(), - cb_data - ); - ykrc - } 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) + ykrc as (i32), ); } } @@ -2698,7 +2698,7 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( fprintf( __stderrp, (*b"could not set new derived mgm key, err = %d\n\0").as_ptr(), - ykrc as (i32) + ykrc as (i32), ); } res = ykrc; @@ -2707,7 +2707,7 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( fprintf( __stderrp, (*b"could not generate new mgm, err = %d\n\0").as_ptr(), - prngrc as (i32) + prngrc as (i32), ); } res = Enum5::YKPIV_RANDOMNESS_ERROR; @@ -2717,13 +2717,13 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( data.as_mut_ptr() as (*mut ::std::os::raw::c_void), ::std::mem::size_of::<[u8; 3072]>(), 0i32, - ::std::mem::size_of::<[u8; 3072]>() + ::std::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]>(), 0i32, - ::std::mem::size_of::<[u8; 24]>() + ::std::mem::size_of::<[u8; 24]>(), ); _ykpiv_end_transaction(state); res @@ -2731,23 +2731,21 @@ pub unsafe extern fn ykpiv_util_set_protected_mgm( } #[no_mangle] -pub unsafe extern fn ykpiv_util_reset( - mut state : *mut ykpiv_state -) -> Enum5 { - 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 sw : i32; +pub unsafe extern "C" fn ykpiv_util_reset(mut state: *mut ykpiv_state) -> Enum5 { + 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 sw: i32; res = ykpiv_transfer_data( - state, - templ as (*const u8), - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - 0isize, - data.as_mut_ptr(), - &mut recv_len as (*mut usize), - &mut sw as (*mut i32) - ); + state, + templ as (*const u8), + 0i32 as (*mut ::std::os::raw::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 } else { @@ -2756,8 +2754,8 @@ pub unsafe extern fn ykpiv_util_reset( } #[no_mangle] -pub unsafe extern fn ykpiv_util_slot_object(mut slot : u8) -> u32 { - let mut object_id : i32 = -1i32; +pub unsafe extern "C" fn ykpiv_util_slot_object(mut slot: u8) -> u32 { + let mut object_id: i32 = -1i32; if slot as (i32) == 0xf9i32 { object_id = 0x5fff01i32; } else if slot as (i32) == 0x9ei32 { @@ -2774,52 +2772,52 @@ pub unsafe extern fn ykpiv_util_slot_object(mut slot : u8) -> u32 { object_id as (u32) } -unsafe extern fn _read_certificate( - mut state : *mut ykpiv_state, - mut slot : u8, - mut buf : *mut u8, - mut buf_len : *mut usize +unsafe extern "C" 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); - let mut object_id : i32 = ykpiv_util_slot_object(slot) as (i32); - let mut len : usize = 0usize; + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::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 } else { if Enum5::YKPIV_OK as (i32) == { - res = _ykpiv_fetch_object(state,object_id,buf,buf_len); - res - } as (i32) { + res = _ykpiv_fetch_object(state, object_id, buf, buf_len); + res + } as (i32) + { ptr = buf; if *buf_len < 2usize { *buf_len = 0usize; return Enum5::YKPIV_OK; } else if *{ - let _old = ptr; - ptr = ptr.offset(1isize); - _old - } as (i32) == 0x70i32 { + let _old = ptr; + ptr = ptr.offset(1isize); + _old + } as (i32) + == 0x70i32 + { ptr = ptr.offset( - _ykpiv_get_length( - ptr as (*const u8), - &mut len as (*mut usize) - ) as (isize) - ); - if len > (*buf_len).wrapping_sub( - ((ptr as (isize)).wrapping_sub( - buf as (isize) - ) / ::std::mem::size_of::() as (isize)) as (usize) - ) { + _ykpiv_get_length(ptr as (*const u8), &mut len as (*mut usize)) as (isize), + ); + if len + > (*buf_len).wrapping_sub( + ((ptr as (isize)).wrapping_sub(buf as (isize)) + / ::std::mem::size_of::() as (isize)) + as (usize), + ) + { *buf_len = 0usize; return Enum5::YKPIV_OK; } else { memmove( buf as (*mut ::std::os::raw::c_void), ptr as (*const ::std::os::raw::c_void), - len + len, ); *buf_len = len; } @@ -2831,117 +2829,99 @@ unsafe extern fn _read_certificate( } } -unsafe extern fn _write_certificate( - mut state : *mut ykpiv_state, - mut slot : u8, - mut data : *mut u8, - mut data_len : usize, - mut certinfo : u8 +unsafe extern "C" fn _write_certificate( + mut state: *mut ykpiv_state, + mut slot: u8, + mut data: *mut u8, + mut data_len: usize, + mut certinfo: u8, ) -> Enum5 { - 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; + 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 - } else { - _ykpiv_save_object( - state, - object_id, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize - ) - }) + Enum5::YKPIV_GENERIC_ERROR + } else { + _ykpiv_save_object( + state, + object_id, + 0i32 as (*mut ::std::os::raw::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(_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 - } else if req_len > _obj_size_max(state) { - Enum5::YKPIV_SIZE_ERROR - } else { - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0x70u8; - offset = offset.wrapping_add( - _ykpiv_set_length( - buf.as_mut_ptr().offset(offset as (isize)), - 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), - data_len - ); - offset = offset.wrapping_add(data_len); - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0x71u8; - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0x1u8; - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = if certinfo as (i32) == 1i32 { - 0x1i32 - } else { - 0x0i32 - } as (u8); - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0xfeu8; - buf[ - { - let _old = offset; - offset = offset.wrapping_add(1usize); - _old - } - ] = 0o0u8; - _ykpiv_save_object(state,object_id,buf.as_mut_ptr(),offset) - }) + Enum5::YKPIV_SIZE_ERROR + } else if req_len > _obj_size_max(state) { + Enum5::YKPIV_SIZE_ERROR + } else { + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0x70u8; + offset = offset.wrapping_add(_ykpiv_set_length( + buf.as_mut_ptr().offset(offset as (isize)), + 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), + data_len, + ); + offset = offset.wrapping_add(data_len); + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0x71u8; + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0x1u8; + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = if certinfo as (i32) == 1i32 { + 0x1i32 + } else { + 0x0i32 + } as (u8); + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0xfeu8; + buf[{ + let _old = offset; + offset = offset.wrapping_add(1usize); + _old + }] = 0o0u8; + _ykpiv_save_object(state, object_id, buf.as_mut_ptr(), offset) + }) } } -unsafe extern 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 +unsafe extern "C" 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 { let mut _currentBlock; - let mut p_temp : *mut u8 = data; - let mut cb_temp : usize = 0usize; - let mut tag_temp : u8 = 0u8; + 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 } else { @@ -2953,25 +2933,22 @@ unsafe extern fn _get_metadata_item( break; } tag_temp = *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - }; + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + }; 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) - ) { + 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), + ) { _currentBlock = 9; break; } - p_temp = p_temp.offset( - _ykpiv_get_length( - p_temp as (*const u8), - &mut cb_temp as (*mut usize) - ) as (isize) - ); + p_temp = p_temp.offset(_ykpiv_get_length( + p_temp as (*const u8), + &mut cb_temp as (*mut usize), + ) as (isize)); if tag_temp as (i32) == tag as (i32) { _currentBlock = 6; break; @@ -2979,20 +2956,20 @@ unsafe extern fn _get_metadata_item( p_temp = p_temp.offset(cb_temp as (isize)); } (if _currentBlock == 6 { - (if p_temp < data.offset(cb_data as (isize)) { - *pp_item = p_temp; - *pcb_item = cb_temp; - Enum5::YKPIV_OK - } else { - Enum5::YKPIV_GENERIC_ERROR - }) - } else { - Enum5::YKPIV_SIZE_ERROR - }) + (if p_temp < data.offset(cb_data as (isize)) { + *pp_item = p_temp; + *pcb_item = cb_temp; + Enum5::YKPIV_OK + } else { + Enum5::YKPIV_GENERIC_ERROR + }) + } else { + Enum5::YKPIV_SIZE_ERROR + }) } } -unsafe extern fn _get_length_size(mut length : usize) -> i32 { +unsafe extern "C" fn _get_length_size(mut length: usize) -> i32 { if length < 0x80usize { 1i32 } else if length < 0xffusize { @@ -3002,23 +2979,21 @@ unsafe extern fn _get_length_size(mut length : usize) -> i32 { } } -unsafe extern 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 +unsafe extern "C" 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 { 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 cb_moved : isize = 0isize; + 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 cb_moved: isize = 0isize; if data.is_null() || pcb_data.is_null() { Enum5::YKPIV_GENERIC_ERROR } else { @@ -3028,14 +3003,12 @@ unsafe extern fn _set_metadata_item( break; } tag_temp = *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - }; - cb_len = _ykpiv_get_length( - p_temp as (*const u8), - &mut cb_temp as (*mut usize) - ) as (usize); + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + }; + cb_len = + _ykpiv_get_length(p_temp as (*const u8), &mut cb_temp as (*mut usize)) as (usize); p_temp = p_temp.offset(cb_len as (isize)); if tag_temp as (i32) == tag as (i32) { _currentBlock = 9; @@ -3044,91 +3017,84 @@ unsafe extern fn _set_metadata_item( p_temp = p_temp.offset(cb_temp as (isize)); } (if _currentBlock == 2 { - (if cb_item == 0usize { - Enum5::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 - } else { - *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _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 - ); - *pcb_data = (*pcb_data).wrapping_add( - 1usize.wrapping_add(cb_len).wrapping_add(cb_item) - ); - Enum5::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 - } else { - p_next = p_temp.offset(cb_temp as (isize)); - cb_moved = cb_item as (isize) - cb_temp as (isize) + (if cb_item != 0usize { - _get_length_size(cb_item) - } else { - -1i32 - } as (isize) - cb_len as (isize)); - (if (*pcb_data).wrapping_add(cb_moved as (usize)) > cb_data_max { - Enum5::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), - (*pcb_data).wrapping_sub( - ((p_next as (isize)).wrapping_sub( - data as (isize) - ) / ::std::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 - ); - } - Enum5::YKPIV_OK - }) - }) + (if cb_item == 0usize { + Enum5::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 + } else { + *{ + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _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, + ); + *pcb_data = + (*pcb_data).wrapping_add(1usize.wrapping_add(cb_len).wrapping_add(cb_item)); + Enum5::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 + } else { + p_next = p_temp.offset(cb_temp as (isize)); + cb_moved = cb_item as (isize) - cb_temp as (isize) + + (if cb_item != 0usize { + _get_length_size(cb_item) + } else { + -1i32 + } as (isize) + - cb_len as (isize)); + (if (*pcb_data).wrapping_add(cb_moved as (usize)) > cb_data_max { + Enum5::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), + (*pcb_data).wrapping_sub( + ((p_next as (isize)).wrapping_sub(data as (isize)) + / ::std::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, + ); + } + Enum5::YKPIV_OK + }) + }) } } -unsafe extern fn _read_metadata( - mut state : *mut ykpiv_state, - mut tag : u8, - mut data : *mut u8, - mut pcb_data : *mut usize +unsafe extern "C" 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); - let mut cb_temp : usize = 0usize; - let mut obj_id : i32 = 0i32; + let mut res: Enum5 = Enum5::YKPIV_OK; + let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::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 } else { @@ -3142,62 +3108,59 @@ unsafe extern fn _read_metadata( cb_temp = *pcb_data; *pcb_data = 0usize; (if Enum5::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 - } else { - p_temp = data; - (if tag as (i32) != *{ - let _old = p_temp; - p_temp = p_temp.offset(1isize); - _old - } as (i32) { - Enum5::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) - ) { - *pcb_data = 0usize; - Enum5::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 - }) - }) - }) + 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 + } else { + p_temp = data; + (if tag as (i32) + != *{ + let _old = p_temp; + p_temp = p_temp.offset(1isize); + _old + } as (i32) + { + Enum5::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), + ) + { + *pcb_data = 0usize; + Enum5::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 + }) + }) + }) } } -unsafe extern fn _write_metadata( - mut state : *mut ykpiv_state, - mut tag : u8, - mut data : *mut u8, - mut cb_data : usize +unsafe extern "C" 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; + let mut res: Enum5 = Enum5::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) - ) { + 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 } else { if tag as (i32) == 0x88i32 { @@ -3209,32 +3172,31 @@ unsafe extern fn _write_metadata( } 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 - ); + state, + obj_id, + 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0usize, + ); } else { *{ - let _old = pTemp; - pTemp = pTemp.offset(1isize); - _old - } = tag; - pTemp = pTemp.offset(_ykpiv_set_length(pTemp,cb_data) as (isize)); + let _old = pTemp; + pTemp = pTemp.offset(1isize); + _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 + 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) - ); + 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), + ); } res } diff --git a/src/version.rs b/src/version.rs index 29203ac..0994608 100644 --- a/src/version.rs +++ b/src/version.rs @@ -25,47 +25,45 @@ // (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 { - 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; +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 fn my_strverscmp( - mut s1 : *const u8, mut s2 : *const u8 -) -> i32 { +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); + 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))) { + 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; + let mut ret: i32; + let mut lz1: i32; + let mut lz2: i32; if { - ret = strncmp(s1,s2,p1); - ret - } != 0i32 { + 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 - }; + lz2 = 0i32; + lz2 + }; if *s1 as (i32) == b'0' as (i32) { lz1 = 1i32; } @@ -92,8 +90,8 @@ unsafe extern fn my_strverscmp( s2 = s2.offset(1isize); _currentBlock = 11; } else { - p1 = strspn(s1,digits); - p2 = strspn(s2,digits); + p1 = strspn(s1, digits); + p2 = strspn(s2, digits); if p1 == 0usize && (p2 > 0usize) { _currentBlock = 33; break 'loop1; @@ -102,7 +100,10 @@ unsafe extern fn my_strverscmp( _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 *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; @@ -115,9 +116,9 @@ unsafe extern fn my_strverscmp( } } else { if p1 < p2 { - ret = strncmp(s1,s2,p1); + ret = strncmp(s1, s2, p1); } else if p1 > p2 { - ret = strncmp(s1,s2,p2); + ret = strncmp(s1, s2, p2); } if ret != 0i32 { _currentBlock = 20; @@ -128,8 +129,8 @@ unsafe extern fn my_strverscmp( } } } else { - p1 = strspn(s1,digits); - p2 = strspn(s2,digits); + p1 = strspn(s1, digits); + p2 = strspn(s2, digits); if p1 < p2 { _currentBlock = 29; break 'loop1; @@ -143,19 +144,20 @@ unsafe extern fn my_strverscmp( break; } if { - ret = strncmp(s1,s2,p1); - ret - } != 0i32 { + 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); + p1 = strcspn(s1, digits); + p2 = strcspn(s2, digits); } if _currentBlock == 2 { - strcmp(s1,s2) + strcmp(s1, s2) } else if _currentBlock == 20 { ret } else if _currentBlock == 27 { @@ -182,13 +184,8 @@ unsafe extern fn my_strverscmp( } #[no_mangle] -pub unsafe extern 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 { +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)