usbfs 0.1.1

Port of the usbfs Linux userspace library in pure Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::{cmp, fmt};

use crate::{USBFS_MAX_DRIVER_NAME, USBFS_MAX_DRIVER_NAME_FFI};

/// Represents a USBFS driver name.
///
/// The internal representation is a null-terminated byte buffer for C-like strings.
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DriverName([u8; USBFS_MAX_DRIVER_NAME_FFI]);

impl DriverName {
    /// Creates a new [DriverName].
    pub const fn new() -> Self {
        Self([0u8; USBFS_MAX_DRIVER_NAME_FFI])
    }

    /// Creates a [DriverName] from a string.
    ///
    /// **NOTE** Sets at most [`USBFS_MAX_DRIVER_NAME`] bytes.
    pub fn from_string(&mut self, driver: &str) {
        let bytes = driver.as_bytes();
        // always leave the last byte null for C-like null-terminated strings
        let len = cmp::min(bytes.len(), USBFS_MAX_DRIVER_NAME);

        self.0[..len].copy_from_slice(&bytes[..len]);
        self.0[len..].copy_from_slice(&[0u8; USBFS_MAX_DRIVER_NAME_FFI][len..]);
    }

    /// Gets a [`&str`] representation of the [DriverName].
    pub fn as_str(&self) -> &str {
        let len = self.driver_len();
        std::str::from_utf8(self.0[..len].as_ref()).unwrap_or("")
    }

    fn driver_len(&self) -> usize {
        self.0.iter().position(|&b| b == 0).unwrap_or(0)
    }
}

impl From<&str> for DriverName {
    fn from(val: &str) -> Self {
        let mut ret = Self::new();
        ret.from_string(val);
        ret
    }
}

impl Default for DriverName {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Display for DriverName {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, r#""{}""#, self.as_str())
    }
}

/// Represents an argument to get a USBFS driver from an `ioctl`.
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct UsbfsGetDriver {
    interface: u32,
    driver: DriverName,
}

impl UsbfsGetDriver {
    /// Creates a new [UbsfGetDriver].
    pub const fn new() -> Self {
        Self {
            interface: 0,
            driver: DriverName::new(),
        }
    }

    /// Creates a new [UsbfsGetDriver] from the provided parameters.
    pub fn create(interface: u32, driver: &str) -> Self {
        Self {
            interface,
            driver: DriverName::from(driver),
        }
    }

    /// Gets the interface.
    pub const fn interface(&self) -> u32 {
        self.interface
    }

    /// Sets the interface.
    pub fn set_interface(&mut self, interface: u32) {
        self.interface = interface;
    }

    /// Builder function that sets the interface.
    pub fn with_interface(mut self, interface: u32) -> Self {
        self.set_interface(interface);
        self
    }

    /// Gets the driver name.
    pub fn driver(&self) -> &str {
        self.driver.as_str()
    }

    /// Sets the driver name.
    ///
    /// **NOTE** Sets at most [`USBFS_MAX_DRIVER_NAME`] bytes.
    pub fn set_driver(&mut self, driver: &str) {
        self.driver.from_string(driver);
    }

    /// Builder function that sets the driver name.
    ///
    /// **NOTE** Sets at most [`USBFS_MAX_DRIVER_NAME`] bytes.
    pub fn with_driver(mut self, driver: &str) -> Self {
        self.set_driver(driver);
        self
    }
}

impl Default for UsbfsGetDriver {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Display for UsbfsGetDriver {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{{")?;
        write!(f, r#""interface": {}, "#, self.interface)?;
        write!(f, r#""driver": {}"#, self.driver)?;
        write!(f, "}}")
    }
}