vendor/redox_syscall-0.1.57/src/scheme/scheme.rs

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