| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use std::io::{self, ErrorKind, Read, Write}; |
| use std::mem; |
| use std::string::String; |
| use std::vec::Vec; |
| |
| use crate::protocol::wire_format::{Data, WireFormat}; |
| |
| // Message type constants. Taken from "include/net/9p/9p.h" in the linux kernel |
| // tree. The protocol specifies each R* message to be the corresponding T* |
| // message plus one. |
| const TLERROR: u8 = 6; |
| const RLERROR: u8 = TLERROR + 1; |
| const TSTATFS: u8 = 8; |
| const RSTATFS: u8 = TSTATFS + 1; |
| const TLOPEN: u8 = 12; |
| const RLOPEN: u8 = TLOPEN + 1; |
| const TLCREATE: u8 = 14; |
| const RLCREATE: u8 = TLCREATE + 1; |
| const TSYMLINK: u8 = 16; |
| const RSYMLINK: u8 = TSYMLINK + 1; |
| const TMKNOD: u8 = 18; |
| const RMKNOD: u8 = TMKNOD + 1; |
| const TRENAME: u8 = 20; |
| const RRENAME: u8 = TRENAME + 1; |
| const TREADLINK: u8 = 22; |
| const RREADLINK: u8 = TREADLINK + 1; |
| const TGETATTR: u8 = 24; |
| const RGETATTR: u8 = TGETATTR + 1; |
| const TSETATTR: u8 = 26; |
| const RSETATTR: u8 = TSETATTR + 1; |
| const TXATTRWALK: u8 = 30; |
| const RXATTRWALK: u8 = TXATTRWALK + 1; |
| const TXATTRCREATE: u8 = 32; |
| const RXATTRCREATE: u8 = TXATTRCREATE + 1; |
| const TREADDIR: u8 = 40; |
| const RREADDIR: u8 = TREADDIR + 1; |
| const TFSYNC: u8 = 50; |
| const RFSYNC: u8 = TFSYNC + 1; |
| const TLOCK: u8 = 52; |
| const RLOCK: u8 = TLOCK + 1; |
| const TGETLOCK: u8 = 54; |
| const RGETLOCK: u8 = TGETLOCK + 1; |
| const TLINK: u8 = 70; |
| const RLINK: u8 = TLINK + 1; |
| const TMKDIR: u8 = 72; |
| const RMKDIR: u8 = TMKDIR + 1; |
| const TRENAMEAT: u8 = 74; |
| const RRENAMEAT: u8 = TRENAMEAT + 1; |
| const TUNLINKAT: u8 = 76; |
| const RUNLINKAT: u8 = TUNLINKAT + 1; |
| const TVERSION: u8 = 100; |
| const RVERSION: u8 = TVERSION + 1; |
| const TAUTH: u8 = 102; |
| const RAUTH: u8 = TAUTH + 1; |
| const TATTACH: u8 = 104; |
| const RATTACH: u8 = TATTACH + 1; |
| const _TERROR: u8 = 106; |
| const _RERROR: u8 = _TERROR + 1; |
| const TFLUSH: u8 = 108; |
| const RFLUSH: u8 = TFLUSH + 1; |
| const TWALK: u8 = 110; |
| const RWALK: u8 = TWALK + 1; |
| const _TOPEN: u8 = 112; |
| const _ROPEN: u8 = _TOPEN + 1; |
| const _TCREATE: u8 = 114; |
| const _RCREATE: u8 = _TCREATE + 1; |
| const TREAD: u8 = 116; |
| const RREAD: u8 = TREAD + 1; |
| const TWRITE: u8 = 118; |
| const RWRITE: u8 = TWRITE + 1; |
| const TCLUNK: u8 = 120; |
| const RCLUNK: u8 = TCLUNK + 1; |
| const TREMOVE: u8 = 122; |
| const RREMOVE: u8 = TREMOVE + 1; |
| const _TSTAT: u8 = 124; |
| const _RSTAT: u8 = _TSTAT + 1; |
| const _TWSTAT: u8 = 126; |
| const _RWSTAT: u8 = _TWSTAT + 1; |
| |
| /// A message sent from a 9P client to a 9P server. |
| #[derive(Debug)] |
| pub enum Tmessage { |
| Version(Tversion), |
| Flush(Tflush), |
| Walk(Twalk), |
| Read(Tread), |
| Write(Twrite), |
| Clunk(Tclunk), |
| Remove(Tremove), |
| Attach(Tattach), |
| Auth(Tauth), |
| Statfs(Tstatfs), |
| Lopen(Tlopen), |
| Lcreate(Tlcreate), |
| Symlink(Tsymlink), |
| Mknod(Tmknod), |
| Rename(Trename), |
| Readlink(Treadlink), |
| GetAttr(Tgetattr), |
| SetAttr(Tsetattr), |
| XattrWalk(Txattrwalk), |
| XattrCreate(Txattrcreate), |
| Readdir(Treaddir), |
| Fsync(Tfsync), |
| Lock(Tlock), |
| GetLock(Tgetlock), |
| Link(Tlink), |
| Mkdir(Tmkdir), |
| RenameAt(Trenameat), |
| UnlinkAt(Tunlinkat), |
| } |
| |
| #[derive(Debug)] |
| pub struct Tframe { |
| pub tag: u16, |
| pub msg: Tmessage, |
| } |
| |
| impl WireFormat for Tframe { |
| fn byte_size(&self) -> u32 { |
| let msg_size = match self.msg { |
| Tmessage::Version(ref version) => version.byte_size(), |
| Tmessage::Flush(ref flush) => flush.byte_size(), |
| Tmessage::Walk(ref walk) => walk.byte_size(), |
| Tmessage::Read(ref read) => read.byte_size(), |
| Tmessage::Write(ref write) => write.byte_size(), |
| Tmessage::Clunk(ref clunk) => clunk.byte_size(), |
| Tmessage::Remove(ref remove) => remove.byte_size(), |
| Tmessage::Attach(ref attach) => attach.byte_size(), |
| Tmessage::Auth(ref auth) => auth.byte_size(), |
| Tmessage::Statfs(ref statfs) => statfs.byte_size(), |
| Tmessage::Lopen(ref lopen) => lopen.byte_size(), |
| Tmessage::Lcreate(ref lcreate) => lcreate.byte_size(), |
| Tmessage::Symlink(ref symlink) => symlink.byte_size(), |
| Tmessage::Mknod(ref mknod) => mknod.byte_size(), |
| Tmessage::Rename(ref rename) => rename.byte_size(), |
| Tmessage::Readlink(ref readlink) => readlink.byte_size(), |
| Tmessage::GetAttr(ref getattr) => getattr.byte_size(), |
| Tmessage::SetAttr(ref setattr) => setattr.byte_size(), |
| Tmessage::XattrWalk(ref xattrwalk) => xattrwalk.byte_size(), |
| Tmessage::XattrCreate(ref xattrcreate) => xattrcreate.byte_size(), |
| Tmessage::Readdir(ref readdir) => readdir.byte_size(), |
| Tmessage::Fsync(ref fsync) => fsync.byte_size(), |
| Tmessage::Lock(ref lock) => lock.byte_size(), |
| Tmessage::GetLock(ref getlock) => getlock.byte_size(), |
| Tmessage::Link(ref link) => link.byte_size(), |
| Tmessage::Mkdir(ref mkdir) => mkdir.byte_size(), |
| Tmessage::RenameAt(ref renameat) => renameat.byte_size(), |
| Tmessage::UnlinkAt(ref unlinkat) => unlinkat.byte_size(), |
| }; |
| |
| // size + type + tag + message size |
| (mem::size_of::<u32>() + mem::size_of::<u8>() + mem::size_of::<u16>()) as u32 + msg_size |
| } |
| |
| fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> { |
| self.byte_size().encode(writer)?; |
| |
| let ty = match self.msg { |
| Tmessage::Version(_) => TVERSION, |
| Tmessage::Flush(_) => TFLUSH, |
| Tmessage::Walk(_) => TWALK, |
| Tmessage::Read(_) => TREAD, |
| Tmessage::Write(_) => TWRITE, |
| Tmessage::Clunk(_) => TCLUNK, |
| Tmessage::Remove(_) => TREMOVE, |
| Tmessage::Attach(_) => TATTACH, |
| Tmessage::Auth(_) => TAUTH, |
| Tmessage::Statfs(_) => TSTATFS, |
| Tmessage::Lopen(_) => TLOPEN, |
| Tmessage::Lcreate(_) => TLCREATE, |
| Tmessage::Symlink(_) => TSYMLINK, |
| Tmessage::Mknod(_) => TMKNOD, |
| Tmessage::Rename(_) => TRENAME, |
| Tmessage::Readlink(_) => TREADLINK, |
| Tmessage::GetAttr(_) => TGETATTR, |
| Tmessage::SetAttr(_) => TSETATTR, |
| Tmessage::XattrWalk(_) => TXATTRWALK, |
| Tmessage::XattrCreate(_) => TXATTRCREATE, |
| Tmessage::Readdir(_) => TREADDIR, |
| Tmessage::Fsync(_) => TFSYNC, |
| Tmessage::Lock(_) => TLOCK, |
| Tmessage::GetLock(_) => TGETLOCK, |
| Tmessage::Link(_) => TLINK, |
| Tmessage::Mkdir(_) => TMKDIR, |
| Tmessage::RenameAt(_) => TRENAMEAT, |
| Tmessage::UnlinkAt(_) => TUNLINKAT, |
| }; |
| |
| ty.encode(writer)?; |
| self.tag.encode(writer)?; |
| |
| match self.msg { |
| Tmessage::Version(ref version) => version.encode(writer), |
| Tmessage::Flush(ref flush) => flush.encode(writer), |
| Tmessage::Walk(ref walk) => walk.encode(writer), |
| Tmessage::Read(ref read) => read.encode(writer), |
| Tmessage::Write(ref write) => write.encode(writer), |
| Tmessage::Clunk(ref clunk) => clunk.encode(writer), |
| Tmessage::Remove(ref remove) => remove.encode(writer), |
| Tmessage::Attach(ref attach) => attach.encode(writer), |
| Tmessage::Auth(ref auth) => auth.encode(writer), |
| Tmessage::Statfs(ref statfs) => statfs.encode(writer), |
| Tmessage::Lopen(ref lopen) => lopen.encode(writer), |
| Tmessage::Lcreate(ref lcreate) => lcreate.encode(writer), |
| Tmessage::Symlink(ref symlink) => symlink.encode(writer), |
| Tmessage::Mknod(ref mknod) => mknod.encode(writer), |
| Tmessage::Rename(ref rename) => rename.encode(writer), |
| Tmessage::Readlink(ref readlink) => readlink.encode(writer), |
| Tmessage::GetAttr(ref getattr) => getattr.encode(writer), |
| Tmessage::SetAttr(ref setattr) => setattr.encode(writer), |
| Tmessage::XattrWalk(ref xattrwalk) => xattrwalk.encode(writer), |
| Tmessage::XattrCreate(ref xattrcreate) => xattrcreate.encode(writer), |
| Tmessage::Readdir(ref readdir) => readdir.encode(writer), |
| Tmessage::Fsync(ref fsync) => fsync.encode(writer), |
| Tmessage::Lock(ref lock) => lock.encode(writer), |
| Tmessage::GetLock(ref getlock) => getlock.encode(writer), |
| Tmessage::Link(ref link) => link.encode(writer), |
| Tmessage::Mkdir(ref mkdir) => mkdir.encode(writer), |
| Tmessage::RenameAt(ref renameat) => renameat.encode(writer), |
| Tmessage::UnlinkAt(ref unlinkat) => unlinkat.encode(writer), |
| } |
| } |
| |
| fn decode<R: Read>(reader: &mut R) -> io::Result<Self> { |
| let byte_size: u32 = WireFormat::decode(reader)?; |
| |
| // byte_size includes the size of byte_size so remove that from the |
| // expected length of the message. Also make sure that byte_size is at least |
| // that long to begin with. |
| if byte_size < mem::size_of::<u32>() as u32 { |
| return Err(io::Error::new( |
| ErrorKind::InvalidData, |
| format!("byte_size(= {}) is less than 4 bytes", byte_size), |
| )); |
| } |
| |
| let reader = &mut reader.take((byte_size - mem::size_of::<u32>() as u32) as u64); |
| |
| let mut ty = [0u8]; |
| reader.read_exact(&mut ty)?; |
| |
| let tag: u16 = WireFormat::decode(reader)?; |
| |
| let msg = match ty[0] { |
| TVERSION => Ok(Tmessage::Version(WireFormat::decode(reader)?)), |
| TFLUSH => Ok(Tmessage::Flush(WireFormat::decode(reader)?)), |
| TWALK => Ok(Tmessage::Walk(WireFormat::decode(reader)?)), |
| TREAD => Ok(Tmessage::Read(WireFormat::decode(reader)?)), |
| TWRITE => Ok(Tmessage::Write(WireFormat::decode(reader)?)), |
| TCLUNK => Ok(Tmessage::Clunk(WireFormat::decode(reader)?)), |
| TREMOVE => Ok(Tmessage::Remove(WireFormat::decode(reader)?)), |
| TATTACH => Ok(Tmessage::Attach(WireFormat::decode(reader)?)), |
| TAUTH => Ok(Tmessage::Auth(WireFormat::decode(reader)?)), |
| TSTATFS => Ok(Tmessage::Statfs(WireFormat::decode(reader)?)), |
| TLOPEN => Ok(Tmessage::Lopen(WireFormat::decode(reader)?)), |
| TLCREATE => Ok(Tmessage::Lcreate(WireFormat::decode(reader)?)), |
| TSYMLINK => Ok(Tmessage::Symlink(WireFormat::decode(reader)?)), |
| TMKNOD => Ok(Tmessage::Mknod(WireFormat::decode(reader)?)), |
| TRENAME => Ok(Tmessage::Rename(WireFormat::decode(reader)?)), |
| TREADLINK => Ok(Tmessage::Readlink(WireFormat::decode(reader)?)), |
| TGETATTR => Ok(Tmessage::GetAttr(WireFormat::decode(reader)?)), |
| TSETATTR => Ok(Tmessage::SetAttr(WireFormat::decode(reader)?)), |
| TXATTRWALK => Ok(Tmessage::XattrWalk(WireFormat::decode(reader)?)), |
| TXATTRCREATE => Ok(Tmessage::XattrCreate(WireFormat::decode(reader)?)), |
| TREADDIR => Ok(Tmessage::Readdir(WireFormat::decode(reader)?)), |
| TFSYNC => Ok(Tmessage::Fsync(WireFormat::decode(reader)?)), |
| TLOCK => Ok(Tmessage::Lock(WireFormat::decode(reader)?)), |
| TGETLOCK => Ok(Tmessage::GetLock(WireFormat::decode(reader)?)), |
| TLINK => Ok(Tmessage::Link(WireFormat::decode(reader)?)), |
| TMKDIR => Ok(Tmessage::Mkdir(WireFormat::decode(reader)?)), |
| TRENAMEAT => Ok(Tmessage::RenameAt(WireFormat::decode(reader)?)), |
| TUNLINKAT => Ok(Tmessage::UnlinkAt(WireFormat::decode(reader)?)), |
| err => Err(io::Error::new( |
| ErrorKind::InvalidData, |
| format!("unknown message type {}", err), |
| )), |
| }?; |
| |
| Ok(Tframe { tag, msg }) |
| } |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tversion { |
| pub msize: u32, |
| pub version: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tflush { |
| pub oldtag: u16, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Twalk { |
| pub fid: u32, |
| pub newfid: u32, |
| pub wnames: Vec<String>, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tread { |
| pub fid: u32, |
| pub offset: u64, |
| pub count: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Twrite { |
| pub fid: u32, |
| pub offset: u64, |
| pub data: Data, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tclunk { |
| pub fid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tremove { |
| pub fid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tauth { |
| pub afid: u32, |
| pub uname: String, |
| pub aname: String, |
| pub n_uname: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tattach { |
| pub fid: u32, |
| pub afid: u32, |
| pub uname: String, |
| pub aname: String, |
| pub n_uname: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tstatfs { |
| pub fid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tlopen { |
| pub fid: u32, |
| pub flags: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tlcreate { |
| pub fid: u32, |
| pub name: String, |
| pub flags: u32, |
| pub mode: u32, |
| pub gid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tsymlink { |
| pub fid: u32, |
| pub name: String, |
| pub symtgt: String, |
| pub gid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tmknod { |
| pub dfid: u32, |
| pub name: String, |
| pub mode: u32, |
| pub major: u32, |
| pub minor: u32, |
| pub gid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Trename { |
| pub fid: u32, |
| pub dfid: u32, |
| pub name: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Treadlink { |
| pub fid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tgetattr { |
| pub fid: u32, |
| pub request_mask: u64, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tsetattr { |
| pub fid: u32, |
| pub valid: u32, |
| pub mode: u32, |
| pub uid: u32, |
| pub gid: u32, |
| pub size: u64, |
| pub atime_sec: u64, |
| pub atime_nsec: u64, |
| pub mtime_sec: u64, |
| pub mtime_nsec: u64, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Txattrwalk { |
| pub fid: u32, |
| pub newfid: u32, |
| pub name: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Txattrcreate { |
| pub fid: u32, |
| pub name: String, |
| pub attr_size: u64, |
| pub flags: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Treaddir { |
| pub fid: u32, |
| pub offset: u64, |
| pub count: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tfsync { |
| pub fid: u32, |
| pub datasync: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tlock { |
| pub fid: u32, |
| pub type_: u8, |
| pub flags: u32, |
| pub start: u64, |
| pub length: u64, |
| pub proc_id: u32, |
| pub client_id: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tgetlock { |
| pub fid: u32, |
| pub type_: u8, |
| pub start: u64, |
| pub length: u64, |
| pub proc_id: u32, |
| pub client_id: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tlink { |
| pub dfid: u32, |
| pub fid: u32, |
| pub name: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tmkdir { |
| pub dfid: u32, |
| pub name: String, |
| pub mode: u32, |
| pub gid: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Trenameat { |
| pub olddirfid: u32, |
| pub oldname: String, |
| pub newdirfid: u32, |
| pub newname: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Tunlinkat { |
| pub dirfd: u32, |
| pub name: String, |
| pub flags: u32, |
| } |
| |
| /// A message sent from a 9P server to a 9P client in response to a request from |
| /// that client. Encapsulates a full frame. |
| #[derive(Debug)] |
| pub enum Rmessage { |
| Version(Rversion), |
| Flush, |
| Walk(Rwalk), |
| Read(Rread), |
| Write(Rwrite), |
| Clunk, |
| Remove, |
| Attach(Rattach), |
| Auth(Rauth), |
| Statfs(Rstatfs), |
| Lopen(Rlopen), |
| Lcreate(Rlcreate), |
| Symlink(Rsymlink), |
| Mknod(Rmknod), |
| Rename, |
| Readlink(Rreadlink), |
| GetAttr(Rgetattr), |
| SetAttr, |
| XattrWalk(Rxattrwalk), |
| XattrCreate, |
| Readdir(Rreaddir), |
| Fsync, |
| Lock(Rlock), |
| GetLock(Rgetlock), |
| Link, |
| Mkdir(Rmkdir), |
| RenameAt, |
| UnlinkAt, |
| Lerror(Rlerror), |
| } |
| |
| #[derive(Debug)] |
| pub struct Rframe { |
| pub tag: u16, |
| pub msg: Rmessage, |
| } |
| |
| impl WireFormat for Rframe { |
| fn byte_size(&self) -> u32 { |
| let msg_size = match self.msg { |
| Rmessage::Version(ref version) => version.byte_size(), |
| Rmessage::Flush => 0, |
| Rmessage::Walk(ref walk) => walk.byte_size(), |
| Rmessage::Read(ref read) => read.byte_size(), |
| Rmessage::Write(ref write) => write.byte_size(), |
| Rmessage::Clunk => 0, |
| Rmessage::Remove => 0, |
| Rmessage::Attach(ref attach) => attach.byte_size(), |
| Rmessage::Auth(ref auth) => auth.byte_size(), |
| Rmessage::Statfs(ref statfs) => statfs.byte_size(), |
| Rmessage::Lopen(ref lopen) => lopen.byte_size(), |
| Rmessage::Lcreate(ref lcreate) => lcreate.byte_size(), |
| Rmessage::Symlink(ref symlink) => symlink.byte_size(), |
| Rmessage::Mknod(ref mknod) => mknod.byte_size(), |
| Rmessage::Rename => 0, |
| Rmessage::Readlink(ref readlink) => readlink.byte_size(), |
| Rmessage::GetAttr(ref getattr) => getattr.byte_size(), |
| Rmessage::SetAttr => 0, |
| Rmessage::XattrWalk(ref xattrwalk) => xattrwalk.byte_size(), |
| Rmessage::XattrCreate => 0, |
| Rmessage::Readdir(ref readdir) => readdir.byte_size(), |
| Rmessage::Fsync => 0, |
| Rmessage::Lock(ref lock) => lock.byte_size(), |
| Rmessage::GetLock(ref getlock) => getlock.byte_size(), |
| Rmessage::Link => 0, |
| Rmessage::Mkdir(ref mkdir) => mkdir.byte_size(), |
| Rmessage::RenameAt => 0, |
| Rmessage::UnlinkAt => 0, |
| Rmessage::Lerror(ref lerror) => lerror.byte_size(), |
| }; |
| |
| // size + type + tag + message size |
| (mem::size_of::<u32>() + mem::size_of::<u8>() + mem::size_of::<u16>()) as u32 + msg_size |
| } |
| |
| fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> { |
| self.byte_size().encode(writer)?; |
| |
| let ty = match self.msg { |
| Rmessage::Version(_) => RVERSION, |
| Rmessage::Flush => RFLUSH, |
| Rmessage::Walk(_) => RWALK, |
| Rmessage::Read(_) => RREAD, |
| Rmessage::Write(_) => RWRITE, |
| Rmessage::Clunk => RCLUNK, |
| Rmessage::Remove => RREMOVE, |
| Rmessage::Attach(_) => RATTACH, |
| Rmessage::Auth(_) => RAUTH, |
| Rmessage::Statfs(_) => RSTATFS, |
| Rmessage::Lopen(_) => RLOPEN, |
| Rmessage::Lcreate(_) => RLCREATE, |
| Rmessage::Symlink(_) => RSYMLINK, |
| Rmessage::Mknod(_) => RMKNOD, |
| Rmessage::Rename => RRENAME, |
| Rmessage::Readlink(_) => RREADLINK, |
| Rmessage::GetAttr(_) => RGETATTR, |
| Rmessage::SetAttr => RSETATTR, |
| Rmessage::XattrWalk(_) => RXATTRWALK, |
| Rmessage::XattrCreate => RXATTRCREATE, |
| Rmessage::Readdir(_) => RREADDIR, |
| Rmessage::Fsync => RFSYNC, |
| Rmessage::Lock(_) => RLOCK, |
| Rmessage::GetLock(_) => RGETLOCK, |
| Rmessage::Link => RLINK, |
| Rmessage::Mkdir(_) => RMKDIR, |
| Rmessage::RenameAt => RRENAMEAT, |
| Rmessage::UnlinkAt => RUNLINKAT, |
| Rmessage::Lerror(_) => RLERROR, |
| }; |
| |
| ty.encode(writer)?; |
| self.tag.encode(writer)?; |
| |
| match self.msg { |
| Rmessage::Version(ref version) => version.encode(writer), |
| Rmessage::Flush => Ok(()), |
| Rmessage::Walk(ref walk) => walk.encode(writer), |
| Rmessage::Read(ref read) => read.encode(writer), |
| Rmessage::Write(ref write) => write.encode(writer), |
| Rmessage::Clunk => Ok(()), |
| Rmessage::Remove => Ok(()), |
| Rmessage::Attach(ref attach) => attach.encode(writer), |
| Rmessage::Auth(ref auth) => auth.encode(writer), |
| Rmessage::Statfs(ref statfs) => statfs.encode(writer), |
| Rmessage::Lopen(ref lopen) => lopen.encode(writer), |
| Rmessage::Lcreate(ref lcreate) => lcreate.encode(writer), |
| Rmessage::Symlink(ref symlink) => symlink.encode(writer), |
| Rmessage::Mknod(ref mknod) => mknod.encode(writer), |
| Rmessage::Rename => Ok(()), |
| Rmessage::Readlink(ref readlink) => readlink.encode(writer), |
| Rmessage::GetAttr(ref getattr) => getattr.encode(writer), |
| Rmessage::SetAttr => Ok(()), |
| Rmessage::XattrWalk(ref xattrwalk) => xattrwalk.encode(writer), |
| Rmessage::XattrCreate => Ok(()), |
| Rmessage::Readdir(ref readdir) => readdir.encode(writer), |
| Rmessage::Fsync => Ok(()), |
| Rmessage::Lock(ref lock) => lock.encode(writer), |
| Rmessage::GetLock(ref getlock) => getlock.encode(writer), |
| Rmessage::Link => Ok(()), |
| Rmessage::Mkdir(ref mkdir) => mkdir.encode(writer), |
| Rmessage::RenameAt => Ok(()), |
| Rmessage::UnlinkAt => Ok(()), |
| Rmessage::Lerror(ref lerror) => lerror.encode(writer), |
| } |
| } |
| |
| fn decode<R: Read>(reader: &mut R) -> io::Result<Self> { |
| let byte_size: u32 = WireFormat::decode(reader)?; |
| |
| // byte_size includes the size of byte_size so remove that from the |
| // expected length of the message. |
| let reader = &mut reader.take((byte_size - mem::size_of::<u32>() as u32) as u64); |
| |
| let mut ty = [0u8]; |
| reader.read_exact(&mut ty)?; |
| |
| let tag: u16 = WireFormat::decode(reader)?; |
| |
| let msg = match ty[0] { |
| RVERSION => Ok(Rmessage::Version(WireFormat::decode(reader)?)), |
| RFLUSH => Ok(Rmessage::Flush), |
| RWALK => Ok(Rmessage::Walk(WireFormat::decode(reader)?)), |
| RREAD => Ok(Rmessage::Read(WireFormat::decode(reader)?)), |
| RWRITE => Ok(Rmessage::Write(WireFormat::decode(reader)?)), |
| RCLUNK => Ok(Rmessage::Clunk), |
| RREMOVE => Ok(Rmessage::Remove), |
| RATTACH => Ok(Rmessage::Attach(WireFormat::decode(reader)?)), |
| RAUTH => Ok(Rmessage::Auth(WireFormat::decode(reader)?)), |
| RSTATFS => Ok(Rmessage::Statfs(WireFormat::decode(reader)?)), |
| RLOPEN => Ok(Rmessage::Lopen(WireFormat::decode(reader)?)), |
| RLCREATE => Ok(Rmessage::Lcreate(WireFormat::decode(reader)?)), |
| RSYMLINK => Ok(Rmessage::Symlink(WireFormat::decode(reader)?)), |
| RMKNOD => Ok(Rmessage::Mknod(WireFormat::decode(reader)?)), |
| RRENAME => Ok(Rmessage::Rename), |
| RREADLINK => Ok(Rmessage::Readlink(WireFormat::decode(reader)?)), |
| RGETATTR => Ok(Rmessage::GetAttr(WireFormat::decode(reader)?)), |
| RSETATTR => Ok(Rmessage::SetAttr), |
| RXATTRWALK => Ok(Rmessage::XattrWalk(WireFormat::decode(reader)?)), |
| RXATTRCREATE => Ok(Rmessage::XattrCreate), |
| RREADDIR => Ok(Rmessage::Readdir(WireFormat::decode(reader)?)), |
| RFSYNC => Ok(Rmessage::Fsync), |
| RLOCK => Ok(Rmessage::Lock(WireFormat::decode(reader)?)), |
| RGETLOCK => Ok(Rmessage::GetLock(WireFormat::decode(reader)?)), |
| RLINK => Ok(Rmessage::Link), |
| RMKDIR => Ok(Rmessage::Mkdir(WireFormat::decode(reader)?)), |
| RRENAMEAT => Ok(Rmessage::RenameAt), |
| RUNLINKAT => Ok(Rmessage::UnlinkAt), |
| RLERROR => Ok(Rmessage::Lerror(WireFormat::decode(reader)?)), |
| err => Err(io::Error::new( |
| ErrorKind::InvalidData, |
| format!("unknown message type {}", err), |
| )), |
| }?; |
| |
| Ok(Rframe { tag, msg }) |
| } |
| } |
| |
| #[derive(Debug, Copy, Clone, P9WireFormat)] |
| pub struct Qid { |
| pub ty: u8, |
| pub version: u32, |
| pub path: u64, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Dirent { |
| pub qid: Qid, |
| pub offset: u64, |
| pub ty: u8, |
| pub name: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rversion { |
| pub msize: u32, |
| pub version: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rwalk { |
| pub wqids: Vec<Qid>, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rread { |
| pub data: Data, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rwrite { |
| pub count: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rauth { |
| pub aqid: Qid, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rattach { |
| pub qid: Qid, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rlerror { |
| pub ecode: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rstatfs { |
| pub ty: u32, |
| pub bsize: u32, |
| pub blocks: u64, |
| pub bfree: u64, |
| pub bavail: u64, |
| pub files: u64, |
| pub ffree: u64, |
| pub fsid: u64, |
| pub namelen: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rlopen { |
| pub qid: Qid, |
| pub iounit: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rlcreate { |
| pub qid: Qid, |
| pub iounit: u32, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rsymlink { |
| pub qid: Qid, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rmknod { |
| pub qid: Qid, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rreadlink { |
| pub target: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rgetattr { |
| pub valid: u64, |
| pub qid: Qid, |
| pub mode: u32, |
| pub uid: u32, |
| pub gid: u32, |
| pub nlink: u64, |
| pub rdev: u64, |
| pub size: u64, |
| pub blksize: u64, |
| pub blocks: u64, |
| pub atime_sec: u64, |
| pub atime_nsec: u64, |
| pub mtime_sec: u64, |
| pub mtime_nsec: u64, |
| pub ctime_sec: u64, |
| pub ctime_nsec: u64, |
| pub btime_sec: u64, |
| pub btime_nsec: u64, |
| pub gen: u64, |
| pub data_version: u64, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rxattrwalk { |
| pub size: u64, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rreaddir { |
| pub data: Data, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rlock { |
| pub status: u8, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rgetlock { |
| pub ty: u8, |
| pub start: u64, |
| pub length: u64, |
| pub proc_id: u32, |
| pub client_id: String, |
| } |
| |
| #[derive(Debug, P9WireFormat)] |
| pub struct Rmkdir { |
| pub qid: Qid, |
| } |
