james/yubikey.rs
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

oxidize: Fix first pass of compile errors

Browse Source 
This commit contains a multitude of fixes and some initial translation
work so the first rustc pass compiles.

It removes `unsafe extern "C"` declarations, so now there are a number
of errors about invocations of unsafe functions that need to be
addressed. They should each be scoped to an `unsafe` block so as to aid
in an eventual safe translation.

Some of the functions are now using the module system rather than
`extern "C"` bindings, but the translation is not complete.
This commit is contained in:
Tony Arcieri
2019-11-17 08:21:48 -08:00
parent 4cd59cb992
commit 1d86885ab1
6 changed files with 1849 additions and 2765 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/error.rs
+88 -52
View File
@@ -1,3 +1,6 @@
// Adapted from yubico-piv-tool:
// <https://github.com/Yubico/yubico-piv-tool/>
//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -25,72 +28,105 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#[derive(Clone, Copy)]
use std::fmt;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(i32)]
pub enum Enum2 {
YKPIV_OK = 0i32,
YKPIV_MEMORY_ERROR = -1i32,
YKPIV_PCSC_ERROR = -2i32,
YKPIV_SIZE_ERROR = -3i32,
YKPIV_APPLET_ERROR = -4i32,
YKPIV_AUTHENTICATION_ERROR = -5i32,
YKPIV_RANDOMNESS_ERROR = -6i32,
YKPIV_GENERIC_ERROR = -7i32,
YKPIV_KEY_ERROR = -8i32,
YKPIV_PARSE_ERROR = -9i32,
YKPIV_WRONG_PIN = -10i32,
YKPIV_INVALID_OBJECT = -11i32,
YKPIV_ALGORITHM_ERROR = -12i32,
YKPIV_PIN_LOCKED = -13i32,
YKPIV_ARGUMENT_ERROR = -14i32,
YKPIV_RANGE_ERROR = -15i32,
YKPIV_NOT_SUPPORTED = -16i32,
#[allow(non_camel_case_types)]
pub enum ErrorKind {
YKPIV_OK = 0,
YKPIV_MEMORY_ERROR = -1,
YKPIV_PCSC_ERROR = -2,
YKPIV_SIZE_ERROR = -3,
YKPIV_APPLET_ERROR = -4,
YKPIV_AUTHENTICATION_ERROR = -5,
YKPIV_RANDOMNESS_ERROR = -6,
YKPIV_GENERIC_ERROR = -7,
YKPIV_KEY_ERROR = -8,
YKPIV_PARSE_ERROR = -9,
YKPIV_WRONG_PIN = -10,
YKPIV_INVALID_OBJECT = -11,
YKPIV_ALGORITHM_ERROR = -12,
YKPIV_PIN_LOCKED = -13,
YKPIV_ARGUMENT_ERROR = -14,
YKPIV_RANGE_ERROR = -15,
YKPIV_NOT_SUPPORTED = -16,
}
impl ErrorKind {
/// Name of the error
pub fn name(self) -> &'static str {
match self {
ErrorKind::YKPIV_OK => "YKPIV_OK",
ErrorKind::YKPIV_MEMORY_ERROR => "YKPIV_MEMORY_ERROR",
ErrorKind::YKPIV_PCSC_ERROR => "YKPIV_PCSC_ERROR",
ErrorKind::YKPIV_SIZE_ERROR => "YKPIV_SIZE_ERROR",
ErrorKind::YKPIV_APPLET_ERROR => "YKPIV_APPLET_ERROR",
ErrorKind::YKPIV_AUTHENTICATION_ERROR => "YKPIV_AUTHENTICATION_ERROR",
ErrorKind::YKPIV_RANDOMNESS_ERROR => "YKPIV_RANDOMNESS_ERROR",
ErrorKind::YKPIV_GENERIC_ERROR => "YKPIV_GENERIC_ERROR",
ErrorKind::YKPIV_KEY_ERROR => "YKPIV_KEY_ERROR",
ErrorKind::YKPIV_PARSE_ERROR => "YKPIV_PARSE_ERROR",
ErrorKind::YKPIV_WRONG_PIN => "YKPIV_WRONG_PIN",
ErrorKind::YKPIV_INVALID_OBJECT => "YKPIV_INVALID_OBJECT",
ErrorKind::YKPIV_ALGORITHM_ERROR => "YKPIV_ALGORITHM_ERROR",
ErrorKind::YKPIV_PIN_LOCKED => "YKPIV_PIN_LOCKED",
ErrorKind::YKPIV_ARGUMENT_ERROR => "YKPIV_ARGUMENT_ERROR",
ErrorKind::YKPIV_RANGE_ERROR => "YKPIV_RANGE_ERROR",
ErrorKind::YKPIV_NOT_SUPPORTED => "YKPIV_NOT_SUPPORTED",
}
}
/// Error message
pub fn msg(self) -> &'static str {
match self {
ErrorKind::YKPIV_OK => "OK",
ErrorKind::YKPIV_MEMORY_ERROR => "memory error",
ErrorKind::YKPIV_PCSC_ERROR => "PCSC error",
ErrorKind::YKPIV_SIZE_ERROR => "size error",
ErrorKind::YKPIV_APPLET_ERROR => "applet error",
ErrorKind::YKPIV_AUTHENTICATION_ERROR => "authentication error",
ErrorKind::YKPIV_RANDOMNESS_ERROR => "randomness error",
ErrorKind::YKPIV_GENERIC_ERROR => "generic error",
ErrorKind::YKPIV_KEY_ERROR => "key error",
ErrorKind::YKPIV_PARSE_ERROR => "parse error",
ErrorKind::YKPIV_WRONG_PIN => "wrong pin",
ErrorKind::YKPIV_INVALID_OBJECT => "invalid object",
ErrorKind::YKPIV_ALGORITHM_ERROR => "algorithm error",
ErrorKind::YKPIV_PIN_LOCKED => "PIN locked",
ErrorKind::YKPIV_ARGUMENT_ERROR => "argument error",
ErrorKind::YKPIV_RANGE_ERROR => "range error",
ErrorKind::YKPIV_NOT_SUPPORTED => "not supported",
}
}
}
impl fmt::Display for ErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.msg())
}
}
impl std::error::Error for ErrorKind {}
#[derive(Copy)]
#[repr(C)]
pub struct Struct1 {
pub rc: Enum2,
pub struct Error {
pub rc: ErrorKind,
pub name: *const u8,
pub description: *const u8,
}
impl Clone for Struct1 {
impl Clone for Error {
fn clone(&self) -> Self {
*self
}
}
static mut errors: *const Struct1 = Enum2::YKPIV_OK as (*const Struct1);
#[no_mangle]
pub unsafe extern "C" fn ykpiv_strerror(mut err: Enum2) -> *const u8 {
static mut unknown: *const u8 = (*b"Unknown ykpiv error\0").as_ptr();
let mut p: *const u8;
if -(err as (i32)) < 0i32
|| -(err as (i32))
>= ::std::mem::size_of::<*const Struct1>()
.wrapping_div(::std::mem::size_of::<Struct1>()) as (i32)
{
unknown
} else {
p = (*errors.offset(-(err as (i32)) as (isize))).description;
if p.is_null() {
p = unknown;
}
p
}
pub fn ykpiv_strerror(err: ErrorKind) -> &'static str {
err.msg()
}
#[no_mangle]
pub unsafe extern "C" fn ykpiv_strerror_name(mut err: Enum2) -> *const u8 {
if -(err as (i32)) < 0i32
|| -(err as (i32))
>= ::std::mem::size_of::<*const Struct1>()
.wrapping_div(::std::mem::size_of::<Struct1>()) as (i32)
{
0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
} else {
(*errors.offset(-(err as (i32)) as (isize))).name
}
pub fn ykpiv_strerror_name(err: ErrorKind) -> &'static str {
err.name()
}
src/internal.rs
+157 -259
View File
@@ -1,3 +1,6 @@
// Adapted from yubico-piv-tool:
// <https://github.com/Yubico/yubico-piv-tool/>
//
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
@@ -25,6 +28,12 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
use libc::{
c_char, c_int, fclose, feof, fgets, fopen, free, getenv, malloc, memcpy, memset, strcasecmp,
strcmp, strlen,
};
use std::ptr;
extern "C" {
fn DES_ecb3_encrypt(
input: *mut [u8; 8],
@@ -48,39 +57,13 @@ extern "C" {
fn RAND_bytes(buf: *mut u8, num: i32) -> i32;
static mut _DefaultRuneLocale: Struct1;
fn __maskrune(arg1: i32, arg2: usize) -> i32;
fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32;
fn __tolower(arg1: i32) -> i32;
fn __toupper(arg1: i32) -> i32;
fn fclose(arg1: *mut __sFILE) -> i32;
fn feof(arg1: *mut __sFILE) -> i32;
fn fgets(arg1: *mut u8, arg2: i32, arg3: *mut __sFILE) -> *mut u8;
fn fopen(__filename: *const u8, __mode: *const u8) -> *mut __sFILE;
fn free(arg1: *mut ::std::os::raw::c_void);
fn getenv(arg1: *const u8) -> *mut u8;
fn malloc(__size: usize) -> *mut ::std::os::raw::c_void;
fn memcpy(
__dst: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: usize,
) -> *mut ::std::os::raw::c_void;
fn memset(
__b: *mut ::std::os::raw::c_void,
__c: i32,
__len: usize,
) -> *mut ::std::os::raw::c_void;
fn snprintf(__str: *mut u8, __size: usize, __format: *const u8, ...) -> i32;
fn sscanf(arg1: *const u8, arg2: *const u8, ...) -> i32;
fn strcasecmp(arg1: *const u8, arg2: *const u8) -> i32;
fn strcmp(__s1: *const u8, __s2: *const u8) -> i32;
fn strlen(__s: *const u8) -> usize;
}
enum Union6 {}
enum __sFILEX {}
#[no_mangle]
pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 {
pub fn isascii(mut _c: i32) -> i32 {
(_c & !0x7fi32 == 0i32) as (i32)
}
@@ -151,8 +134,7 @@ impl Clone for Struct1 {
}
}
#[no_mangle]
pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
pub fn __istype(mut _c: i32, mut _f: usize) -> i32 {
if isascii(_c) != 0 {
!(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32)
} else {
@@ -160,8 +142,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 {
}
}
#[no_mangle]
pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
if _c < 0i32 || _c >= 256i32 {
0i32
} else {
@@ -169,8 +150,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 {
}
}
#[no_mangle]
pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
pub fn __wcwidth(mut _c: i32) -> i32 {
let mut _x: u32;
if _c == 0i32 {
0i32
@@ -186,113 +166,91 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 {
}
}
#[no_mangle]
pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 {
pub fn isalnum(mut _c: i32) -> i32 {
__istype(_c, (0x100isize | 0x400isize) as (usize))
}
#[no_mangle]
pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 {
pub fn isalpha(mut _c: i32) -> i32 {
__istype(_c, 0x100usize)
}
#[no_mangle]
pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 {
pub fn isblank(mut _c: i32) -> i32 {
__istype(_c, 0x20000usize)
}
#[no_mangle]
pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 {
pub fn iscntrl(mut _c: i32) -> i32 {
__istype(_c, 0x200usize)
}
#[no_mangle]
pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 {
pub fn isdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x400usize)
}
#[no_mangle]
pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 {
pub fn isgraph(mut _c: i32) -> i32 {
__istype(_c, 0x800usize)
}
#[no_mangle]
pub unsafe extern "C" fn islower(mut _c: i32) -> i32 {
pub fn islower(mut _c: i32) -> i32 {
__istype(_c, 0x1000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 {
pub fn isprint(mut _c: i32) -> i32 {
__istype(_c, 0x40000usize)
}
#[no_mangle]
pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 {
pub fn ispunct(mut _c: i32) -> i32 {
__istype(_c, 0x2000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 {
pub fn isspace(mut _c: i32) -> i32 {
__istype(_c, 0x4000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 {
pub fn isupper(mut _c: i32) -> i32 {
__istype(_c, 0x8000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 {
pub fn isxdigit(mut _c: i32) -> i32 {
__isctype(_c, 0x10000usize)
}
#[no_mangle]
pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 {
pub fn toascii(mut _c: i32) -> i32 {
_c & 0x7fi32
}
#[no_mangle]
pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 {
pub fn tolower(mut _c: i32) -> i32 {
__tolower(_c)
}
#[no_mangle]
pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 {
pub fn toupper(mut _c: i32) -> i32 {
__toupper(_c)
}
#[no_mangle]
pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 {
pub fn digittoint(mut _c: i32) -> i32 {
__maskrune(_c, 0xfusize)
}
#[no_mangle]
pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 {
pub fn ishexnumber(mut _c: i32) -> i32 {
__istype(_c, 0x10000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 {
pub fn isideogram(mut _c: i32) -> i32 {
__istype(_c, 0x80000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 {
pub fn isnumber(mut _c: i32) -> i32 {
__istype(_c, 0x400usize)
}
#[no_mangle]
pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 {
pub fn isphonogram(mut _c: i32) -> i32 {
__istype(_c, 0x200000usize)
}
#[no_mangle]
pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 {
pub fn isrune(mut _c: i32) -> i32 {
__istype(_c, 0xfffffff0usize)
}
#[no_mangle]
pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 {
pub fn isspecial(mut _c: i32) -> i32 {
__istype(_c, 0x100000usize)
}
@@ -309,65 +267,11 @@ impl Clone for __sbuf {
}
}
#[derive(Copy)]
#[repr(C)]
pub struct __sFILE {
pub _p: *mut u8,
pub _r: i32,
pub _w: i32,
pub _flags: i16,
pub _file: i16,
pub _bf: __sbuf,
pub _lbfsize: i32,
pub _cookie: *mut ::std::os::raw::c_void,
pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32,
pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32,
pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize,
pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32,
pub _ub: __sbuf,
pub _extra: *mut __sFILEX,
pub _ur: i32,
pub _ubuf: [u8; 3],
pub _nbuf: [u8; 1],
pub _lb: __sbuf,
pub _blksize: i32,
pub _offset: isize,
}
impl Clone for __sFILE {
fn clone(&self) -> Self {
*self
}
}
#[no_mangle]
pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 {
if {
(*_p)._w = (*_p)._w - 1;
(*_p)._w
} >= 0i32
|| (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32))
{
({
let _rhs = _c;
let _lhs = &mut *{
let _old = (*_p)._p;
(*_p)._p = (*_p)._p.offset(1isize);
_old
};
*_lhs = _rhs as (u8);
*_lhs
}) as (i32)
} else {
__swbuf(_c, _p)
}
}
#[no_mangle]
pub static mut szLOG_SOURCE: *const u8 = (*b"YubiKey PIV Library\0").as_ptr();
#[derive(Clone, Copy)]
#[repr(i32)]
#[allow(non_camel_case_types)]
pub enum Enum5 {
DES_OK = 0i32,
DES_INVALID_PARAMETER = -1i32,
@@ -379,7 +283,7 @@ pub enum Enum5 {
#[derive(Copy)]
#[repr(C)]
pub struct DES_ks {
pub ks: [Union6; 16],
pub ks: [u8; 16],
}
impl Clone for DES_ks {
@@ -390,24 +294,23 @@ impl Clone for DES_ks {
#[derive(Copy)]
#[repr(C)]
pub struct des_key {
pub struct DesKey {
pub ks1: DES_ks,
pub ks2: DES_ks,
pub ks3: DES_ks,
}
impl Clone for des_key {
impl Clone for DesKey {
fn clone(&self) -> Self {
*self
}
}
#[no_mangle]
pub unsafe extern "C" fn des_import_key(
pub fn des_import_key(
type_: i32,
mut keyraw: *const u8,
keyrawlen: usize,
mut key: *mut *mut des_key,
mut key: *mut *mut DesKey,
) -> Enum5 {
let mut _currentBlock;
let mut rc: Enum5 = Enum5::DES_OK;
@@ -430,7 +333,7 @@ pub unsafe extern "C" fn des_import_key(
rc = Enum5::DES_INVALID_PARAMETER;
_currentBlock = 15;
} else if {
*key = malloc(::std::mem::size_of::<des_key>()) as (*mut des_key);
*key = malloc(::std::mem::size_of::<DesKey>()) as (*mut DesKey);
*key
}
.is_null()
@@ -441,7 +344,7 @@ pub unsafe extern "C" fn des_import_key(
memset(
*key as (*mut ::std::os::raw::c_void),
0i32,
::std::mem::size_of::<des_key>(),
::std::mem::size_of::<DesKey>(),
);
memcpy(
key_tmp.as_mut_ptr() as (*mut ::std::os::raw::c_void),
@@ -480,23 +383,21 @@ pub unsafe extern "C" fn des_import_key(
if _currentBlock == 15 {
if !key.is_null() {
des_destroy_key(*key);
*key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut des_key);
*key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut DesKey);
}
}
rc
}
#[no_mangle]
pub unsafe extern "C" fn des_destroy_key(mut key: *mut des_key) -> Enum5 {
pub fn des_destroy_key(mut key: *mut DesKey) -> Enum5 {
if !key.is_null() {
free(key as (*mut ::std::os::raw::c_void));
}
Enum5::DES_OK
}
#[no_mangle]
pub unsafe extern "C" fn des_encrypt(
mut key: *mut des_key,
pub fn des_encrypt(
mut key: *mut DesKey,
mut in_: *const u8,
inlen: usize,
mut out: *mut u8,
@@ -518,9 +419,8 @@ pub unsafe extern "C" fn des_encrypt(
rc
}
#[no_mangle]
pub unsafe extern "C" fn des_decrypt(
mut key: *mut des_key,
pub fn des_decrypt(
mut key: *mut DesKey,
mut in_: *const u8,
inlen: usize,
mut out: *mut u8,
@@ -542,21 +442,20 @@ pub unsafe extern "C" fn des_decrypt(
rc
}
#[no_mangle]
pub unsafe extern "C" fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool {
pub fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool {
cb_key;
DES_is_weak_key(key as (*mut [u8; 8])) != 0
}
#[derive(Clone, Copy)]
#[repr(i32)]
#[allow(non_camel_case_types)]
pub enum Enum7 {
PRNG_OK = 0i32,
PRNG_GENERAL_ERROR = -1i32,
}
#[no_mangle]
pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 {
pub fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 {
let mut rc: Enum7 = Enum7::PRNG_OK;
if -1i32 == RAND_bytes(buffer, cb_req as (i32)) {
rc = Enum7::PRNG_GENERAL_ERROR;
@@ -566,13 +465,13 @@ pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize
#[derive(Clone, Copy)]
#[repr(i32)]
#[allow(non_camel_case_types)]
pub enum Enum8 {
PKCS5_OK = 0i32,
PKCS5_GENERAL_ERROR = -1i32,
}
#[no_mangle]
pub unsafe extern "C" fn pkcs5_pbkdf2_sha1(
pub fn pkcs5_pbkdf2_sha1(
mut password: *const u8,
cb_password: usize,
mut salt: *const u8,
@@ -594,14 +493,13 @@ pub unsafe extern "C" fn pkcs5_pbkdf2_sha1(
rc
}
#[no_mangle]
pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 {
let mut psz_head: *mut u8 = sz;
let mut psz_tail: *mut u8 = sz
.offset(strlen(sz as (*const u8)) as (isize))
pub fn _strip_ws(mut sz: *mut c_char) -> *mut c_char {
let mut psz_head: *mut c_char = sz;
let mut psz_tail: *mut c_char = sz
.offset(strlen(sz as *const c_char) as (isize))
.offset(-1isize);
'loop1: loop {
if isspace(*psz_head as (i32)) == 0 {
if isspace(*psz_head as i32) == 0 {
break;
}
psz_head = psz_head.offset(1isize);
@@ -614,150 +512,150 @@ pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 {
let _old = psz_tail;
psz_tail = psz_tail.offset(-1isize);
_old
} = b'\0';
} = 0;
}
psz_head
}
#[derive(Clone, Copy)]
#[repr(i32)]
pub enum _setting_source_t {
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[allow(non_camel_case_types)]
pub enum SettingSource {
SETTING_SOURCE_USER,
SETTING_SOURCE_ADMIN,
SETTING_SOURCE_DEFAULT,
}
#[derive(Copy)]
#[repr(C)]
pub struct _setting_bool_t {
pub struct SettingBool {
pub value: bool,
pub source: _setting_source_t,
pub source: SettingSource,
}
impl Clone for _setting_bool_t {
impl Clone for SettingBool {
fn clone(&self) -> Self {
*self
}
}
#[no_mangle]
pub unsafe extern "C" fn _get_bool_config(mut sz_setting: *const u8) -> _setting_bool_t {
let mut _currentBlock;
let mut setting: _setting_bool_t = _setting_bool_t {
pub unsafe fn _get_bool_config(mut sz_setting: *const c_char) -> SettingBool {
let mut setting: SettingBool = SettingBool {
value: false,
source: _setting_source_t::SETTING_SOURCE_DEFAULT,
source: SettingSource::SETTING_SOURCE_DEFAULT,
};
let mut sz_line: [u8; 256];
let mut psz_name: *mut u8 = 0i32 as (*mut u8);
let mut psz_value: *mut u8 = 0i32 as (*mut u8);
let mut sz_line = [0u8; 256];
let mut psz_name: *mut c_char = ptr::null_mut();
let mut psz_value: *mut c_char = ptr::null_mut();
let mut sz_name = [0u8; 256];
let mut sz_value = [0u8; 256];
let mut pf: *mut __sFILE = 0i32 as (*mut __sFILE);
if !{
pf = fopen(
(*b"/etc/yubico/yubikeypiv.conf\0").as_ptr(),
(*b"r\0").as_ptr(),
);
pf
let mut pf = unsafe {
fopen(
b"/etc/yubico/yubikeypiv.conf\0".as_ptr() as *const c_char,
b"r\0".as_ptr() as *const c_char,
)
};
if pf.is_null() {
return setting;
}
.is_null()
{
_currentBlock = 1;
} else {
_currentBlock = 10;
}
'loop1: loop {
if _currentBlock == 1 {
if feof(pf) == 0 {
if fgets(
sz_line.as_mut_ptr(),
::std::mem::size_of::<[u8; 256]>() as (i32),
pf,
)
.is_null()
{
_currentBlock = 1;
continue;
}
if sz_line[0usize] as (i32) == b'#' as (i32) {
_currentBlock = 1;
continue;
}
if sz_line[0usize] as (i32) == b'\r' as (i32) {
_currentBlock = 1;
continue;
}
if sz_line[0usize] as (i32) == b'\n' as (i32) {
_currentBlock = 1;
continue;
}
if !(sscanf(
sz_line.as_mut_ptr() as (*const u8),
(*b"%255[^=]=%255s\0").as_ptr(),
sz_name.as_mut_ptr(),
sz_value.as_mut_ptr(),
) == 2i32)
{
_currentBlock = 1;
continue;
}
psz_name = _strip_ws(sz_name.as_mut_ptr());
if !(strcasecmp(psz_name as (*const u8), sz_setting) == 0) {
_currentBlock = 1;
continue;
}
psz_value = _strip_ws(sz_value.as_mut_ptr());
setting.source = _setting_source_t::SETTING_SOURCE_ADMIN;
setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0
|| strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0;
}
fclose(pf);
_currentBlock = 10;
} else {
return setting;
while feof(pf) == 0 {
if fgets(
sz_line.as_mut_ptr() as *mut c_char,
sz_line.len() as c_int,
pf,
)
.is_null()
{
continue;
}
if sz_line[0] == b'#' {
continue;
}
if sz_line[0] == b'\r' {
continue;
}
if sz_line[0] == b'\n' {
continue;
}
if !(sscanf(
sz_line.as_mut_ptr(),
(*b"%255[^=]=%255s\0").as_ptr(),
sz_name.as_mut_ptr(),
sz_value.as_mut_ptr(),
) == 2)
{
continue;
}
psz_name = _strip_ws(sz_name.as_mut_ptr() as *mut c_char);
if !(strcasecmp(psz_name as *const c_char, sz_setting as *const c_char) == 0) {
continue;
}
psz_value = _strip_ws(sz_value.as_mut_ptr() as *mut c_char);
setting.source = SettingSource::SETTING_SOURCE_ADMIN;
setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0
|| strcasecmp(
psz_value as *const c_char,
b"true\0".as_ptr() as *const c_char,
) == 0;
}
fclose(pf);
setting
}
#[no_mangle]
pub unsafe extern "C" fn _get_bool_env(mut sz_setting: *const u8) -> _setting_bool_t {
let mut setting: _setting_bool_t = _setting_bool_t {
pub fn _get_bool_env(mut sz_setting: *const c_char) -> SettingBool {
let mut setting: SettingBool = SettingBool {
value: false,
source: _setting_source_t::SETTING_SOURCE_DEFAULT,
source: SettingSource::SETTING_SOURCE_DEFAULT,
};
let mut psz_value: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8);
let mut psz_value: *mut c_char = ptr::null_mut();
let mut sz_name = [0u8; 256];
snprintf(
sz_name.as_mut_ptr(),
::std::mem::size_of::<[u8; 256]>().wrapping_sub(1usize),
(*b"%s%s\0").as_ptr(),
(*b"YUBIKEY_PIV_\0").as_ptr(),
b"%s%s\0".as_ptr(),
b"YUBIKEY_PIV_\0".as_ptr(),
sz_setting,
);
psz_value = getenv(sz_name.as_mut_ptr() as (*const u8));
psz_value = getenv(sz_name.as_mut_ptr() as *const c_char);
if !psz_value.is_null() {
setting.source = _setting_source_t::SETTING_SOURCE_USER;
setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0
|| strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0;
setting.source = SettingSource::SETTING_SOURCE_USER;
setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0
|| strcasecmp(
psz_value as *const c_char,
b"true\0".as_ptr() as *const c_char,
) == 0;
}
setting
}
#[no_mangle]
pub unsafe extern "C" fn setting_get_bool(
mut sz_setting: *const u8,
mut def: bool,
) -> _setting_bool_t {
let mut setting: _setting_bool_t = _setting_bool_t {
pub fn setting_get_bool(mut sz_setting: *const c_char, mut def: bool) -> SettingBool {
let mut setting: SettingBool = SettingBool {
value: def,
source: _setting_source_t::SETTING_SOURCE_DEFAULT,
source: SettingSource::SETTING_SOURCE_DEFAULT,
};
setting = _get_bool_config(sz_setting);
if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) {
if setting.source == SettingSource::SETTING_SOURCE_DEFAULT {
setting = _get_bool_env(sz_setting);
}
if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) {
if setting.source == SettingSource::SETTING_SOURCE_DEFAULT {
setting.value = def;
}
setting
}
src/lib.rs
+1008 -1331
View File
File diff suppressed because it is too large Load Diff
src/util.rs
+594 -930
View File
File diff suppressed because it is too large Load Diff
src/version.rs
-193
View File
@@ -1,193 +0,0 @@
// Copyright (c) 2014-2016 Yubico AB
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
extern "C" {
fn strcmp(__s1: *const u8, __s2: *const u8) -> i32;
fn strcspn(__s: *const u8, __charset: *const u8) -> usize;
fn strncmp(__s1: *const u8, __s2: *const u8, __n: usize) -> i32;
fn strspn(__s: *const u8, __charset: *const u8) -> usize;
}
unsafe extern "C" fn my_strverscmp(mut s1: *const u8, mut s2: *const u8) -> i32 {
let mut _currentBlock;
static mut digits: *const u8 = (*b"0123456789\0").as_ptr();
let mut p1: usize;
let mut p2: usize;
p1 = strcspn(s1, digits);
p2 = strcspn(s2, digits);
'loop1: loop {
if !(p1 == p2
&& (*s1.offset(p1 as (isize)) as (i32) != b'\0' as (i32))
&& (*s2.offset(p2 as (isize)) as (i32) != b'\0' as (i32)))
{
_currentBlock = 2;
break;
}
let mut ret: i32;
let mut lz1: i32;
let mut lz2: i32;
if {
ret = strncmp(s1, s2, p1);
ret
} != 0i32
{
_currentBlock = 37;
break;
}
s1 = s1.offset(p1 as (isize));
s2 = s2.offset(p2 as (isize));
lz1 = {
lz2 = 0i32;
lz2
};
if *s1 as (i32) == b'0' as (i32) {
lz1 = 1i32;
}
if *s2 as (i32) == b'0' as (i32) {
lz2 = 1i32;
}
if lz1 > lz2 {
_currentBlock = 36;
break;
}
if lz1 < lz2 {
_currentBlock = 35;
break;
}
if lz1 == 1i32 {
_currentBlock = 11;
} else {
_currentBlock = 23;
}
'loop11: loop {
if _currentBlock == 11 {
if *s1 as (i32) == b'0' as (i32) && (*s2 as (i32) == b'0' as (i32)) {
s1 = s1.offset(1isize);
s2 = s2.offset(1isize);
_currentBlock = 11;
} else {
p1 = strspn(s1, digits);
p2 = strspn(s2, digits);
if p1 == 0usize && (p2 > 0usize) {
_currentBlock = 33;
break 'loop1;
}
if p2 == 0usize && (p1 > 0usize) {
_currentBlock = 32;
break 'loop1;
}
if *s1 as (i32) != *s2 as (i32)
&& (*s1 as (i32) != b'0' as (i32))
&& (*s2 as (i32) != b'0' as (i32))
{
if p1 < p2 {
_currentBlock = 31;
break 'loop1;
}
if p1 > p2 {
_currentBlock = 30;
break 'loop1;
} else {
_currentBlock = 23;
}
} else {
if p1 < p2 {
ret = strncmp(s1, s2, p1);
} else if p1 > p2 {
ret = strncmp(s1, s2, p2);
}
if ret != 0i32 {
_currentBlock = 20;
break 'loop1;
} else {
_currentBlock = 23;
}
}
}
} else {
p1 = strspn(s1, digits);
p2 = strspn(s2, digits);
if p1 < p2 {
_currentBlock = 29;
break 'loop1;
} else {
break;
}
}
}
if p1 > p2 {
_currentBlock = 28;
break;
}
if {
ret = strncmp(s1, s2, p1);
ret
} != 0i32
{
_currentBlock = 27;
break;
}
s1 = s1.offset(p1 as (isize));
s2 = s2.offset(p2 as (isize));
p1 = strcspn(s1, digits);
p2 = strcspn(s2, digits);
}
if _currentBlock == 2 {
strcmp(s1, s2)
} else if _currentBlock == 20 {
ret
} else if _currentBlock == 27 {
ret
} else if _currentBlock == 28 {
1i32
} else if _currentBlock == 29 {
-1i32
} else if _currentBlock == 30 {
-1i32
} else if _currentBlock == 31 {
1i32
} else if _currentBlock == 32 {
-1i32
} else if _currentBlock == 33 {
1i32
} else if _currentBlock == 35 {
1i32
} else if _currentBlock == 36 {
-1i32
} else {
ret
}
}
#[no_mangle]
pub unsafe extern "C" fn ykpiv_check_version(mut req_version: *const u8) -> *const u8 {
if req_version.is_null() || my_strverscmp(req_version, (*b"@VERSION@\0").as_ptr()) <= 0i32 {
(*b"@VERSION@\0").as_ptr()
} else {
0i32 as (*mut ::std::os::raw::c_void) as (*const u8)
}
}