Hotplug support

Author: richo

examples/hotplug.rs

@@ -0,0 +1,107 @@
+extern crate libusb_sys as ffi;
+extern crate libc;
+
+use libc::{c_int, c_void, timeval};
+
+use std::mem;
+use std::ptr;
+use std::time::Instant;
+
+fn main() {
+    let mut context: *mut ::ffi::libusb_context = unsafe { mem::uninitialized() };
+
+    match unsafe { ::ffi::libusb_init(&mut context) } {
+        0 => (),
+        e => panic!("libusb_init: {}", get_error(e)),
+    };
+
+    if unsafe { ::ffi::libusb_has_capability(::ffi::LIBUSB_CAP_HAS_HOTPLUG) == 0 } {
+        panic!("libusb doesn't support hotplug on this platform");
+    }
+
+    let mut callback_handle = unsafe { mem::uninitialized() };
+
+    let res = unsafe {
+        ::ffi::libusb_hotplug_register_callback(
+            context,
+            ::ffi::LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | ::ffi::LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
+            ::ffi::LIBUSB_HOTPLUG_ENUMERATE,
+            ::ffi::LIBUSB_HOTPLUG_MATCH_ANY,
+            ::ffi::LIBUSB_HOTPLUG_MATCH_ANY,
+            ::ffi::LIBUSB_HOTPLUG_MATCH_ANY,
+            callback_fn,
+            ptr::null_mut() as *mut c_void,
+            &mut callback_handle as *mut ::ffi::libusb_hotplug_callback_handle,
+        )
+    };
+
+    if res != ::ffi::LIBUSB_SUCCESS {
+        panic!("libusb_hotplug_register_callback: {}", get_error(res));
+    }
+
+    let start = Instant::now();
+    let mut timeout = timeval {
+        tv_sec: 0,
+        tv_usec: 100_000,
+    };
+
+    while start.elapsed().as_secs() < 30 {
+        match unsafe { ::ffi::libusb_handle_events_timeout_completed(context, &mut timeout, ptr::null_mut()) } {
+            0 => (),
+            e => panic!("libusb_handle_events: {}", get_error(e)),
+        };
+    }
+
+    unsafe {
+        ::ffi::libusb_hotplug_deregister_callback(context, callback_handle);
+        ::ffi::libusb_exit(context);
+    }
+}
+
+extern "C" fn callback_fn(_ctx: *mut ::ffi::libusb_context, device: *mut ::ffi::libusb_device, event: ::ffi::libusb_hotplug_event, _data: *mut c_void) -> i32 {
+    let event_name = match event {
+        ::ffi::LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED => "ATTACH",
+        ::ffi::LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT =>  "REMOVE",
+        _ => "OTHER",
+    };
+
+    let mut device_descriptor = unsafe { mem::uninitialized() };
+
+    unsafe {
+        match ::ffi::libusb_get_device_descriptor(device, &mut device_descriptor) {
+            0 => {
+                println!(
+                    "{}: {:04X}:{:04X} {}.{}.{}",
+                     event_name,
+                     device_descriptor.idVendor,
+                     device_descriptor.idProduct,
+                     ::ffi::libusb_get_bus_number(device),
+                     ::ffi::libusb_get_port_number(device),
+                     ::ffi::libusb_get_device_address(device),
+                );
+            },
+            e => println!("libusb_get_device_descriptor: {}", get_error(e)),
+        };
+    }
+
+    0
+}
+
+fn get_error(err: c_int) -> &'static str {
+    match err {
+        ::ffi::LIBUSB_SUCCESS             => "success",
+        ::ffi::LIBUSB_ERROR_IO            => "I/O error",
+        ::ffi::LIBUSB_ERROR_INVALID_PARAM => "invalid parameter",
+        ::ffi::LIBUSB_ERROR_ACCESS        => "access denied",
+        ::ffi::LIBUSB_ERROR_NO_DEVICE     => "no such device",
+        ::ffi::LIBUSB_ERROR_NOT_FOUND     => "entity not found",
+        ::ffi::LIBUSB_ERROR_BUSY          => "resource busy",
+        ::ffi::LIBUSB_ERROR_TIMEOUT       => "opteration timed out",
+        ::ffi::LIBUSB_ERROR_OVERFLOW      => "overflow error",
+        ::ffi::LIBUSB_ERROR_PIPE          => "pipe error",
+        ::ffi::LIBUSB_ERROR_INTERRUPTED   => "system call interrupted",
+        ::ffi::LIBUSB_ERROR_NO_MEM        => "insufficient memory",
+        ::ffi::LIBUSB_ERROR_NOT_SUPPORTED => "operation not supported",
+        ::ffi::LIBUSB_ERROR_OTHER | _     => "other error"
+    }
+}

src/lib.rs

@@ -192,10 +192,14 @@ pub struct libusb_pollfd {
     pub events: c_short,
 }
 
+
+pub type libusb_hotplug_callback_handle = c_int;
+pub type libusb_hotplug_callback_fn = extern "C" fn(*mut libusb_context, *mut libusb_device, libusb_hotplug_event, *mut c_void) -> c_int;
 pub type libusb_transfer_cb_fn = extern "C" fn(*mut libusb_transfer);
 pub type libusb_pollfd_added_cb = extern "C" fn(c_int, c_short, *mut c_void);
 pub type libusb_pollfd_removed_cb = extern "C" fn(c_int, *mut c_void);
 
+
 // libusb_error
 pub const LIBUSB_SUCCESS:             c_int = 0;
 pub const LIBUSB_ERROR_IO:            c_int = -1;
@@ -347,6 +351,18 @@ pub const LIBUSB_REQUEST_SET_SEL:           u8 = 0x30;
 pub const LIBUSB_SET_ISOCH_DELAY:           u8 = 0x31;
 
 
+// libusb_hotplug_event
+pub type libusb_hotplug_event = c_int;
+pub const LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: libusb_hotplug_event = 1 << 0;
+pub const LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:    libusb_hotplug_event = 1 << 1;
+
+
+// libusb_hotplug_flag
+pub const LIBUSB_HOTPLUG_NO_FLAGS:  c_int = 0;
+pub const LIBUSB_HOTPLUG_MATCH_ANY: c_int = -1;
+pub const LIBUSB_HOTPLUG_ENUMERATE: c_int = 1 << 0;
+
+
 extern "C" {
     pub fn libusb_get_version() -> *const libusb_version;
     pub fn libusb_has_capability(capability: u32) -> c_int;
@@ -442,6 +458,10 @@ extern "C" {
     pub fn libusb_get_next_timeout(context: *mut libusb_context, tv: *mut timeval) -> c_int;
     pub fn libusb_get_pollfds(context: *mut libusb_context) -> *const *mut libusb_pollfd;
     pub fn libusb_set_pollfd_notifiers(context: *mut libusb_context, added_cb: libusb_pollfd_added_cb, removed_cb: libusb_pollfd_removed_cb, user_data: *mut c_void);
+
+    pub fn libusb_hotplug_register_callback(context: *mut libusb_context, events: c_int, flags: c_int, vendor_id: c_int, product_id: c_int, dev_class: c_int, cb_fn: libusb_hotplug_callback_fn, user_data: *mut c_void, callback_handle: *mut libusb_hotplug_callback_handle) -> c_int;
+    pub fn libusb_hotplug_deregister_callback(context: *mut libusb_context, callback_handle: libusb_hotplug_callback_handle);
+    pub fn libusb_hotplug_get_user_data(context: *mut libusb_context, callback_handle: libusb_hotplug_callback_handle) -> *mut c_void;
 }