extern crate libusb_sys as ffi;
extern crate libc;
use libc::{c_int,c_uint,c_uchar};
use std::mem;
use std::slice;
use std::io::{Read,Cursor};
use std::str::FromStr;
#[derive(Debug)]
struct Endpoint {
config: u8,
iface: u8,
setting: u8,
address: u8
}
fn main() {
let args: Vec<String> = std::env::args().collect();
if args.len() < 3 {
println!("usage: show_device <vendor-id> <product-id>");
return;
}
let vid: u16 = FromStr::from_str(args[1].as_ref()).unwrap();
let pid: u16 = FromStr::from_str(args[2].as_ref()).unwrap();
let mut context: *mut ::ffi::libusb_context = unsafe { mem::uninitialized() };
let mut device_list: *const *mut ::ffi::libusb_device = unsafe { mem::uninitialized() };
match unsafe { ::ffi::libusb_init(&mut context) } {
0 => (),
e => panic!("libusb_init: {}", e)
};
let handle = unsafe { ::ffi::libusb_open_device_with_vid_pid(context, vid, pid) };
if !handle.is_null() {
match unsafe { ::ffi::libusb_reset_device(handle) } {
0 => {
unsafe { ::ffi::libusb_set_auto_detach_kernel_driver(handle, 0) };
let device = unsafe { ::ffi::libusb_get_device(handle) };
unsafe { ::ffi::libusb_ref_device(device) };
if unsafe { ::ffi::libusb_get_device_list(context, &mut device_list) } >= 0 {
print_device_tree(device);
println!("");
unsafe { ::ffi::libusb_free_device_list(device_list, 1) };
}
let languages = get_language_ids(handle);
println!("Supported languages: {:?}", languages);
let mut active_config: c_int = unsafe { mem::uninitialized() };
match unsafe { ::ffi::libusb_get_configuration(handle, &mut active_config) } {
0 => println!("Active configuration: {}", active_config),
e => println!("libusb_get_configuration: {}", e)
}
println!("");
match find_readable_endpoint(device, ::ffi::LIBUSB_TRANSFER_TYPE_INTERRUPT) {
Some(ep) => read_endpoint(handle, device, ep, ::ffi::LIBUSB_TRANSFER_TYPE_INTERRUPT),
None => println!("No readable interrupt endpoint")
}
println!("");
match find_readable_endpoint(device, ::ffi::LIBUSB_TRANSFER_TYPE_BULK) {
Some(ep) => read_endpoint(handle, device, ep, ::ffi::LIBUSB_TRANSFER_TYPE_BULK),
None => println!("No readable bulk endpoint")
}
unsafe { ::ffi::libusb_unref_device(device) };
},
e => println!("libusb_reset_device: {}", e)
}
unsafe { ::ffi::libusb_close(handle) };
}
unsafe { ::ffi::libusb_exit(context) };
}
fn print_device_tree(device: *mut ::ffi::libusb_device) -> usize {
if device.is_null() {
return 0;
}
let parent = unsafe { ::ffi::libusb_get_parent(device) };
let depth = print_device_tree(parent);
for _ in 0..depth {
print!(" ");
}
let bus = unsafe { ::ffi::libusb_get_bus_number(device) };
let address = unsafe { ::ffi::libusb_get_device_address(device) };
println!("Bus {:03} Device {:03}", bus, address);
return depth + 1;
}
fn get_language_ids(handle: *mut ::ffi::libusb_device_handle) -> Vec<u16> {
let mut buf = Vec::<u8>::with_capacity(255);
let len = unsafe { ::ffi::libusb_get_string_descriptor(handle, 0, 0, (&mut buf[..]).as_mut_ptr() as *mut c_uchar, buf.capacity() as c_int) };
let mut languages = Vec::<u16>::new();
if len >= 0 {
unsafe { buf.set_len(len as usize) };
if buf.len() >= 2 {
let num_languages = (buf.len() - 2) / 2;
languages.reserve(num_languages);
let mut cursor = Cursor::new(buf);
cursor.set_position(2);
for _ in 0..num_languages {
let mut bytes = Vec::<u8>::with_capacity(2);
match cursor.read(unsafe { slice::from_raw_parts_mut((&mut bytes[..]).as_mut_ptr(), bytes.capacity()) }) {
Ok(len) => {
if len == 2 {
unsafe { bytes.set_len(len) };
let langid = (bytes[1] as u16) << 8 | (bytes[0] as u16);
languages.push(langid)
}
else {
return languages;
}
},
Err(_) => return languages
}
}
}
}
else {
println!("libusb_get_string_descriptor: {}", len);
}
languages
}
fn find_readable_endpoint(device: *mut ::ffi::libusb_device, transfer_type: u8) -> Option<Endpoint> {
let mut device_descriptor: ::ffi::libusb_device_descriptor = unsafe { mem::uninitialized() };
match unsafe { ::ffi::libusb_get_device_descriptor(device, &mut device_descriptor) } {
0 => {
for i in 0..device_descriptor.bNumConfigurations {
let mut config_ptr: *const ::ffi::libusb_config_descriptor = unsafe { mem::uninitialized() };
match unsafe { ::ffi::libusb_get_config_descriptor(device, i, &mut config_ptr) } {
0 => {
let config_descriptor = unsafe { &*config_ptr };
let interfaces = unsafe { slice::from_raw_parts(config_descriptor.interface, config_descriptor.bNumInterfaces as usize) };
for iface in interfaces {
let settings = unsafe { slice::from_raw_parts(iface.altsetting, iface.num_altsetting as usize) };
for iface_descriptor in settings {
let endpoints = unsafe { slice::from_raw_parts(iface_descriptor.endpoint, iface_descriptor.bNumEndpoints as usize) };
for endpoint_descriptor in endpoints {
let is_input = endpoint_descriptor.bEndpointAddress & ::ffi::LIBUSB_ENDPOINT_DIR_MASK == ::ffi::LIBUSB_ENDPOINT_IN;
let matches_type = endpoint_descriptor.bmAttributes & ::ffi::LIBUSB_TRANSFER_TYPE_MASK == transfer_type;
if is_input && matches_type {
return Some(Endpoint {
config: config_descriptor.bConfigurationValue,
iface: iface_descriptor.bInterfaceNumber,
setting: iface_descriptor.bAlternateSetting,
address: endpoint_descriptor.bEndpointAddress
});
}
}
}
}
},
e => println!("libusb_get_config_descriptor: {}", e)
}
}
None
},
e => {
println!("libusb_get_device_descriptor: {}", e);
None
}
}
}
fn read_endpoint(handle: *mut ::ffi::libusb_device_handle, device: *mut ::ffi::libusb_device, endpoint: Endpoint, transfer_type: u8) {
println!("Reading from endpoint: {:?}", endpoint);
let has_kernel_driver = unsafe {
if ::ffi::libusb_kernel_driver_active(handle, endpoint.iface as c_int) == 1 {
match ::ffi::libusb_detach_kernel_driver(handle, endpoint.iface as c_int) {
0 => (),
e => println!("libusb_detach_kernel_driver: {}", e)
}
true
}
else {
false
}
};
println!(" - kernel driver? {}", has_kernel_driver);
match unsafe { ::ffi::libusb_set_configuration(handle, endpoint.config as c_int) } {
0 => {
println!(" - max packet size: {}", unsafe { ::ffi::libusb_get_max_packet_size(device, endpoint.address as c_uchar) });
println!(" - max iso packet size: {}", unsafe { ::ffi::libusb_get_max_iso_packet_size(device, endpoint.address as c_uchar) });
match unsafe { ::ffi::libusb_claim_interface(handle, endpoint.iface as c_int) } {
0 => {
match unsafe { ::ffi::libusb_set_interface_alt_setting(handle, endpoint.iface as c_int, endpoint.setting as c_int) } {
0 => {
let mut vec = Vec::<u8>::with_capacity(256);
let timeout: c_uint = 1000;
let mut transferred: c_int = unsafe { mem::uninitialized() };
match transfer_type {
::ffi::LIBUSB_TRANSFER_TYPE_INTERRUPT => {
match unsafe { ::ffi::libusb_interrupt_transfer(handle, endpoint.address as c_uchar, (&vec[..]).as_ptr() as *mut c_uchar, vec.capacity() as c_int, &mut transferred, timeout) } {
0 => {
unsafe { vec.set_len(transferred as usize) };
println!(" - read: {:?}", vec);
},
e => println!("libusb_interrupt_transfer: {}", e)
}
},
::ffi::LIBUSB_TRANSFER_TYPE_BULK => {
match unsafe { ::ffi::libusb_bulk_transfer(handle, endpoint.address as c_uchar, (&vec[..]).as_ptr() as *mut c_uchar, vec.capacity() as c_int, &mut transferred, timeout) } {
0 => {
unsafe { vec.set_len(transferred as usize) };
println!(" - read: {:?}", vec);
},
e => println!("libusb_interrupt_transfer: {}", e)
}
},
tt => println!(" - can't read endpoint with transfer type {}", tt)
}
},
e => println!("libusb_set_interface_alt_setting: {}", e)
}
match unsafe { ::ffi::libusb_release_interface(handle, endpoint.iface as c_int) } {
0 => (),
e => println!("libusb_release_interface: {}", e)
}
},
e => println!("libusb_claim_interface: {}", e)
}
},
e => println!("libusb_set_configuration: {}", e)
}
if has_kernel_driver {
match unsafe { ::ffi::libusb_attach_kernel_driver(handle, endpoint.iface as c_int) } {
0 => (),
e => println!("libusb_attach_kernel_driver: {}", e)
}
}
}