pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __TIMESIZE: u32 = 64;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 35;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const CRYPT_LOG_NORMAL: u32 = 0;
pub const CRYPT_LOG_ERROR: u32 = 1;
pub const CRYPT_LOG_VERBOSE: u32 = 2;
pub const CRYPT_LOG_DEBUG: i32 = -1;
pub const CRYPT_LOG_DEBUG_JSON: i32 = -2;
pub const CRYPT_RNG_URANDOM: u32 = 0;
pub const CRYPT_RNG_RANDOM: u32 = 1;
pub const CRYPT_PBKDF_ITER_TIME_SET: u32 = 1;
pub const CRYPT_PBKDF_NO_BENCHMARK: u32 = 2;
pub const CRYPT_KDF_PBKDF2: &[u8; 7] = b"pbkdf2\0";
pub const CRYPT_KDF_ARGON2I: &[u8; 8] = b"argon2i\0";
pub const CRYPT_KDF_ARGON2ID: &[u8; 9] = b"argon2id\0";
pub const CRYPT_PLAIN: &[u8; 6] = b"PLAIN\0";
pub const CRYPT_LUKS1: &[u8; 6] = b"LUKS1\0";
pub const CRYPT_LUKS2: &[u8; 6] = b"LUKS2\0";
pub const CRYPT_LOOPAES: &[u8; 8] = b"LOOPAES\0";
pub const CRYPT_VERITY: &[u8; 7] = b"VERITY\0";
pub const CRYPT_TCRYPT: &[u8; 7] = b"TCRYPT\0";
pub const CRYPT_INTEGRITY: &[u8; 10] = b"INTEGRITY\0";
pub const CRYPT_BITLK: &[u8; 6] = b"BITLK\0";
pub const CRYPT_VERITY_NO_HEADER: u32 = 1;
pub const CRYPT_VERITY_CHECK_HASH: u32 = 2;
pub const CRYPT_VERITY_CREATE_HASH: u32 = 4;
pub const CRYPT_VERITY_ROOT_HASH_SIGNATURE: u32 = 8;
pub const CRYPT_TCRYPT_LEGACY_MODES: u32 = 1;
pub const CRYPT_TCRYPT_HIDDEN_HEADER: u32 = 2;
pub const CRYPT_TCRYPT_BACKUP_HEADER: u32 = 4;
pub const CRYPT_TCRYPT_SYSTEM_HEADER: u32 = 8;
pub const CRYPT_TCRYPT_VERA_MODES: u32 = 16;
pub const CRYPT_COMPAT_LEGACY_INTEGRITY_PADDING: u32 = 1;
pub const CRYPT_COMPAT_LEGACY_INTEGRITY_HMAC: u32 = 2;
pub const CRYPT_COMPAT_LEGACY_INTEGRITY_RECALC: u32 = 4;
pub const CRYPT_ANY_SLOT: i32 = -1;
pub const CRYPT_VOLUME_KEY_NO_SEGMENT: u32 = 1;
pub const CRYPT_VOLUME_KEY_SET: u32 = 2;
pub const CRYPT_VOLUME_KEY_DIGEST_REUSE: u32 = 4;
pub const CRYPT_ACTIVATE_READONLY: u32 = 1;
pub const CRYPT_ACTIVATE_NO_UUID: u32 = 2;
pub const CRYPT_ACTIVATE_SHARED: u32 = 4;
pub const CRYPT_ACTIVATE_ALLOW_DISCARDS: u32 = 8;
pub const CRYPT_ACTIVATE_PRIVATE: u32 = 16;
pub const CRYPT_ACTIVATE_CORRUPTED: u32 = 32;
pub const CRYPT_ACTIVATE_SAME_CPU_CRYPT: u32 = 64;
pub const CRYPT_ACTIVATE_SUBMIT_FROM_CRYPT_CPUS: u32 = 128;
pub const CRYPT_ACTIVATE_IGNORE_CORRUPTION: u32 = 256;
pub const CRYPT_ACTIVATE_RESTART_ON_CORRUPTION: u32 = 512;
pub const CRYPT_ACTIVATE_IGNORE_ZERO_BLOCKS: u32 = 1024;
pub const CRYPT_ACTIVATE_KEYRING_KEY: u32 = 2048;
pub const CRYPT_ACTIVATE_NO_JOURNAL: u32 = 4096;
pub const CRYPT_ACTIVATE_RECOVERY: u32 = 8192;
pub const CRYPT_ACTIVATE_IGNORE_PERSISTENT: u32 = 16384;
pub const CRYPT_ACTIVATE_CHECK_AT_MOST_ONCE: u32 = 32768;
pub const CRYPT_ACTIVATE_ALLOW_UNBOUND_KEY: u32 = 65536;
pub const CRYPT_ACTIVATE_RECALCULATE: u32 = 131072;
pub const CRYPT_ACTIVATE_REFRESH: u32 = 262144;
pub const CRYPT_ACTIVATE_SERIALIZE_MEMORY_HARD_PBKDF: u32 = 524288;
pub const CRYPT_ACTIVATE_NO_JOURNAL_BITMAP: u32 = 1048576;
pub const CRYPT_ACTIVATE_SUSPENDED: u32 = 2097152;
pub const CRYPT_ACTIVATE_IV_LARGE_SECTORS: u32 = 4194304;
pub const CRYPT_ACTIVATE_PANIC_ON_CORRUPTION: u32 = 8388608;
pub const CRYPT_ACTIVATE_NO_READ_WORKQUEUE: u32 = 16777216;
pub const CRYPT_ACTIVATE_NO_WRITE_WORKQUEUE: u32 = 33554432;
pub const CRYPT_ACTIVATE_RECALCULATE_RESET: u32 = 67108864;
pub const CRYPT_REQUIREMENT_OFFLINE_REENCRYPT: u32 = 1;
pub const CRYPT_REQUIREMENT_ONLINE_REENCRYPT: u32 = 2;
pub const CRYPT_REQUIREMENT_UNKNOWN: u32 = 2147483648;
pub const CRYPT_DEACTIVATE_DEFERRED: u32 = 1;
pub const CRYPT_DEACTIVATE_FORCE: u32 = 2;
pub const CRYPT_DEACTIVATE_DEFERRED_CANCEL: u32 = 4;
pub const CRYPT_DEBUG_ALL: i32 = -1;
pub const CRYPT_DEBUG_JSON: i32 = -2;
pub const CRYPT_DEBUG_NONE: u32 = 0;
pub const CRYPT_KEYFILE_STOP_EOL: u32 = 1;
pub const CRYPT_WIPE_NO_DIRECT_IO: u32 = 1;
pub const CRYPT_ANY_TOKEN: i32 = -1;
pub const CRYPT_TOKEN_ABI_VERSION1: &[u8; 21] = b"CRYPTSETUP_TOKEN_1.0\0";
pub const CRYPT_TOKEN_ABI_OPEN: &[u8; 22] = b"cryptsetup_token_open\0";
pub const CRYPT_TOKEN_ABI_OPEN_PIN: &[u8; 26] = b"cryptsetup_token_open_pin\0";
pub const CRYPT_TOKEN_ABI_BUFFER_FREE: &[u8; 29] = b"cryptsetup_token_buffer_free\0";
pub const CRYPT_TOKEN_ABI_VALIDATE: &[u8; 26] = b"cryptsetup_token_validate\0";
pub const CRYPT_TOKEN_ABI_DUMP: &[u8; 22] = b"cryptsetup_token_dump\0";
pub const CRYPT_TOKEN_ABI_VERSION: &[u8; 25] = b"cryptsetup_token_version\0";
pub const CRYPT_REENCRYPT_INITIALIZE_ONLY: u32 = 1;
pub const CRYPT_REENCRYPT_MOVE_FIRST_SEGMENT: u32 = 2;
pub const CRYPT_REENCRYPT_RESUME_ONLY: u32 = 4;
pub const CRYPT_REENCRYPT_RECOVERY: u32 = 8;
pub const CRYPT_REENCRYPT_REPAIR_NEEDED: u32 = 16;
pub type wchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
pub __bindgen_padding_0: u64,
pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_max_align_t() {
const UNINIT: ::std::mem::MaybeUninit<max_align_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<max_align_t>(),
32usize,
concat!("Size of: ", stringify!(max_align_t))
);
assert_eq!(
::std::mem::align_of::<max_align_t>(),
16usize,
concat!("Alignment of ", stringify!(max_align_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce2)
)
);
}
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __suseconds64_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_device {
_unused: [u8; 0],
}
extern "C" {
pub fn crypt_init(
cd: *mut *mut crypt_device,
device: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_init_data_device(
cd: *mut *mut crypt_device,
device: *const ::std::os::raw::c_char,
data_device: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_init_by_name_and_header(
cd: *mut *mut crypt_device,
name: *const ::std::os::raw::c_char,
header_device: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_init_by_name(
cd: *mut *mut crypt_device,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_free(cd: *mut crypt_device);
}
extern "C" {
pub fn crypt_set_confirm_callback(
cd: *mut crypt_device,
confirm: ::std::option::Option<
unsafe extern "C" fn(
msg: *const ::std::os::raw::c_char,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
usrptr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn crypt_set_data_device(
cd: *mut crypt_device,
device: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_data_offset(cd: *mut crypt_device, data_offset: u64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_log_callback(
cd: *mut crypt_device,
log: ::std::option::Option<
unsafe extern "C" fn(
level: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
usrptr: *mut ::std::os::raw::c_void,
),
>,
usrptr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn crypt_log(
cd: *mut crypt_device,
level: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn crypt_logf(
cd: *mut crypt_device,
level: ::std::os::raw::c_int,
format: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn crypt_set_rng_type(cd: *mut crypt_device, rng_type: ::std::os::raw::c_int);
}
extern "C" {
pub fn crypt_get_rng_type(cd: *mut crypt_device) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_pbkdf_type {
pub type_: *const ::std::os::raw::c_char,
pub hash: *const ::std::os::raw::c_char,
pub time_ms: u32,
pub iterations: u32,
pub max_memory_kb: u32,
pub parallel_threads: u32,
pub flags: u32,
}
#[test]
fn bindgen_test_layout_crypt_pbkdf_type() {
const UNINIT: ::std::mem::MaybeUninit<crypt_pbkdf_type> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_pbkdf_type>(),
40usize,
concat!("Size of: ", stringify!(crypt_pbkdf_type))
);
assert_eq!(
::std::mem::align_of::<crypt_pbkdf_type>(),
8usize,
concat!("Alignment of ", stringify!(crypt_pbkdf_type))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_ms) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(time_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).iterations) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(iterations)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_memory_kb) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(max_memory_kb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parallel_threads) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(parallel_threads)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_pbkdf_type),
"::",
stringify!(flags)
)
);
}
extern "C" {
pub fn crypt_set_pbkdf_type(
cd: *mut crypt_device,
pbkdf: *const crypt_pbkdf_type,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_pbkdf_type_params(
pbkdf_type: *const ::std::os::raw::c_char,
) -> *const crypt_pbkdf_type;
}
extern "C" {
pub fn crypt_get_pbkdf_default(type_: *const ::std::os::raw::c_char)
-> *const crypt_pbkdf_type;
}
extern "C" {
pub fn crypt_get_pbkdf_type(cd: *mut crypt_device) -> *const crypt_pbkdf_type;
}
extern "C" {
pub fn crypt_set_iteration_time(cd: *mut crypt_device, iteration_time_ms: u64);
}
extern "C" {
pub fn crypt_memory_lock(
cd: *mut crypt_device,
lock: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_metadata_locking(
cd: *mut crypt_device,
enable: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_metadata_size(
cd: *mut crypt_device,
metadata_size: u64,
keyslots_size: u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_metadata_size(
cd: *mut crypt_device,
metadata_size: *mut u64,
keyslots_size: *mut u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_type(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_default_type() -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_plain {
pub hash: *const ::std::os::raw::c_char,
pub offset: u64,
pub skip: u64,
pub size: u64,
pub sector_size: u32,
}
#[test]
fn bindgen_test_layout_crypt_params_plain() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_plain> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_plain>(),
40usize,
concat!("Size of: ", stringify!(crypt_params_plain))
);
assert_eq!(
::std::mem::align_of::<crypt_params_plain>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_plain))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_plain),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_plain),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).skip) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_plain),
"::",
stringify!(skip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_plain),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sector_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_plain),
"::",
stringify!(sector_size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_luks1 {
pub hash: *const ::std::os::raw::c_char,
pub data_alignment: usize,
pub data_device: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_crypt_params_luks1() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_luks1> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_luks1>(),
24usize,
concat!("Size of: ", stringify!(crypt_params_luks1))
);
assert_eq!(
::std::mem::align_of::<crypt_params_luks1>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_luks1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks1),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_alignment) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks1),
"::",
stringify!(data_alignment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_device) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks1),
"::",
stringify!(data_device)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_loopaes {
pub hash: *const ::std::os::raw::c_char,
pub offset: u64,
pub skip: u64,
}
#[test]
fn bindgen_test_layout_crypt_params_loopaes() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_loopaes> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_loopaes>(),
24usize,
concat!("Size of: ", stringify!(crypt_params_loopaes))
);
assert_eq!(
::std::mem::align_of::<crypt_params_loopaes>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_loopaes))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_loopaes),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_loopaes),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).skip) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_loopaes),
"::",
stringify!(skip)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_verity {
pub hash_name: *const ::std::os::raw::c_char,
pub data_device: *const ::std::os::raw::c_char,
pub hash_device: *const ::std::os::raw::c_char,
pub fec_device: *const ::std::os::raw::c_char,
pub salt: *const ::std::os::raw::c_char,
pub salt_size: u32,
pub hash_type: u32,
pub data_block_size: u32,
pub hash_block_size: u32,
pub data_size: u64,
pub hash_area_offset: u64,
pub fec_area_offset: u64,
pub fec_roots: u32,
pub flags: u32,
}
#[test]
fn bindgen_test_layout_crypt_params_verity() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_verity> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_verity>(),
88usize,
concat!("Size of: ", stringify!(crypt_params_verity))
);
assert_eq!(
::std::mem::align_of::<crypt_params_verity>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_verity))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(hash_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_device) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(data_device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_device) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(hash_device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fec_device) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(fec_device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).salt) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(salt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).salt_size) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(salt_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_type) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(hash_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_block_size) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(data_block_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_block_size) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(hash_block_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_size) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(data_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_area_offset) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(hash_area_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fec_area_offset) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(fec_area_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fec_roots) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(fec_roots)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_verity),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_tcrypt {
pub passphrase: *const ::std::os::raw::c_char,
pub passphrase_size: usize,
pub keyfiles: *mut *const ::std::os::raw::c_char,
pub keyfiles_count: ::std::os::raw::c_uint,
pub hash_name: *const ::std::os::raw::c_char,
pub cipher: *const ::std::os::raw::c_char,
pub mode: *const ::std::os::raw::c_char,
pub key_size: usize,
pub flags: u32,
pub veracrypt_pim: u32,
}
#[test]
fn bindgen_test_layout_crypt_params_tcrypt() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_tcrypt> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_tcrypt>(),
72usize,
concat!("Size of: ", stringify!(crypt_params_tcrypt))
);
assert_eq!(
::std::mem::align_of::<crypt_params_tcrypt>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_tcrypt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).passphrase) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(passphrase)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).passphrase_size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(passphrase_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyfiles) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(keyfiles)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyfiles_count) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(keyfiles_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_name) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(hash_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cipher) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(cipher)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key_size) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(key_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).veracrypt_pim) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_tcrypt),
"::",
stringify!(veracrypt_pim)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_integrity {
pub journal_size: u64,
pub journal_watermark: ::std::os::raw::c_uint,
pub journal_commit_time: ::std::os::raw::c_uint,
pub interleave_sectors: u32,
pub tag_size: u32,
pub sector_size: u32,
pub buffer_sectors: u32,
pub integrity: *const ::std::os::raw::c_char,
pub integrity_key_size: u32,
pub journal_integrity: *const ::std::os::raw::c_char,
pub journal_integrity_key: *const ::std::os::raw::c_char,
pub journal_integrity_key_size: u32,
pub journal_crypt: *const ::std::os::raw::c_char,
pub journal_crypt_key: *const ::std::os::raw::c_char,
pub journal_crypt_key_size: u32,
}
#[test]
fn bindgen_test_layout_crypt_params_integrity() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_integrity> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_integrity>(),
96usize,
concat!("Size of: ", stringify!(crypt_params_integrity))
);
assert_eq!(
::std::mem::align_of::<crypt_params_integrity>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_integrity))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_watermark) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_watermark)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_commit_time) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_commit_time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).interleave_sectors) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(interleave_sectors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tag_size) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(tag_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sector_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(sector_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_sectors) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(buffer_sectors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integrity) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(integrity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integrity_key_size) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(integrity_key_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_integrity) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_integrity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_integrity_key) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_integrity_key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_integrity_key_size) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_integrity_key_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_crypt) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_crypt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_crypt_key) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_crypt_key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).journal_crypt_key_size) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_integrity),
"::",
stringify!(journal_crypt_key_size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_luks2 {
pub pbkdf: *const crypt_pbkdf_type,
pub integrity: *const ::std::os::raw::c_char,
pub integrity_params: *const crypt_params_integrity,
pub data_alignment: usize,
pub data_device: *const ::std::os::raw::c_char,
pub sector_size: u32,
pub label: *const ::std::os::raw::c_char,
pub subsystem: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_crypt_params_luks2() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_luks2> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_luks2>(),
64usize,
concat!("Size of: ", stringify!(crypt_params_luks2))
);
assert_eq!(
::std::mem::align_of::<crypt_params_luks2>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_luks2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pbkdf) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(pbkdf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integrity) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(integrity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integrity_params) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(integrity_params)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_alignment) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(data_alignment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_device) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(data_device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sector_size) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(sector_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subsystem) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_luks2),
"::",
stringify!(subsystem)
)
);
}
extern "C" {
pub fn crypt_format(
cd: *mut crypt_device,
type_: *const ::std::os::raw::c_char,
cipher: *const ::std::os::raw::c_char,
cipher_mode: *const ::std::os::raw::c_char,
uuid: *const ::std::os::raw::c_char,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
params: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_compatibility(cd: *mut crypt_device, flags: u32);
}
extern "C" {
pub fn crypt_get_compatibility(cd: *mut crypt_device) -> u32;
}
extern "C" {
pub fn crypt_convert(
cd: *mut crypt_device,
type_: *const ::std::os::raw::c_char,
params: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_uuid(
cd: *mut crypt_device,
uuid: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_label(
cd: *mut crypt_device,
label: *const ::std::os::raw::c_char,
subsystem: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_volume_key_keyring(
cd: *mut crypt_device,
enable: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_load(
cd: *mut crypt_device,
requested_type: *const ::std::os::raw::c_char,
params: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_repair(
cd: *mut crypt_device,
requested_type: *const ::std::os::raw::c_char,
params: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resize(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
new_size: u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_suspend(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resume_by_passphrase(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resume_by_keyfile_device_offset(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resume_by_keyfile_offset(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resume_by_keyfile(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_resume_by_volume_key(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_passphrase(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
new_passphrase: *const ::std::os::raw::c_char,
new_passphrase_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_change_by_passphrase(
cd: *mut crypt_device,
keyslot_old: ::std::os::raw::c_int,
keyslot_new: ::std::os::raw::c_int,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
new_passphrase: *const ::std::os::raw::c_char,
new_passphrase_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_keyfile_device_offset(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: u64,
new_keyfile: *const ::std::os::raw::c_char,
new_keyfile_size: usize,
new_keyfile_offset: u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_keyfile_offset(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: usize,
new_keyfile: *const ::std::os::raw::c_char,
new_keyfile_size: usize,
new_keyfile_offset: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_keyfile(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
new_keyfile: *const ::std::os::raw::c_char,
new_keyfile_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_volume_key(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_add_by_key(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_destroy(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_active_device {
pub offset: u64,
pub iv_offset: u64,
pub size: u64,
pub flags: u32,
}
#[test]
fn bindgen_test_layout_crypt_active_device() {
const UNINIT: ::std::mem::MaybeUninit<crypt_active_device> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_active_device>(),
32usize,
concat!("Size of: ", stringify!(crypt_active_device))
);
assert_eq!(
::std::mem::align_of::<crypt_active_device>(),
8usize,
concat!("Alignment of ", stringify!(crypt_active_device))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_active_device),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).iv_offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_active_device),
"::",
stringify!(iv_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_active_device),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_active_device),
"::",
stringify!(flags)
)
);
}
extern "C" {
pub fn crypt_get_active_device(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
cad: *mut crypt_active_device,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_active_integrity_failures(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
) -> u64;
}
pub const crypt_flags_type_CRYPT_FLAGS_ACTIVATION: crypt_flags_type = 0;
pub const crypt_flags_type_CRYPT_FLAGS_REQUIREMENTS: crypt_flags_type = 1;
pub type crypt_flags_type = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_persistent_flags_set(
cd: *mut crypt_device,
type_: crypt_flags_type,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_persistent_flags_get(
cd: *mut crypt_device,
type_: crypt_flags_type,
flags: *mut u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_passphrase(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_keyfile_device_offset(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: u64,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_keyfile_offset(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
keyfile_offset: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_keyfile(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
keyfile: *const ::std::os::raw::c_char,
keyfile_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_volume_key(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_signed_key(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
signature: *const ::std::os::raw::c_char,
signature_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_keyring(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
key_description: *const ::std::os::raw::c_char,
keyslot: ::std::os::raw::c_int,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_deactivate_by_name(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_deactivate(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_volume_key_get(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
volume_key: *mut ::std::os::raw::c_char,
volume_key_size: *mut usize,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_volume_key_verify(
cd: *mut crypt_device,
volume_key: *const ::std::os::raw::c_char,
volume_key_size: usize,
) -> ::std::os::raw::c_int;
}
pub const crypt_status_info_CRYPT_INVALID: crypt_status_info = 0;
pub const crypt_status_info_CRYPT_INACTIVE: crypt_status_info = 1;
pub const crypt_status_info_CRYPT_ACTIVE: crypt_status_info = 2;
pub const crypt_status_info_CRYPT_BUSY: crypt_status_info = 3;
pub type crypt_status_info = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_status(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
) -> crypt_status_info;
}
extern "C" {
pub fn crypt_dump(cd: *mut crypt_device) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_dump_json(
cd: *mut crypt_device,
json: *mut *const ::std::os::raw::c_char,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_cipher(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_cipher_mode(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_uuid(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_device_name(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_metadata_device_name(cd: *mut crypt_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_get_data_offset(cd: *mut crypt_device) -> u64;
}
extern "C" {
pub fn crypt_get_iv_offset(cd: *mut crypt_device) -> u64;
}
extern "C" {
pub fn crypt_get_volume_key_size(cd: *mut crypt_device) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_sector_size(cd: *mut crypt_device) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_header_is_detached(cd: *mut crypt_device) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_verity_info(
cd: *mut crypt_device,
vp: *mut crypt_params_verity,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_integrity_info(
cd: *mut crypt_device,
ip: *mut crypt_params_integrity,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_benchmark(
cd: *mut crypt_device,
cipher: *const ::std::os::raw::c_char,
cipher_mode: *const ::std::os::raw::c_char,
volume_key_size: usize,
iv_size: usize,
buffer_size: usize,
encryption_mbs: *mut f64,
decryption_mbs: *mut f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_benchmark_pbkdf(
cd: *mut crypt_device,
pbkdf: *mut crypt_pbkdf_type,
password: *const ::std::os::raw::c_char,
password_size: usize,
salt: *const ::std::os::raw::c_char,
salt_size: usize,
volume_key_size: usize,
progress: ::std::option::Option<
unsafe extern "C" fn(
time_ms: u32,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
pub const crypt_keyslot_info_CRYPT_SLOT_INVALID: crypt_keyslot_info = 0;
pub const crypt_keyslot_info_CRYPT_SLOT_INACTIVE: crypt_keyslot_info = 1;
pub const crypt_keyslot_info_CRYPT_SLOT_ACTIVE: crypt_keyslot_info = 2;
pub const crypt_keyslot_info_CRYPT_SLOT_ACTIVE_LAST: crypt_keyslot_info = 3;
pub const crypt_keyslot_info_CRYPT_SLOT_UNBOUND: crypt_keyslot_info = 4;
pub type crypt_keyslot_info = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_keyslot_status(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
) -> crypt_keyslot_info;
}
pub const crypt_keyslot_priority_CRYPT_SLOT_PRIORITY_INVALID: crypt_keyslot_priority = -1;
pub const crypt_keyslot_priority_CRYPT_SLOT_PRIORITY_IGNORE: crypt_keyslot_priority = 0;
pub const crypt_keyslot_priority_CRYPT_SLOT_PRIORITY_NORMAL: crypt_keyslot_priority = 1;
pub const crypt_keyslot_priority_CRYPT_SLOT_PRIORITY_PREFER: crypt_keyslot_priority = 2;
pub type crypt_keyslot_priority = ::std::os::raw::c_int;
extern "C" {
pub fn crypt_keyslot_get_priority(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
) -> crypt_keyslot_priority;
}
extern "C" {
pub fn crypt_keyslot_set_priority(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
priority: crypt_keyslot_priority,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_max(type_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_area(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
offset: *mut u64,
length: *mut u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_get_key_size(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_get_encryption(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
key_size: *mut usize,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_keyslot_get_pbkdf(
cd: *mut crypt_device,
keyslot: ::std::os::raw::c_int,
pbkdf: *mut crypt_pbkdf_type,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyslot_set_encryption(
cd: *mut crypt_device,
cipher: *const ::std::os::raw::c_char,
key_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_get_dir() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_header_backup(
cd: *mut crypt_device,
requested_type: *const ::std::os::raw::c_char,
backup_file: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_header_restore(
cd: *mut crypt_device,
requested_type: *const ::std::os::raw::c_char,
backup_file: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_set_debug_level(level: ::std::os::raw::c_int);
}
extern "C" {
pub fn crypt_keyfile_device_read(
cd: *mut crypt_device,
keyfile: *const ::std::os::raw::c_char,
key: *mut *mut ::std::os::raw::c_char,
key_size_read: *mut usize,
keyfile_offset: u64,
key_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_keyfile_read(
cd: *mut crypt_device,
keyfile: *const ::std::os::raw::c_char,
key: *mut *mut ::std::os::raw::c_char,
key_size_read: *mut usize,
keyfile_offset: usize,
key_size: usize,
flags: u32,
) -> ::std::os::raw::c_int;
}
pub const crypt_wipe_pattern_CRYPT_WIPE_ZERO: crypt_wipe_pattern = 0;
pub const crypt_wipe_pattern_CRYPT_WIPE_RANDOM: crypt_wipe_pattern = 1;
pub const crypt_wipe_pattern_CRYPT_WIPE_ENCRYPTED_ZERO: crypt_wipe_pattern = 2;
pub const crypt_wipe_pattern_CRYPT_WIPE_SPECIAL: crypt_wipe_pattern = 3;
pub type crypt_wipe_pattern = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_wipe(
cd: *mut crypt_device,
dev_path: *const ::std::os::raw::c_char,
pattern: crypt_wipe_pattern,
offset: u64,
length: u64,
wipe_block_size: usize,
flags: u32,
progress: ::std::option::Option<
unsafe extern "C" fn(
size: u64,
offset: u64,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_max(type_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_json_get(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
json: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_json_set(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
json: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
pub const crypt_token_info_CRYPT_TOKEN_INVALID: crypt_token_info = 0;
pub const crypt_token_info_CRYPT_TOKEN_INACTIVE: crypt_token_info = 1;
pub const crypt_token_info_CRYPT_TOKEN_INTERNAL: crypt_token_info = 2;
pub const crypt_token_info_CRYPT_TOKEN_INTERNAL_UNKNOWN: crypt_token_info = 3;
pub const crypt_token_info_CRYPT_TOKEN_EXTERNAL: crypt_token_info = 4;
pub const crypt_token_info_CRYPT_TOKEN_EXTERNAL_UNKNOWN: crypt_token_info = 5;
pub type crypt_token_info = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_token_status(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
type_: *mut *const ::std::os::raw::c_char,
) -> crypt_token_info;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_token_params_luks2_keyring {
pub key_description: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_crypt_token_params_luks2_keyring() {
const UNINIT: ::std::mem::MaybeUninit<crypt_token_params_luks2_keyring> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_token_params_luks2_keyring>(),
8usize,
concat!("Size of: ", stringify!(crypt_token_params_luks2_keyring))
);
assert_eq!(
::std::mem::align_of::<crypt_token_params_luks2_keyring>(),
8usize,
concat!(
"Alignment of ",
stringify!(crypt_token_params_luks2_keyring)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key_description) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_params_luks2_keyring),
"::",
stringify!(key_description)
)
);
}
extern "C" {
pub fn crypt_token_luks2_keyring_set(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
params: *const crypt_token_params_luks2_keyring,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_luks2_keyring_get(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
params: *mut crypt_token_params_luks2_keyring,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_assign_keyslot(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
keyslot: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_unassign_keyslot(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
keyslot: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_is_assigned(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
keyslot: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type crypt_token_open_func = ::std::option::Option<
unsafe extern "C" fn(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
buffer: *mut *mut ::std::os::raw::c_char,
buffer_len: *mut usize,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type crypt_token_open_pin_func = ::std::option::Option<
unsafe extern "C" fn(
cd: *mut crypt_device,
token: ::std::os::raw::c_int,
pin: *const ::std::os::raw::c_char,
pin_size: usize,
buffer: *mut *mut ::std::os::raw::c_char,
buffer_len: *mut usize,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type crypt_token_buffer_free_func = ::std::option::Option<
unsafe extern "C" fn(buffer: *mut ::std::os::raw::c_void, buffer_len: usize),
>;
pub type crypt_token_validate_func = ::std::option::Option<
unsafe extern "C" fn(
cd: *mut crypt_device,
json: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>;
pub type crypt_token_dump_func = ::std::option::Option<
unsafe extern "C" fn(cd: *mut crypt_device, json: *const ::std::os::raw::c_char),
>;
pub type crypt_token_version_func =
::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_token_handler {
pub name: *const ::std::os::raw::c_char,
pub open: crypt_token_open_func,
pub buffer_free: crypt_token_buffer_free_func,
pub validate: crypt_token_validate_func,
pub dump: crypt_token_dump_func,
}
#[test]
fn bindgen_test_layout_crypt_token_handler() {
const UNINIT: ::std::mem::MaybeUninit<crypt_token_handler> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_token_handler>(),
40usize,
concat!("Size of: ", stringify!(crypt_token_handler))
);
assert_eq!(
::std::mem::align_of::<crypt_token_handler>(),
8usize,
concat!("Alignment of ", stringify!(crypt_token_handler))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_handler),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_handler),
"::",
stringify!(open)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_free) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_handler),
"::",
stringify!(buffer_free)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).validate) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_handler),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dump) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_token_handler),
"::",
stringify!(dump)
)
);
}
extern "C" {
pub fn crypt_token_register(handler: *const crypt_token_handler) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_token_external_path() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn crypt_token_external_disable();
}
extern "C" {
pub fn crypt_activate_by_token(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
token: ::std::os::raw::c_int,
usrptr: *mut ::std::os::raw::c_void,
flags: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_activate_by_token_pin(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
type_: *const ::std::os::raw::c_char,
token: ::std::os::raw::c_int,
pin: *const ::std::os::raw::c_char,
pin_size: usize,
usrptr: *mut ::std::os::raw::c_void,
flags: u32,
) -> ::std::os::raw::c_int;
}
pub const crypt_reencrypt_direction_info_CRYPT_REENCRYPT_FORWARD: crypt_reencrypt_direction_info =
0;
pub const crypt_reencrypt_direction_info_CRYPT_REENCRYPT_BACKWARD: crypt_reencrypt_direction_info =
1;
pub type crypt_reencrypt_direction_info = ::std::os::raw::c_uint;
pub const crypt_reencrypt_mode_info_CRYPT_REENCRYPT_REENCRYPT: crypt_reencrypt_mode_info = 0;
pub const crypt_reencrypt_mode_info_CRYPT_REENCRYPT_ENCRYPT: crypt_reencrypt_mode_info = 1;
pub const crypt_reencrypt_mode_info_CRYPT_REENCRYPT_DECRYPT: crypt_reencrypt_mode_info = 2;
pub type crypt_reencrypt_mode_info = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypt_params_reencrypt {
pub mode: crypt_reencrypt_mode_info,
pub direction: crypt_reencrypt_direction_info,
pub resilience: *const ::std::os::raw::c_char,
pub hash: *const ::std::os::raw::c_char,
pub data_shift: u64,
pub max_hotzone_size: u64,
pub device_size: u64,
pub luks2: *const crypt_params_luks2,
pub flags: u32,
}
#[test]
fn bindgen_test_layout_crypt_params_reencrypt() {
const UNINIT: ::std::mem::MaybeUninit<crypt_params_reencrypt> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<crypt_params_reencrypt>(),
64usize,
concat!("Size of: ", stringify!(crypt_params_reencrypt))
);
assert_eq!(
::std::mem::align_of::<crypt_params_reencrypt>(),
8usize,
concat!("Alignment of ", stringify!(crypt_params_reencrypt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resilience) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(resilience)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_shift) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(data_shift)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_hotzone_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(max_hotzone_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device_size) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(device_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).luks2) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(luks2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(crypt_params_reencrypt),
"::",
stringify!(flags)
)
);
}
extern "C" {
pub fn crypt_reencrypt_init_by_passphrase(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
passphrase: *const ::std::os::raw::c_char,
passphrase_size: usize,
keyslot_old: ::std::os::raw::c_int,
keyslot_new: ::std::os::raw::c_int,
cipher: *const ::std::os::raw::c_char,
cipher_mode: *const ::std::os::raw::c_char,
params: *const crypt_params_reencrypt,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_reencrypt_init_by_keyring(
cd: *mut crypt_device,
name: *const ::std::os::raw::c_char,
key_description: *const ::std::os::raw::c_char,
keyslot_old: ::std::os::raw::c_int,
keyslot_new: ::std::os::raw::c_int,
cipher: *const ::std::os::raw::c_char,
cipher_mode: *const ::std::os::raw::c_char,
params: *const crypt_params_reencrypt,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_reencrypt(
cd: *mut crypt_device,
progress: ::std::option::Option<
unsafe extern "C" fn(
size: u64,
offset: u64,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn crypt_reencrypt_run(
cd: *mut crypt_device,
progress: ::std::option::Option<
unsafe extern "C" fn(
size: u64,
offset: u64,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
usrptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
pub const crypt_reencrypt_info_CRYPT_REENCRYPT_NONE: crypt_reencrypt_info = 0;
pub const crypt_reencrypt_info_CRYPT_REENCRYPT_CLEAN: crypt_reencrypt_info = 1;
pub const crypt_reencrypt_info_CRYPT_REENCRYPT_CRASH: crypt_reencrypt_info = 2;
pub const crypt_reencrypt_info_CRYPT_REENCRYPT_INVALID: crypt_reencrypt_info = 3;
pub type crypt_reencrypt_info = ::std::os::raw::c_uint;
extern "C" {
pub fn crypt_reencrypt_status(
cd: *mut crypt_device,
params: *mut crypt_params_reencrypt,
) -> crypt_reencrypt_info;
}
extern "C" {
pub fn crypt_safe_alloc(size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn crypt_safe_free(data: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn crypt_safe_realloc(
data: *mut ::std::os::raw::c_void,
size: usize,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn crypt_safe_memzero(data: *mut ::std::os::raw::c_void, size: usize);
}
pub const crypt_activate_readonly: u32 = 1;
pub const crypt_activate_no_uuid: u32 = 2;
pub const crypt_activate_shared: u32 = 4;
pub const crypt_activate_allow_discards: u32 = 8;
pub const crypt_activate_private: u32 = 16;
pub const crypt_activate_corrupted: u32 = 32;
pub const crypt_activate_same_cpu_crypt: u32 = 64;
pub const crypt_activate_submit_from_crypt_cpus: u32 = 128;
pub const crypt_activate_ignore_corruption: u32 = 256;
pub const crypt_activate_restart_on_corruption: u32 = 512;
pub const crypt_activate_ignore_zero_blocks: u32 = 1024;
pub const crypt_activate_keyring_key: u32 = 2048;
pub const crypt_activate_no_journal: u32 = 4096;
pub const crypt_activate_recovery: u32 = 8192;
pub const crypt_activate_ignore_persistent: u32 = 16384;
pub const crypt_activate_check_at_most_once: u32 = 32768;
pub const crypt_activate_allow_unbound_key: u32 = 65536;
pub const crypt_activate_recalculate: u32 = 131072;
pub const crypt_activate_refresh: u32 = 262144;
pub const crypt_activate_serialize_memory_hard_pbkdf: u32 = 524288;
pub const crypt_activate_no_journal_bitmap: u32 = 1048576;
pub const crypt_activate_suspended: u32 = 2097152;
pub const crypt_activate_iv_large_sectors: u32 = 4194304;
pub const crypt_activate_panic_on_corruption: u32 = 8388608;
pub const crypt_activate_no_read_workqueue: u32 = 16777216;
pub const crypt_activate_no_write_workqueue: u32 = 33554432;
pub const crypt_activate_recalculate_reset: u32 = 67108864;
pub const crypt_deactivate_deferred: u32 = 1;
pub const crypt_deactivate_force: u32 = 2;
pub const crypt_verity_no_header: u32 = 1;
pub const crypt_verity_check_hash: u32 = 2;
pub const crypt_verity_create_hash: u32 = 4;
pub const crypt_tcrypt_legacy_modes: u32 = 1;
pub const crypt_tcrypt_hidden_header: u32 = 2;
pub const crypt_tcrypt_backup_header: u32 = 4;
pub const crypt_tcrypt_system_header: u32 = 8;
pub const crypt_tcrypt_vera_modes: u32 = 16;
pub const crypt_keyfile_stop_eol: u32 = 1;
pub const crypt_volume_key_no_segment: u32 = 1;
pub const crypt_volume_key_set: u32 = 2;
pub const crypt_volume_key_digest_reuse: u32 = 4;
pub const crypt_requirement_offline_reencrypt: u32 = 1;
pub const crypt_requirement_online_reencrypt: u32 = 2;
pub const crypt_requirement_unknown: u32 = 2147483648;
pub const crypt_reencrypt_recovery: u32 = 8;
pub const crypt_reencrypt_resume_only: u32 = 4;
pub const crypt_reencrypt_initialize_only: u32 = 1;
pub const crypt_reencrypt_move_first_segment: u32 = 2;
pub const crypt_pbkdf_iter_time_set: u32 = 1;
pub const crypt_pbkdf_no_benchmark: u32 = 2;
pub const crypt_wipe_no_direct_io: u32 = 1;