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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::fmt;

/// Represents USBFS stream information.
#[repr(C)]
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UsbfsStreams {
    num_streams: u32,
    eps: Vec<u8>,
}

impl UsbfsStreams {
    /// Creates a new [UsbfsStreams].
    pub const fn new() -> Self {
        Self {
            num_streams: 0,
            eps: Vec::new(),
        }
    }

    /// Gets the number of streams.
    pub const fn num_streams(&self) -> u32 {
        self.num_streams
    }

    /// Sets the number of streams.
    pub fn set_num_streams(&mut self, num_streams: u32) {
        self.num_streams = num_streams;
    }

    /// Builder function that sets the number of streams.
    pub fn with_num_streams(mut self, num_streams: u32) -> Self {
        self.set_num_streams(num_streams);
        self
    }

    /// Gets a reference to the list of endpoints.
    pub fn eps(&self) -> &[u8] {
        self.eps.as_ref()
    }

    /// Sets the list of endpoints.
    pub fn set_eps<E: IntoIterator<Item = u8>>(&mut self, eps: E) {
        self.eps = eps.into_iter().collect();
    }

    /// Builder function that sets the list of endpoints.
    pub fn with_eps<E: IntoIterator<Item = u8>>(mut self, eps: E) -> Self {
        self.set_eps(eps);
        self
    }
}

impl From<&UsbfsStreamsFfi> for UsbfsStreams {
    fn from(val: &UsbfsStreamsFfi) -> Self {
        Self {
            num_streams: val.num_streams,
            eps: if val.eps.is_null() {
                Vec::new()
            } else {
                // SAFETY: memory returned by the kernel should be valid, if non-null.
                unsafe { std::slice::from_raw_parts(val.eps, val.num_eps as usize) }.into()
            },
        }
    }
}

impl From<UsbfsStreamsFfi> for UsbfsStreams {
    fn from(val: UsbfsStreamsFfi) -> Self {
        (&val).into()
    }
}

impl fmt::Display for UsbfsStreams {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{{")?;
        write!(f, r#""num_streams": {}, "#, self.num_streams)?;
        write!(f, r#""eps": ["#)?;
        for (i, ep) in self.eps.iter().enumerate() {
            if i != 0 {
                write!(f, ", ")?;
            }
            write!(f, "{ep}")?;
        }
        write!(f, "]}}")
    }
}

/// Represents USBFS stream information for `ioctl` FFI.
#[repr(C)]
#[derive(Debug, PartialEq)]
pub struct UsbfsStreamsFfi {
    num_streams: u32,
    num_eps: u32,
    eps: *mut u8,
}

impl UsbfsStreamsFfi {
    /// Creates a new [UsbfsStreamsFfi].
    pub fn new() -> Self {
        Self {
            num_streams: 0,
            num_eps: 0,
            eps: std::ptr::null_mut(),
        }
    }
}

impl From<&mut UsbfsStreams> for UsbfsStreamsFfi {
    fn from(val: &mut UsbfsStreams) -> Self {
        Self {
            num_streams: val.num_streams,
            num_eps: val.eps.len() as u32,
            eps: if val.eps.is_empty() {
                std::ptr::null_mut()
            } else {
                val.eps.as_mut_ptr()
            },
        }
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_usbfs_streams() {
        let exp_num_streams = 1;
        let exp_num_eps = 1;
        let exp_eps = [1u8];

        let exp_streams = UsbfsStreams::new()
            .with_num_streams(exp_num_streams)
            .with_eps(exp_eps);

        let mut null_streams = UsbfsStreams::new();

        assert_eq!(exp_streams.num_streams(), exp_num_streams);
        assert_eq!(exp_streams.eps(), exp_eps.as_ref());
        assert_eq!(exp_streams.eps().len(), exp_num_eps);

        null_streams.set_num_streams(exp_num_streams);
        assert_eq!(null_streams.num_streams(), exp_num_streams);

        null_streams.set_eps(exp_eps);
        assert_eq!(null_streams.eps(), exp_eps.as_ref());

        assert_eq!(null_streams, exp_streams);
    }
}