libudev-sys-0.1.4/.gitignore01006440001750000175000000000022132244736030014171 0ustar0000000000000000target Cargo.lock libudev-sys-0.1.4/.travis.yml01006440001750000175000000000462132245006350014316 0ustar0000000000000000sudo: false language: rust rust: - 1.7.0 - stable - beta - nightly matrix: allow_failures: - rust: nightly addons: apt: packages: - build-essential - libudev-dev before_install: - pkg-config --list-all - pkg-config --libs libudev - pkg-config --modversion libudev libudev-sys-0.1.4/Cargo.toml.orig01006440001750000175000000000726132245007030015073 0ustar0000000000000000[package] name = "libudev-sys" version = "0.1.4" authors = ["David Cuddeback "] description = "FFI bindings to libudev" license = "MIT" homepage = "https://github.com/dcuddeback/libudev-sys" repository = "https://github.com/dcuddeback/libudev-sys" readme = "README.md" keywords = ["udev", "hardware", "bindings", "sysfs", "systemd"] build = "build.rs" links = "libudev" [dependencies] libc = "0.2" [build-dependencies] pkg-config = "0.3.2" libudev-sys-0.1.4/Cargo.toml0000644000000017570010333 0ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g. crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "libudev-sys" version = "0.1.4" authors = ["David Cuddeback "] build = "build.rs" links = "libudev" description = "FFI bindings to libudev" homepage = "https://github.com/dcuddeback/libudev-sys" readme = "README.md" keywords = ["udev", "hardware", "bindings", "sysfs", "systemd"] license = "MIT" repository = "https://github.com/dcuddeback/libudev-sys" [dependencies.libc] version = "0.2" [build-dependencies.pkg-config] version = "0.3.2" libudev-sys-0.1.4/LICENSE01006440001750000175000000002043132244736030013213 0ustar0000000000000000Copyright (c) 2015 David Cuddeback Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. libudev-sys-0.1.4/README.md01006440001750000175000000006132132245007540013466 0ustar0000000000000000# Libudev Rust Bindings The `libudev-sys` crate provides declarations and linkage for the `libudev` C library. Following the `*-sys` package conventions, the `libudev-sys` crate does not define higher-level abstractions over the native `libudev` library functions. ## Dependencies In order to use the `libudev-sys` crate, you must have a Linux system with the `libudev` library installed where it can be found by `pkg-config`. To install `libudev` on Debian-based Linux distributions, execute the following command: ``` sudo apt-get install libudev-dev ``` `libudev` is a Linux-specific package. It is not available for Windows, OSX, or other operating systems. ### Cross-Compiling To link to a cross-compiled version of the native `libudev` library, it's necessary to set several environment variables to configure `pkg-config` to work with a cross-compiler's sysroot. [Autotools Mythbuster](https://autotools.io/) has a good explanation of [supporting cross-compilation](https://autotools.io/pkgconfig/cross-compiling.html) with `pkg-config`. However, Rust's [`pkg-config` build helper](https://github.com/alexcrichton/pkg-config-rs) doesn't support calling a `$CHOST`-prefixed `pkg-config`. It will always call `pkg-config` without a prefix. To cross-compile `libudev-sys` with the `pkg-config` build helper, one must define the environment variables `PKG_CONFIG_DIR`, `PKG_CONFIG_LIBDIR`, and `PKG_CONFIG_SYSROOT_DIR` for the *default* `pkg-config`. It's also necessary to set `PKG_CONFIG_ALLOW_CROSS` to tell Rust's `pkg-config` helper that it's okay to proceed with a cross-compile. To adapt the `pkg-config` wrapper in the Autotools Mythbuster guide so that it works with Rust, one will end up with a script similar to the following: ```sh #!/bin/sh SYSROOT=/build/root export PKG_CONFIG_DIR= export PKG_CONFIG_LIBDIR=${SYSROOT}/usr/lib/pkgconfig:${SYSROOT}/usr/share/pkgconfig export PKG_CONFIG_SYSROOT_DIR=${SYSROOT} export PKG_CONFIG_ALLOW_CROSS=1 cargo build ``` ## Usage Add `libudev-sys` as a dependency in `Cargo.toml`: ```toml [dependencies] libudev-sys = "0.1" ``` Import the `libudev_sys` crate and use the functions as they're defined in the native `libudev` library. See the [`libudev` API documention](http://www.freedesktop.org/software/systemd/libudev/) for more usage information. ```rust extern crate libudev_sys as ffi; ``` The `libudev-sys` build script detects the presence of native `libudev` functions and exports the functions found to exist. `libudev-sys` exports this information from its build script, which Cargo will provide to the build scripts of dependent packages in the form of environment variables: * `DEP_LIBUDEV_HWDB={true,false}`: The native `libudev` library has `udev_hwdb_*` functions. They will be exported by `libudev-sys`. ### Finding Help Since `libudev-sys` does nothing more than export symbols from the native `libudev` library, the best source for help is the information already available for the native `libudev`: * [API Documentation](http://www.freedesktop.org/software/systemd/libudev/) ## License Copyright © 2015 David Cuddeback Distributed under the [MIT License](LICENSE). libudev-sys-0.1.4/build.rs01006440001750000175000000002535132245006350013655 0ustar0000000000000000extern crate pkg_config; use std::env; use std::fs::File; use std::path::Path; use std::process::Command; use std::io::prelude::*; fn check_func(function_name: &str) -> bool { let out_dir = env::var_os("OUT_DIR").unwrap(); let test_file_name = Path::new(&out_dir).join(format!("check_{}.rs", function_name)); { let mut test_file = File::create(&test_file_name).unwrap(); writeln!(&mut test_file, "extern \"C\" {{").unwrap(); writeln!(&mut test_file, " fn {}();", function_name).unwrap(); writeln!(&mut test_file, "}}").unwrap(); writeln!(&mut test_file, "").unwrap(); writeln!(&mut test_file, "fn main() {{").unwrap(); writeln!(&mut test_file, " unsafe {{").unwrap(); writeln!(&mut test_file, " {}();", function_name).unwrap(); writeln!(&mut test_file, " }}").unwrap(); writeln!(&mut test_file, "}}").unwrap(); } let output = Command::new("rustc"). arg(&test_file_name). arg("--out-dir").arg(&out_dir). arg("-l").arg("udev"). output().unwrap(); output.status.success() } fn main() { pkg_config::find_library("libudev").unwrap(); if check_func("udev_hwdb_new") { println!("cargo:rustc-cfg=hwdb"); println!("cargo:hwdb=true"); } else { println!("cargo:hwdb=false"); } } libudev-sys-0.1.4/examples/hwdb_query.rs01006440001750000175000000003124132244736030016544 0ustar0000000000000000extern 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::>(); if args.len() != 2 { println!("Usage: hwdb_query "); 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"); } libudev-sys-0.1.4/examples/list_devices.rs01006440001750000175000000007374132244736030017063 0ustar0000000000000000extern 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("") } } libudev-sys-0.1.4/examples/monitor.rs01006440001750000175000000004244132244736030016066 0ustar0000000000000000extern 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("") } } libudev-sys-0.1.4/src/lib.rs01006440001750000175000000020423132244736030014113 0ustar0000000000000000#![allow(non_camel_case_types)] extern crate libc; use libc::{c_void,c_int,c_char,c_ulonglong,size_t,dev_t}; #[cfg(hwdb)] pub use hwdb::*; #[repr(C)] pub struct udev { __private: c_void, } #[repr(C)] pub struct udev_list_entry { __private: c_void, } #[repr(C)] pub struct udev_device { __private: c_void, } #[repr(C)] pub struct udev_monitor { __private: c_void, } #[repr(C)] pub struct udev_enumerate { __private: c_void, } #[repr(C)] pub struct udev_queue { __private: c_void, } extern "C" { // udev pub fn udev_new() -> *mut udev; pub fn udev_ref(udev: *mut udev) -> *mut udev; pub fn udev_unref(udev: *mut udev) -> *mut udev; pub fn udev_set_userdata(udev: *mut udev, userdata: *mut c_void); pub fn udev_get_userdata(udev: *mut udev) -> *mut c_void; // udev_list pub fn udev_list_entry_get_next(list_entry: *mut udev_list_entry) -> *mut udev_list_entry; pub fn udev_list_entry_get_by_name(list_entry: *mut udev_list_entry, name: *const c_char) -> *mut udev_list_entry; pub fn udev_list_entry_get_name(list_entry: *mut udev_list_entry) -> *const c_char; pub fn udev_list_entry_get_value(list_entry: *mut udev_list_entry) -> *const c_char; // udev_device pub fn udev_device_ref(udev_device: *mut udev_device) -> *mut udev_device; pub fn udev_device_unref(udev_device: *mut udev_device) -> *mut udev_device; pub fn udev_device_get_udev(udev_device: *mut udev_device) -> *mut udev; pub fn udev_device_new_from_syspath(udev: *mut udev, syspath: *const c_char) -> *mut udev_device; pub fn udev_device_new_from_devnum(udev: *mut udev, dev_type: c_char, devnum: dev_t) -> *mut udev_device; pub fn udev_device_new_from_subsystem_sysname(udev: *mut udev, subsystem: *const c_char, sysname: *const c_char) -> *mut udev_device; pub fn udev_device_new_from_device_id(udev: *mut udev, id: *const c_char) -> *mut udev_device; pub fn udev_device_new_from_environment(udev: *mut udev) -> *mut udev_device; pub fn udev_device_get_parent(udev_device: *mut udev_device) -> *mut udev_device; pub fn udev_device_get_parent_with_subsystem_devtype(udev_device: *mut udev_device, subsystem: *const c_char, devtype: *const c_char) -> *mut udev_device; pub fn udev_device_get_devpath(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_subsystem(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_devtype(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_syspath(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_sysname(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_sysnum(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_devnode(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_is_initialized(udev_device: *mut udev_device) -> c_int; pub fn udev_device_get_devlinks_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry; pub fn udev_device_get_properties_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry; pub fn udev_device_get_tags_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry; pub fn udev_device_get_property_value(udev_device: *mut udev_device, key: *const c_char) -> *const c_char; pub fn udev_device_get_driver(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_devnum(udev_device: *mut udev_device) -> dev_t; pub fn udev_device_get_action(udev_device: *mut udev_device) -> *const c_char; pub fn udev_device_get_sysattr_value(udev_device: *mut udev_device, sysattr: *const c_char) -> *const c_char; pub fn udev_device_set_sysattr_value(udev_device: *mut udev_device, sysattr: *const c_char, value: *mut c_char) -> c_int; pub fn udev_device_get_sysattr_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry; pub fn udev_device_get_seqnum(udev_device: *mut udev_device) -> c_ulonglong; pub fn udev_device_get_usec_since_initialized(udev_device: *mut udev_device) -> c_ulonglong; pub fn udev_device_has_tag(udev_device: *mut udev_device, tag: *const c_char) -> c_int; // udev_monitor pub fn udev_monitor_ref(udev_monitor: *mut udev_monitor) -> *mut udev_monitor; pub fn udev_monitor_unref(udev_monitor: *mut udev_monitor) -> *mut udev_monitor; pub fn udev_monitor_get_udev(udev_monitor: *mut udev_monitor) -> *mut udev; pub fn udev_monitor_new_from_netlink(udev: *mut udev, name: *const c_char) -> *mut udev_monitor; pub fn udev_monitor_enable_receiving(udev_monitor: *mut udev_monitor) -> c_int; pub fn udev_monitor_set_receive_buffer_size(udev_monitor: *mut udev_monitor, size: c_int) -> c_int; pub fn udev_monitor_get_fd(udev_monitor: *mut udev_monitor) -> c_int; pub fn udev_monitor_receive_device(udev_monitor: *mut udev_monitor) -> *mut udev_device; pub fn udev_monitor_filter_add_match_subsystem_devtype(udev_monitor: *mut udev_monitor, subsystem: *const c_char, devtype: *const c_char) -> c_int; pub fn udev_monitor_filter_add_match_tag(udev_monitor: *mut udev_monitor, tag: *const c_char) -> c_int; pub fn udev_monitor_filter_update(udev_monitor: *mut udev_monitor) -> c_int; pub fn udev_monitor_filter_remove(udev_monitor: *mut udev_monitor) -> c_int; // udev_enumerate pub fn udev_enumerate_ref(udev_enumerate: *mut udev_enumerate) -> *mut udev_enumerate; pub fn udev_enumerate_unref(udev_enumerate: *mut udev_enumerate) -> *mut udev_enumerate; pub fn udev_enumerate_get_udev(udev_enumerate: *mut udev_enumerate) -> *mut udev; pub fn udev_enumerate_new(udev: *mut udev) -> *mut udev_enumerate; pub fn udev_enumerate_add_match_subsystem(udev_enumerate: *mut udev_enumerate, subsystem: *const c_char) -> c_int; pub fn udev_enumerate_add_nomatch_subsystem(udev_enumerate: *mut udev_enumerate, subsystem: *const c_char) -> c_int; pub fn udev_enumerate_add_match_sysattr(udev_enumerate: *mut udev_enumerate, sysattr: *const c_char, value: *const c_char) -> c_int; pub fn udev_enumerate_add_nomatch_sysattr(udev_enumerate: *mut udev_enumerate, sysattr: *const c_char, value: *const c_char) -> c_int; pub fn udev_enumerate_add_match_property(udev_enumerate: *mut udev_enumerate, property: *const c_char, value: *const c_char) -> c_int; pub fn udev_enumerate_add_match_tag(udev_enumerate: *mut udev_enumerate, tag: *const c_char) -> c_int; pub fn udev_enumerate_add_match_parent(udev_enumerate: *mut udev_enumerate, parent: *mut udev_device) -> c_int; pub fn udev_enumerate_add_match_is_initialized(udev_enumerate: *mut udev_enumerate) -> c_int; pub fn udev_enumerate_add_match_sysname(udev_enumerate: *mut udev_enumerate, sysname: *const c_char) -> c_int; pub fn udev_enumerate_add_syspath(udev_enumerate: *mut udev_enumerate, syspath: *const c_char) -> c_int; pub fn udev_enumerate_scan_devices(udev_enumerate: *mut udev_enumerate) -> c_int; pub fn udev_enumerate_scan_subsystems(udev_enumerate: *mut udev_enumerate) -> c_int; pub fn udev_enumerate_get_list_entry(udev_enumerate: *mut udev_enumerate) -> *mut udev_list_entry; // udev_queue pub fn udev_queue_ref(udev_queue: *mut udev_queue) -> *mut udev_queue; pub fn udev_queue_unref(udev_queue: *mut udev_queue) -> *mut udev_queue; pub fn udev_queue_get_udev(udev_queue: *mut udev_queue) -> *mut udev; pub fn udev_queue_new(udev: *mut udev) -> *mut udev_queue; pub fn udev_queue_get_udev_is_active(udev_queue: *mut udev_queue) -> c_int; pub fn udev_queue_get_queue_is_empty(udev_queue: *mut udev_queue) -> c_int; pub fn udev_queue_get_fd(udev_queue: *mut udev_queue) -> c_int; pub fn udev_queue_flush(udev_queue: *mut udev_queue) -> c_int; // udev_util pub fn udev_util_encode_string(str: *const c_char, str_enc: *mut c_char, len: size_t) -> c_int; } #[cfg(hwdb)] mod hwdb { use super::libc::{c_void,c_uint,c_char}; use super::{udev,udev_list_entry}; #[repr(C)] pub struct udev_hwdb { __private: c_void, } extern "C" { pub fn udev_hwdb_ref(hwdb: *mut udev_hwdb) -> *mut udev_hwdb; pub fn udev_hwdb_unref(hwdb: *mut udev_hwdb) -> *mut udev_hwdb; pub fn udev_hwdb_new(udev: *mut udev) -> *mut udev_hwdb; pub fn udev_hwdb_get_properties_list_entry(hwdb: *mut udev_hwdb, modalias: *const c_char, flags: c_uint) -> *mut udev_list_entry; } }