Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 340 insertions, 0 deletions

diff --git a/third_party/rust/libudev/src/device.rs b/third_party/rust/libudev/src/device.rs
new file mode 100644
index 0000000000..736e7b58ff
--- /dev/null
+++ b/third_party/rust/libudev/src/device.rs
@@ -0,0 +1,340 @@
+use std::str;
+
+use std::ffi::{CStr,OsStr};
+use std::path::Path;
+use std::str::FromStr;
+
+use libc::{c_char,dev_t};
+
+use ::context::Context;
+use ::handle::*;
+
+pub fn new(context: &Context, device: *mut ::ffi::udev_device) -> Device {
+    Device {
+        _context: context,
+        device: device,
+    }
+}
+
+/// A structure that provides access to sysfs/kernel devices.
+pub struct Device<'a> {
+    _context: &'a Context,
+    device: *mut ::ffi::udev_device,
+}
+
+impl<'a> Drop for Device<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            ::ffi::udev_device_unref(self.device);
+        }
+    }
+}
+
+#[doc(hidden)]
+impl<'a> Handle<::ffi::udev_device> for Device<'a> {
+    fn as_ptr(&self) -> *mut ::ffi::udev_device {
+        self.device
+    }
+}
+
+impl<'a> Device<'a> {
+    /// Checks whether the device has already been handled by udev.
+    ///
+    /// When a new device is connected to the system, udev initializes the device by setting
+    /// permissions, renaming network devices, and possibly other initialization routines. This
+    /// method returns `true` if udev has performed all of its work to initialize this device.
+    ///
+    /// This method only applies to devices with device nodes or network interfaces. All other
+    /// devices return `true` by default.
+    pub fn is_initialized(&self) -> bool {
+        unsafe {
+            ::ffi::udev_device_get_is_initialized(self.device) > 0
+        }
+    }
+
+    /// Gets the device's major/minor number.
+    pub fn devnum(&self) -> Option<dev_t> {
+        match unsafe { ::ffi::udev_device_get_devnum(self.device) } {
+            0 => None,
+            n => Some(n)
+        }
+    }
+
+    /// Returns the syspath of the device.
+    ///
+    /// The path is an absolute path and includes the sys mount point. For example, the syspath for
+    /// `tty0` could be `/sys/devices/virtual/tty/tty0`, which includes the sys mount point,
+    /// `/sys`.
+    pub fn syspath(&self) -> &Path {
+        Path::new(unsafe {
+            ::util::ptr_to_os_str_unchecked(::ffi::udev_device_get_syspath(self.device))
+        })
+    }
+
+    /// Returns the kernel devpath value of the device.
+    ///
+    /// The path does not contain the sys mount point, but does start with a `/`. For example, the
+    /// devpath for `tty0` could be `/devices/virtual/tty/tty0`.
+    pub fn devpath(&self) -> &OsStr {
+        unsafe {
+            ::util::ptr_to_os_str_unchecked(::ffi::udev_device_get_devpath(self.device))
+        }
+    }
+
+    /// Returns the path to the device node belonging to the device.
+    ///
+    /// The path is an absolute path and starts with the device directory. For example, the device
+    /// node for `tty0` could be `/dev/tty0`.
+    pub fn devnode(&self) -> Option<&Path> {
+        ::util::ptr_to_os_str(unsafe { ::ffi::udev_device_get_devnode(self.device) }).map(|path| {
+            Path::new(path)
+        })
+    }
+
+    /// Returns the parent of the device.
+    pub fn parent(&self) -> Option<Device> {
+        let ptr = unsafe { ::ffi::udev_device_get_parent(self.device) };
+
+        if !ptr.is_null() {
+            unsafe {
+                ::ffi::udev_device_ref(ptr);
+            }
+
+            Some(Device {
+                _context: self._context,
+                device: ptr,
+            })
+        }
+        else {
+            None
+        }
+    }
+
+    /// Returns the subsystem name of the device.
+    ///
+    /// The subsystem name is a string that indicates which kernel subsystem the device belongs to.
+    /// Examples of subsystem names are `tty`, `vtconsole`, `block`, `scsi`, and `net`.
+    pub fn subsystem(&self) -> &OsStr {
+        unsafe {
+            ::util::ptr_to_os_str_unchecked(::ffi::udev_device_get_subsystem(self.device))
+        }
+    }
+
+    /// Returns the kernel device name for the device.
+    ///
+    /// The sysname is a string that differentiates the device from others in the same subsystem.
+    /// For example, `tty0` is the sysname for a TTY device that differentiates it from others,
+    /// such as `tty1`.
+    pub fn sysname(&self) -> &OsStr {
+        unsafe {
+            ::util::ptr_to_os_str_unchecked(::ffi::udev_device_get_sysname(self.device))
+        }
+    }
+
+    /// Returns the instance number of the device.
+    ///
+    /// The instance number is used to differentiate many devices of the same type. For example,
+    /// `/dev/tty0` and `/dev/tty1` are both TTY devices but have instance numbers of 0 and 1,
+    /// respectively.
+    ///
+    /// Some devices don't have instance numbers, such as `/dev/console`, in which case the method
+    /// returns `None`.
+    pub fn sysnum(&self) -> Option<usize> {
+        let ptr = unsafe { ::ffi::udev_device_get_sysnum(self.device) };
+
+        if !ptr.is_null() {
+            match str::from_utf8(unsafe { CStr::from_ptr(ptr) }.to_bytes()) {
+                Err(_) => None,
+                Ok(s) => FromStr::from_str(s).ok()
+            }
+        }
+        else {
+            None
+        }
+    }
+
+    /// Returns the devtype name of the device.
+    pub fn devtype(&self) -> Option<&OsStr> {
+        ::util::ptr_to_os_str(unsafe { ::ffi::udev_device_get_devtype(self.device) })
+    }
+
+    /// Returns the name of the kernel driver attached to the device.
+    pub fn driver(&self) -> Option<&OsStr> {
+        ::util::ptr_to_os_str(unsafe { ::ffi::udev_device_get_driver(self.device) })
+    }
+
+    /// Retreives the value of a device property.
+    pub fn property_value<T: AsRef<OsStr>>(&self, property: T) -> Option<&OsStr> {
+        let prop = match ::util::os_str_to_cstring(property) {
+            Ok(s) => s,
+            Err(_) => return None
+        };
+
+        ::util::ptr_to_os_str(unsafe {
+            ::ffi::udev_device_get_property_value(self.device, prop.as_ptr())
+        })
+    }
+
+    /// Retreives the value of a device attribute.
+    pub fn attribute_value<T: AsRef<OsStr>>(&self, attribute: T) -> Option<&OsStr> {
+        let attr = match ::util::os_str_to_cstring(attribute) {
+            Ok(s) => s,
+            Err(_) => return None
+        };
+
+        ::util::ptr_to_os_str(unsafe {
+            ::ffi::udev_device_get_sysattr_value(self.device, attr.as_ptr())
+        })
+    }
+
+    /// Sets the value of a device attribute.
+    pub fn set_attribute_value<T: AsRef<OsStr>, U: AsRef<OsStr>>(&mut self, attribute: T, value: U) -> ::Result<()> {
+        let attribute = try!(::util::os_str_to_cstring(attribute));
+        let value = try!(::util::os_str_to_cstring(value));
+
+        ::util::errno_to_result(unsafe {
+            ::ffi::udev_device_set_sysattr_value(self.device, attribute.as_ptr(), value.as_ptr() as *mut c_char)
+        })
+    }
+
+    /// Returns an iterator over the device's properties.
+    ///
+    /// ## Example
+    ///
+    /// This example prints out all of a device's properties:
+    ///
+    /// ```no_run
+    /// # use std::path::Path;
+    /// # let mut context = libudev::Context::new().unwrap();
+    /// # let device = context.device_from_syspath(Path::new("/sys/devices/virtual/tty/tty0")).unwrap();
+    /// for property in device.properties() {
+    ///     println!("{:?} = {:?}", property.name(), property.value());
+    /// }
+    /// ```
+    pub fn properties(&self) -> Properties {
+        Properties {
+            _device: self,
+            entry: unsafe { ::ffi::udev_device_get_properties_list_entry(self.device) }
+        }
+    }
+
+    /// Returns an iterator over the device's attributes.
+    ///
+    /// ## Example
+    ///
+    /// This example prints out all of a device's attributes:
+    ///
+    /// ```no_run
+    /// # use std::path::Path;
+    /// # let mut context = libudev::Context::new().unwrap();
+    /// # let device = context.device_from_syspath(Path::new("/sys/devices/virtual/tty/tty0")).unwrap();
+    /// for attribute in device.attributes() {
+    ///     println!("{:?} = {:?}", attribute.name(), attribute.value());
+    /// }
+    /// ```
+    pub fn attributes(&self) -> Attributes {
+        Attributes {
+            device: self,
+            entry: unsafe { ::ffi::udev_device_get_sysattr_list_entry(self.device) }
+        }
+    }
+}
+
+
+/// Iterator over a device's properties.
+pub struct Properties<'a> {
+    _device: &'a Device<'a>,
+    entry: *mut ::ffi::udev_list_entry
+}
+
+impl<'a> Iterator for Properties<'a> {
+    type Item = Property<'a>;
+
+    fn next(&mut self) -> Option<Property<'a>> {
+        if self.entry.is_null() {
+            None
+        }
+        else {
+            let name = unsafe { ::util::ptr_to_os_str_unchecked(::ffi::udev_list_entry_get_name(self.entry)) };
+            let value = unsafe { ::util::ptr_to_os_str_unchecked(::ffi::udev_list_entry_get_value(self.entry)) };
+
+            self.entry = unsafe { ::ffi::udev_list_entry_get_next(self.entry) };
+
+            Some(Property {
+                name: name,
+                value: value
+            })
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+}
+
+/// A device property.
+pub struct Property<'a> {
+    name: &'a OsStr,
+    value: &'a OsStr
+}
+
+impl<'a> Property<'a> {
+    /// Returns the property name.
+    pub fn name(&self) -> &OsStr {
+        self.name
+    }
+
+    /// Returns the property value.
+    pub fn value(&self) -> &OsStr {
+        self.value
+    }
+}
+
+
+/// Iterator over a device's attributes.
+pub struct Attributes<'a> {
+    device: &'a Device<'a>,
+    entry: *mut ::ffi::udev_list_entry
+}
+
+impl<'a> Iterator for Attributes<'a> {
+    type Item = Attribute<'a>;
+
+    fn next(&mut self) -> Option<Attribute<'a>> {
+        if !self.entry.is_null() {
+            let name = unsafe { ::util::ptr_to_os_str_unchecked(::ffi::udev_list_entry_get_name(self.entry)) };
+
+            self.entry = unsafe { ::ffi::udev_list_entry_get_next(self.entry) };
+
+            Some(Attribute {
+                device: self.device,
+                name: name
+            })
+        }
+        else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+}
+
+/// A device attribute.
+pub struct Attribute<'a> {
+    device: &'a Device<'a>,
+    name: &'a OsStr
+}
+
+impl<'a> Attribute<'a> {
+    /// Returns the attribute name.
+    pub fn name(&self) -> &OsStr {
+        self.name
+    }
+
+    /// Returns the attribute value.
+    pub fn value(&self) -> Option<&OsStr> {
+        self.device.attribute_value(self.name)
+    }
+}