pub type DWORD = ::std::os::raw::c_ulong;
pub type BOOL = ::std::os::raw::c_int;
pub type UINT = ::std::os::raw::c_uint;
pub type UINT32 = ::std::os::raw::c_uint;
pub type UINT64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HWND__ {
pub unused: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_HWND__() {
assert_eq!(
::std::mem::size_of::<HWND__>(),
4usize,
concat!("Size of: ", stringify!(HWND__))
);
assert_eq!(
::std::mem::align_of::<HWND__>(),
4usize,
concat!("Alignment of ", stringify!(HWND__))
);
fn test_field_unused() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<HWND__>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(HWND__),
"::",
stringify!(unused)
)
);
}
test_field_unused();
}
pub type HWND = *mut HWND__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagVS_FIXEDFILEINFO {
pub dwSignature: DWORD,
pub dwStrucVersion: DWORD,
pub dwFileVersionMS: DWORD,
pub dwFileVersionLS: DWORD,
pub dwProductVersionMS: DWORD,
pub dwProductVersionLS: DWORD,
pub dwFileFlagsMask: DWORD,
pub dwFileFlags: DWORD,
pub dwFileOS: DWORD,
pub dwFileType: DWORD,
pub dwFileSubtype: DWORD,
pub dwFileDateMS: DWORD,
pub dwFileDateLS: DWORD,
}
#[test]
fn bindgen_test_layout_tagVS_FIXEDFILEINFO() {
assert_eq!(
::std::mem::size_of::<tagVS_FIXEDFILEINFO>(),
52usize,
concat!("Size of: ", stringify!(tagVS_FIXEDFILEINFO))
);
assert_eq!(
::std::mem::align_of::<tagVS_FIXEDFILEINFO>(),
4usize,
concat!("Alignment of ", stringify!(tagVS_FIXEDFILEINFO))
);
fn test_field_dwSignature() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwSignature) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwSignature)
)
);
}
test_field_dwSignature();
fn test_field_dwStrucVersion() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwStrucVersion) as usize - ptr as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwStrucVersion)
)
);
}
test_field_dwStrucVersion();
fn test_field_dwFileVersionMS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileVersionMS) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileVersionMS)
)
);
}
test_field_dwFileVersionMS();
fn test_field_dwFileVersionLS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileVersionLS) as usize - ptr as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileVersionLS)
)
);
}
test_field_dwFileVersionLS();
fn test_field_dwProductVersionMS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwProductVersionMS) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwProductVersionMS)
)
);
}
test_field_dwProductVersionMS();
fn test_field_dwProductVersionLS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwProductVersionLS) as usize - ptr as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwProductVersionLS)
)
);
}
test_field_dwProductVersionLS();
fn test_field_dwFileFlagsMask() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileFlagsMask) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileFlagsMask)
)
);
}
test_field_dwFileFlagsMask();
fn test_field_dwFileFlags() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileFlags) as usize - ptr as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileFlags)
)
);
}
test_field_dwFileFlags();
fn test_field_dwFileOS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileOS) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileOS)
)
);
}
test_field_dwFileOS();
fn test_field_dwFileType() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileType) as usize - ptr as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileType)
)
);
}
test_field_dwFileType();
fn test_field_dwFileSubtype() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileSubtype) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileSubtype)
)
);
}
test_field_dwFileSubtype();
fn test_field_dwFileDateMS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileDateMS) as usize - ptr as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileDateMS)
)
);
}
test_field_dwFileDateMS();
fn test_field_dwFileDateLS() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<tagVS_FIXEDFILEINFO>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).dwFileDateLS) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(tagVS_FIXEDFILEINFO),
"::",
stringify!(dwFileDateLS)
)
);
}
test_field_dwFileDateLS();
}
pub type VS_FIXEDFILEINFO = tagVS_FIXEDFILEINFO;
pub const WDI_WINUSB: wdi_driver_type = 0;
pub const WDI_LIBUSB0: wdi_driver_type = 1;
pub const WDI_LIBUSBK: wdi_driver_type = 2;
pub const WDI_CDC: wdi_driver_type = 3;
pub const WDI_USER: wdi_driver_type = 4;
pub const WDI_NB_DRIVERS: wdi_driver_type = 5;
pub type wdi_driver_type = ::std::os::raw::c_int;
pub const WDI_LOG_LEVEL_DEBUG: wdi_log_level = 0;
pub const WDI_LOG_LEVEL_INFO: wdi_log_level = 1;
pub const WDI_LOG_LEVEL_WARNING: wdi_log_level = 2;
pub const WDI_LOG_LEVEL_ERROR: wdi_log_level = 3;
pub const WDI_LOG_LEVEL_NONE: wdi_log_level = 4;
pub type wdi_log_level = ::std::os::raw::c_int;
#[doc = " Success (no error)"]
pub const WDI_SUCCESS: wdi_error = 0;
#[doc = " Input/output error"]
pub const WDI_ERROR_IO: wdi_error = -1;
#[doc = " Invalid parameter"]
pub const WDI_ERROR_INVALID_PARAM: wdi_error = -2;
#[doc = " Access denied (insufficient permissions)"]
pub const WDI_ERROR_ACCESS: wdi_error = -3;
#[doc = " No such device (it may have been disconnected)"]
pub const WDI_ERROR_NO_DEVICE: wdi_error = -4;
#[doc = " Entity not found"]
pub const WDI_ERROR_NOT_FOUND: wdi_error = -5;
#[doc = " Resource busy, or API call already running"]
pub const WDI_ERROR_BUSY: wdi_error = -6;
#[doc = " Operation timed out"]
pub const WDI_ERROR_TIMEOUT: wdi_error = -7;
#[doc = " Overflow"]
pub const WDI_ERROR_OVERFLOW: wdi_error = -8;
#[doc = " Another installation is pending"]
pub const WDI_ERROR_PENDING_INSTALLATION: wdi_error = -9;
#[doc = " System call interrupted (perhaps due to signal)"]
pub const WDI_ERROR_INTERRUPTED: wdi_error = -10;
#[doc = " Could not acquire resource (Insufficient memory, etc)"]
pub const WDI_ERROR_RESOURCE: wdi_error = -11;
#[doc = " Operation not supported or unimplemented on this platform"]
pub const WDI_ERROR_NOT_SUPPORTED: wdi_error = -12;
#[doc = " Entity already exists"]
pub const WDI_ERROR_EXISTS: wdi_error = -13;
#[doc = " Cancelled by user"]
pub const WDI_ERROR_USER_CANCEL: wdi_error = -14;
#[doc = " Couldn't run installer with required privileges"]
pub const WDI_ERROR_NEEDS_ADMIN: wdi_error = -15;
#[doc = " Attempted to run the 32 bit installer on 64 bit"]
pub const WDI_ERROR_WOW64: wdi_error = -16;
#[doc = " Bad inf syntax"]
pub const WDI_ERROR_INF_SYNTAX: wdi_error = -17;
#[doc = " Missing cat file"]
pub const WDI_ERROR_CAT_MISSING: wdi_error = -18;
#[doc = " System policy prevents the installation of unsigned drivers"]
pub const WDI_ERROR_UNSIGNED: wdi_error = -19;
#[doc = " Other error"]
pub const WDI_ERROR_OTHER: wdi_error = -99;
pub type wdi_error = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wdi_device_info {
#[doc = " (Optional) Pointer to the next element in the chained list. NULL if unused"]
pub next: *mut wdi_device_info,
#[doc = " USB VID"]
pub vid: ::std::os::raw::c_ushort,
#[doc = " USB PID"]
pub pid: ::std::os::raw::c_ushort,
#[doc = " Whether the USB device is composite"]
pub is_composite: BOOL,
#[doc = " (Optional) Composite USB interface number"]
pub mi: ::std::os::raw::c_uchar,
#[doc = " USB Device description, usually provided by the device itself"]
pub desc: *mut ::std::os::raw::c_char,
#[doc = " Windows' driver (service) name"]
pub driver: *mut ::std::os::raw::c_char,
#[doc = " (Optional) Microsoft's device URI string. NULL if unused"]
pub device_id: *mut ::std::os::raw::c_char,
#[doc = " (Optional) Microsoft's Hardware ID string. NULL if unused"]
pub hardware_id: *mut ::std::os::raw::c_char,
#[doc = " (Optional) Microsoft's Compatible ID string. NULL if unused"]
pub compatible_id: *mut ::std::os::raw::c_char,
#[doc = " (Optional) Upper filter. NULL if unused"]
pub upper_filter: *mut ::std::os::raw::c_char,
#[doc = " (Optional) Driver version (four WORDS). 0 if unused"]
pub driver_version: UINT64,
}
#[test]
fn bindgen_test_layout_wdi_device_info() {
assert_eq!(
::std::mem::size_of::<wdi_device_info>(),
80usize,
concat!("Size of: ", stringify!(wdi_device_info))
);
assert_eq!(
::std::mem::align_of::<wdi_device_info>(),
8usize,
concat!("Alignment of ", stringify!(wdi_device_info))
);
fn test_field_next() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(next)
)
);
}
test_field_next();
fn test_field_vid() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).vid) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(vid)
)
);
}
test_field_vid();
fn test_field_pid() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).pid) as usize - ptr as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(pid)
)
);
}
test_field_pid();
fn test_field_is_composite() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).is_composite) as usize - ptr as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(is_composite)
)
);
}
test_field_is_composite();
fn test_field_mi() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).mi) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(mi)
)
);
}
test_field_mi();
fn test_field_desc() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(desc)
)
);
}
test_field_desc();
fn test_field_driver() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).driver) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(driver)
)
);
}
test_field_driver();
fn test_field_device_id() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).device_id) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(device_id)
)
);
}
test_field_device_id();
fn test_field_hardware_id() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).hardware_id) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(hardware_id)
)
);
}
test_field_hardware_id();
fn test_field_compatible_id() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).compatible_id) as usize - ptr as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(compatible_id)
)
);
}
test_field_compatible_id();
fn test_field_upper_filter() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).upper_filter) as usize - ptr as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(upper_filter)
)
);
}
test_field_upper_filter();
fn test_field_driver_version() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_device_info>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).driver_version) as usize - ptr as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(wdi_device_info),
"::",
stringify!(driver_version)
)
);
}
test_field_driver_version();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wdi_options_create_list {
#[doc = " list all devices, instead of just the ones that are driverless"]
pub list_all: BOOL,
#[doc = " also list generic hubs and composite parent devices"]
pub list_hubs: BOOL,
#[doc = " trim trailing whitespaces from the description string"]
pub trim_whitespaces: BOOL,
}
#[test]
fn bindgen_test_layout_wdi_options_create_list() {
assert_eq!(
::std::mem::size_of::<wdi_options_create_list>(),
12usize,
concat!("Size of: ", stringify!(wdi_options_create_list))
);
assert_eq!(
::std::mem::align_of::<wdi_options_create_list>(),
4usize,
concat!("Alignment of ", stringify!(wdi_options_create_list))
);
fn test_field_list_all() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_create_list>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_all) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_create_list),
"::",
stringify!(list_all)
)
);
}
test_field_list_all();
fn test_field_list_hubs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_create_list>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_hubs) as usize - ptr as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_create_list),
"::",
stringify!(list_hubs)
)
);
}
test_field_list_hubs();
fn test_field_trim_whitespaces() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_create_list>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).trim_whitespaces) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_create_list),
"::",
stringify!(trim_whitespaces)
)
);
}
test_field_trim_whitespaces();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wdi_options_prepare_driver {
#[doc = " Type of driver to use. Should be either WDI_WINUSB, WDI_LIBUSB, WDI_LIBUSBK or WDI_USER"]
pub driver_type: ::std::os::raw::c_int,
#[doc = " Vendor name that should be used for the Manufacturer in the inf"]
pub vendor_name: *mut ::std::os::raw::c_char,
#[doc = " Device GUID (with braces) that should be used, instead of the automatically generated one"]
pub device_guid: *mut ::std::os::raw::c_char,
#[doc = " Disable the generation of a cat file for libusbK, libusb0 or WinUSB drivers"]
pub disable_cat: BOOL,
#[doc = " Disable the signing and installation of a self-signed certificate, for libusbK, libusb0 or WinUSB drivers"]
pub disable_signing: BOOL,
#[doc = " Subject to use for the self-signing autogenerated certificate."]
#[doc = " default is \"CN=USB\\VID_####&PID_####[&MI_##] (libwdi autogenerated)\""]
pub cert_subject: *mut ::std::os::raw::c_char,
#[doc = " Install a generic driver, for WCID devices, to allow for automated installation"]
pub use_wcid_driver: BOOL,
#[doc = " Use an externally provided inf file"]
pub external_inf: BOOL,
}
#[test]
fn bindgen_test_layout_wdi_options_prepare_driver() {
assert_eq!(
::std::mem::size_of::<wdi_options_prepare_driver>(),
48usize,
concat!("Size of: ", stringify!(wdi_options_prepare_driver))
);
assert_eq!(
::std::mem::align_of::<wdi_options_prepare_driver>(),
8usize,
concat!("Alignment of ", stringify!(wdi_options_prepare_driver))
);
fn test_field_driver_type() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).driver_type) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(driver_type)
)
);
}
test_field_driver_type();
fn test_field_vendor_name() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).vendor_name) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(vendor_name)
)
);
}
test_field_vendor_name();
fn test_field_device_guid() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).device_guid) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(device_guid)
)
);
}
test_field_device_guid();
fn test_field_disable_cat() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).disable_cat) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(disable_cat)
)
);
}
test_field_disable_cat();
fn test_field_disable_signing() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).disable_signing) as usize - ptr as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(disable_signing)
)
);
}
test_field_disable_signing();
fn test_field_cert_subject() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).cert_subject) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(cert_subject)
)
);
}
test_field_cert_subject();
fn test_field_use_wcid_driver() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).use_wcid_driver) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(use_wcid_driver)
)
);
}
test_field_use_wcid_driver();
fn test_field_external_inf() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_prepare_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).external_inf) as usize - ptr as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_prepare_driver),
"::",
stringify!(external_inf)
)
);
}
test_field_external_inf();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wdi_options_install_driver {
#[doc = " Handle to a Window application that should receive a modal progress dialog"]
pub hWnd: HWND,
#[doc = " Install a filter driver instead of a regular driver (libusb-win32 only)"]
pub install_filter_driver: BOOL,
#[doc = " Number of milliseconds to wait for any pending installations"]
pub pending_install_timeout: UINT32,
}
#[test]
fn bindgen_test_layout_wdi_options_install_driver() {
assert_eq!(
::std::mem::size_of::<wdi_options_install_driver>(),
16usize,
concat!("Size of: ", stringify!(wdi_options_install_driver))
);
assert_eq!(
::std::mem::align_of::<wdi_options_install_driver>(),
8usize,
concat!("Alignment of ", stringify!(wdi_options_install_driver))
);
fn test_field_hWnd() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_install_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).hWnd) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_install_driver),
"::",
stringify!(hWnd)
)
);
}
test_field_hWnd();
fn test_field_install_filter_driver() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_install_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).install_filter_driver) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_install_driver),
"::",
stringify!(install_filter_driver)
)
);
}
test_field_install_filter_driver();
fn test_field_pending_install_timeout() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_install_driver>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).pending_install_timeout) as usize - ptr as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_install_driver),
"::",
stringify!(pending_install_timeout)
)
);
}
test_field_pending_install_timeout();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wdi_options_install_cert {
#[doc = " handle to a Window application that can receive a modal progress dialog"]
pub hWnd: HWND,
#[doc = " Should the warning about a Trusted Publisher installation be disabled?"]
pub disable_warning: BOOL,
}
#[test]
fn bindgen_test_layout_wdi_options_install_cert() {
assert_eq!(
::std::mem::size_of::<wdi_options_install_cert>(),
16usize,
concat!("Size of: ", stringify!(wdi_options_install_cert))
);
assert_eq!(
::std::mem::align_of::<wdi_options_install_cert>(),
8usize,
concat!("Alignment of ", stringify!(wdi_options_install_cert))
);
fn test_field_hWnd() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_install_cert>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).hWnd) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_install_cert),
"::",
stringify!(hWnd)
)
);
}
test_field_hWnd();
fn test_field_disable_warning() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<wdi_options_install_cert>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).disable_warning) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(wdi_options_install_cert),
"::",
stringify!(disable_warning)
)
);
}
test_field_disable_warning();
}
extern "C" {
pub fn wdi_strerror(errcode: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn wdi_is_driver_supported(
driver_type: ::std::os::raw::c_int,
driver_info: *mut VS_FIXEDFILEINFO,
) -> BOOL;
}
extern "C" {
pub fn wdi_is_file_embedded(
path: *const ::std::os::raw::c_char,
name: *const ::std::os::raw::c_char,
) -> BOOL;
}
extern "C" {
pub fn wdi_get_vendor_name(vid: ::std::os::raw::c_ushort) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn wdi_create_list(
list: *mut *mut wdi_device_info,
options: *mut wdi_options_create_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_destroy_list(list: *mut wdi_device_info) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_prepare_driver(
device_info: *mut wdi_device_info,
path: *const ::std::os::raw::c_char,
inf_name: *const ::std::os::raw::c_char,
options: *mut wdi_options_prepare_driver,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_install_driver(
device_info: *mut wdi_device_info,
path: *const ::std::os::raw::c_char,
inf_name: *const ::std::os::raw::c_char,
options: *mut wdi_options_install_driver,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_install_trusted_certificate(
cert_name: *const ::std::os::raw::c_char,
options: *mut wdi_options_install_cert,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_set_log_level(level: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_register_logger(hWnd: HWND, message: UINT, buffsize: DWORD)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_unregister_logger(hWnd: HWND) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_read_logger(
buffer: *mut ::std::os::raw::c_char,
buffer_size: DWORD,
message_size: *mut DWORD,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wdi_get_wdf_version() -> ::std::os::raw::c_int;
}