]>
Commit | Line | Data |
---|---|---|
8faf50e0 XL |
1 | use core::{mem, slice}; |
2 | ||
3 | use data::*; | |
4 | use error::*; | |
5 | use number::*; | |
6 | ||
7 | pub trait SchemeBlock { | |
8 | fn handle(&self, packet: &Packet) -> Option<usize> { | |
9 | let res = match packet.a { | |
10 | SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), | |
11 | SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), | |
12 | SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), | |
13 | SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), | |
14 | ||
15 | SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), | |
16 | SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), | |
17 | SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), | |
18 | SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), | |
19 | SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), | |
20 | SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), | |
21 | SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), | |
22 | SYS_FEVENT => self.fevent(packet.b, packet.c), | |
23 | SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), | |
24 | SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), | |
25 | SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), | |
26 | SYS_FSTAT => if packet.d >= mem::size_of::<Stat>() { | |
27 | self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) | |
28 | } else { | |
29 | Err(Error::new(EFAULT)) | |
30 | }, | |
31 | SYS_FSTATVFS => if packet.d >= mem::size_of::<StatVfs>() { | |
32 | self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) | |
33 | } else { | |
34 | Err(Error::new(EFAULT)) | |
35 | }, | |
36 | SYS_FSYNC => self.fsync(packet.b), | |
37 | SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), | |
38 | SYS_FUTIMENS => if packet.d >= mem::size_of::<TimeSpec>() { | |
39 | self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::<TimeSpec>()) }) | |
40 | } else { | |
41 | Err(Error::new(EFAULT)) | |
42 | }, | |
43 | SYS_CLOSE => self.close(packet.b), | |
44 | _ => Err(Error::new(ENOSYS)) | |
45 | }; | |
46 | ||
47 | res.transpose().map(Error::mux) | |
48 | } | |
49 | ||
50 | /* Scheme operations */ | |
51 | ||
52 | #[allow(unused_variables)] | |
53 | fn open(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result<Option<usize>> { | |
54 | Err(Error::new(ENOENT)) | |
55 | } | |
56 | ||
57 | #[allow(unused_variables)] | |
58 | fn chmod(&self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result<Option<usize>> { | |
59 | Err(Error::new(ENOENT)) | |
60 | } | |
61 | ||
62 | #[allow(unused_variables)] | |
63 | fn rmdir(&self, path: &[u8], uid: u32, gid: u32) -> Result<Option<usize>> { | |
64 | Err(Error::new(ENOENT)) | |
65 | } | |
66 | ||
67 | #[allow(unused_variables)] | |
68 | fn unlink(&self, path: &[u8], uid: u32, gid: u32) -> Result<Option<usize>> { | |
69 | Err(Error::new(ENOENT)) | |
70 | } | |
71 | ||
72 | /* Resource operations */ | |
73 | #[allow(unused_variables)] | |
74 | fn dup(&self, old_id: usize, buf: &[u8]) -> Result<Option<usize>> { | |
75 | Err(Error::new(EBADF)) | |
76 | } | |
77 | ||
78 | #[allow(unused_variables)] | |
79 | fn read(&self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> { | |
80 | Err(Error::new(EBADF)) | |
81 | } | |
82 | ||
83 | #[allow(unused_variables)] | |
84 | fn write(&self, id: usize, buf: &[u8]) -> Result<Option<usize>> { | |
85 | Err(Error::new(EBADF)) | |
86 | } | |
87 | ||
88 | #[allow(unused_variables)] | |
89 | fn seek(&self, id: usize, pos: usize, whence: usize) -> Result<Option<usize>> { | |
90 | Err(Error::new(EBADF)) | |
91 | } | |
92 | ||
93 | #[allow(unused_variables)] | |
94 | fn fchmod(&self, id: usize, mode: u16) -> Result<Option<usize>> { | |
95 | Err(Error::new(EBADF)) | |
96 | } | |
97 | ||
98 | #[allow(unused_variables)] | |
99 | fn fchown(&self, id: usize, uid: u32, gid: u32) -> Result<Option<usize>> { | |
100 | Err(Error::new(EBADF)) | |
101 | } | |
102 | ||
103 | #[allow(unused_variables)] | |
104 | fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result<Option<usize>> { | |
105 | Err(Error::new(EBADF)) | |
106 | } | |
107 | ||
108 | #[allow(unused_variables)] | |
109 | fn fevent(&self, id: usize, flags: usize) -> Result<Option<usize>> { | |
110 | Err(Error::new(EBADF)) | |
111 | } | |
112 | ||
113 | #[allow(unused_variables)] | |
114 | fn fmap(&self, id: usize, offset: usize, size: usize) -> Result<Option<usize>> { | |
115 | Err(Error::new(EBADF)) | |
116 | } | |
117 | ||
118 | #[allow(unused_variables)] | |
119 | fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> { | |
120 | Err(Error::new(EBADF)) | |
121 | } | |
122 | ||
123 | #[allow(unused_variables)] | |
124 | fn frename(&self, id: usize, path: &[u8], uid: u32, gid: u32) -> Result<Option<usize>> { | |
125 | Err(Error::new(EBADF)) | |
126 | } | |
127 | ||
128 | #[allow(unused_variables)] | |
129 | fn fstat(&self, id: usize, stat: &mut Stat) -> Result<Option<usize>> { | |
130 | Err(Error::new(EBADF)) | |
131 | } | |
132 | ||
133 | #[allow(unused_variables)] | |
134 | fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result<Option<usize>> { | |
135 | Err(Error::new(EBADF)) | |
136 | } | |
137 | ||
138 | #[allow(unused_variables)] | |
139 | fn fsync(&self, id: usize) -> Result<Option<usize>> { | |
140 | Err(Error::new(EBADF)) | |
141 | } | |
142 | ||
143 | #[allow(unused_variables)] | |
144 | fn ftruncate(&self, id: usize, len: usize) -> Result<Option<usize>> { | |
145 | Err(Error::new(EBADF)) | |
146 | } | |
147 | ||
148 | #[allow(unused_variables)] | |
149 | fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result<Option<usize>> { | |
150 | Err(Error::new(EBADF)) | |
151 | } | |
152 | ||
153 | #[allow(unused_variables)] | |
154 | fn close(&self, id: usize) -> Result<Option<usize>> { | |
155 | Err(Error::new(EBADF)) | |
156 | } | |
157 | } |