1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17
18#[cfg(unix)]
19#[allow(unused_imports)]
20use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
21#[allow(unused_imports)]
22use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
23#[allow(unused_imports)]
24use std::ffi::{
25 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
26};
27
28#[allow(unused_imports)]
29use glib::{gboolean, gconstpointer, gpointer, GType};
30
31pub type GUdevDeviceNumber = u64;
33
34pub type GUdevDeviceType = c_int;
36pub const G_UDEV_DEVICE_TYPE_NONE: GUdevDeviceType = 0;
37pub const G_UDEV_DEVICE_TYPE_BLOCK: GUdevDeviceType = 98;
38pub const G_UDEV_DEVICE_TYPE_CHAR: GUdevDeviceType = 99;
39
40#[derive(Copy, Clone)]
42#[repr(C)]
43pub struct GUdevClientClass {
44 pub parent_class: gobject::GObjectClass,
45 pub uevent: Option<unsafe extern "C" fn(*mut GUdevClient, *const c_char, *mut GUdevDevice)>,
46 pub reserved1: Option<unsafe extern "C" fn()>,
47 pub reserved2: Option<unsafe extern "C" fn()>,
48 pub reserved3: Option<unsafe extern "C" fn()>,
49 pub reserved4: Option<unsafe extern "C" fn()>,
50 pub reserved5: Option<unsafe extern "C" fn()>,
51 pub reserved6: Option<unsafe extern "C" fn()>,
52 pub reserved7: Option<unsafe extern "C" fn()>,
53 pub reserved8: Option<unsafe extern "C" fn()>,
54}
55
56impl ::std::fmt::Debug for GUdevClientClass {
57 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
58 f.debug_struct(&format!("GUdevClientClass @ {self:p}"))
59 .field("parent_class", &self.parent_class)
60 .field("uevent", &self.uevent)
61 .field("reserved1", &self.reserved1)
62 .field("reserved2", &self.reserved2)
63 .field("reserved3", &self.reserved3)
64 .field("reserved4", &self.reserved4)
65 .field("reserved5", &self.reserved5)
66 .field("reserved6", &self.reserved6)
67 .field("reserved7", &self.reserved7)
68 .field("reserved8", &self.reserved8)
69 .finish()
70 }
71}
72
73#[repr(C)]
74#[allow(dead_code)]
75pub struct _GUdevClientPrivate {
76 _data: [u8; 0],
77 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
78}
79
80pub type GUdevClientPrivate = _GUdevClientPrivate;
81
82#[derive(Copy, Clone)]
83#[repr(C)]
84pub struct GUdevDeviceClass {
85 pub parent_class: gobject::GObjectClass,
86 pub reserved1: Option<unsafe extern "C" fn()>,
87 pub reserved2: Option<unsafe extern "C" fn()>,
88 pub reserved3: Option<unsafe extern "C" fn()>,
89 pub reserved4: Option<unsafe extern "C" fn()>,
90 pub reserved5: Option<unsafe extern "C" fn()>,
91 pub reserved6: Option<unsafe extern "C" fn()>,
92 pub reserved7: Option<unsafe extern "C" fn()>,
93 pub reserved8: Option<unsafe extern "C" fn()>,
94}
95
96impl ::std::fmt::Debug for GUdevDeviceClass {
97 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
98 f.debug_struct(&format!("GUdevDeviceClass @ {self:p}"))
99 .field("parent_class", &self.parent_class)
100 .field("reserved1", &self.reserved1)
101 .field("reserved2", &self.reserved2)
102 .field("reserved3", &self.reserved3)
103 .field("reserved4", &self.reserved4)
104 .field("reserved5", &self.reserved5)
105 .field("reserved6", &self.reserved6)
106 .field("reserved7", &self.reserved7)
107 .field("reserved8", &self.reserved8)
108 .finish()
109 }
110}
111
112#[repr(C)]
113#[allow(dead_code)]
114pub struct _GUdevDevicePrivate {
115 _data: [u8; 0],
116 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
117}
118
119pub type GUdevDevicePrivate = _GUdevDevicePrivate;
120
121#[derive(Copy, Clone)]
122#[repr(C)]
123pub struct GUdevEnumeratorClass {
124 pub parent_class: gobject::GObjectClass,
125 pub reserved1: Option<unsafe extern "C" fn()>,
126 pub reserved2: Option<unsafe extern "C" fn()>,
127 pub reserved3: Option<unsafe extern "C" fn()>,
128 pub reserved4: Option<unsafe extern "C" fn()>,
129 pub reserved5: Option<unsafe extern "C" fn()>,
130 pub reserved6: Option<unsafe extern "C" fn()>,
131 pub reserved7: Option<unsafe extern "C" fn()>,
132 pub reserved8: Option<unsafe extern "C" fn()>,
133}
134
135impl ::std::fmt::Debug for GUdevEnumeratorClass {
136 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
137 f.debug_struct(&format!("GUdevEnumeratorClass @ {self:p}"))
138 .field("parent_class", &self.parent_class)
139 .field("reserved1", &self.reserved1)
140 .field("reserved2", &self.reserved2)
141 .field("reserved3", &self.reserved3)
142 .field("reserved4", &self.reserved4)
143 .field("reserved5", &self.reserved5)
144 .field("reserved6", &self.reserved6)
145 .field("reserved7", &self.reserved7)
146 .field("reserved8", &self.reserved8)
147 .finish()
148 }
149}
150
151#[repr(C)]
152#[allow(dead_code)]
153pub struct _GUdevEnumeratorPrivate {
154 _data: [u8; 0],
155 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
156}
157
158pub type GUdevEnumeratorPrivate = _GUdevEnumeratorPrivate;
159
160#[derive(Copy, Clone)]
162#[repr(C)]
163pub struct GUdevClient {
164 pub parent: gobject::GObject,
165 pub priv_: *mut GUdevClientPrivate,
166}
167
168impl ::std::fmt::Debug for GUdevClient {
169 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
170 f.debug_struct(&format!("GUdevClient @ {self:p}"))
171 .field("parent", &self.parent)
172 .finish()
173 }
174}
175
176#[derive(Copy, Clone)]
177#[repr(C)]
178pub struct GUdevDevice {
179 pub parent: gobject::GObject,
180 pub priv_: *mut GUdevDevicePrivate,
181}
182
183impl ::std::fmt::Debug for GUdevDevice {
184 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
185 f.debug_struct(&format!("GUdevDevice @ {self:p}"))
186 .field("parent", &self.parent)
187 .finish()
188 }
189}
190
191#[derive(Copy, Clone)]
192#[repr(C)]
193pub struct GUdevEnumerator {
194 pub parent: gobject::GObject,
195 pub priv_: *mut GUdevEnumeratorPrivate,
196}
197
198impl ::std::fmt::Debug for GUdevEnumerator {
199 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
200 f.debug_struct(&format!("GUdevEnumerator @ {self:p}"))
201 .field("parent", &self.parent)
202 .finish()
203 }
204}
205
206extern "C" {
207
208 pub fn g_udev_device_type_get_type() -> GType;
212
213 pub fn g_udev_client_get_type() -> GType;
217 pub fn g_udev_client_new(subsystems: *const *const c_char) -> *mut GUdevClient;
218 pub fn g_udev_client_query_by_device_file(
219 client: *mut GUdevClient,
220 device_file: *const c_char,
221 ) -> *mut GUdevDevice;
222 pub fn g_udev_client_query_by_device_number(
223 client: *mut GUdevClient,
224 type_: GUdevDeviceType,
225 number: GUdevDeviceNumber,
226 ) -> *mut GUdevDevice;
227 pub fn g_udev_client_query_by_subsystem(
228 client: *mut GUdevClient,
229 subsystem: *const c_char,
230 ) -> *mut glib::GList;
231 pub fn g_udev_client_query_by_subsystem_and_name(
232 client: *mut GUdevClient,
233 subsystem: *const c_char,
234 name: *const c_char,
235 ) -> *mut GUdevDevice;
236 pub fn g_udev_client_query_by_sysfs_path(
237 client: *mut GUdevClient,
238 sysfs_path: *const c_char,
239 ) -> *mut GUdevDevice;
240
241 pub fn g_udev_device_get_type() -> GType;
245 pub fn g_udev_device_get_action(device: *mut GUdevDevice) -> *const c_char;
246 pub fn g_udev_device_get_device_file(device: *mut GUdevDevice) -> *const c_char;
247 pub fn g_udev_device_get_device_file_symlinks(device: *mut GUdevDevice)
248 -> *const *const c_char;
249 pub fn g_udev_device_get_device_number(device: *mut GUdevDevice) -> GUdevDeviceNumber;
250 pub fn g_udev_device_get_device_type(device: *mut GUdevDevice) -> GUdevDeviceType;
251 pub fn g_udev_device_get_devtype(device: *mut GUdevDevice) -> *const c_char;
252 pub fn g_udev_device_get_driver(device: *mut GUdevDevice) -> *const c_char;
253 pub fn g_udev_device_get_is_initialized(device: *mut GUdevDevice) -> gboolean;
254 pub fn g_udev_device_get_name(device: *mut GUdevDevice) -> *const c_char;
255 pub fn g_udev_device_get_number(device: *mut GUdevDevice) -> *const c_char;
256 pub fn g_udev_device_get_parent(device: *mut GUdevDevice) -> *mut GUdevDevice;
257 pub fn g_udev_device_get_parent_with_subsystem(
258 device: *mut GUdevDevice,
259 subsystem: *const c_char,
260 devtype: *const c_char,
261 ) -> *mut GUdevDevice;
262 pub fn g_udev_device_get_property(
263 device: *mut GUdevDevice,
264 key: *const c_char,
265 ) -> *const c_char;
266 pub fn g_udev_device_get_property_as_boolean(
267 device: *mut GUdevDevice,
268 key: *const c_char,
269 ) -> gboolean;
270 pub fn g_udev_device_get_property_as_double(
271 device: *mut GUdevDevice,
272 key: *const c_char,
273 ) -> c_double;
274 pub fn g_udev_device_get_property_as_int(device: *mut GUdevDevice, key: *const c_char)
275 -> c_int;
276 pub fn g_udev_device_get_property_as_strv(
277 device: *mut GUdevDevice,
278 key: *const c_char,
279 ) -> *const *const c_char;
280 pub fn g_udev_device_get_property_as_uint64(
281 device: *mut GUdevDevice,
282 key: *const c_char,
283 ) -> u64;
284 pub fn g_udev_device_get_property_keys(device: *mut GUdevDevice) -> *const *const c_char;
285 pub fn g_udev_device_get_seqnum(device: *mut GUdevDevice) -> u64;
286 pub fn g_udev_device_get_subsystem(device: *mut GUdevDevice) -> *const c_char;
287 pub fn g_udev_device_get_sysfs_attr(
288 device: *mut GUdevDevice,
289 name: *const c_char,
290 ) -> *const c_char;
291 pub fn g_udev_device_get_sysfs_attr_as_boolean(
292 device: *mut GUdevDevice,
293 name: *const c_char,
294 ) -> gboolean;
295 pub fn g_udev_device_get_sysfs_attr_as_boolean_uncached(
296 device: *mut GUdevDevice,
297 name: *const c_char,
298 ) -> gboolean;
299 pub fn g_udev_device_get_sysfs_attr_as_double(
300 device: *mut GUdevDevice,
301 name: *const c_char,
302 ) -> c_double;
303 pub fn g_udev_device_get_sysfs_attr_as_double_uncached(
304 device: *mut GUdevDevice,
305 name: *const c_char,
306 ) -> c_double;
307 pub fn g_udev_device_get_sysfs_attr_as_int(
308 device: *mut GUdevDevice,
309 name: *const c_char,
310 ) -> c_int;
311 pub fn g_udev_device_get_sysfs_attr_as_int_uncached(
312 device: *mut GUdevDevice,
313 name: *const c_char,
314 ) -> c_int;
315 pub fn g_udev_device_get_sysfs_attr_as_strv(
316 device: *mut GUdevDevice,
317 name: *const c_char,
318 ) -> *const *const c_char;
319 pub fn g_udev_device_get_sysfs_attr_as_strv_uncached(
320 device: *mut GUdevDevice,
321 name: *const c_char,
322 ) -> *const *const c_char;
323 pub fn g_udev_device_get_sysfs_attr_as_uint64(
324 device: *mut GUdevDevice,
325 name: *const c_char,
326 ) -> u64;
327 pub fn g_udev_device_get_sysfs_attr_as_uint64_uncached(
328 device: *mut GUdevDevice,
329 name: *const c_char,
330 ) -> u64;
331 pub fn g_udev_device_get_sysfs_attr_keys(device: *mut GUdevDevice) -> *const *const c_char;
332 pub fn g_udev_device_get_sysfs_attr_uncached(
333 device: *mut GUdevDevice,
334 name: *const c_char,
335 ) -> *const c_char;
336 pub fn g_udev_device_get_sysfs_path(device: *mut GUdevDevice) -> *const c_char;
337 pub fn g_udev_device_get_tags(device: *mut GUdevDevice) -> *const *const c_char;
338 pub fn g_udev_device_get_usec_since_initialized(device: *mut GUdevDevice) -> u64;
339 pub fn g_udev_device_has_property(device: *mut GUdevDevice, key: *const c_char) -> gboolean;
340 pub fn g_udev_device_has_sysfs_attr(device: *mut GUdevDevice, key: *const c_char) -> gboolean;
341 pub fn g_udev_device_has_sysfs_attr_uncached(
342 device: *mut GUdevDevice,
343 key: *const c_char,
344 ) -> gboolean;
345
346 pub fn g_udev_enumerator_get_type() -> GType;
350 pub fn g_udev_enumerator_new(client: *mut GUdevClient) -> *mut GUdevEnumerator;
351 pub fn g_udev_enumerator_add_match_is_initialized(
352 enumerator: *mut GUdevEnumerator,
353 ) -> *mut GUdevEnumerator;
354 pub fn g_udev_enumerator_add_match_name(
355 enumerator: *mut GUdevEnumerator,
356 name: *const c_char,
357 ) -> *mut GUdevEnumerator;
358 pub fn g_udev_enumerator_add_match_property(
359 enumerator: *mut GUdevEnumerator,
360 name: *const c_char,
361 value: *const c_char,
362 ) -> *mut GUdevEnumerator;
363 pub fn g_udev_enumerator_add_match_subsystem(
364 enumerator: *mut GUdevEnumerator,
365 subsystem: *const c_char,
366 ) -> *mut GUdevEnumerator;
367 pub fn g_udev_enumerator_add_match_sysfs_attr(
368 enumerator: *mut GUdevEnumerator,
369 name: *const c_char,
370 value: *const c_char,
371 ) -> *mut GUdevEnumerator;
372 pub fn g_udev_enumerator_add_match_tag(
373 enumerator: *mut GUdevEnumerator,
374 tag: *const c_char,
375 ) -> *mut GUdevEnumerator;
376 pub fn g_udev_enumerator_add_nomatch_subsystem(
377 enumerator: *mut GUdevEnumerator,
378 subsystem: *const c_char,
379 ) -> *mut GUdevEnumerator;
380 pub fn g_udev_enumerator_add_nomatch_sysfs_attr(
381 enumerator: *mut GUdevEnumerator,
382 name: *const c_char,
383 value: *const c_char,
384 ) -> *mut GUdevEnumerator;
385 pub fn g_udev_enumerator_add_sysfs_path(
386 enumerator: *mut GUdevEnumerator,
387 sysfs_path: *const c_char,
388 ) -> *mut GUdevEnumerator;
389 pub fn g_udev_enumerator_execute(enumerator: *mut GUdevEnumerator) -> *mut glib::GList;
390
391}