confuse 0.1.0

A fuser-compatible filesystem API facade using Dokan on Windows and fuser elsewhere.
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239

use super::super::notifier::PollNotifier;
use super::super::reply::*;
use super::super::request::Request;
use super::super::types::*;
use std::ffi::OsStr;
use std::io;
use std::path::Path;
use std::time::SystemTime;

#[allow(clippy::too_many_arguments)]
pub trait Filesystem: Send + Sync + 'static {
    fn init(&mut self, _req: &Request, _config: &mut KernelConfig) -> io::Result<()> {
        Err(io::Error::from_raw_os_error(Errno::ENOSYS.raw_os_error()))
    }
    fn destroy(&mut self) {}
    fn lookup(&self, _req: &Request, _parent: INodeNo, _name: &OsStr, reply: ReplyEntry) {
        reply.error(Errno::ENOSYS);
    }
    fn forget(&self, _req: &Request, _ino: INodeNo, _nlookup: u64) {}
    fn getattr(&self, _req: &Request, _ino: INodeNo, _fh: Option<FileHandle>, reply: ReplyAttr) {
        reply.error(Errno::ENOSYS);
    }
    fn setattr(
        &self, _req: &Request, _ino: INodeNo, _mode: Option<u32>, _uid: Option<u32>,
        _gid: Option<u32>, _size: Option<u64>, _atime: Option<TimeOrNow>,
        _mtime: Option<TimeOrNow>, _ctime: Option<SystemTime>, _fh: Option<FileHandle>,
        _crtime: Option<SystemTime>, _chgtime: Option<SystemTime>, _bkuptime: Option<SystemTime>,
        _flags: Option<BsdFileFlags>, reply: ReplyAttr,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn readlink(&self, _req: &Request, _ino: INodeNo, reply: ReplyData) {
        reply.error(Errno::ENOSYS);
    }
    fn mknod(
        &self, _req: &Request, _parent: INodeNo, _name: &OsStr, _mode: u32, _umask: u32,
        _rdev: u32, reply: ReplyEntry,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn mkdir(
        &self, _req: &Request, _parent: INodeNo, _name: &OsStr, _mode: u32, _umask: u32,
        reply: ReplyEntry,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn unlink(&self, _req: &Request, _parent: INodeNo, _name: &OsStr, reply: ReplyEmpty) {
        reply.error(Errno::ENOSYS);
    }
    fn rmdir(&self, _req: &Request, _parent: INodeNo, _name: &OsStr, reply: ReplyEmpty) {
        reply.error(Errno::ENOSYS);
    }
    fn symlink(
        &self, _req: &Request, _parent: INodeNo, _link_name: &OsStr, _target: &Path,
        reply: ReplyEntry,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn rename(
        &self, _req: &Request, _parent: INodeNo, _name: &OsStr, _newparent: INodeNo,
        _newname: &OsStr, _flags: RenameFlags, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn link(
        &self, _req: &Request, _ino: INodeNo, _newparent: INodeNo, _newname: &OsStr,
        reply: ReplyEntry,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn open(&self, _req: &Request, _ino: INodeNo, _flags: OpenFlags, reply: ReplyOpen) {
        reply.error(Errno::ENOSYS);
    }
    fn read(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: u64, _size: u32,
        _flags: OpenFlags, _lock_owner: Option<LockOwner>, reply: ReplyData,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn write(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: u64, _data: &[u8],
        _write_flags: WriteFlags, _flags: OpenFlags, _lock_owner: Option<LockOwner>,
        reply: ReplyWrite,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn flush(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _lock_owner: LockOwner,
        reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn release(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _flags: OpenFlags,
        _lock_owner: Option<LockOwner>, _flush: bool, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn fsync(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _datasync: bool, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn opendir(&self, _req: &Request, _ino: INodeNo, _flags: OpenFlags, reply: ReplyOpen) {
        reply.error(Errno::ENOSYS);
    }
    fn readdir(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: u64, reply: ReplyDirectory,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn readdirplus(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: u64,
        reply: ReplyDirectoryPlus,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn releasedir(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _flags: OpenFlags, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn fsyncdir(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _datasync: bool, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn statfs(&self, _req: &Request, _ino: INodeNo, reply: ReplyStatfs) {
        reply.error(Errno::ENOSYS);
    }
    fn setxattr(
        &self, _req: &Request, _ino: INodeNo, _name: &OsStr, _value: &[u8], _flags: i32,
        _position: u32, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn getxattr(
        &self, _req: &Request, _ino: INodeNo, _name: &OsStr, _size: u32, reply: ReplyXattr,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn listxattr(&self, _req: &Request, _ino: INodeNo, _size: u32, reply: ReplyXattr) {
        reply.error(Errno::ENOSYS);
    }
    fn removexattr(&self, _req: &Request, _ino: INodeNo, _name: &OsStr, reply: ReplyEmpty) {
        reply.error(Errno::ENOSYS);
    }
    fn access(&self, _req: &Request, _ino: INodeNo, _mask: AccessFlags, reply: ReplyEmpty) {
        reply.error(Errno::ENOSYS);
    }
    fn create(
        &self, _req: &Request, _parent: INodeNo, _name: &OsStr, _mode: u32, _umask: u32,
        _flags: i32, reply: ReplyCreate,
    ) {
        reply.error(Errno::ENOSYS);
    }
    #[allow(clippy::too_many_arguments)]
    fn getlk(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _lock_owner: LockOwner, _start: u64,
        _end: u64, _typ: i32, _pid: u32, reply: ReplyLock,
    ) {
        reply.error(Errno::ENOSYS);
    }
    #[allow(clippy::too_many_arguments)]
    fn setlk(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _lock_owner: LockOwner, _start: u64,
        _end: u64, _typ: i32, _pid: u32, _sleep: bool, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn bmap(&self, _req: &Request, _ino: INodeNo, _blocksize: u32, _idx: u64, reply: ReplyBmap) {
        reply.error(Errno::ENOSYS);
    }
    fn ioctl(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _flags: IoctlFlags, _cmd: u32,
        _in_data: &[u8], _out_size: u32, reply: ReplyIoctl,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn fallocate(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: u64, _length: u64,
        _mode: i32, reply: ReplyEmpty,
    ) {
        reply.error(Errno::ENOSYS);
    }
    fn lseek(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _offset: i64, _whence: i32,
        reply: ReplyLseek,
    ) {
        reply.error(Errno::ENOSYS);
    }
    #[allow(clippy::too_many_arguments)]
    fn copy_file_range(
        &self, _req: &Request, _ino_in: INodeNo, _fh_in: FileHandle, _offset_in: u64,
        _ino_out: INodeNo, _fh_out: FileHandle, _offset_out: u64, _len: u64,
        _flags: CopyFileRangeFlags, reply: ReplyWrite,
    ) {
        reply.error(Errno::ENOSYS);
    }

    fn poll(
        &self, _req: &Request, _ino: INodeNo, _fh: FileHandle, _ph: PollNotifier,
        _events: PollEvents, _flags: PollFlags, reply: ReplyPoll,
    ) {
        reply.error(Errno::ENOSYS);
    }

    fn batch_forget(&self, req: &Request, nodes: &[ForgetOne]) {
        for node in nodes {
            self.forget(req, node.nodeid(), node.nlookup());
        }
    }

    /// macOS only: Rename the volume. Set `fuse_init_out.flags` during init to
    /// `FUSE_VOL_RENAME` to enable.
    #[cfg(feature = "macos-api")]
    fn setvolname(&self, _req: &Request, name: &OsStr, reply: ReplyEmpty) {
        let _ = name;
        reply.error(Errno::ENOSYS);
    }

    /// macOS only (undocumented).
    #[cfg(feature = "macos-api")]
    fn exchange(
        &self, _req: &Request, parent: INodeNo, name: &OsStr, newparent: INodeNo, newname: &OsStr,
        options: u64, reply: ReplyEmpty,
    ) {
        let _ = (parent, name, newparent, newname, options);
        reply.error(Errno::ENOSYS);
    }

    /// macOS only: Query extended times (`bkuptime` and `crtime`).
    /// Set `fuse_init_out.flags` to `FUSE_XTIMES` to enable.
    #[cfg(feature = "macos-api")]
    fn getxtimes(&self, _req: &Request, ino: INodeNo, reply: ReplyXTimes) {
        let _ = ino;
        reply.error(Errno::ENOSYS);
    }
}