Vendor dependencies for 0.3.0 release

vendor/libudev-sys/examples/hwdb_query.rs

@@ -0,0 +1,70 @@
+extern crate libudev_sys as udev;
+extern crate libc;
+
+
+#[cfg(hwdb)] use std::env;
+#[cfg(hwdb)] use std::str;
+#[cfg(hwdb)] use std::ffi::{CString,CStr};
+#[cfg(hwdb)] use libc::c_char;
+
+#[cfg(hwdb)]
+fn main() {
+
+    let args = env::args().collect::<Vec<_>>();
+
+    if args.len() != 2 {
+        println!("Usage: hwdb_query <modalias>");
+        return;
+    }
+
+    let query = CString::new(args[1].clone()).unwrap();
+
+    unsafe {
+        let udev = udev::udev_new();
+
+        if !udev.is_null() {
+            let hwdb = udev::udev_hwdb_new(udev);
+
+            if !hwdb.is_null() {
+                query_hwdb(hwdb, &query);
+                udev::udev_hwdb_unref(hwdb);
+            }
+
+            udev::udev_unref(udev);
+        }
+    }
+}
+
+#[cfg(hwdb)]
+unsafe fn query_hwdb(hwdb: *mut udev::udev_hwdb, query: &CString) {
+    println!("{:>30}: {:?}", "query", query);
+
+    udev::udev_hwdb_ref(hwdb);
+    print_results(udev::udev_hwdb_get_properties_list_entry(hwdb, query.as_ptr(), 0));
+    udev::udev_hwdb_unref(hwdb);
+}
+
+#[cfg(hwdb)]
+unsafe fn print_results(list_entry: *mut udev::udev_list_entry) {
+    if list_entry.is_null() {
+        return;
+    }
+
+    let key = unwrap_str(udev::udev_list_entry_get_name(list_entry));
+    let val = unwrap_str(udev::udev_list_entry_get_value(list_entry));
+
+    println!("{:>30}: {}", key, val);
+
+    print_results(udev::udev_list_entry_get_next(list_entry));
+}
+
+#[cfg(hwdb)]
+unsafe fn unwrap_str<'a>(ptr: *const c_char) -> &'a str {
+    str::from_utf8(CStr::from_ptr(ptr).to_bytes()).unwrap()
+}
+
+
+#[cfg(not(hwdb))]
+fn main() {
+    println!("hwdb is not supported by native libudev");
+}

vendor/libudev-sys/examples/list_devices.rs

@@ -0,0 +1,124 @@
+extern crate libudev_sys as udev;
+extern crate libc;
+
+use std::ffi::CStr;
+use std::str;
+
+use libc::c_char;
+
+fn main() {
+    unsafe {
+        let udev = udev::udev_new();
+
+        if !udev.is_null() {
+            enumerate_devices(udev);
+            udev::udev_unref(udev);
+        }
+    }
+}
+
+unsafe fn enumerate_devices(udev: *mut udev::udev) {
+    udev::udev_ref(udev);
+
+    let enumerate = udev::udev_enumerate_new(udev);
+
+    if !enumerate.is_null() {
+        list_devices(enumerate);
+        udev::udev_enumerate_unref(enumerate);
+    }
+
+    udev::udev_unref(udev);
+}
+
+unsafe fn list_devices(enumerate: *mut udev::udev_enumerate) {
+    udev::udev_enumerate_ref(enumerate);
+
+    if udev::udev_enumerate_scan_devices(enumerate) < 0 {
+        udev::udev_enumerate_unref(enumerate);
+        return;
+    }
+
+    print_devices(
+        udev::udev_enumerate_get_udev(enumerate),
+        udev::udev_enumerate_get_list_entry(enumerate));
+
+    udev::udev_enumerate_unref(enumerate);
+}
+
+unsafe fn print_devices(udev: *mut udev::udev, list_entry: *mut udev::udev_list_entry) {
+    if list_entry.is_null() {
+        return;
+    }
+
+    let syspath = udev::udev_list_entry_get_name(list_entry);
+    let device = udev::udev_device_new_from_syspath(udev, syspath);
+
+    if !device.is_null() {
+        print_device(device);
+    }
+
+    print_devices(udev, udev::udev_list_entry_get_next(list_entry));
+}
+
+unsafe fn print_device(device: *mut udev::udev_device) {
+    udev::udev_device_ref(device);
+
+    println!("");
+
+    let initialized = udev::udev_device_get_is_initialized(device) != 0;
+    let since = udev::udev_device_get_usec_since_initialized(device);
+
+    println!("initialized: {} usec={}", initialized, since);
+    println!("     devnum: {}", udev::udev_device_get_devnum(device));
+    println!("    devpath: {}", unwrap_cstr(udev::udev_device_get_devpath(device)));
+    println!("  subsystem: {}", unwrap_cstr(udev::udev_device_get_subsystem(device)));
+    println!("    devtype: {}", unwrap_cstr(udev::udev_device_get_devtype(device)));
+    println!("    syspath: {}", unwrap_cstr(udev::udev_device_get_syspath(device)));
+    println!("    sysname: {}", unwrap_cstr(udev::udev_device_get_sysname(device)));
+    println!("     sysnum: {}", unwrap_cstr(udev::udev_device_get_sysnum(device)));
+    println!("    devnode: {}", unwrap_cstr(udev::udev_device_get_devnode(device)));
+    println!("     driver: {}", unwrap_cstr(udev::udev_device_get_driver(device)));
+
+    println!(" properties:");
+    print_device_properties(udev::udev_device_get_properties_list_entry(device), device);
+
+    println!(" attributes:");
+    print_device_attributes(udev::udev_device_get_sysattr_list_entry(device), device);
+
+    udev::udev_device_unref(device);
+}
+
+unsafe fn print_device_properties(list_entry: *mut udev::udev_list_entry, device: *mut udev::udev_device) {
+    if list_entry.is_null() {
+        return;
+    }
+
+    let propname = udev::udev_list_entry_get_name(list_entry);
+    let propval = udev::udev_device_get_property_value(device, propname);
+
+    println!("{:>15}: {}", unwrap_cstr(propname), unwrap_cstr(propval));
+
+    print_device_properties(udev::udev_list_entry_get_next(list_entry), device);
+}
+
+unsafe fn print_device_attributes(list_entry: *mut udev::udev_list_entry, device: *mut udev::udev_device) {
+    if list_entry.is_null() {
+        return;
+    }
+
+    let attrname = udev::udev_list_entry_get_name(list_entry);
+    let attrval = udev::udev_device_get_sysattr_value(device, attrname);
+
+    println!("{:>15}: {}", unwrap_cstr(attrname), unwrap_cstr(attrval));
+
+    print_device_attributes(udev::udev_list_entry_get_next(list_entry), device);
+}
+
+unsafe fn unwrap_cstr<'a>(ptr: *const c_char) -> &'a str {
+    if ptr.is_null() {
+        ""
+    }
+    else {
+        str::from_utf8(CStr::from_ptr(ptr).to_bytes()).unwrap_or("")
+    }
+}

vendor/libudev-sys/examples/monitor.rs

@@ -0,0 +1,88 @@
+extern crate libudev_sys as udev;
+extern crate libc;
+
+use std::str;
+
+use std::ffi::{CString,CStr};
+
+use self::libc::{c_int,c_short,c_char};
+
+
+#[cfg(target_os = "linux")]
+#[allow(non_camel_case_types)]
+type nfds_t = libc::c_ulong;
+
+#[cfg(not(target_os = "linux"))]
+#[allow(non_camel_case_types)]
+type nfds_t = libc::c_uint;
+
+#[repr(C)]
+struct PollFd {
+  fd: c_int,
+  events: c_short,
+  revents: c_short
+}
+
+const POLLIN: c_short = 0x0001;
+
+extern "C" {
+  fn poll(fds: *mut PollFd, nfds: nfds_t, timeout: c_int) -> c_int;
+}
+
+
+fn main() {
+    let netlink = CString::new("udev").unwrap();
+
+    unsafe {
+        let udev = udev::udev_new();
+
+        if !udev.is_null() {
+            let monitor = udev::udev_monitor_new_from_netlink(udev, netlink.as_ptr());
+
+            if !monitor.is_null() {
+                listen(monitor);
+                udev::udev_monitor_unref(monitor);
+            }
+
+            udev::udev_unref(udev);
+        }
+    }
+}
+
+unsafe fn listen(monitor: *mut udev::udev_monitor) {
+    udev::udev_monitor_ref(monitor);
+
+    udev::udev_monitor_enable_receiving(monitor);
+
+    let fd = udev::udev_monitor_get_fd(monitor);
+    let mut fds = vec!(PollFd { fd: fd, events: POLLIN, revents: 0 });
+
+    while poll((&mut fds[..]).as_mut_ptr(), fds.len() as nfds_t, -1) > 0 {
+        if fds[0].revents & POLLIN != 0 {
+            let device = udev::udev_monitor_receive_device(monitor);
+            print_device(device);
+            udev::udev_device_unref(device);
+        }
+    }
+
+    udev::udev_monitor_unref(monitor);
+}
+
+unsafe fn print_device(device: *mut udev::udev_device) {
+    let seqnum = udev::udev_device_get_seqnum(device);
+    let action = unwrap_cstr(udev::udev_device_get_action(device));
+    let devpath = unwrap_cstr(udev::udev_device_get_devpath(device));
+    let initialized = udev::udev_device_get_is_initialized(device) != 0;
+    let since = udev::udev_device_get_usec_since_initialized(device);
+
+    println!("{}: [{}] {} (intialized={} usec={})", seqnum, action, devpath, initialized, since);
+}
+
+unsafe fn unwrap_cstr<'a>(ptr: *const c_char) -> &'a str {
+    if ptr.is_null() {
+        ""
+    }
+    else {
+        str::from_utf8(CStr::from_ptr(ptr).to_bytes()).unwrap_or("")
+    }
+}