fuser 0.7.0

Filesystem in Userspace (FUSE) for 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

//! Argument decomposition for FUSE operation requests.
//!
//! Helper to decompose a slice of binary data (incoming FUSE request) into multiple data
//! structures (request arguments).

use std::ffi::OsStr;
use std::mem;
use std::os::unix::ffi::OsStrExt;

/// An iterator that can be used to fetch typed arguments from a byte slice.
pub struct ArgumentIterator<'a> {
    data: &'a [u8],
}

impl<'a> ArgumentIterator<'a> {
    /// Create a new argument iterator for the given byte slice.
    pub fn new(data: &'a [u8]) -> ArgumentIterator<'a> {
        ArgumentIterator { data }
    }

    /// Returns the size of the remaining data.
    pub fn len(&self) -> usize {
        self.data.len()
    }

    /// Fetch a slice of all remaining bytes.
    pub fn fetch_all(&mut self) -> &'a [u8] {
        let bytes = self.data;
        self.data = &[];
        bytes
    }

    /// Fetch a slice of bytes of the given size. Returns `None` if there's not enough data left.
    pub fn fetch_bytes(&mut self, amt: usize) -> Option<&'a [u8]> {
        if amt > self.data.len() {
            return None;
        }
        let bytes = &self.data[..amt];
        self.data = &self.data[amt..];
        Some(bytes)
    }

    /// Fetch a typed argument. Returns `None` if there's not enough data left. This function is
    /// unsafe because there is no guarantee that the data actually contains the type T.
    pub unsafe fn fetch<T>(&mut self) -> Option<&'a T> {
        let len = mem::size_of::<T>();
        let bytes = self.fetch_bytes(len)?;
        (bytes.as_ptr() as *const T).as_ref()
    }

    /// Fetch a (zero-terminated) string (can be non-utf8). Returns `None` if there's not enough
    /// data left or no zero-termination could be found. This function is unsafe because there is
    /// no guarantee that the data actually contains a string.
    pub unsafe fn fetch_str(&mut self) -> Option<&'a OsStr> {
        let len = self.data.iter().position(|&c| c == 0)?;
        let bytes = self.fetch_bytes(len)?;
        let _zero = self.fetch_bytes(1)?;
        Some(OsStr::from_bytes(&bytes))
    }
}

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

    const TEST_DATA: [u8; 10] = [0x66, 0x6f, 0x6f, 0x00, 0x62, 0x61, 0x72, 0x00, 0x62, 0x61];

    #[repr(C)]
    struct TestArgument {
        p1: u8,
        p2: u8,
        p3: u16,
    }

    #[test]
    fn all_data() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        unsafe { it.fetch_str().unwrap() };
        let arg = it.fetch_all();
        assert_eq!(arg, [0x62, 0x61, 0x72, 0x00, 0x62, 0x61]);
    }

    #[test]
    fn bytes_data() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        let arg = it.fetch_bytes(5).unwrap();
        assert_eq!(arg, [0x66, 0x6f, 0x6f, 0x00, 0x62]);
        let arg = it.fetch_bytes(2).unwrap();
        assert_eq!(arg, [0x61, 0x72]);
        assert_eq!(it.len(), 3);
    }

    #[test]
    fn generic_argument() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        let arg: &TestArgument = unsafe { it.fetch().unwrap() };
        assert_eq!(arg.p1, 0x66);
        assert_eq!(arg.p2, 0x6f);
        assert_eq!(arg.p3, 0x006f);
        let arg: &TestArgument = unsafe { it.fetch().unwrap() };
        assert_eq!(arg.p1, 0x62);
        assert_eq!(arg.p2, 0x61);
        assert_eq!(arg.p3, 0x0072);
        assert_eq!(it.len(), 2);
    }

    #[test]
    fn string_argument() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        let arg = unsafe { it.fetch_str().unwrap() };
        assert_eq!(arg, "foo");
        let arg = unsafe { it.fetch_str().unwrap() };
        assert_eq!(arg, "bar");
        assert_eq!(it.len(), 2);
    }

    #[test]
    fn mixed_arguments() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        let arg: &TestArgument = unsafe { it.fetch().unwrap() };
        assert_eq!(arg.p1, 0x66);
        assert_eq!(arg.p2, 0x6f);
        assert_eq!(arg.p3, 0x006f);
        let arg = unsafe { it.fetch_str().unwrap() };
        assert_eq!(arg, "bar");
        let arg = it.fetch_all();
        assert_eq!(arg, [0x62, 0x61]);
    }

    #[test]
    fn out_of_data() {
        let mut it = ArgumentIterator::new(&TEST_DATA);
        let _arg = it.fetch_bytes(8).unwrap();
        let arg: Option<&TestArgument> = unsafe { it.fetch() };
        assert!(arg.is_none());
        assert_eq!(it.len(), 2);
        let arg = unsafe { it.fetch_str() };
        assert!(arg.is_none());
        assert_eq!(it.len(), 2);
    }
}