Skip to main content

libudev_sys_azul/
lib.rs

1#![allow(non_camel_case_types, clippy::missing_safety_doc)]
2//! dlopen-based drop-in fork of `libudev-sys` 0.1.4.
3//!
4//! API-identical to upstream `libudev-sys` (same opaque structs + the same
5//! `udev_*` functions), but instead of *link-binding* `libudev` at build time
6//! (upstream's `build.rs` runs `pkg_config::find_library("libudev").unwrap()`,
7//! which fails when cross-compiling to a host that has no libudev), every
8//! function loads `libudev.so` lazily at *runtime* via `libloading` and
9//! dispatches through a function pointer.
10//!
11//! Consequences:
12//! - The crate has **no build-time native dependency**, so anything depending
13//!   on it (gilrs-core -> gilrs) cross-compiles to any target with no libudev
14//!   present (e.g. `cargo build --target x86_64-unknown-linux-gnu` from macOS).
15//! - If `libudev.so` is not loadable at runtime, every function returns a
16//!   zeroed value (null pointer / 0), so the caller (gilrs) simply observes "no
17//!   udev / no devices" and gracefully reports no gamepads - rather than the
18//!   process failing to start.
19//!
20//! Drop-in for `libudev-sys`: depend on `libudev-azul` and either rename it in
21//! `Cargo.toml` (`libudev-sys = { package = "libudev-azul", version = "..." }`)
22//! or redirect via `[patch.crates-io] libudev-sys = { package = "libudev-azul",
23//! version = "..." }`, so consumers like gilrs build unmodified.
24//!
25//! Fork of `libudev-sys` (c) 2015 David Cuddeback, MIT-licensed
26//! (<https://github.com/dcuddeback/libudev-sys>). The only change is the
27//! runtime-`dlopen` loading described above; the FFI surface is identical.
28
29use libc::{c_char, c_int, c_ulonglong, c_void, dev_t, size_t};
30
31#[repr(C)]
32pub struct udev {
33    __private: c_void,
34}
35#[repr(C)]
36pub struct udev_list_entry {
37    __private: c_void,
38}
39#[repr(C)]
40pub struct udev_device {
41    __private: c_void,
42}
43#[repr(C)]
44pub struct udev_monitor {
45    __private: c_void,
46}
47#[repr(C)]
48pub struct udev_enumerate {
49    __private: c_void,
50}
51#[repr(C)]
52pub struct udev_queue {
53    __private: c_void,
54}
55
56/// Generate, for each declared function:
57/// - a field in `LibudevFns` holding the dlsym'd function pointer,
58/// - a public `extern "C"` wrapper that dispatches to it (or returns zeroed if
59///   libudev isn't loadable).
60macro_rules! libudev_dlopen {
61    ($( fn $name:ident( $($arg:ident : $aty:ty),* $(,)? ) $(-> $ret:ty)? ; )*) => {
62        struct LibudevFns {
63            $( $name: unsafe extern "C" fn($($aty),*) $(-> $ret)?, )*
64        }
65
66        unsafe fn load() -> Option<(libloading::Library, LibudevFns)> {
67            let lib = libloading::Library::new("libudev.so.1")
68                .or_else(|_| libloading::Library::new("libudev.so.0"))
69                .or_else(|_| libloading::Library::new("libudev.so"))
70                .ok()?;
71            let fns = LibudevFns {
72                $( $name: {
73                    let sym: libloading::Symbol<unsafe extern "C" fn($($aty),*) $(-> $ret)?> =
74                        lib.get(concat!(stringify!($name), "\0").as_bytes()).ok()?;
75                    *sym
76                }, )*
77            };
78            Some((lib, fns))
79        }
80
81        // Loaded once; the `Library` is kept alive in the tuple so the function
82        // pointers stay valid for the process lifetime.
83        static LIBUDEV: std::sync::OnceLock<Option<(libloading::Library, LibudevFns)>> =
84            std::sync::OnceLock::new();
85
86        #[inline]
87        fn fns() -> Option<&'static LibudevFns> {
88            LIBUDEV.get_or_init(|| unsafe { load() }).as_ref().map(|(_, f)| f)
89        }
90
91        $(
92            pub unsafe extern "C" fn $name( $($arg : $aty),* ) $(-> $ret)? {
93                match fns() {
94                    Some(f) => (f.$name)($($arg),*),
95                    // libudev not loadable: null / 0 (POD return types only).
96                    None => ::core::mem::zeroed(),
97                }
98            }
99        )*
100    };
101}
102
103libudev_dlopen! {
104    // udev
105    fn udev_new() -> *mut udev;
106    fn udev_ref(udev: *mut udev) -> *mut udev;
107    fn udev_unref(udev: *mut udev) -> *mut udev;
108    fn udev_set_userdata(udev: *mut udev, userdata: *mut c_void);
109    fn udev_get_userdata(udev: *mut udev) -> *mut c_void;
110
111    // udev_list
112    fn udev_list_entry_get_next(list_entry: *mut udev_list_entry) -> *mut udev_list_entry;
113    fn udev_list_entry_get_by_name(list_entry: *mut udev_list_entry, name: *const c_char) -> *mut udev_list_entry;
114    fn udev_list_entry_get_name(list_entry: *mut udev_list_entry) -> *const c_char;
115    fn udev_list_entry_get_value(list_entry: *mut udev_list_entry) -> *const c_char;
116
117    // udev_device
118    fn udev_device_ref(udev_device: *mut udev_device) -> *mut udev_device;
119    fn udev_device_unref(udev_device: *mut udev_device) -> *mut udev_device;
120    fn udev_device_get_udev(udev_device: *mut udev_device) -> *mut udev;
121    fn udev_device_new_from_syspath(udev: *mut udev, syspath: *const c_char) -> *mut udev_device;
122    fn udev_device_new_from_devnum(udev: *mut udev, dev_type: c_char, devnum: dev_t) -> *mut udev_device;
123    fn udev_device_new_from_subsystem_sysname(udev: *mut udev, subsystem: *const c_char, sysname: *const c_char) -> *mut udev_device;
124    fn udev_device_new_from_device_id(udev: *mut udev, id: *const c_char) -> *mut udev_device;
125    fn udev_device_new_from_environment(udev: *mut udev) -> *mut udev_device;
126    fn udev_device_get_parent(udev_device: *mut udev_device) -> *mut udev_device;
127    fn udev_device_get_parent_with_subsystem_devtype(udev_device: *mut udev_device, subsystem: *const c_char, devtype: *const c_char) -> *mut udev_device;
128    fn udev_device_get_devpath(udev_device: *mut udev_device) -> *const c_char;
129    fn udev_device_get_subsystem(udev_device: *mut udev_device) -> *const c_char;
130    fn udev_device_get_devtype(udev_device: *mut udev_device) -> *const c_char;
131    fn udev_device_get_syspath(udev_device: *mut udev_device) -> *const c_char;
132    fn udev_device_get_sysname(udev_device: *mut udev_device) -> *const c_char;
133    fn udev_device_get_sysnum(udev_device: *mut udev_device) -> *const c_char;
134    fn udev_device_get_devnode(udev_device: *mut udev_device) -> *const c_char;
135    fn udev_device_get_is_initialized(udev_device: *mut udev_device) -> c_int;
136    fn udev_device_get_devlinks_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry;
137    fn udev_device_get_properties_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry;
138    fn udev_device_get_tags_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry;
139    fn udev_device_get_property_value(udev_device: *mut udev_device, key: *const c_char) -> *const c_char;
140    fn udev_device_get_driver(udev_device: *mut udev_device) -> *const c_char;
141    fn udev_device_get_devnum(udev_device: *mut udev_device) -> dev_t;
142    fn udev_device_get_action(udev_device: *mut udev_device) -> *const c_char;
143    fn udev_device_get_sysattr_value(udev_device: *mut udev_device, sysattr: *const c_char) -> *const c_char;
144    fn udev_device_set_sysattr_value(udev_device: *mut udev_device, sysattr: *const c_char, value: *mut c_char) -> c_int;
145    fn udev_device_get_sysattr_list_entry(udev_device: *mut udev_device) -> *mut udev_list_entry;
146    fn udev_device_get_seqnum(udev_device: *mut udev_device) -> c_ulonglong;
147    fn udev_device_get_usec_since_initialized(udev_device: *mut udev_device) -> c_ulonglong;
148    fn udev_device_has_tag(udev_device: *mut udev_device, tag: *const c_char) -> c_int;
149
150    // udev_monitor
151    fn udev_monitor_ref(udev_monitor: *mut udev_monitor) -> *mut udev_monitor;
152    fn udev_monitor_unref(udev_monitor: *mut udev_monitor) -> *mut udev_monitor;
153    fn udev_monitor_get_udev(udev_monitor: *mut udev_monitor) -> *mut udev;
154    fn udev_monitor_new_from_netlink(udev: *mut udev, name: *const c_char) -> *mut udev_monitor;
155    fn udev_monitor_enable_receiving(udev_monitor: *mut udev_monitor) -> c_int;
156    fn udev_monitor_set_receive_buffer_size(udev_monitor: *mut udev_monitor, size: c_int) -> c_int;
157    fn udev_monitor_get_fd(udev_monitor: *mut udev_monitor) -> c_int;
158    fn udev_monitor_receive_device(udev_monitor: *mut udev_monitor) -> *mut udev_device;
159    fn udev_monitor_filter_add_match_subsystem_devtype(udev_monitor: *mut udev_monitor, subsystem: *const c_char, devtype: *const c_char) -> c_int;
160    fn udev_monitor_filter_add_match_tag(udev_monitor: *mut udev_monitor, tag: *const c_char) -> c_int;
161    fn udev_monitor_filter_update(udev_monitor: *mut udev_monitor) -> c_int;
162    fn udev_monitor_filter_remove(udev_monitor: *mut udev_monitor) -> c_int;
163
164    // udev_enumerate
165    fn udev_enumerate_ref(udev_enumerate: *mut udev_enumerate) -> *mut udev_enumerate;
166    fn udev_enumerate_unref(udev_enumerate: *mut udev_enumerate) -> *mut udev_enumerate;
167    fn udev_enumerate_get_udev(udev_enumerate: *mut udev_enumerate) -> *mut udev;
168    fn udev_enumerate_new(udev: *mut udev) -> *mut udev_enumerate;
169    fn udev_enumerate_add_match_subsystem(udev_enumerate: *mut udev_enumerate, subsystem: *const c_char) -> c_int;
170    fn udev_enumerate_add_nomatch_subsystem(udev_enumerate: *mut udev_enumerate, subsystem: *const c_char) -> c_int;
171    fn udev_enumerate_add_match_sysattr(udev_enumerate: *mut udev_enumerate, sysattr: *const c_char, value: *const c_char) -> c_int;
172    fn udev_enumerate_add_nomatch_sysattr(udev_enumerate: *mut udev_enumerate, sysattr: *const c_char, value: *const c_char) -> c_int;
173    fn udev_enumerate_add_match_property(udev_enumerate: *mut udev_enumerate, property: *const c_char, value: *const c_char) -> c_int;
174    fn udev_enumerate_add_match_tag(udev_enumerate: *mut udev_enumerate, tag: *const c_char) -> c_int;
175    fn udev_enumerate_add_match_parent(udev_enumerate: *mut udev_enumerate, parent: *mut udev_device) -> c_int;
176    fn udev_enumerate_add_match_is_initialized(udev_enumerate: *mut udev_enumerate) -> c_int;
177    fn udev_enumerate_add_match_sysname(udev_enumerate: *mut udev_enumerate, sysname: *const c_char) -> c_int;
178    fn udev_enumerate_add_syspath(udev_enumerate: *mut udev_enumerate, syspath: *const c_char) -> c_int;
179    fn udev_enumerate_scan_devices(udev_enumerate: *mut udev_enumerate) -> c_int;
180    fn udev_enumerate_scan_subsystems(udev_enumerate: *mut udev_enumerate) -> c_int;
181    fn udev_enumerate_get_list_entry(udev_enumerate: *mut udev_enumerate) -> *mut udev_list_entry;
182
183    // udev_queue
184    fn udev_queue_ref(udev_queue: *mut udev_queue) -> *mut udev_queue;
185    fn udev_queue_unref(udev_queue: *mut udev_queue) -> *mut udev_queue;
186    fn udev_queue_get_udev(udev_queue: *mut udev_queue) -> *mut udev;
187    fn udev_queue_new(udev: *mut udev) -> *mut udev_queue;
188    fn udev_queue_get_udev_is_active(udev_queue: *mut udev_queue) -> c_int;
189    fn udev_queue_get_queue_is_empty(udev_queue: *mut udev_queue) -> c_int;
190    fn udev_queue_get_fd(udev_queue: *mut udev_queue) -> c_int;
191    fn udev_queue_flush(udev_queue: *mut udev_queue) -> c_int;
192
193    // udev_util
194    fn udev_util_encode_string(s: *const c_char, str_enc: *mut c_char, len: size_t) -> c_int;
195}