| /* automatically generated by rust-bindgen */ |
| |
| #[repr(C)] |
| #[derive(Default)] |
| pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>); |
| impl<T> __IncompleteArrayField<T> { |
| #[inline] |
| pub fn new() -> Self { |
| __IncompleteArrayField(::std::marker::PhantomData) |
| } |
| #[inline] |
| pub unsafe fn as_ptr(&self) -> *const T { |
| ::std::mem::transmute(self) |
| } |
| #[inline] |
| pub unsafe fn as_mut_ptr(&mut self) -> *mut T { |
| ::std::mem::transmute(self) |
| } |
| #[inline] |
| pub unsafe fn as_slice(&self, len: usize) -> &[T] { |
| ::std::slice::from_raw_parts(self.as_ptr(), len) |
| } |
| #[inline] |
| pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { |
| ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) |
| } |
| } |
| impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> { |
| fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { |
| fmt.write_str("__IncompleteArrayField") |
| } |
| } |
| impl<T> ::std::clone::Clone for __IncompleteArrayField<T> { |
| #[inline] |
| fn clone(&self) -> Self { |
| Self::new() |
| } |
| } |
| impl<T> ::std::marker::Copy for __IncompleteArrayField<T> {} |
| pub const _STDINT_H: u32 = 1; |
| pub const _FEATURES_H: u32 = 1; |
| pub const _DEFAULT_SOURCE: u32 = 1; |
| 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 __USE_MISC: u32 = 1; |
| pub const __USE_ATFILE: u32 = 1; |
| pub const __USE_FORTIFY_LEVEL: u32 = 0; |
| pub const _STDC_PREDEF_H: u32 = 1; |
| pub const __STDC_IEC_559__: u32 = 1; |
| pub const __STDC_IEC_559_COMPLEX__: u32 = 1; |
| pub const __STDC_ISO_10646__: u32 = 201605; |
| pub const __STDC_NO_THREADS__: u32 = 1; |
| pub const __GNU_LIBRARY__: u32 = 6; |
| pub const __GLIBC__: u32 = 2; |
| pub const __GLIBC_MINOR__: u32 = 24; |
| pub const _SYS_CDEFS_H: u32 = 1; |
| pub const __WORDSIZE: u32 = 64; |
| pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1; |
| pub const __SYSCALL_WORDSIZE: u32 = 64; |
| pub const _BITS_WCHAR_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 _SYS_TYPES_H: u32 = 1; |
| 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 __FD_SETSIZE: u32 = 1024; |
| pub const __clock_t_defined: u32 = 1; |
| pub const __time_t_defined: u32 = 1; |
| pub const __clockid_t_defined: u32 = 1; |
| pub const __timer_t_defined: u32 = 1; |
| pub const __BIT_TYPES_DEFINED__: u32 = 1; |
| pub const _ENDIAN_H: u32 = 1; |
| pub const __LITTLE_ENDIAN: u32 = 1234; |
| pub const __BIG_ENDIAN: u32 = 4321; |
| pub const __PDP_ENDIAN: u32 = 3412; |
| pub const __BYTE_ORDER: u32 = 1234; |
| pub const __FLOAT_WORD_ORDER: u32 = 1234; |
| pub const LITTLE_ENDIAN: u32 = 1234; |
| pub const BIG_ENDIAN: u32 = 4321; |
| pub const PDP_ENDIAN: u32 = 3412; |
| pub const BYTE_ORDER: u32 = 1234; |
| pub const _BITS_BYTESWAP_H: u32 = 1; |
| pub const _SYS_SELECT_H: u32 = 1; |
| pub const __FD_ZERO_STOS: &'static [u8; 6usize] = b"stosq\0"; |
| pub const _SIGSET_H_types: u32 = 1; |
| pub const __timespec_defined: u32 = 1; |
| pub const _STRUCT_TIMEVAL: u32 = 1; |
| pub const FD_SETSIZE: u32 = 1024; |
| pub const _SYS_SYSMACROS_H: u32 = 1; |
| pub const _BITS_PTHREADTYPES_H: u32 = 1; |
| pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56; |
| pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40; |
| pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4; |
| pub const __SIZEOF_PTHREAD_COND_T: u32 = 48; |
| pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4; |
| pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56; |
| pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8; |
| pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32; |
| pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4; |
| pub const __have_pthread_attr_t: u32 = 1; |
| pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1; |
| pub const __PTHREAD_RWLOCK_INT_FLAGS_SHARED: u32 = 1; |
| pub const _SYS_TIME_H: u32 = 1; |
| pub const _TIME_H: u32 = 1; |
| pub const _BITS_TIME_H: u32 = 1; |
| pub const CLOCK_REALTIME: u32 = 0; |
| pub const CLOCK_MONOTONIC: u32 = 1; |
| pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2; |
| pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3; |
| pub const CLOCK_MONOTONIC_RAW: u32 = 4; |
| pub const CLOCK_REALTIME_COARSE: u32 = 5; |
| pub const CLOCK_MONOTONIC_COARSE: u32 = 6; |
| pub const CLOCK_BOOTTIME: u32 = 7; |
| pub const CLOCK_REALTIME_ALARM: u32 = 8; |
| pub const CLOCK_BOOTTIME_ALARM: u32 = 9; |
| pub const CLOCK_TAI: u32 = 11; |
| pub const TIMER_ABSTIME: u32 = 1; |
| pub const TIME_UTC: u32 = 1; |
| pub const _XLOCALE_H: u32 = 1; |
| pub const _LIBC_LIMITS_H_: u32 = 1; |
| pub const MB_LEN_MAX: u32 = 16; |
| pub const _BITS_POSIX1_LIM_H: u32 = 1; |
| pub const _POSIX_AIO_LISTIO_MAX: u32 = 2; |
| pub const _POSIX_AIO_MAX: u32 = 1; |
| pub const _POSIX_ARG_MAX: u32 = 4096; |
| pub const _POSIX_CHILD_MAX: u32 = 25; |
| pub const _POSIX_DELAYTIMER_MAX: u32 = 32; |
| pub const _POSIX_HOST_NAME_MAX: u32 = 255; |
| pub const _POSIX_LINK_MAX: u32 = 8; |
| pub const _POSIX_LOGIN_NAME_MAX: u32 = 9; |
| pub const _POSIX_MAX_CANON: u32 = 255; |
| pub const _POSIX_MAX_INPUT: u32 = 255; |
| pub const _POSIX_MQ_OPEN_MAX: u32 = 8; |
| pub const _POSIX_MQ_PRIO_MAX: u32 = 32; |
| pub const _POSIX_NAME_MAX: u32 = 14; |
| pub const _POSIX_NGROUPS_MAX: u32 = 8; |
| pub const _POSIX_OPEN_MAX: u32 = 20; |
| pub const _POSIX_PATH_MAX: u32 = 256; |
| pub const _POSIX_PIPE_BUF: u32 = 512; |
| pub const _POSIX_RE_DUP_MAX: u32 = 255; |
| pub const _POSIX_RTSIG_MAX: u32 = 8; |
| pub const _POSIX_SEM_NSEMS_MAX: u32 = 256; |
| pub const _POSIX_SEM_VALUE_MAX: u32 = 32767; |
| pub const _POSIX_SIGQUEUE_MAX: u32 = 32; |
| pub const _POSIX_SSIZE_MAX: u32 = 32767; |
| pub const _POSIX_STREAM_MAX: u32 = 8; |
| pub const _POSIX_SYMLINK_MAX: u32 = 255; |
| pub const _POSIX_SYMLOOP_MAX: u32 = 8; |
| pub const _POSIX_TIMER_MAX: u32 = 32; |
| pub const _POSIX_TTY_NAME_MAX: u32 = 9; |
| pub const _POSIX_TZNAME_MAX: u32 = 6; |
| pub const _POSIX_CLOCKRES_MIN: u32 = 20000000; |
| pub const NR_OPEN: u32 = 1024; |
| pub const NGROUPS_MAX: u32 = 65536; |
| pub const ARG_MAX: u32 = 131072; |
| pub const LINK_MAX: u32 = 127; |
| pub const MAX_CANON: u32 = 255; |
| pub const MAX_INPUT: u32 = 255; |
| pub const NAME_MAX: u32 = 255; |
| pub const PATH_MAX: u32 = 4096; |
| pub const PIPE_BUF: u32 = 4096; |
| pub const XATTR_NAME_MAX: u32 = 255; |
| pub const XATTR_SIZE_MAX: u32 = 65536; |
| pub const XATTR_LIST_MAX: u32 = 65536; |
| pub const RTSIG_MAX: u32 = 32; |
| pub const _POSIX_THREAD_KEYS_MAX: u32 = 128; |
| pub const PTHREAD_KEYS_MAX: u32 = 1024; |
| pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4; |
| pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4; |
| pub const _POSIX_THREAD_THREADS_MAX: u32 = 64; |
| pub const AIO_PRIO_DELTA_MAX: u32 = 20; |
| pub const PTHREAD_STACK_MIN: u32 = 16384; |
| pub const DELAYTIMER_MAX: u32 = 2147483647; |
| pub const TTY_NAME_MAX: u32 = 32; |
| pub const LOGIN_NAME_MAX: u32 = 256; |
| pub const HOST_NAME_MAX: u32 = 64; |
| pub const MQ_PRIO_MAX: u32 = 32768; |
| pub const SEM_VALUE_MAX: u32 = 2147483647; |
| pub const _BITS_POSIX2_LIM_H: u32 = 1; |
| pub const _POSIX2_BC_BASE_MAX: u32 = 99; |
| pub const _POSIX2_BC_DIM_MAX: u32 = 2048; |
| pub const _POSIX2_BC_SCALE_MAX: u32 = 99; |
| pub const _POSIX2_BC_STRING_MAX: u32 = 1000; |
| pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2; |
| pub const _POSIX2_EXPR_NEST_MAX: u32 = 32; |
| pub const _POSIX2_LINE_MAX: u32 = 2048; |
| pub const _POSIX2_RE_DUP_MAX: u32 = 255; |
| pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14; |
| pub const BC_BASE_MAX: u32 = 99; |
| pub const BC_DIM_MAX: u32 = 2048; |
| pub const BC_SCALE_MAX: u32 = 99; |
| pub const BC_STRING_MAX: u32 = 1000; |
| pub const COLL_WEIGHTS_MAX: u32 = 255; |
| pub const EXPR_NEST_MAX: u32 = 32; |
| pub const LINE_MAX: u32 = 2048; |
| pub const CHARCLASS_NAME_MAX: u32 = 2048; |
| pub const RE_DUP_MAX: u32 = 32767; |
| pub const LIBUSB_API_VERSION: u32 = 16777477; |
| pub const LIBUSBX_API_VERSION: u32 = 16777477; |
| pub const LIBUSB_DT_DEVICE_SIZE: u32 = 18; |
| pub const LIBUSB_DT_CONFIG_SIZE: u32 = 9; |
| pub const LIBUSB_DT_INTERFACE_SIZE: u32 = 9; |
| pub const LIBUSB_DT_ENDPOINT_SIZE: u32 = 7; |
| pub const LIBUSB_DT_ENDPOINT_AUDIO_SIZE: u32 = 9; |
| pub const LIBUSB_DT_HUB_NONVAR_SIZE: u32 = 7; |
| pub const LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE: u32 = 6; |
| pub const LIBUSB_DT_BOS_SIZE: u32 = 5; |
| pub const LIBUSB_DT_DEVICE_CAPABILITY_SIZE: u32 = 3; |
| pub const LIBUSB_BT_USB_2_0_EXTENSION_SIZE: u32 = 7; |
| pub const LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE: u32 = 10; |
| pub const LIBUSB_BT_CONTAINER_ID_SIZE: u32 = 20; |
| pub const LIBUSB_DT_BOS_MAX_SIZE: u32 = 42; |
| pub const LIBUSB_ENDPOINT_ADDRESS_MASK: u32 = 15; |
| pub const LIBUSB_ENDPOINT_DIR_MASK: u32 = 128; |
| pub const LIBUSB_TRANSFER_TYPE_MASK: u32 = 3; |
| pub const LIBUSB_ISO_SYNC_TYPE_MASK: u32 = 12; |
| pub const LIBUSB_ISO_USAGE_TYPE_MASK: u32 = 48; |
| pub const LIBUSB_ERROR_COUNT: u32 = 14; |
| pub const LIBUSB_HOTPLUG_MATCH_ANY: i32 = -1; |
| pub type int_least8_t = ::std::os::raw::c_schar; |
| pub type int_least16_t = ::std::os::raw::c_short; |
| pub type int_least32_t = ::std::os::raw::c_int; |
| pub type int_least64_t = ::std::os::raw::c_long; |
| pub type uint_least8_t = ::std::os::raw::c_uchar; |
| pub type uint_least16_t = ::std::os::raw::c_ushort; |
| pub type uint_least32_t = ::std::os::raw::c_uint; |
| pub type uint_least64_t = ::std::os::raw::c_ulong; |
| 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 = ::std::os::raw::c_long; |
| pub type uintmax_t = ::std::os::raw::c_ulong; |
| 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 __quad_t = ::std::os::raw::c_long; |
| pub type __u_quad_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() { |
| 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::null::<__fsid_t>())).__val as *const _ 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 __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 __qaddr_t = *mut __quad_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 u_char = __u_char; |
| pub type u_short = __u_short; |
| pub type u_int = __u_int; |
| pub type u_long = __u_long; |
| pub type quad_t = __quad_t; |
| pub type u_quad_t = __u_quad_t; |
| pub type fsid_t = __fsid_t; |
| pub type loff_t = __loff_t; |
| pub type ino_t = __ino_t; |
| pub type dev_t = __dev_t; |
| pub type gid_t = __gid_t; |
| pub type mode_t = __mode_t; |
| pub type nlink_t = __nlink_t; |
| pub type uid_t = __uid_t; |
| pub type off_t = __off_t; |
| pub type pid_t = __pid_t; |
| pub type id_t = __id_t; |
| pub type daddr_t = __daddr_t; |
| pub type caddr_t = __caddr_t; |
| pub type key_t = __key_t; |
| pub type clock_t = __clock_t; |
| pub type time_t = __time_t; |
| pub type clockid_t = __clockid_t; |
| pub type timer_t = __timer_t; |
| pub type ulong = ::std::os::raw::c_ulong; |
| pub type ushort = ::std::os::raw::c_ushort; |
| pub type uint = ::std::os::raw::c_uint; |
| pub type u_int8_t = ::std::os::raw::c_uchar; |
| pub type u_int16_t = ::std::os::raw::c_ushort; |
| pub type u_int32_t = ::std::os::raw::c_uint; |
| pub type u_int64_t = ::std::os::raw::c_ulong; |
| pub type register_t = ::std::os::raw::c_long; |
| pub type __sig_atomic_t = ::std::os::raw::c_int; |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct __sigset_t { |
| pub __val: [::std::os::raw::c_ulong; 16usize], |
| } |
| #[test] |
| fn bindgen_test_layout___sigset_t() { |
| assert_eq!( |
| ::std::mem::size_of::<__sigset_t>(), |
| 128usize, |
| concat!("Size of: ", stringify!(__sigset_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<__sigset_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(__sigset_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__sigset_t), |
| "::", |
| stringify!(__val) |
| ) |
| ); |
| } |
| pub type sigset_t = __sigset_t; |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct timespec { |
| pub tv_sec: __time_t, |
| pub tv_nsec: __syscall_slong_t, |
| } |
| #[test] |
| fn bindgen_test_layout_timespec() { |
| assert_eq!( |
| ::std::mem::size_of::<timespec>(), |
| 16usize, |
| concat!("Size of: ", stringify!(timespec)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<timespec>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(timespec)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timespec), |
| "::", |
| stringify!(tv_sec) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timespec), |
| "::", |
| stringify!(tv_nsec) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct timeval { |
| pub tv_sec: __time_t, |
| pub tv_usec: __suseconds_t, |
| } |
| #[test] |
| fn bindgen_test_layout_timeval() { |
| assert_eq!( |
| ::std::mem::size_of::<timeval>(), |
| 16usize, |
| concat!("Size of: ", stringify!(timeval)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<timeval>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(timeval)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timeval>())).tv_sec as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timeval), |
| "::", |
| stringify!(tv_sec) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timeval>())).tv_usec as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timeval), |
| "::", |
| stringify!(tv_usec) |
| ) |
| ); |
| } |
| pub type suseconds_t = __suseconds_t; |
| pub type __fd_mask = ::std::os::raw::c_long; |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct fd_set { |
| pub __fds_bits: [__fd_mask; 16usize], |
| } |
| #[test] |
| fn bindgen_test_layout_fd_set() { |
| assert_eq!( |
| ::std::mem::size_of::<fd_set>(), |
| 128usize, |
| concat!("Size of: ", stringify!(fd_set)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<fd_set>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(fd_set)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<fd_set>())).__fds_bits as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(fd_set), |
| "::", |
| stringify!(__fds_bits) |
| ) |
| ); |
| } |
| pub type fd_mask = __fd_mask; |
| extern "C" { |
| pub fn select( |
| __nfds: ::std::os::raw::c_int, |
| __readfds: *mut fd_set, |
| __writefds: *mut fd_set, |
| __exceptfds: *mut fd_set, |
| __timeout: *mut timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn pselect( |
| __nfds: ::std::os::raw::c_int, |
| __readfds: *mut fd_set, |
| __writefds: *mut fd_set, |
| __exceptfds: *mut fd_set, |
| __timeout: *const timespec, |
| __sigmask: *const __sigset_t, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn gnu_dev_major(__dev: ::std::os::raw::c_ulonglong) -> ::std::os::raw::c_uint; |
| } |
| extern "C" { |
| pub fn gnu_dev_minor(__dev: ::std::os::raw::c_ulonglong) -> ::std::os::raw::c_uint; |
| } |
| extern "C" { |
| pub fn gnu_dev_makedev( |
| __major: ::std::os::raw::c_uint, |
| __minor: ::std::os::raw::c_uint, |
| ) -> ::std::os::raw::c_ulonglong; |
| } |
| pub type blksize_t = __blksize_t; |
| pub type blkcnt_t = __blkcnt_t; |
| pub type fsblkcnt_t = __fsblkcnt_t; |
| pub type fsfilcnt_t = __fsfilcnt_t; |
| pub type pthread_t = ::std::os::raw::c_ulong; |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_attr_t { |
| pub __size: [::std::os::raw::c_char; 56usize], |
| pub __align: ::std::os::raw::c_long, |
| _bindgen_union_align: [u64; 7usize], |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_attr_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_attr_t>(), |
| 56usize, |
| concat!("Size of: ", stringify!(pthread_attr_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_attr_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_attr_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_attr_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_attr_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct __pthread_internal_list { |
| pub __prev: *mut __pthread_internal_list, |
| pub __next: *mut __pthread_internal_list, |
| } |
| #[test] |
| fn bindgen_test_layout___pthread_internal_list() { |
| assert_eq!( |
| ::std::mem::size_of::<__pthread_internal_list>(), |
| 16usize, |
| concat!("Size of: ", stringify!(__pthread_internal_list)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<__pthread_internal_list>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(__pthread_internal_list)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__pthread_internal_list), |
| "::", |
| stringify!(__prev) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__pthread_internal_list), |
| "::", |
| stringify!(__next) |
| ) |
| ); |
| } |
| pub type __pthread_list_t = __pthread_internal_list; |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_mutex_t { |
| pub __data: pthread_mutex_t___pthread_mutex_s, |
| pub __size: [::std::os::raw::c_char; 40usize], |
| pub __align: ::std::os::raw::c_long, |
| _bindgen_union_align: [u64; 5usize], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct pthread_mutex_t___pthread_mutex_s { |
| pub __lock: ::std::os::raw::c_int, |
| pub __count: ::std::os::raw::c_uint, |
| pub __owner: ::std::os::raw::c_int, |
| pub __nusers: ::std::os::raw::c_uint, |
| pub __kind: ::std::os::raw::c_int, |
| pub __spins: ::std::os::raw::c_short, |
| pub __elision: ::std::os::raw::c_short, |
| pub __list: __pthread_list_t, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_mutex_t___pthread_mutex_s() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_mutex_t___pthread_mutex_s>(), |
| 40usize, |
| concat!("Size of: ", stringify!(pthread_mutex_t___pthread_mutex_s)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_mutex_t___pthread_mutex_s>(), |
| 8usize, |
| concat!( |
| "Alignment of ", |
| stringify!(pthread_mutex_t___pthread_mutex_s) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__lock as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__lock) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__count as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__count) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__owner as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__owner) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__nusers as *const _ |
| as usize |
| }, |
| 12usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__nusers) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__kind as *const _ |
| as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__kind) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__spins as *const _ |
| as usize |
| }, |
| 20usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__spins) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__elision as *const _ |
| as usize |
| }, |
| 22usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__elision) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_mutex_t___pthread_mutex_s>())).__list as *const _ |
| as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t___pthread_mutex_s), |
| "::", |
| stringify!(__list) |
| ) |
| ); |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_mutex_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_mutex_t>(), |
| 40usize, |
| concat!("Size of: ", stringify!(pthread_mutex_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_mutex_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_mutex_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t), |
| "::", |
| stringify!(__data) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutex_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_mutexattr_t { |
| pub __size: [::std::os::raw::c_char; 4usize], |
| pub __align: ::std::os::raw::c_int, |
| _bindgen_union_align: u32, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_mutexattr_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_mutexattr_t>(), |
| 4usize, |
| concat!("Size of: ", stringify!(pthread_mutexattr_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_mutexattr_t>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(pthread_mutexattr_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutexattr_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_mutexattr_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_cond_t { |
| pub __data: pthread_cond_t__bindgen_ty_1, |
| pub __size: [::std::os::raw::c_char; 48usize], |
| pub __align: ::std::os::raw::c_longlong, |
| _bindgen_union_align: [u64; 6usize], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct pthread_cond_t__bindgen_ty_1 { |
| pub __lock: ::std::os::raw::c_int, |
| pub __futex: ::std::os::raw::c_uint, |
| pub __total_seq: ::std::os::raw::c_ulonglong, |
| pub __wakeup_seq: ::std::os::raw::c_ulonglong, |
| pub __woken_seq: ::std::os::raw::c_ulonglong, |
| pub __mutex: *mut ::std::os::raw::c_void, |
| pub __nwaiters: ::std::os::raw::c_uint, |
| pub __broadcast_seq: ::std::os::raw::c_uint, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_cond_t__bindgen_ty_1() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_cond_t__bindgen_ty_1>(), |
| 48usize, |
| concat!("Size of: ", stringify!(pthread_cond_t__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_cond_t__bindgen_ty_1>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_cond_t__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__lock as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__lock) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__futex as *const _ as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__futex) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__total_seq as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__total_seq) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__wakeup_seq as *const _ |
| as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__wakeup_seq) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__woken_seq as *const _ |
| as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__woken_seq) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__mutex as *const _ as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__mutex) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__nwaiters as *const _ as usize |
| }, |
| 40usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__nwaiters) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_cond_t__bindgen_ty_1>())).__broadcast_seq as *const _ |
| as usize |
| }, |
| 44usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t__bindgen_ty_1), |
| "::", |
| stringify!(__broadcast_seq) |
| ) |
| ); |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_cond_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_cond_t>(), |
| 48usize, |
| concat!("Size of: ", stringify!(pthread_cond_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_cond_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_cond_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t), |
| "::", |
| stringify!(__data) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_cond_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_condattr_t { |
| pub __size: [::std::os::raw::c_char; 4usize], |
| pub __align: ::std::os::raw::c_int, |
| _bindgen_union_align: u32, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_condattr_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_condattr_t>(), |
| 4usize, |
| concat!("Size of: ", stringify!(pthread_condattr_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_condattr_t>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(pthread_condattr_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_condattr_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_condattr_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| pub type pthread_key_t = ::std::os::raw::c_uint; |
| pub type pthread_once_t = ::std::os::raw::c_int; |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_rwlock_t { |
| pub __data: pthread_rwlock_t__bindgen_ty_1, |
| pub __size: [::std::os::raw::c_char; 56usize], |
| pub __align: ::std::os::raw::c_long, |
| _bindgen_union_align: [u64; 7usize], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct pthread_rwlock_t__bindgen_ty_1 { |
| pub __lock: ::std::os::raw::c_int, |
| pub __nr_readers: ::std::os::raw::c_uint, |
| pub __readers_wakeup: ::std::os::raw::c_uint, |
| pub __writer_wakeup: ::std::os::raw::c_uint, |
| pub __nr_readers_queued: ::std::os::raw::c_uint, |
| pub __nr_writers_queued: ::std::os::raw::c_uint, |
| pub __writer: ::std::os::raw::c_int, |
| pub __shared: ::std::os::raw::c_int, |
| pub __rwelision: ::std::os::raw::c_schar, |
| pub __pad1: [::std::os::raw::c_uchar; 7usize], |
| pub __pad2: ::std::os::raw::c_ulong, |
| pub __flags: ::std::os::raw::c_uint, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_rwlock_t__bindgen_ty_1() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_rwlock_t__bindgen_ty_1>(), |
| 56usize, |
| concat!("Size of: ", stringify!(pthread_rwlock_t__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_rwlock_t__bindgen_ty_1>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_rwlock_t__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__lock as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__lock) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__nr_readers as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__nr_readers) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__readers_wakeup as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__readers_wakeup) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__writer_wakeup as *const _ |
| as usize |
| }, |
| 12usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__writer_wakeup) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__nr_readers_queued |
| as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__nr_readers_queued) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__nr_writers_queued |
| as *const _ as usize |
| }, |
| 20usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__nr_writers_queued) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__writer as *const _ as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__writer) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__shared as *const _ as usize |
| }, |
| 28usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__shared) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__rwelision as *const _ |
| as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__rwelision) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__pad1 as *const _ as usize |
| }, |
| 33usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__pad1) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__pad2 as *const _ as usize |
| }, |
| 40usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__pad2) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<pthread_rwlock_t__bindgen_ty_1>())).__flags as *const _ as usize |
| }, |
| 48usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t__bindgen_ty_1), |
| "::", |
| stringify!(__flags) |
| ) |
| ); |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_rwlock_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_rwlock_t>(), |
| 56usize, |
| concat!("Size of: ", stringify!(pthread_rwlock_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_rwlock_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_rwlock_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t), |
| "::", |
| stringify!(__data) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlock_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_rwlockattr_t { |
| pub __size: [::std::os::raw::c_char; 8usize], |
| pub __align: ::std::os::raw::c_long, |
| _bindgen_union_align: u64, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_rwlockattr_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_rwlockattr_t>(), |
| 8usize, |
| concat!("Size of: ", stringify!(pthread_rwlockattr_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_rwlockattr_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_rwlockattr_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlockattr_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_rwlockattr_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| pub type pthread_spinlock_t = ::std::os::raw::c_int; |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_barrier_t { |
| pub __size: [::std::os::raw::c_char; 32usize], |
| pub __align: ::std::os::raw::c_long, |
| _bindgen_union_align: [u64; 4usize], |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_barrier_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_barrier_t>(), |
| 32usize, |
| concat!("Size of: ", stringify!(pthread_barrier_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_barrier_t>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(pthread_barrier_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_barrier_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_barrier_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Copy, Clone)] |
| pub union pthread_barrierattr_t { |
| pub __size: [::std::os::raw::c_char; 4usize], |
| pub __align: ::std::os::raw::c_int, |
| _bindgen_union_align: u32, |
| } |
| #[test] |
| fn bindgen_test_layout_pthread_barrierattr_t() { |
| assert_eq!( |
| ::std::mem::size_of::<pthread_barrierattr_t>(), |
| 4usize, |
| concat!("Size of: ", stringify!(pthread_barrierattr_t)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<pthread_barrierattr_t>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(pthread_barrierattr_t)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_barrierattr_t), |
| "::", |
| stringify!(__size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(pthread_barrierattr_t), |
| "::", |
| stringify!(__align) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct timezone { |
| pub tz_minuteswest: ::std::os::raw::c_int, |
| pub tz_dsttime: ::std::os::raw::c_int, |
| } |
| #[test] |
| fn bindgen_test_layout_timezone() { |
| assert_eq!( |
| ::std::mem::size_of::<timezone>(), |
| 8usize, |
| concat!("Size of: ", stringify!(timezone)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<timezone>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(timezone)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timezone>())).tz_minuteswest as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timezone), |
| "::", |
| stringify!(tz_minuteswest) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<timezone>())).tz_dsttime as *const _ as usize }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(timezone), |
| "::", |
| stringify!(tz_dsttime) |
| ) |
| ); |
| } |
| pub type __timezone_ptr_t = *mut timezone; |
| extern "C" { |
| pub fn gettimeofday(__tv: *mut timeval, __tz: __timezone_ptr_t) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn settimeofday(__tv: *const timeval, __tz: *const timezone) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn adjtime(__delta: *const timeval, __olddelta: *mut timeval) -> ::std::os::raw::c_int; |
| } |
| pub const ITIMER_REAL: __itimer_which = 0; |
| pub const ITIMER_VIRTUAL: __itimer_which = 1; |
| pub const ITIMER_PROF: __itimer_which = 2; |
| pub type __itimer_which = u32; |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct itimerval { |
| pub it_interval: timeval, |
| pub it_value: timeval, |
| } |
| #[test] |
| fn bindgen_test_layout_itimerval() { |
| assert_eq!( |
| ::std::mem::size_of::<itimerval>(), |
| 32usize, |
| concat!("Size of: ", stringify!(itimerval)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<itimerval>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(itimerval)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<itimerval>())).it_interval as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(itimerval), |
| "::", |
| stringify!(it_interval) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<itimerval>())).it_value as *const _ as usize }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(itimerval), |
| "::", |
| stringify!(it_value) |
| ) |
| ); |
| } |
| pub type __itimer_which_t = ::std::os::raw::c_int; |
| extern "C" { |
| pub fn getitimer(__which: __itimer_which_t, __value: *mut itimerval) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn setitimer( |
| __which: __itimer_which_t, |
| __new: *const itimerval, |
| __old: *mut itimerval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn utimes( |
| __file: *const ::std::os::raw::c_char, |
| __tvp: *const timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn lutimes( |
| __file: *const ::std::os::raw::c_char, |
| __tvp: *const timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn futimes(__fd: ::std::os::raw::c_int, __tvp: *const timeval) -> ::std::os::raw::c_int; |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct tm { |
| pub tm_sec: ::std::os::raw::c_int, |
| pub tm_min: ::std::os::raw::c_int, |
| pub tm_hour: ::std::os::raw::c_int, |
| pub tm_mday: ::std::os::raw::c_int, |
| pub tm_mon: ::std::os::raw::c_int, |
| pub tm_year: ::std::os::raw::c_int, |
| pub tm_wday: ::std::os::raw::c_int, |
| pub tm_yday: ::std::os::raw::c_int, |
| pub tm_isdst: ::std::os::raw::c_int, |
| pub tm_gmtoff: ::std::os::raw::c_long, |
| pub tm_zone: *const ::std::os::raw::c_char, |
| } |
| #[test] |
| fn bindgen_test_layout_tm() { |
| assert_eq!( |
| ::std::mem::size_of::<tm>(), |
| 56usize, |
| concat!("Size of: ", stringify!(tm)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<tm>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(tm)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_sec as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_sec) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_min as *const _ as usize }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_min) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_hour as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_hour) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_mday as *const _ as usize }, |
| 12usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_mday) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_mon as *const _ as usize }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_mon) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_year as *const _ as usize }, |
| 20usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_year) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_wday as *const _ as usize }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_wday) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_yday as *const _ as usize }, |
| 28usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_yday) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_isdst as *const _ as usize }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_isdst) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_gmtoff as *const _ as usize }, |
| 40usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_gmtoff) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<tm>())).tm_zone as *const _ as usize }, |
| 48usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(tm), |
| "::", |
| stringify!(tm_zone) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct itimerspec { |
| pub it_interval: timespec, |
| pub it_value: timespec, |
| } |
| #[test] |
| fn bindgen_test_layout_itimerspec() { |
| assert_eq!( |
| ::std::mem::size_of::<itimerspec>(), |
| 32usize, |
| concat!("Size of: ", stringify!(itimerspec)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<itimerspec>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(itimerspec)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<itimerspec>())).it_interval as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(itimerspec), |
| "::", |
| stringify!(it_interval) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<itimerspec>())).it_value as *const _ as usize }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(itimerspec), |
| "::", |
| stringify!(it_value) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct sigevent { |
| _unused: [u8; 0], |
| } |
| extern "C" { |
| pub fn clock() -> clock_t; |
| } |
| extern "C" { |
| pub fn time(__timer: *mut time_t) -> time_t; |
| } |
| extern "C" { |
| pub fn difftime(__time1: time_t, __time0: time_t) -> f64; |
| } |
| extern "C" { |
| pub fn mktime(__tp: *mut tm) -> time_t; |
| } |
| extern "C" { |
| pub fn strftime( |
| __s: *mut ::std::os::raw::c_char, |
| __maxsize: usize, |
| __format: *const ::std::os::raw::c_char, |
| __tp: *const tm, |
| ) -> usize; |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct __locale_struct { |
| pub __locales: [*mut __locale_data; 13usize], |
| pub __ctype_b: *const ::std::os::raw::c_ushort, |
| pub __ctype_tolower: *const ::std::os::raw::c_int, |
| pub __ctype_toupper: *const ::std::os::raw::c_int, |
| pub __names: [*const ::std::os::raw::c_char; 13usize], |
| } |
| #[test] |
| fn bindgen_test_layout___locale_struct() { |
| assert_eq!( |
| ::std::mem::size_of::<__locale_struct>(), |
| 232usize, |
| concat!("Size of: ", stringify!(__locale_struct)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<__locale_struct>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(__locale_struct)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__locale_struct>())).__locales as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__locale_struct), |
| "::", |
| stringify!(__locales) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_b as *const _ as usize }, |
| 104usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__locale_struct), |
| "::", |
| stringify!(__ctype_b) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_tolower as *const _ as usize }, |
| 112usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__locale_struct), |
| "::", |
| stringify!(__ctype_tolower) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_toupper as *const _ as usize }, |
| 120usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__locale_struct), |
| "::", |
| stringify!(__ctype_toupper) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<__locale_struct>())).__names as *const _ as usize }, |
| 128usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(__locale_struct), |
| "::", |
| stringify!(__names) |
| ) |
| ); |
| } |
| pub type __locale_t = *mut __locale_struct; |
| pub type locale_t = __locale_t; |
| extern "C" { |
| pub fn strftime_l( |
| __s: *mut ::std::os::raw::c_char, |
| __maxsize: usize, |
| __format: *const ::std::os::raw::c_char, |
| __tp: *const tm, |
| __loc: __locale_t, |
| ) -> usize; |
| } |
| extern "C" { |
| pub fn gmtime(__timer: *const time_t) -> *mut tm; |
| } |
| extern "C" { |
| pub fn localtime(__timer: *const time_t) -> *mut tm; |
| } |
| extern "C" { |
| pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; |
| } |
| extern "C" { |
| pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; |
| } |
| extern "C" { |
| pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char; |
| } |
| extern "C" { |
| pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char; |
| } |
| extern "C" { |
| pub fn asctime_r( |
| __tp: *const tm, |
| __buf: *mut ::std::os::raw::c_char, |
| ) -> *mut ::std::os::raw::c_char; |
| } |
| extern "C" { |
| pub fn ctime_r( |
| __timer: *const time_t, |
| __buf: *mut ::std::os::raw::c_char, |
| ) -> *mut ::std::os::raw::c_char; |
| } |
| extern "C" { |
| #[link_name = "\u{1}__tzname"] |
| pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize]; |
| } |
| extern "C" { |
| #[link_name = "\u{1}__daylight"] |
| pub static mut __daylight: ::std::os::raw::c_int; |
| } |
| extern "C" { |
| #[link_name = "\u{1}__timezone"] |
| pub static mut __timezone: ::std::os::raw::c_long; |
| } |
| extern "C" { |
| #[link_name = "\u{1}tzname"] |
| pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize]; |
| } |
| extern "C" { |
| pub fn tzset(); |
| } |
| extern "C" { |
| #[link_name = "\u{1}daylight"] |
| pub static mut daylight: ::std::os::raw::c_int; |
| } |
| extern "C" { |
| #[link_name = "\u{1}timezone"] |
| pub static mut timezone: ::std::os::raw::c_long; |
| } |
| extern "C" { |
| pub fn stime(__when: *const time_t) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timegm(__tp: *mut tm) -> time_t; |
| } |
| extern "C" { |
| pub fn timelocal(__tp: *mut tm) -> time_t; |
| } |
| extern "C" { |
| pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn nanosleep( |
| __requested_time: *const timespec, |
| __remaining: *mut timespec, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn clock_nanosleep( |
| __clock_id: clockid_t, |
| __flags: ::std::os::raw::c_int, |
| __req: *const timespec, |
| __rem: *mut timespec, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timer_create( |
| __clock_id: clockid_t, |
| __evp: *mut sigevent, |
| __timerid: *mut timer_t, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timer_settime( |
| __timerid: timer_t, |
| __flags: ::std::os::raw::c_int, |
| __value: *const itimerspec, |
| __ovalue: *mut itimerspec, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn timespec_get( |
| __ts: *mut timespec, |
| __base: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| /// In the context of a \ref libusb_device_descriptor "device descriptor", |
| /// this bDeviceClass value indicates that each interface specifies its |
| /// own class information and all interfaces operate independently. |
| pub const LIBUSB_CLASS_PER_INTERFACE: libusb_class_code = 0; |
| /// Audio class |
| pub const LIBUSB_CLASS_AUDIO: libusb_class_code = 1; |
| /// Communications class |
| pub const LIBUSB_CLASS_COMM: libusb_class_code = 2; |
| /// Human Interface Device class |
| pub const LIBUSB_CLASS_HID: libusb_class_code = 3; |
| /// Physical |
| pub const LIBUSB_CLASS_PHYSICAL: libusb_class_code = 5; |
| /// Printer class |
| pub const LIBUSB_CLASS_PRINTER: libusb_class_code = 7; |
| /// Image class |
| pub const LIBUSB_CLASS_PTP: libusb_class_code = 6; |
| /// Image class |
| pub const LIBUSB_CLASS_IMAGE: libusb_class_code = 6; |
| /// Mass storage class |
| pub const LIBUSB_CLASS_MASS_STORAGE: libusb_class_code = 8; |
| /// Hub class |
| pub const LIBUSB_CLASS_HUB: libusb_class_code = 9; |
| /// Data class |
| pub const LIBUSB_CLASS_DATA: libusb_class_code = 10; |
| /// Smart Card |
| pub const LIBUSB_CLASS_SMART_CARD: libusb_class_code = 11; |
| /// Content Security |
| pub const LIBUSB_CLASS_CONTENT_SECURITY: libusb_class_code = 13; |
| /// Video |
| pub const LIBUSB_CLASS_VIDEO: libusb_class_code = 14; |
| /// Personal Healthcare |
| pub const LIBUSB_CLASS_PERSONAL_HEALTHCARE: libusb_class_code = 15; |
| /// Diagnostic Device |
| pub const LIBUSB_CLASS_DIAGNOSTIC_DEVICE: libusb_class_code = 220; |
| /// Wireless class |
| pub const LIBUSB_CLASS_WIRELESS: libusb_class_code = 224; |
| /// Application class |
| pub const LIBUSB_CLASS_APPLICATION: libusb_class_code = 254; |
| /// Class is vendor-specific |
| pub const LIBUSB_CLASS_VENDOR_SPEC: libusb_class_code = 255; |
| /// \ingroup libusb_desc |
| /// Device and/or Interface Class codes |
| pub type libusb_class_code = u32; |
| /// Device descriptor. See libusb_device_descriptor. |
| pub const LIBUSB_DT_DEVICE: libusb_descriptor_type = 1; |
| /// Configuration descriptor. See libusb_config_descriptor. |
| pub const LIBUSB_DT_CONFIG: libusb_descriptor_type = 2; |
| /// String descriptor |
| pub const LIBUSB_DT_STRING: libusb_descriptor_type = 3; |
| /// Interface descriptor. See libusb_interface_descriptor. |
| pub const LIBUSB_DT_INTERFACE: libusb_descriptor_type = 4; |
| /// Endpoint descriptor. See libusb_endpoint_descriptor. |
| pub const LIBUSB_DT_ENDPOINT: libusb_descriptor_type = 5; |
| /// BOS descriptor |
| pub const LIBUSB_DT_BOS: libusb_descriptor_type = 15; |
| /// Device Capability descriptor |
| pub const LIBUSB_DT_DEVICE_CAPABILITY: libusb_descriptor_type = 16; |
| /// HID descriptor |
| pub const LIBUSB_DT_HID: libusb_descriptor_type = 33; |
| /// HID report descriptor |
| pub const LIBUSB_DT_REPORT: libusb_descriptor_type = 34; |
| /// Physical descriptor |
| pub const LIBUSB_DT_PHYSICAL: libusb_descriptor_type = 35; |
| /// Hub descriptor |
| pub const LIBUSB_DT_HUB: libusb_descriptor_type = 41; |
| /// SuperSpeed Hub descriptor |
| pub const LIBUSB_DT_SUPERSPEED_HUB: libusb_descriptor_type = 42; |
| /// SuperSpeed Endpoint Companion descriptor |
| pub const LIBUSB_DT_SS_ENDPOINT_COMPANION: libusb_descriptor_type = 48; |
| /// \ingroup libusb_desc |
| /// Descriptor types as defined by the USB specification. |
| pub type libusb_descriptor_type = u32; |
| /// In: device-to-host |
| pub const LIBUSB_ENDPOINT_IN: libusb_endpoint_direction = 128; |
| /// Out: host-to-device |
| pub const LIBUSB_ENDPOINT_OUT: libusb_endpoint_direction = 0; |
| /// \ingroup libusb_desc |
| /// Endpoint direction. Values for bit 7 of the |
| /// \ref libusb_endpoint_descriptor::bEndpointAddress "endpoint address" scheme. |
| pub type libusb_endpoint_direction = u32; |
| /// Control endpoint |
| pub const LIBUSB_TRANSFER_TYPE_CONTROL: libusb_transfer_type = 0; |
| /// Isochronous endpoint |
| pub const LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: libusb_transfer_type = 1; |
| /// Bulk endpoint |
| pub const LIBUSB_TRANSFER_TYPE_BULK: libusb_transfer_type = 2; |
| /// Interrupt endpoint |
| pub const LIBUSB_TRANSFER_TYPE_INTERRUPT: libusb_transfer_type = 3; |
| /// Stream endpoint |
| pub const LIBUSB_TRANSFER_TYPE_BULK_STREAM: libusb_transfer_type = 4; |
| /// \ingroup libusb_desc |
| /// Endpoint transfer type. Values for bits 0:1 of the |
| /// \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field. |
| pub type libusb_transfer_type = u32; |
| /// Request status of the specific recipient |
| pub const LIBUSB_REQUEST_GET_STATUS: libusb_standard_request = 0; |
| /// Clear or disable a specific feature |
| pub const LIBUSB_REQUEST_CLEAR_FEATURE: libusb_standard_request = 1; |
| /// Set or enable a specific feature |
| pub const LIBUSB_REQUEST_SET_FEATURE: libusb_standard_request = 3; |
| /// Set device address for all future accesses |
| pub const LIBUSB_REQUEST_SET_ADDRESS: libusb_standard_request = 5; |
| /// Get the specified descriptor |
| pub const LIBUSB_REQUEST_GET_DESCRIPTOR: libusb_standard_request = 6; |
| /// Used to update existing descriptors or add new descriptors |
| pub const LIBUSB_REQUEST_SET_DESCRIPTOR: libusb_standard_request = 7; |
| /// Get the current device configuration value |
| pub const LIBUSB_REQUEST_GET_CONFIGURATION: libusb_standard_request = 8; |
| /// Set device configuration |
| pub const LIBUSB_REQUEST_SET_CONFIGURATION: libusb_standard_request = 9; |
| /// Return the selected alternate setting for the specified interface |
| pub const LIBUSB_REQUEST_GET_INTERFACE: libusb_standard_request = 10; |
| /// Select an alternate interface for the specified interface |
| pub const LIBUSB_REQUEST_SET_INTERFACE: libusb_standard_request = 11; |
| /// Set then report an endpoint's synchronization frame |
| pub const LIBUSB_REQUEST_SYNCH_FRAME: libusb_standard_request = 12; |
| /// Sets both the U1 and U2 Exit Latency |
| pub const LIBUSB_REQUEST_SET_SEL: libusb_standard_request = 48; |
| /// Delay from the time a host transmits a packet to the time it is |
| /// received by the device. |
| pub const LIBUSB_SET_ISOCH_DELAY: libusb_standard_request = 49; |
| /// \ingroup libusb_misc |
| /// Standard requests, as defined in table 9-5 of the USB 3.0 specifications |
| pub type libusb_standard_request = u32; |
| /// Standard |
| pub const LIBUSB_REQUEST_TYPE_STANDARD: libusb_request_type = 0; |
| /// Class |
| pub const LIBUSB_REQUEST_TYPE_CLASS: libusb_request_type = 32; |
| /// Vendor |
| pub const LIBUSB_REQUEST_TYPE_VENDOR: libusb_request_type = 64; |
| /// Reserved |
| pub const LIBUSB_REQUEST_TYPE_RESERVED: libusb_request_type = 96; |
| /// \ingroup libusb_misc |
| /// Request type bits of the |
| /// \ref libusb_control_setup::bmRequestType "bmRequestType" field in control |
| /// transfers. |
| pub type libusb_request_type = u32; |
| /// Device |
| pub const LIBUSB_RECIPIENT_DEVICE: libusb_request_recipient = 0; |
| /// Interface |
| pub const LIBUSB_RECIPIENT_INTERFACE: libusb_request_recipient = 1; |
| /// Endpoint |
| pub const LIBUSB_RECIPIENT_ENDPOINT: libusb_request_recipient = 2; |
| /// Other |
| pub const LIBUSB_RECIPIENT_OTHER: libusb_request_recipient = 3; |
| /// \ingroup libusb_misc |
| /// Recipient bits of the |
| /// \ref libusb_control_setup::bmRequestType "bmRequestType" field in control |
| /// transfers. Values 4 through 31 are reserved. |
| pub type libusb_request_recipient = u32; |
| /// No synchronization |
| pub const LIBUSB_ISO_SYNC_TYPE_NONE: libusb_iso_sync_type = 0; |
| /// Asynchronous |
| pub const LIBUSB_ISO_SYNC_TYPE_ASYNC: libusb_iso_sync_type = 1; |
| /// Adaptive |
| pub const LIBUSB_ISO_SYNC_TYPE_ADAPTIVE: libusb_iso_sync_type = 2; |
| /// Synchronous |
| pub const LIBUSB_ISO_SYNC_TYPE_SYNC: libusb_iso_sync_type = 3; |
| /// \ingroup libusb_desc |
| /// Synchronization type for isochronous endpoints. Values for bits 2:3 of the |
| /// \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in |
| /// libusb_endpoint_descriptor. |
| pub type libusb_iso_sync_type = u32; |
| /// Data endpoint |
| pub const LIBUSB_ISO_USAGE_TYPE_DATA: libusb_iso_usage_type = 0; |
| /// Feedback endpoint |
| pub const LIBUSB_ISO_USAGE_TYPE_FEEDBACK: libusb_iso_usage_type = 1; |
| /// Implicit feedback Data endpoint |
| pub const LIBUSB_ISO_USAGE_TYPE_IMPLICIT: libusb_iso_usage_type = 2; |
| /// \ingroup libusb_desc |
| /// Usage type for isochronous endpoints. Values for bits 4:5 of the |
| /// \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in |
| /// libusb_endpoint_descriptor. |
| pub type libusb_iso_usage_type = u32; |
| /// \ingroup libusb_desc |
| /// A structure representing the standard USB device descriptor. This |
| /// descriptor is documented in section 9.6.1 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_device_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_DEVICE LIBUSB_DT_DEVICE in this |
| /// context. |
| pub bDescriptorType: u8, |
| /// USB specification release number in binary-coded decimal. A value of |
| /// 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1, etc. |
| pub bcdUSB: u16, |
| /// USB-IF class code for the device. See \ref libusb_class_code. |
| pub bDeviceClass: u8, |
| /// USB-IF subclass code for the device, qualified by the bDeviceClass |
| /// value |
| pub bDeviceSubClass: u8, |
| /// USB-IF protocol code for the device, qualified by the bDeviceClass and |
| /// bDeviceSubClass values |
| pub bDeviceProtocol: u8, |
| /// Maximum packet size for endpoint 0 |
| pub bMaxPacketSize0: u8, |
| /// USB-IF vendor ID |
| pub idVendor: u16, |
| /// USB-IF product ID |
| pub idProduct: u16, |
| /// Device release number in binary-coded decimal |
| pub bcdDevice: u16, |
| /// Index of string descriptor describing manufacturer |
| pub iManufacturer: u8, |
| /// Index of string descriptor describing product |
| pub iProduct: u8, |
| /// Index of string descriptor containing device serial number |
| pub iSerialNumber: u8, |
| /// Number of possible configurations |
| pub bNumConfigurations: u8, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_device_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_device_descriptor>(), |
| 18usize, |
| concat!("Size of: ", stringify!(libusb_device_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_device_descriptor>(), |
| 2usize, |
| concat!("Alignment of ", stringify!(libusb_device_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bLength as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bDescriptorType as *const _ |
| as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_device_descriptor>())).bcdUSB as *const _ as usize }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bcdUSB) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bDeviceClass as *const _ as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bDeviceClass) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bDeviceSubClass as *const _ |
| as usize |
| }, |
| 5usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bDeviceSubClass) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bDeviceProtocol as *const _ |
| as usize |
| }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bDeviceProtocol) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bMaxPacketSize0 as *const _ |
| as usize |
| }, |
| 7usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bMaxPacketSize0) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).idVendor as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(idVendor) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).idProduct as *const _ as usize |
| }, |
| 10usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(idProduct) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bcdDevice as *const _ as usize |
| }, |
| 12usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bcdDevice) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).iManufacturer as *const _ as usize |
| }, |
| 14usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(iManufacturer) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).iProduct as *const _ as usize |
| }, |
| 15usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(iProduct) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).iSerialNumber as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(iSerialNumber) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_device_descriptor>())).bNumConfigurations as *const _ |
| as usize |
| }, |
| 17usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_device_descriptor), |
| "::", |
| stringify!(bNumConfigurations) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the standard USB endpoint descriptor. This |
| /// descriptor is documented in section 9.6.6 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_endpoint_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_ENDPOINT LIBUSB_DT_ENDPOINT in |
| /// this context. |
| pub bDescriptorType: u8, |
| /// The address of the endpoint described by this descriptor. Bits 0:3 are |
| /// the endpoint number. Bits 4:6 are reserved. Bit 7 indicates direction, |
| /// see \ref libusb_endpoint_direction. |
| pub bEndpointAddress: u8, |
| /// Attributes which apply to the endpoint when it is configured using |
| /// the bConfigurationValue. Bits 0:1 determine the transfer type and |
| /// correspond to \ref libusb_transfer_type. Bits 2:3 are only used for |
| /// isochronous endpoints and correspond to \ref libusb_iso_sync_type. |
| /// Bits 4:5 are also only used for isochronous endpoints and correspond to |
| /// \ref libusb_iso_usage_type. Bits 6:7 are reserved. |
| pub bmAttributes: u8, |
| /// Maximum packet size this endpoint is capable of sending/receiving. |
| pub wMaxPacketSize: u16, |
| /// Interval for polling endpoint for data transfers. |
| pub bInterval: u8, |
| /// For audio devices only: the rate at which synchronization feedback |
| /// is provided. |
| pub bRefresh: u8, |
| /// For audio devices only: the address if the synch endpoint |
| pub bSynchAddress: u8, |
| /// Extra descriptors. If libusb encounters unknown endpoint descriptors, |
| /// it will store them here, should you wish to parse them. |
| pub extra: *const ::std::os::raw::c_uchar, |
| /// Length of the extra descriptors, in bytes. |
| pub extra_length: ::std::os::raw::c_int, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_endpoint_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_endpoint_descriptor>(), |
| 32usize, |
| concat!("Size of: ", stringify!(libusb_endpoint_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_endpoint_descriptor>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_endpoint_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bLength as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bDescriptorType as *const _ |
| as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bEndpointAddress as *const _ |
| as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bEndpointAddress) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bmAttributes as *const _ as usize |
| }, |
| 3usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bmAttributes) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).wMaxPacketSize as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(wMaxPacketSize) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bInterval as *const _ as usize |
| }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bInterval) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bRefresh as *const _ as usize |
| }, |
| 7usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bRefresh) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).bSynchAddress as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(bSynchAddress) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).extra as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(extra) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_endpoint_descriptor>())).extra_length as *const _ as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_endpoint_descriptor), |
| "::", |
| stringify!(extra_length) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the standard USB interface descriptor. This |
| /// descriptor is documented in section 9.6.5 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_interface_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE LIBUSB_DT_INTERFACE |
| /// in this context. |
| pub bDescriptorType: u8, |
| /// Number of this interface |
| pub bInterfaceNumber: u8, |
| /// Value used to select this alternate setting for this interface |
| pub bAlternateSetting: u8, |
| /// Number of endpoints used by this interface (excluding the control |
| /// endpoint). |
| pub bNumEndpoints: u8, |
| /// USB-IF class code for this interface. See \ref libusb_class_code. |
| pub bInterfaceClass: u8, |
| /// USB-IF subclass code for this interface, qualified by the |
| /// bInterfaceClass value |
| pub bInterfaceSubClass: u8, |
| /// USB-IF protocol code for this interface, qualified by the |
| /// bInterfaceClass and bInterfaceSubClass values |
| pub bInterfaceProtocol: u8, |
| /// Index of string descriptor describing this interface |
| pub iInterface: u8, |
| /// Array of endpoint descriptors. This length of this array is determined |
| /// by the bNumEndpoints field. |
| pub endpoint: *const libusb_endpoint_descriptor, |
| /// Extra descriptors. If libusb encounters unknown interface descriptors, |
| /// it will store them here, should you wish to parse them. |
| pub extra: *const ::std::os::raw::c_uchar, |
| /// Length of the extra descriptors, in bytes. |
| pub extra_length: ::std::os::raw::c_int, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_interface_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_interface_descriptor>(), |
| 40usize, |
| concat!("Size of: ", stringify!(libusb_interface_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_interface_descriptor>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_interface_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bLength as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bDescriptorType as *const _ |
| as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bInterfaceNumber as *const _ |
| as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bInterfaceNumber) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bAlternateSetting as *const _ |
| as usize |
| }, |
| 3usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bAlternateSetting) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bNumEndpoints as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bNumEndpoints) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bInterfaceClass as *const _ |
| as usize |
| }, |
| 5usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bInterfaceClass) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bInterfaceSubClass as *const _ |
| as usize |
| }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bInterfaceSubClass) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).bInterfaceProtocol as *const _ |
| as usize |
| }, |
| 7usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(bInterfaceProtocol) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).iInterface as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(iInterface) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).endpoint as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(endpoint) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).extra as *const _ as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(extra) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_interface_descriptor>())).extra_length as *const _ |
| as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface_descriptor), |
| "::", |
| stringify!(extra_length) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A collection of alternate settings for a particular USB interface. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_interface { |
| /// Array of interface descriptors. The length of this array is determined |
| /// by the num_altsetting field. |
| pub altsetting: *const libusb_interface_descriptor, |
| /// The number of alternate settings that belong to this interface |
| pub num_altsetting: ::std::os::raw::c_int, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_interface() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_interface>(), |
| 16usize, |
| concat!("Size of: ", stringify!(libusb_interface)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_interface>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_interface)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_interface>())).altsetting as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface), |
| "::", |
| stringify!(altsetting) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_interface>())).num_altsetting as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_interface), |
| "::", |
| stringify!(num_altsetting) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the standard USB configuration descriptor. This |
| /// descriptor is documented in section 9.6.3 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_config_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_CONFIG LIBUSB_DT_CONFIG |
| /// in this context. |
| pub bDescriptorType: u8, |
| /// Total length of data returned for this configuration |
| pub wTotalLength: u16, |
| /// Number of interfaces supported by this configuration |
| pub bNumInterfaces: u8, |
| /// Identifier value for this configuration |
| pub bConfigurationValue: u8, |
| /// Index of string descriptor describing this configuration |
| pub iConfiguration: u8, |
| /// Configuration characteristics |
| pub bmAttributes: u8, |
| /// Maximum power consumption of the USB device from this bus in this |
| /// configuration when the device is fully operation. Expressed in units |
| /// of 2 mA when the device is operating in high-speed mode and in units |
| /// of 8 mA when the device is operating in super-speed mode. |
| pub MaxPower: u8, |
| /// Array of interfaces supported by this configuration. The length of |
| /// this array is determined by the bNumInterfaces field. |
| pub interface: *const libusb_interface, |
| /// Extra descriptors. If libusb encounters unknown configuration |
| /// descriptors, it will store them here, should you wish to parse them. |
| pub extra: *const ::std::os::raw::c_uchar, |
| /// Length of the extra descriptors, in bytes. |
| pub extra_length: ::std::os::raw::c_int, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_config_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_config_descriptor>(), |
| 40usize, |
| concat!("Size of: ", stringify!(libusb_config_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_config_descriptor>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_config_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).bLength as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).bDescriptorType as *const _ |
| as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).wTotalLength as *const _ as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(wTotalLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).bNumInterfaces as *const _ as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(bNumInterfaces) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).bConfigurationValue as *const _ |
| as usize |
| }, |
| 5usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(bConfigurationValue) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).iConfiguration as *const _ as usize |
| }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(iConfiguration) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).bmAttributes as *const _ as usize |
| }, |
| 7usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(bmAttributes) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).MaxPower as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(MaxPower) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).interface as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(interface) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_config_descriptor>())).extra as *const _ as usize }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(extra) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_config_descriptor>())).extra_length as *const _ as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_config_descriptor), |
| "::", |
| stringify!(extra_length) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the superspeed endpoint companion |
| /// descriptor. This descriptor is documented in section 9.6.7 of |
| /// the USB 3.0 specification. All multiple-byte fields are represented in |
| /// host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_ss_endpoint_companion_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_SS_ENDPOINT_COMPANION in |
| /// this context. |
| pub bDescriptorType: u8, |
| /// The maximum number of packets the endpoint can send or |
| /// receive as part of a burst. |
| pub bMaxBurst: u8, |
| /// In bulk EP: bits 4:0 represents the maximum number of |
| /// streams the EP supports. In isochronous EP: bits 1:0 |
| /// represents the Mult - a zero based value that determines |
| /// the maximum number of packets within a service interval |
| pub bmAttributes: u8, |
| /// The total number of bytes this EP will transfer every |
| /// service interval. valid only for periodic EPs. |
| pub wBytesPerInterval: u16, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_ss_endpoint_companion_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_ss_endpoint_companion_descriptor>(), |
| 6usize, |
| concat!( |
| "Size of: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor) |
| ) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_ss_endpoint_companion_descriptor>(), |
| 2usize, |
| concat!( |
| "Alignment of ", |
| stringify!(libusb_ss_endpoint_companion_descriptor) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_endpoint_companion_descriptor>())).bLength as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_endpoint_companion_descriptor>())).bDescriptorType |
| as *const _ as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_endpoint_companion_descriptor>())).bMaxBurst |
| as *const _ as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor), |
| "::", |
| stringify!(bMaxBurst) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_endpoint_companion_descriptor>())).bmAttributes |
| as *const _ as usize |
| }, |
| 3usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor), |
| "::", |
| stringify!(bmAttributes) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_endpoint_companion_descriptor>())).wBytesPerInterval |
| as *const _ as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_endpoint_companion_descriptor), |
| "::", |
| stringify!(wBytesPerInterval) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A generic representation of a BOS Device Capability descriptor. It is |
| /// advised to check bDevCapabilityType and call the matching |
| /// libusb_get_*_descriptor function to get a structure fully matching the type. |
| #[repr(C)] |
| #[derive(Debug)] |
| pub struct libusb_bos_dev_capability_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY |
| /// LIBUSB_DT_DEVICE_CAPABILITY in this context. |
| pub bDescriptorType: u8, |
| /// Device Capability type |
| pub bDevCapabilityType: u8, |
| /// Device Capability data (bLength - 3 bytes) |
| pub dev_capability_data: __IncompleteArrayField<u8>, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_bos_dev_capability_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_bos_dev_capability_descriptor>(), |
| 3usize, |
| concat!( |
| "Size of: ", |
| stringify!(libusb_bos_dev_capability_descriptor) |
| ) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_bos_dev_capability_descriptor>(), |
| 1usize, |
| concat!( |
| "Alignment of ", |
| stringify!(libusb_bos_dev_capability_descriptor) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the Binary Device Object Store (BOS) descriptor. |
| /// This descriptor is documented in section 9.6.2 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug)] |
| pub struct libusb_bos_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_BOS LIBUSB_DT_BOS |
| /// in this context. |
| pub bDescriptorType: u8, |
| /// Length of this descriptor and all of its sub descriptors |
| pub wTotalLength: u16, |
| /// The number of separate device capability descriptors in |
| /// the BOS |
| pub bNumDeviceCaps: u8, |
| /// bNumDeviceCap Device Capability Descriptors |
| pub dev_capability: __IncompleteArrayField<*mut libusb_bos_dev_capability_descriptor>, |
| pub __bindgen_align: [u64; 0usize], |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_bos_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_bos_descriptor>(), |
| 8usize, |
| concat!("Size of: ", stringify!(libusb_bos_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_bos_descriptor>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_bos_descriptor)) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the USB 2.0 Extension descriptor |
| /// This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_usb_2_0_extension_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY |
| /// LIBUSB_DT_DEVICE_CAPABILITY in this context. |
| pub bDescriptorType: u8, |
| /// Capability type. Will have value |
| /// \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION |
| /// LIBUSB_BT_USB_2_0_EXTENSION in this context. |
| pub bDevCapabilityType: u8, |
| /// Bitmap encoding of supported device level features. |
| /// A value of one in a bit location indicates a feature is |
| /// supported; a value of zero indicates it is not supported. |
| /// See \ref libusb_usb_2_0_extension_attributes. |
| pub bmAttributes: u32, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_usb_2_0_extension_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_usb_2_0_extension_descriptor>(), |
| 8usize, |
| concat!("Size of: ", stringify!(libusb_usb_2_0_extension_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_usb_2_0_extension_descriptor>(), |
| 4usize, |
| concat!( |
| "Alignment of ", |
| stringify!(libusb_usb_2_0_extension_descriptor) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_usb_2_0_extension_descriptor>())).bLength as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_usb_2_0_extension_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_usb_2_0_extension_descriptor>())).bDescriptorType |
| as *const _ as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_usb_2_0_extension_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_usb_2_0_extension_descriptor>())).bDevCapabilityType |
| as *const _ as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_usb_2_0_extension_descriptor), |
| "::", |
| stringify!(bDevCapabilityType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_usb_2_0_extension_descriptor>())).bmAttributes as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_usb_2_0_extension_descriptor), |
| "::", |
| stringify!(bmAttributes) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the SuperSpeed USB Device Capability descriptor |
| /// This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification. |
| /// All multiple-byte fields are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_ss_usb_device_capability_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY |
| /// LIBUSB_DT_DEVICE_CAPABILITY in this context. |
| pub bDescriptorType: u8, |
| /// Capability type. Will have value |
| /// \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY |
| /// LIBUSB_BT_SS_USB_DEVICE_CAPABILITY in this context. |
| pub bDevCapabilityType: u8, |
| /// Bitmap encoding of supported device level features. |
| /// A value of one in a bit location indicates a feature is |
| /// supported; a value of zero indicates it is not supported. |
| /// See \ref libusb_ss_usb_device_capability_attributes. |
| pub bmAttributes: u8, |
| /// Bitmap encoding of the speed supported by this device when |
| /// operating in SuperSpeed mode. See \ref libusb_supported_speed. |
| pub wSpeedSupported: u16, |
| /// The lowest speed at which all the functionality supported |
| /// by the device is available to the user. For example if the |
| /// device supports all its functionality when connected at |
| /// full speed and above then it sets this value to 1. |
| pub bFunctionalitySupport: u8, |
| /// U1 Device Exit Latency. |
| pub bU1DevExitLat: u8, |
| /// U2 Device Exit Latency. |
| pub bU2DevExitLat: u16, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_ss_usb_device_capability_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_ss_usb_device_capability_descriptor>(), |
| 10usize, |
| concat!( |
| "Size of: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor) |
| ) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_ss_usb_device_capability_descriptor>(), |
| 2usize, |
| concat!( |
| "Alignment of ", |
| stringify!(libusb_ss_usb_device_capability_descriptor) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).bLength |
| as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).bDescriptorType |
| as *const _ as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())) |
| .bDevCapabilityType as *const _ as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bDevCapabilityType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).bmAttributes |
| as *const _ as usize |
| }, |
| 3usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bmAttributes) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).wSpeedSupported |
| as *const _ as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(wSpeedSupported) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())) |
| .bFunctionalitySupport as *const _ as usize |
| }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bFunctionalitySupport) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).bU1DevExitLat |
| as *const _ as usize |
| }, |
| 7usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bU1DevExitLat) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_ss_usb_device_capability_descriptor>())).bU2DevExitLat |
| as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_ss_usb_device_capability_descriptor), |
| "::", |
| stringify!(bU2DevExitLat) |
| ) |
| ); |
| } |
| /// \ingroup libusb_desc |
| /// A structure representing the Container ID descriptor. |
| /// This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification. |
| /// All multiple-byte fields, except UUIDs, are represented in host-endian format. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_container_id_descriptor { |
| /// Size of this descriptor (in bytes) |
| pub bLength: u8, |
| /// Descriptor type. Will have value |
| /// \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY |
| /// LIBUSB_DT_DEVICE_CAPABILITY in this context. |
| pub bDescriptorType: u8, |
| /// Capability type. Will have value |
| /// \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID |
| /// LIBUSB_BT_CONTAINER_ID in this context. |
| pub bDevCapabilityType: u8, |
| /// Reserved field |
| pub bReserved: u8, |
| /// 128 bit UUID |
| pub ContainerID: [u8; 16usize], |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_container_id_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_container_id_descriptor>(), |
| 20usize, |
| concat!("Size of: ", stringify!(libusb_container_id_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_container_id_descriptor>(), |
| 1usize, |
| concat!("Alignment of ", stringify!(libusb_container_id_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_container_id_descriptor>())).bLength as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_container_id_descriptor), |
| "::", |
| stringify!(bLength) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_container_id_descriptor>())).bDescriptorType as *const _ |
| as usize |
| }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_container_id_descriptor), |
| "::", |
| stringify!(bDescriptorType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_container_id_descriptor>())).bDevCapabilityType |
| as *const _ as usize |
| }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_container_id_descriptor), |
| "::", |
| stringify!(bDevCapabilityType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_container_id_descriptor>())).bReserved as *const _ |
| as usize |
| }, |
| 3usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_container_id_descriptor), |
| "::", |
| stringify!(bReserved) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_container_id_descriptor>())).ContainerID as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_container_id_descriptor), |
| "::", |
| stringify!(ContainerID) |
| ) |
| ); |
| } |
| /// \ingroup libusb_asyncio |
| /// Setup packet for control transfers. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_control_setup { |
| /// Request type. Bits 0:4 determine recipient, see |
| /// \ref libusb_request_recipient. Bits 5:6 determine type, see |
| /// \ref libusb_request_type. Bit 7 determines data transfer direction, see |
| /// \ref libusb_endpoint_direction. |
| pub bmRequestType: u8, |
| /// Request. If the type bits of bmRequestType are equal to |
| /// \ref libusb_request_type::LIBUSB_REQUEST_TYPE_STANDARD |
| /// "LIBUSB_REQUEST_TYPE_STANDARD" then this field refers to |
| /// \ref libusb_standard_request. For other cases, use of this field is |
| /// application-specific. |
| pub bRequest: u8, |
| /// Value. Varies according to request |
| pub wValue: u16, |
| /// Index. Varies according to request, typically used to pass an index |
| /// or offset |
| pub wIndex: u16, |
| /// Number of bytes to transfer |
| pub wLength: u16, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_control_setup() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_control_setup>(), |
| 8usize, |
| concat!("Size of: ", stringify!(libusb_control_setup)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_control_setup>(), |
| 2usize, |
| concat!("Alignment of ", stringify!(libusb_control_setup)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_control_setup>())).bmRequestType as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_control_setup), |
| "::", |
| stringify!(bmRequestType) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_control_setup>())).bRequest as *const _ as usize }, |
| 1usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_control_setup), |
| "::", |
| stringify!(bRequest) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_control_setup>())).wValue as *const _ as usize }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_control_setup), |
| "::", |
| stringify!(wValue) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_control_setup>())).wIndex as *const _ as usize }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_control_setup), |
| "::", |
| stringify!(wIndex) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_control_setup>())).wLength as *const _ as usize }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_control_setup), |
| "::", |
| stringify!(wLength) |
| ) |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_context { |
| _unused: [u8; 0], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_device { |
| _unused: [u8; 0], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_device_handle { |
| _unused: [u8; 0], |
| } |
| /// \ingroup libusb_lib |
| /// Structure providing the version of the libusb runtime |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_version { |
| /// Library major version. |
| pub major: u16, |
| /// Library minor version. |
| pub minor: u16, |
| /// Library micro version. |
| pub micro: u16, |
| /// Library nano version. |
| pub nano: u16, |
| /// Library release candidate suffix string, e.g. "-rc4". |
| pub rc: *const ::std::os::raw::c_char, |
| /// For ABI compatibility only. |
| pub describe: *const ::std::os::raw::c_char, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_version() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_version>(), |
| 24usize, |
| concat!("Size of: ", stringify!(libusb_version)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_version>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_version)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).major as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(major) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).minor as *const _ as usize }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(minor) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).micro as *const _ as usize }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(micro) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).nano as *const _ as usize }, |
| 6usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(nano) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).rc as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(rc) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_version>())).describe as *const _ as usize }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_version), |
| "::", |
| stringify!(describe) |
| ) |
| ); |
| } |
| /// The OS doesn't report or know the device speed. |
| pub const LIBUSB_SPEED_UNKNOWN: libusb_speed = 0; |
| /// The device is operating at low speed (1.5MBit/s). |
| pub const LIBUSB_SPEED_LOW: libusb_speed = 1; |
| /// The device is operating at full speed (12MBit/s). |
| pub const LIBUSB_SPEED_FULL: libusb_speed = 2; |
| /// The device is operating at high speed (480MBit/s). |
| pub const LIBUSB_SPEED_HIGH: libusb_speed = 3; |
| /// The device is operating at super speed (5000MBit/s). |
| pub const LIBUSB_SPEED_SUPER: libusb_speed = 4; |
| /// \ingroup libusb_dev |
| /// Speed codes. Indicates the speed at which the device is operating. |
| pub type libusb_speed = u32; |
| /// Low speed operation supported (1.5MBit/s). |
| pub const LIBUSB_LOW_SPEED_OPERATION: libusb_supported_speed = 1; |
| /// Full speed operation supported (12MBit/s). |
| pub const LIBUSB_FULL_SPEED_OPERATION: libusb_supported_speed = 2; |
| /// High speed operation supported (480MBit/s). |
| pub const LIBUSB_HIGH_SPEED_OPERATION: libusb_supported_speed = 4; |
| /// Superspeed operation supported (5000MBit/s). |
| pub const LIBUSB_SUPER_SPEED_OPERATION: libusb_supported_speed = 8; |
| /// \ingroup libusb_dev |
| /// Supported speeds (wSpeedSupported) bitfield. Indicates what |
| /// speeds the device supports. |
| pub type libusb_supported_speed = u32; |
| /// Supports Link Power Management (LPM) |
| pub const LIBUSB_BM_LPM_SUPPORT: libusb_usb_2_0_extension_attributes = 2; |
| /// \ingroup libusb_dev |
| /// Masks for the bits of the |
| /// \ref libusb_usb_2_0_extension_descriptor::bmAttributes "bmAttributes" field |
| /// of the USB 2.0 Extension descriptor. |
| pub type libusb_usb_2_0_extension_attributes = u32; |
| /// Supports Latency Tolerance Messages (LTM) |
| pub const LIBUSB_BM_LTM_SUPPORT: libusb_ss_usb_device_capability_attributes = 2; |
| /// \ingroup libusb_dev |
| /// Masks for the bits of the |
| /// \ref libusb_ss_usb_device_capability_descriptor::bmAttributes "bmAttributes" field |
| /// field of the SuperSpeed USB Device Capability descriptor. |
| pub type libusb_ss_usb_device_capability_attributes = u32; |
| /// Wireless USB device capability |
| pub const LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY: libusb_bos_type = 1; |
| /// USB 2.0 extensions |
| pub const LIBUSB_BT_USB_2_0_EXTENSION: libusb_bos_type = 2; |
| /// SuperSpeed USB device capability |
| pub const LIBUSB_BT_SS_USB_DEVICE_CAPABILITY: libusb_bos_type = 3; |
| /// Container ID type |
| pub const LIBUSB_BT_CONTAINER_ID: libusb_bos_type = 4; |
| /// \ingroup libusb_dev |
| /// USB capability types |
| pub type libusb_bos_type = u32; |
| /// Success (no error) |
| pub const LIBUSB_SUCCESS: libusb_error = 0; |
| /// Input/output error |
| pub const LIBUSB_ERROR_IO: libusb_error = -1; |
| /// Invalid parameter |
| pub const LIBUSB_ERROR_INVALID_PARAM: libusb_error = -2; |
| /// Access denied (insufficient permissions) |
| pub const LIBUSB_ERROR_ACCESS: libusb_error = -3; |
| /// No such device (it may have been disconnected) |
| pub const LIBUSB_ERROR_NO_DEVICE: libusb_error = -4; |
| /// Entity not found |
| pub const LIBUSB_ERROR_NOT_FOUND: libusb_error = -5; |
| /// Resource busy |
| pub const LIBUSB_ERROR_BUSY: libusb_error = -6; |
| /// Operation timed out |
| pub const LIBUSB_ERROR_TIMEOUT: libusb_error = -7; |
| /// Overflow |
| pub const LIBUSB_ERROR_OVERFLOW: libusb_error = -8; |
| /// Pipe error |
| pub const LIBUSB_ERROR_PIPE: libusb_error = -9; |
| /// System call interrupted (perhaps due to signal) |
| pub const LIBUSB_ERROR_INTERRUPTED: libusb_error = -10; |
| /// Insufficient memory |
| pub const LIBUSB_ERROR_NO_MEM: libusb_error = -11; |
| /// Operation not supported or unimplemented on this platform |
| pub const LIBUSB_ERROR_NOT_SUPPORTED: libusb_error = -12; |
| /// Other error |
| pub const LIBUSB_ERROR_OTHER: libusb_error = -99; |
| /// \ingroup libusb_misc |
| /// Error codes. Most libusb functions return 0 on success or one of these |
| /// codes on failure. |
| /// You can call libusb_error_name() to retrieve a string representation of an |
| /// error code or libusb_strerror() to get an end-user suitable description of |
| /// an error code. |
| pub type libusb_error = i32; |
| /// Transfer completed without error. Note that this does not indicate |
| /// that the entire amount of requested data was transferred. |
| pub const LIBUSB_TRANSFER_COMPLETED: libusb_transfer_status = 0; |
| /// Transfer failed |
| pub const LIBUSB_TRANSFER_ERROR: libusb_transfer_status = 1; |
| /// Transfer timed out |
| pub const LIBUSB_TRANSFER_TIMED_OUT: libusb_transfer_status = 2; |
| /// Transfer was cancelled |
| pub const LIBUSB_TRANSFER_CANCELLED: libusb_transfer_status = 3; |
| /// For bulk/interrupt endpoints: halt condition detected (endpoint |
| /// stalled). For control endpoints: control request not supported. |
| pub const LIBUSB_TRANSFER_STALL: libusb_transfer_status = 4; |
| /// Device was disconnected |
| pub const LIBUSB_TRANSFER_NO_DEVICE: libusb_transfer_status = 5; |
| /// Device sent more data than requested |
| pub const LIBUSB_TRANSFER_OVERFLOW: libusb_transfer_status = 6; |
| /// \ingroup libusb_asyncio |
| /// Transfer status codes |
| pub type libusb_transfer_status = u32; |
| /// Report short frames as errors |
| pub const LIBUSB_TRANSFER_SHORT_NOT_OK: libusb_transfer_flags = 1; |
| /// Automatically free() transfer buffer during libusb_free_transfer(). |
| /// Note that buffers allocated with libusb_dev_mem_alloc() should not |
| /// be attempted freed in this way, since free() is not an appropriate |
| /// way to release such memory. |
| pub const LIBUSB_TRANSFER_FREE_BUFFER: libusb_transfer_flags = 2; |
| /// Automatically call libusb_free_transfer() after callback returns. |
| /// If this flag is set, it is illegal to call libusb_free_transfer() |
| /// from your transfer callback, as this will result in a double-free |
| /// when this flag is acted upon. |
| pub const LIBUSB_TRANSFER_FREE_TRANSFER: libusb_transfer_flags = 4; |
| /// Terminate transfers that are a multiple of the endpoint's |
| /// wMaxPacketSize with an extra zero length packet. This is useful |
| /// when a device protocol mandates that each logical request is |
| /// terminated by an incomplete packet (i.e. the logical requests are |
| /// not separated by other means). |
| /// |
| /// This flag only affects host-to-device transfers to bulk and interrupt |
| /// endpoints. In other situations, it is ignored. |
| /// |
| /// This flag only affects transfers with a length that is a multiple of |
| /// the endpoint's wMaxPacketSize. On transfers of other lengths, this |
| /// flag has no effect. Therefore, if you are working with a device that |
| /// needs a ZLP whenever the end of the logical request falls on a packet |
| /// boundary, then it is sensible to set this flag on <em>every</em> |
| /// transfer (you do not have to worry about only setting it on transfers |
| /// that end on the boundary). |
| /// |
| /// This flag is currently only supported on Linux. |
| /// On other systems, libusb_submit_transfer() will return |
| /// LIBUSB_ERROR_NOT_SUPPORTED for every transfer where this flag is set. |
| /// |
| /// Available since libusb-1.0.9. |
| pub const LIBUSB_TRANSFER_ADD_ZERO_PACKET: libusb_transfer_flags = 8; |
| /// \ingroup libusb_asyncio |
| /// libusb_transfer.flags values |
| pub type libusb_transfer_flags = u32; |
| /// \ingroup libusb_asyncio |
| /// Isochronous packet descriptor. |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_iso_packet_descriptor { |
| /// Length of data to request in this packet |
| pub length: ::std::os::raw::c_uint, |
| /// Amount of data that was actually transferred |
| pub actual_length: ::std::os::raw::c_uint, |
| /// Status code for this packet |
| pub status: libusb_transfer_status, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_iso_packet_descriptor() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_iso_packet_descriptor>(), |
| 12usize, |
| concat!("Size of: ", stringify!(libusb_iso_packet_descriptor)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_iso_packet_descriptor>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(libusb_iso_packet_descriptor)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_iso_packet_descriptor>())).length as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_iso_packet_descriptor), |
| "::", |
| stringify!(length) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_iso_packet_descriptor>())).actual_length as *const _ |
| as usize |
| }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_iso_packet_descriptor), |
| "::", |
| stringify!(actual_length) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<libusb_iso_packet_descriptor>())).status as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_iso_packet_descriptor), |
| "::", |
| stringify!(status) |
| ) |
| ); |
| } |
| /// \ingroup libusb_asyncio |
| /// Asynchronous transfer callback function type. When submitting asynchronous |
| /// transfers, you pass a pointer to a callback function of this type via the |
| /// \ref libusb_transfer::callback "callback" member of the libusb_transfer |
| /// structure. libusb will call this function later, when the transfer has |
| /// completed or failed. See \ref libusb_asyncio for more information. |
| /// \param transfer The libusb_transfer struct the callback function is being |
| /// notified about. |
| pub type libusb_transfer_cb_fn = |
| ::std::option::Option<unsafe extern "C" fn(transfer: *mut libusb_transfer)>; |
| /// \ingroup libusb_asyncio |
| /// The generic USB transfer structure. The user populates this structure and |
| /// then submits it in order to request a transfer. After the transfer has |
| /// completed, the library populates the transfer with the results and passes |
| /// it back to the user. |
| #[repr(C)] |
| #[derive(Debug)] |
| pub struct libusb_transfer { |
| /// Handle of the device that this transfer will be submitted to |
| pub dev_handle: *mut libusb_device_handle, |
| /// A bitwise OR combination of \ref libusb_transfer_flags. |
| pub flags: u8, |
| /// Address of the endpoint where this transfer will be sent. |
| pub endpoint: ::std::os::raw::c_uchar, |
| /// Type of the endpoint from \ref libusb_transfer_type |
| pub type_: ::std::os::raw::c_uchar, |
| /// Timeout for this transfer in millseconds. A value of 0 indicates no |
| /// timeout. |
| pub timeout: ::std::os::raw::c_uint, |
| /// The status of the transfer. Read-only, and only for use within |
| /// transfer callback function. |
| /// |
| /// If this is an isochronous transfer, this field may read COMPLETED even |
| /// if there were errors in the frames. Use the |
| /// \ref libusb_iso_packet_descriptor::status "status" field in each packet |
| /// to determine if errors occurred. |
| pub status: libusb_transfer_status, |
| /// Length of the data buffer |
| pub length: ::std::os::raw::c_int, |
| /// Actual length of data that was transferred. Read-only, and only for |
| /// use within transfer callback function. Not valid for isochronous |
| /// endpoint transfers. |
| pub actual_length: ::std::os::raw::c_int, |
| /// Callback function. This will be invoked when the transfer completes, |
| /// fails, or is cancelled. |
| pub callback: libusb_transfer_cb_fn, |
| /// User context data to pass to the callback function. |
| pub user_data: *mut ::std::os::raw::c_void, |
| /// Data buffer |
| pub buffer: *mut ::std::os::raw::c_uchar, |
| /// Number of isochronous packets. Only used for I/O with isochronous |
| /// endpoints. |
| pub num_iso_packets: ::std::os::raw::c_int, |
| /// Isochronous packet descriptors, for isochronous transfers only. |
| pub iso_packet_desc: __IncompleteArrayField<libusb_iso_packet_descriptor>, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_transfer() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_transfer>(), |
| 64usize, |
| concat!("Size of: ", stringify!(libusb_transfer)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_transfer>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(libusb_transfer)) |
| ); |
| } |
| /// The libusb_has_capability() API is available. |
| pub const LIBUSB_CAP_HAS_CAPABILITY: libusb_capability = 0; |
| /// Hotplug support is available on this platform. |
| pub const LIBUSB_CAP_HAS_HOTPLUG: libusb_capability = 1; |
| /// The library can access HID devices without requiring user intervention. |
| /// Note that before being able to actually access an HID device, you may |
| /// still have to call additional libusb functions such as |
| /// \ref libusb_detach_kernel_driver(). |
| pub const LIBUSB_CAP_HAS_HID_ACCESS: libusb_capability = 256; |
| /// The library supports detaching of the default USB driver, using |
| /// \ref libusb_detach_kernel_driver(), if one is set by the OS kernel |
| pub const LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER: libusb_capability = 257; |
| /// \ingroup libusb_misc |
| /// Capabilities supported by an instance of libusb on the current running |
| /// platform. Test if the loaded library supports a given capability by calling |
| /// \ref libusb_has_capability(). |
| pub type libusb_capability = u32; |
| pub const LIBUSB_LOG_LEVEL_NONE: libusb_log_level = 0; |
| pub const LIBUSB_LOG_LEVEL_ERROR: libusb_log_level = 1; |
| pub const LIBUSB_LOG_LEVEL_WARNING: libusb_log_level = 2; |
| pub const LIBUSB_LOG_LEVEL_INFO: libusb_log_level = 3; |
| pub const LIBUSB_LOG_LEVEL_DEBUG: libusb_log_level = 4; |
| /// \ingroup libusb_lib |
| /// Log message levels. |
| /// - LIBUSB_LOG_LEVEL_NONE (0) : no messages ever printed by the library (default) |
| /// - LIBUSB_LOG_LEVEL_ERROR (1) : error messages are printed to stderr |
| /// - LIBUSB_LOG_LEVEL_WARNING (2) : warning and error messages are printed to stderr |
| /// - LIBUSB_LOG_LEVEL_INFO (3) : informational messages are printed to stdout, warning |
| /// and error messages are printed to stderr |
| /// - LIBUSB_LOG_LEVEL_DEBUG (4) : debug and informational messages are printed to stdout, |
| /// warnings and errors to stderr |
| pub type libusb_log_level = u32; |
| extern "C" { |
| pub fn libusb_init(ctx: *mut *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_exit(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_set_debug(ctx: *mut libusb_context, level: ::std::os::raw::c_int); |
| } |
| extern "C" { |
| pub fn libusb_get_version() -> *const libusb_version; |
| } |
| extern "C" { |
| pub fn libusb_has_capability(capability: u32) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_error_name(errcode: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; |
| } |
| extern "C" { |
| pub fn libusb_setlocale(locale: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_strerror(errcode: libusb_error) -> *const ::std::os::raw::c_char; |
| } |
| extern "C" { |
| pub fn libusb_get_device_list( |
| ctx: *mut libusb_context, |
| list: *mut *mut *mut libusb_device, |
| ) -> isize; |
| } |
| extern "C" { |
| pub fn libusb_free_device_list( |
| list: *mut *mut libusb_device, |
| unref_devices: ::std::os::raw::c_int, |
| ); |
| } |
| extern "C" { |
| pub fn libusb_ref_device(dev: *mut libusb_device) -> *mut libusb_device; |
| } |
| extern "C" { |
| pub fn libusb_unref_device(dev: *mut libusb_device); |
| } |
| extern "C" { |
| pub fn libusb_get_configuration( |
| dev: *mut libusb_device_handle, |
| config: *mut ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_device_descriptor( |
| dev: *mut libusb_device, |
| desc: *mut libusb_device_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_active_config_descriptor( |
| dev: *mut libusb_device, |
| config: *mut *mut libusb_config_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_config_descriptor( |
| dev: *mut libusb_device, |
| config_index: u8, |
| config: *mut *mut libusb_config_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_config_descriptor_by_value( |
| dev: *mut libusb_device, |
| bConfigurationValue: u8, |
| config: *mut *mut libusb_config_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_config_descriptor(config: *mut libusb_config_descriptor); |
| } |
| extern "C" { |
| pub fn libusb_get_ss_endpoint_companion_descriptor( |
| ctx: *mut libusb_context, |
| endpoint: *const libusb_endpoint_descriptor, |
| ep_comp: *mut *mut libusb_ss_endpoint_companion_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_ss_endpoint_companion_descriptor( |
| ep_comp: *mut libusb_ss_endpoint_companion_descriptor, |
| ); |
| } |
| extern "C" { |
| pub fn libusb_get_bos_descriptor( |
| dev_handle: *mut libusb_device_handle, |
| bos: *mut *mut libusb_bos_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_bos_descriptor(bos: *mut libusb_bos_descriptor); |
| } |
| extern "C" { |
| pub fn libusb_get_usb_2_0_extension_descriptor( |
| ctx: *mut libusb_context, |
| dev_cap: *mut libusb_bos_dev_capability_descriptor, |
| usb_2_0_extension: *mut *mut libusb_usb_2_0_extension_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_usb_2_0_extension_descriptor( |
| usb_2_0_extension: *mut libusb_usb_2_0_extension_descriptor, |
| ); |
| } |
| extern "C" { |
| pub fn libusb_get_ss_usb_device_capability_descriptor( |
| ctx: *mut libusb_context, |
| dev_cap: *mut libusb_bos_dev_capability_descriptor, |
| ss_usb_device_cap: *mut *mut libusb_ss_usb_device_capability_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_ss_usb_device_capability_descriptor( |
| ss_usb_device_cap: *mut libusb_ss_usb_device_capability_descriptor, |
| ); |
| } |
| extern "C" { |
| pub fn libusb_get_container_id_descriptor( |
| ctx: *mut libusb_context, |
| dev_cap: *mut libusb_bos_dev_capability_descriptor, |
| container_id: *mut *mut libusb_container_id_descriptor, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_container_id_descriptor(container_id: *mut libusb_container_id_descriptor); |
| } |
| extern "C" { |
| pub fn libusb_get_bus_number(dev: *mut libusb_device) -> u8; |
| } |
| extern "C" { |
| pub fn libusb_get_port_number(dev: *mut libusb_device) -> u8; |
| } |
| extern "C" { |
| pub fn libusb_get_port_numbers( |
| dev: *mut libusb_device, |
| port_numbers: *mut u8, |
| port_numbers_len: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_port_path( |
| ctx: *mut libusb_context, |
| dev: *mut libusb_device, |
| path: *mut u8, |
| path_length: u8, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_parent(dev: *mut libusb_device) -> *mut libusb_device; |
| } |
| extern "C" { |
| pub fn libusb_get_device_address(dev: *mut libusb_device) -> u8; |
| } |
| extern "C" { |
| pub fn libusb_get_device_speed(dev: *mut libusb_device) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_max_packet_size( |
| dev: *mut libusb_device, |
| endpoint: ::std::os::raw::c_uchar, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_max_iso_packet_size( |
| dev: *mut libusb_device, |
| endpoint: ::std::os::raw::c_uchar, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_open( |
| dev: *mut libusb_device, |
| dev_handle: *mut *mut libusb_device_handle, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_close(dev_handle: *mut libusb_device_handle); |
| } |
| extern "C" { |
| pub fn libusb_get_device(dev_handle: *mut libusb_device_handle) -> *mut libusb_device; |
| } |
| extern "C" { |
| pub fn libusb_set_configuration( |
| dev_handle: *mut libusb_device_handle, |
| configuration: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_claim_interface( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_release_interface( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_open_device_with_vid_pid( |
| ctx: *mut libusb_context, |
| vendor_id: u16, |
| product_id: u16, |
| ) -> *mut libusb_device_handle; |
| } |
| extern "C" { |
| pub fn libusb_set_interface_alt_setting( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| alternate_setting: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_clear_halt( |
| dev_handle: *mut libusb_device_handle, |
| endpoint: ::std::os::raw::c_uchar, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_reset_device(dev_handle: *mut libusb_device_handle) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_alloc_streams( |
| dev_handle: *mut libusb_device_handle, |
| num_streams: u32, |
| endpoints: *mut ::std::os::raw::c_uchar, |
| num_endpoints: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_streams( |
| dev_handle: *mut libusb_device_handle, |
| endpoints: *mut ::std::os::raw::c_uchar, |
| num_endpoints: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_dev_mem_alloc( |
| dev_handle: *mut libusb_device_handle, |
| length: usize, |
| ) -> *mut ::std::os::raw::c_uchar; |
| } |
| extern "C" { |
| pub fn libusb_dev_mem_free( |
| dev_handle: *mut libusb_device_handle, |
| buffer: *mut ::std::os::raw::c_uchar, |
| length: usize, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_kernel_driver_active( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_detach_kernel_driver( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_attach_kernel_driver( |
| dev_handle: *mut libusb_device_handle, |
| interface_number: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_set_auto_detach_kernel_driver( |
| dev_handle: *mut libusb_device_handle, |
| enable: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_alloc_transfer(iso_packets: ::std::os::raw::c_int) -> *mut libusb_transfer; |
| } |
| extern "C" { |
| pub fn libusb_submit_transfer(transfer: *mut libusb_transfer) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_cancel_transfer(transfer: *mut libusb_transfer) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_free_transfer(transfer: *mut libusb_transfer); |
| } |
| extern "C" { |
| pub fn libusb_transfer_set_stream_id(transfer: *mut libusb_transfer, stream_id: u32); |
| } |
| extern "C" { |
| pub fn libusb_transfer_get_stream_id(transfer: *mut libusb_transfer) -> u32; |
| } |
| extern "C" { |
| pub fn libusb_control_transfer( |
| dev_handle: *mut libusb_device_handle, |
| request_type: u8, |
| bRequest: u8, |
| wValue: u16, |
| wIndex: u16, |
| data: *mut ::std::os::raw::c_uchar, |
| wLength: u16, |
| timeout: ::std::os::raw::c_uint, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_bulk_transfer( |
| dev_handle: *mut libusb_device_handle, |
| endpoint: ::std::os::raw::c_uchar, |
| data: *mut ::std::os::raw::c_uchar, |
| length: ::std::os::raw::c_int, |
| actual_length: *mut ::std::os::raw::c_int, |
| timeout: ::std::os::raw::c_uint, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_interrupt_transfer( |
| dev_handle: *mut libusb_device_handle, |
| endpoint: ::std::os::raw::c_uchar, |
| data: *mut ::std::os::raw::c_uchar, |
| length: ::std::os::raw::c_int, |
| actual_length: *mut ::std::os::raw::c_int, |
| timeout: ::std::os::raw::c_uint, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_string_descriptor_ascii( |
| dev_handle: *mut libusb_device_handle, |
| desc_index: u8, |
| data: *mut ::std::os::raw::c_uchar, |
| length: ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_try_lock_events(ctx: *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_lock_events(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_unlock_events(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_event_handling_ok(ctx: *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_event_handler_active(ctx: *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_interrupt_event_handler(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_lock_event_waiters(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_unlock_event_waiters(ctx: *mut libusb_context); |
| } |
| extern "C" { |
| pub fn libusb_wait_for_event( |
| ctx: *mut libusb_context, |
| tv: *mut timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_handle_events_timeout( |
| ctx: *mut libusb_context, |
| tv: *mut timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_handle_events_timeout_completed( |
| ctx: *mut libusb_context, |
| tv: *mut timeval, |
| completed: *mut ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_handle_events(ctx: *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_handle_events_completed( |
| ctx: *mut libusb_context, |
| completed: *mut ::std::os::raw::c_int, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_handle_events_locked( |
| ctx: *mut libusb_context, |
| tv: *mut timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_pollfds_handle_timeouts(ctx: *mut libusb_context) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| pub fn libusb_get_next_timeout( |
| ctx: *mut libusb_context, |
| tv: *mut timeval, |
| ) -> ::std::os::raw::c_int; |
| } |
| /// \ingroup libusb_poll |
| /// File descriptor for polling |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct libusb_pollfd { |
| /// Numeric file descriptor |
| pub fd: ::std::os::raw::c_int, |
| /// Event flags to poll for from <poll.h>. POLLIN indicates that you |
| /// should monitor this file descriptor for becoming ready to read from, |
| /// and POLLOUT indicates that you should monitor this file descriptor for |
| /// nonblocking write readiness. |
| pub events: ::std::os::raw::c_short, |
| } |
| #[test] |
| fn bindgen_test_layout_libusb_pollfd() { |
| assert_eq!( |
| ::std::mem::size_of::<libusb_pollfd>(), |
| 8usize, |
| concat!("Size of: ", stringify!(libusb_pollfd)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<libusb_pollfd>(), |
| 4usize, |
| concat!("Alignment of ", stringify!(libusb_pollfd)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_pollfd>())).fd as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_pollfd), |
| "::", |
| stringify!(fd) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<libusb_pollfd>())).events as *const _ as usize }, |
| 4usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(libusb_pollfd), |
| "::", |
| stringify!(events) |
| ) |
| ); |
| } |
| /// \ingroup libusb_poll |
| /// Callback function, invoked when a new file descriptor should be added |
| /// to the set of file descriptors monitored for events. |
| /// \param fd the new file descriptor |
| /// \param events events to monitor for, see \ref libusb_pollfd for a |
| /// description |
| /// \param user_data User data pointer specified in |
| /// libusb_set_pollfd_notifiers() call |
| /// \see libusb_set_pollfd_notifiers() |
| pub type libusb_pollfd_added_cb = ::std::option::Option< |
| unsafe extern "C" fn( |
| fd: ::std::os::raw::c_int, |
| events: ::std::os::raw::c_short, |
| user_data: *mut ::std::os::raw::c_void, |
| ), |
| >; |
| /// \ingroup libusb_poll |
| /// Callback function, invoked when a file descriptor should be removed from |
| /// the set of file descriptors being monitored for events. After returning |
| /// from this callback, do not use that file descriptor again. |
| /// \param fd the file descriptor to stop monitoring |
| /// \param user_data User data pointer specified in |
| /// libusb_set_pollfd_notifiers() call |
| /// \see libusb_set_pollfd_notifiers() |
| pub type libusb_pollfd_removed_cb = ::std::option::Option< |
| unsafe extern "C" fn(fd: ::std::os::raw::c_int, user_data: *mut ::std::os::raw::c_void), |
| >; |
| extern "C" { |
| pub fn libusb_get_pollfds(ctx: *mut libusb_context) -> *mut *const libusb_pollfd; |
| } |
| extern "C" { |
| pub fn libusb_free_pollfds(pollfds: *mut *const libusb_pollfd); |
| } |
| extern "C" { |
| pub fn libusb_set_pollfd_notifiers( |
| ctx: *mut libusb_context, |
| added_cb: libusb_pollfd_added_cb, |
| removed_cb: libusb_pollfd_removed_cb, |
| user_data: *mut ::std::os::raw::c_void, |
| ); |
| } |
| /// \ingroup libusb_hotplug |
| /// Callback handle. |
| /// |
| /// Callbacks handles are generated by libusb_hotplug_register_callback() |
| /// and can be used to deregister callbacks. Callback handles are unique |
| /// per libusb_context and it is safe to call libusb_hotplug_deregister_callback() |
| /// on an already deregisted callback. |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// For more information, see \ref libusb_hotplug. |
| pub type libusb_hotplug_callback_handle = ::std::os::raw::c_int; |
| /// Default value when not using any flags. |
| pub const LIBUSB_HOTPLUG_NO_FLAGS: libusb_hotplug_flag = 0; |
| /// Arm the callback and fire it for all matching currently attached devices. |
| pub const LIBUSB_HOTPLUG_ENUMERATE: libusb_hotplug_flag = 1; |
| /// \ingroup libusb_hotplug |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// Flags for hotplug events |
| pub type libusb_hotplug_flag = u32; |
| /// A device has been plugged in and is ready to use |
| pub const LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: libusb_hotplug_event = 1; |
| /// A device has left and is no longer available. |
| /// It is the user's responsibility to call libusb_close on any handle associated with a disconnected device. |
| /// It is safe to call libusb_get_device_descriptor on a device that has left |
| pub const LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT: libusb_hotplug_event = 2; |
| /// \ingroup libusb_hotplug |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// Hotplug events |
| pub type libusb_hotplug_event = u32; |
| /// \ingroup libusb_hotplug |
| /// Hotplug callback function type. When requesting hotplug event notifications, |
| /// you pass a pointer to a callback function of this type. |
| /// |
| /// This callback may be called by an internal event thread and as such it is |
| /// recommended the callback do minimal processing before returning. |
| /// |
| /// libusb will call this function later, when a matching event had happened on |
| /// a matching device. See \ref libusb_hotplug for more information. |
| /// |
| /// It is safe to call either libusb_hotplug_register_callback() or |
| /// libusb_hotplug_deregister_callback() from within a callback function. |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// \param ctx context of this notification |
| /// \param device libusb_device this event occurred on |
| /// \param event event that occurred |
| /// \param user_data user data provided when this callback was registered |
| /// \returns bool whether this callback is finished processing events. |
| /// returning 1 will cause this callback to be deregistered |
| pub type libusb_hotplug_callback_fn = ::std::option::Option< |
| unsafe extern "C" fn( |
| ctx: *mut libusb_context, |
| device: *mut libusb_device, |
| event: libusb_hotplug_event, |
| user_data: *mut ::std::os::raw::c_void, |
| ) -> ::std::os::raw::c_int, |
| >; |
| extern "C" { |
| /// \ingroup libusb_hotplug |
| /// Register a hotplug callback function |
| /// |
| /// Register a callback with the libusb_context. The callback will fire |
| /// when a matching event occurs on a matching device. The callback is |
| /// armed until either it is deregistered with libusb_hotplug_deregister_callback() |
| /// or the supplied callback returns 1 to indicate it is finished processing events. |
| /// |
| /// If the \ref LIBUSB_HOTPLUG_ENUMERATE is passed the callback will be |
| /// called with a \ref LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED for all devices |
| /// already plugged into the machine. Note that libusb modifies its internal |
| /// device list from a separate thread, while calling hotplug callbacks from |
| /// libusb_handle_events(), so it is possible for a device to already be present |
| /// on, or removed from, its internal device list, while the hotplug callbacks |
| /// still need to be dispatched. This means that when using \ref |
| /// LIBUSB_HOTPLUG_ENUMERATE, your callback may be called twice for the arrival |
| /// of the same device, once from libusb_hotplug_register_callback() and once |
| /// from libusb_handle_events(); and/or your callback may be called for the |
| /// removal of a device for which an arrived call was never made. |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// \param[in] ctx context to register this callback with |
| /// \param[in] events bitwise or of events that will trigger this callback. See \ref |
| /// libusb_hotplug_event |
| /// \param[in] flags hotplug callback flags. See \ref libusb_hotplug_flag |
| /// \param[in] vendor_id the vendor id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY |
| /// \param[in] product_id the product id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY |
| /// \param[in] dev_class the device class to match or \ref LIBUSB_HOTPLUG_MATCH_ANY |
| /// \param[in] cb_fn the function to be invoked on a matching event/device |
| /// \param[in] user_data user data to pass to the callback function |
| /// \param[out] callback_handle pointer to store the handle of the allocated callback (can be NULL) |
| /// \returns LIBUSB_SUCCESS on success LIBUSB_ERROR code on failure |
| pub fn libusb_hotplug_register_callback( |
| ctx: *mut libusb_context, |
| events: libusb_hotplug_event, |
| flags: libusb_hotplug_flag, |
| vendor_id: ::std::os::raw::c_int, |
| product_id: ::std::os::raw::c_int, |
| dev_class: ::std::os::raw::c_int, |
| cb_fn: libusb_hotplug_callback_fn, |
| user_data: *mut ::std::os::raw::c_void, |
| callback_handle: *mut libusb_hotplug_callback_handle, |
| ) -> ::std::os::raw::c_int; |
| } |
| extern "C" { |
| /// \ingroup libusb_hotplug |
| /// Deregisters a hotplug callback. |
| /// |
| /// Deregister a callback from a libusb_context. This function is safe to call from within |
| /// a hotplug callback. |
| /// |
| /// Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 |
| /// |
| /// \param[in] ctx context this callback is registered with |
| /// \param[in] callback_handle the handle of the callback to deregister |
| pub fn libusb_hotplug_deregister_callback( |
| ctx: *mut libusb_context, |
| callback_handle: libusb_hotplug_callback_handle, |
| ); |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct __locale_data { |
| pub _address: u8, |
| } |
