Grcov report - server.rs

1

use jetstream_rpc::{context::Context, Frame, Framer, Protocol};

2

use jetstream_wireformat::WireFormat;

3

4

use crate::{ninep_2000_l::NineP200L, *};

5

6

// Message type constants.  Taken from "include/net/9p/9p.h" in the linux kernel

7

// tree.  The protocol specifies each R* message to be the corresponding T*

8

// message plus one.

9

const TLERROR: u8 = 6;

10

const RLERROR: u8 = TLERROR + 1;

11

const TSTATFS: u8 = 8;

12

const RSTATFS: u8 = TSTATFS + 1;

13

const TLOPEN: u8 = 12;

14

const RLOPEN: u8 = TLOPEN + 1;

15

const TLCREATE: u8 = 14;

16

const RLCREATE: u8 = TLCREATE + 1;

17

const TSYMLINK: u8 = 16;

18

const RSYMLINK: u8 = TSYMLINK + 1;

19

const TMKNOD: u8 = 18;

20

const RMKNOD: u8 = TMKNOD + 1;

21

const TRENAME: u8 = 20;

22

const RRENAME: u8 = TRENAME + 1;

23

const TREADLINK: u8 = 22;

24

const RREADLINK: u8 = TREADLINK + 1;

25

const TGETATTR: u8 = 24;

26

const RGETATTR: u8 = TGETATTR + 1;

27

const TSETATTR: u8 = 26;

28

const RSETATTR: u8 = TSETATTR + 1;

29

const TXATTRWALK: u8 = 30;

30

const RXATTRWALK: u8 = TXATTRWALK + 1;

31

const TXATTRCREATE: u8 = 32;

32

const RXATTRCREATE: u8 = TXATTRCREATE + 1;

33

const TREADDIR: u8 = 40;

34

const RREADDIR: u8 = TREADDIR + 1;

35

const TFSYNC: u8 = 50;

36

const RFSYNC: u8 = TFSYNC + 1;

37

const TLOCK: u8 = 52;

38

const RLOCK: u8 = TLOCK + 1;

39

const TGETLOCK: u8 = 54;

40

const RGETLOCK: u8 = TGETLOCK + 1;

41

const TLINK: u8 = 70;

42

const RLINK: u8 = TLINK + 1;

43

const TMKDIR: u8 = 72;

44

const RMKDIR: u8 = TMKDIR + 1;

45

const TRENAMEAT: u8 = 74;

46

const RRENAMEAT: u8 = TRENAMEAT + 1;

47

const TUNLINKAT: u8 = 76;

48

const RUNLINKAT: u8 = TUNLINKAT + 1;

49

const TVERSION: u8 = 100;

50

const RVERSION: u8 = TVERSION + 1;

51

const TAUTH: u8 = 102;

52

const RAUTH: u8 = TAUTH + 1;

53

const TATTACH: u8 = 104;

54

const RATTACH: u8 = TATTACH + 1;

55

const _TERROR: u8 = 106;

56

const _RERROR: u8 = _TERROR + 1;

57

const TFLUSH: u8 = 108;

58

const RFLUSH: u8 = TFLUSH + 1;

59

const TWALK: u8 = 110;

60

const RWALK: u8 = TWALK + 1;

61

const _TOPEN: u8 = 112;

62

const _ROPEN: u8 = _TOPEN + 1;

63

const _TCREATE: u8 = 114;

64

const _RCREATE: u8 = _TCREATE + 1;

65

const TREAD: u8 = 116;

66

const RREAD: u8 = TREAD + 1;

67

const TWRITE: u8 = 118;

68

const RWRITE: u8 = TWRITE + 1;

69

const TCLUNK: u8 = 120;

70

const RCLUNK: u8 = TCLUNK + 1;

71

const TREMOVE: u8 = 122;

72

const RREMOVE: u8 = TREMOVE + 1;

73

const _TSTAT: u8 = 124;

74

const _RSTAT: u8 = _TSTAT + 1;

75

const _TWSTAT: u8 = 126;

76

const _RWSTAT: u8 = _TWSTAT + 1;

77

78

/// A message sent from a 9P client to a 9P server.

79

#[derive(Debug)]

80

#[repr(u8)]

81

pub enum Tmessage {

82

    Version(Tversion) = TVERSION,

83

    Flush(Tflush) = TFLUSH,

84

    Walk(Twalk) = TWALK,

85

    Read(Tread) = TREAD,

86

    Write(Twrite) = TWRITE,

87

    Clunk(Tclunk) = TCLUNK,

88

    Remove(Tremove) = TREMOVE,

89

    Attach(Tattach) = TATTACH,

90

    Auth(Tauth) = TAUTH,

91

    Statfs(Tstatfs) = TSTATFS,

92

    Lopen(Tlopen) = TLOPEN,

93

    Lcreate(Tlcreate) = TLCREATE,

94

    Symlink(Tsymlink) = TSYMLINK,

95

    Mknod(Tmknod) = TMKNOD,

96

    Rename(Trename) = TRENAME,

97

    Readlink(Treadlink) = TREADLINK,

98

    GetAttr(Tgetattr) = TGETATTR,

99

    SetAttr(Tsetattr) = TSETATTR,

100

    XattrWalk(Txattrwalk) = TXATTRWALK,

101

    XattrCreate(Txattrcreate) = TXATTRCREATE,

102

    Readdir(Treaddir) = TREADDIR,

103

    Fsync(Tfsync) = TFSYNC,

104

    Lock(Tlock) = TLOCK,

105

    GetLock(Tgetlock) = TGETLOCK,

106

    Link(Tlink) = TLINK,

107

    Mkdir(Tmkdir) = TMKDIR,

108

    RenameAt(Trenameat) = TRENAMEAT,

109

    UnlinkAt(Tunlinkat) = TUNLINKAT,

110

111

112

impl Framer for Tmessage {

113

    fn message_type(&self) -> u8 {

114

        match self {

115

            Tmessage::Version(_) => TVERSION,

116

            Tmessage::Flush(_) => TFLUSH,

117

            Tmessage::Walk(_) => TWALK,

118

            Tmessage::Read(_) => TREAD,

119

            Tmessage::Write(_) => TWRITE,

120

            Tmessage::Clunk(_) => TCLUNK,

121

            Tmessage::Remove(_) => TREMOVE,

122

            Tmessage::Attach(_) => TATTACH,

123

            Tmessage::Auth(_) => TAUTH,

124

            Tmessage::Statfs(_) => TSTATFS,

125

            Tmessage::Lopen(_) => TLOPEN,

126

            Tmessage::Lcreate(_) => TLCREATE,

127

            Tmessage::Symlink(_) => TSYMLINK,

128

            Tmessage::Mknod(_) => TMKNOD,

129

            Tmessage::Rename(_) => TRENAME,

130

            Tmessage::Readlink(_) => TREADLINK,

131

            Tmessage::GetAttr(_) => TGETATTR,

132

            Tmessage::SetAttr(_) => TSETATTR,

133

            Tmessage::XattrWalk(_) => TXATTRWALK,

134

            Tmessage::XattrCreate(_) => TXATTRCREATE,

135

            Tmessage::Readdir(_) => TREADDIR,

136

            Tmessage::Fsync(_) => TFSYNC,

137

            Tmessage::Lock(_) => TLOCK,

138

            Tmessage::GetLock(_) => TGETLOCK,

139

            Tmessage::Link(_) => TLINK,

140

            Tmessage::Mkdir(_) => TMKDIR,

141

            Tmessage::RenameAt(_) => TRENAMEAT,

142

            Tmessage::UnlinkAt(_) => TUNLINKAT,

143

144

145

146

    fn byte_size(&self) -> u32 {

147

        match self {

148

            Tmessage::Version(msg) => msg.byte_size(),

149

            Tmessage::Flush(msg) => msg.byte_size(),

150

            Tmessage::Walk(msg) => msg.byte_size(),

151

            Tmessage::Read(msg) => msg.byte_size(),

152

            Tmessage::Write(msg) => msg.byte_size(),

153

            Tmessage::Clunk(msg) => msg.byte_size(),

154

            Tmessage::Remove(msg) => msg.byte_size(),

155

            Tmessage::Attach(msg) => msg.byte_size(),

156

            Tmessage::Auth(msg) => msg.byte_size(),

157

            Tmessage::Statfs(msg) => msg.byte_size(),

158

            Tmessage::Lopen(msg) => msg.byte_size(),

159

            Tmessage::Lcreate(msg) => msg.byte_size(),

160

            Tmessage::Symlink(msg) => msg.byte_size(),

161

            Tmessage::Mknod(msg) => msg.byte_size(),

162

            Tmessage::Rename(msg) => msg.byte_size(),

163

            Tmessage::Readlink(msg) => msg.byte_size(),

164

            Tmessage::GetAttr(msg) => msg.byte_size(),

165

            Tmessage::SetAttr(msg) => msg.byte_size(),

166

            Tmessage::XattrWalk(msg) => msg.byte_size(),

167

            Tmessage::XattrCreate(msg) => msg.byte_size(),

168

            Tmessage::Readdir(msg) => msg.byte_size(),

169

            Tmessage::Fsync(msg) => msg.byte_size(),

170

            Tmessage::Lock(msg) => msg.byte_size(),

171

            Tmessage::GetLock(msg) => msg.byte_size(),

172

            Tmessage::Link(msg) => msg.byte_size(),

173

            Tmessage::Mkdir(msg) => msg.byte_size(),

174

            Tmessage::RenameAt(msg) => msg.byte_size(),

175

            Tmessage::UnlinkAt(msg) => msg.byte_size(),

176

177

178

179

    fn encode<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {

180

        match self {

181

            Tmessage::Version(msg) => msg.encode(writer),

182

            Tmessage::Flush(msg) => msg.encode(writer),

183

            Tmessage::Walk(msg) => msg.encode(writer),

184

            Tmessage::Read(msg) => msg.encode(writer),

185

            Tmessage::Write(msg) => msg.encode(writer),

186

            Tmessage::Clunk(msg) => msg.encode(writer),

187

            Tmessage::Remove(msg) => msg.encode(writer),

188

            Tmessage::Attach(msg) => msg.encode(writer),

189

            Tmessage::Auth(msg) => msg.encode(writer),

190

            Tmessage::Statfs(msg) => msg.encode(writer),

191

            Tmessage::Lopen(msg) => msg.encode(writer),

192

            Tmessage::Lcreate(msg) => msg.encode(writer),

193

            Tmessage::Symlink(msg) => msg.encode(writer),

194

            Tmessage::Mknod(msg) => msg.encode(writer),

195

            Tmessage::Rename(msg) => msg.encode(writer),

196

            Tmessage::Readlink(msg) => msg.encode(writer),

197

            Tmessage::GetAttr(msg) => msg.encode(writer),

198

            Tmessage::SetAttr(msg) => msg.encode(writer),

199

            Tmessage::XattrWalk(msg) => msg.encode(writer),

200

            Tmessage::XattrCreate(msg) => msg.encode(writer),

201

            Tmessage::Readdir(msg) => msg.encode(writer),

202

            Tmessage::Fsync(msg) => msg.encode(writer),

203

            Tmessage::Lock(msg) => msg.encode(writer),

204

            Tmessage::GetLock(msg) => msg.encode(writer),

205

            Tmessage::Link(msg) => msg.encode(writer),

206

            Tmessage::Mkdir(msg) => msg.encode(writer),

207

            Tmessage::RenameAt(msg) => msg.encode(writer),

208

            Tmessage::UnlinkAt(msg) => msg.encode(writer),

209

210

211

212

    fn decode<R: std::io::Read>(

213

        reader: &mut R,

214

        ty: u8,

215

    ) -> std::io::Result<Self> {

216

        match ty {

217

            TVERSION => Ok(Tmessage::Version(Tversion::decode(reader)?)),

218

            TFLUSH => Ok(Tmessage::Flush(Tflush::decode(reader)?)),

219

            TWALK => Ok(Tmessage::Walk(Twalk::decode(reader)?)),

220

            TREAD => Ok(Tmessage::Read(Tread::decode(reader)?)),

221

            TWRITE => Ok(Tmessage::Write(Twrite::decode(reader)?)),

222

            TCLUNK => Ok(Tmessage::Clunk(Tclunk::decode(reader)?)),

223

            TREMOVE => Ok(Tmessage::Remove(Tremove::decode(reader)?)),

224

            TATTACH => Ok(Tmessage::Attach(Tattach::decode(reader)?)),

225

            TAUTH => Ok(Tmessage::Auth(Tauth::decode(reader)?)),

226

            TSTATFS => Ok(Tmessage::Statfs(Tstatfs::decode(reader)?)),

227

            TLOPEN => Ok(Tmessage::Lopen(Tlopen::decode(reader)?)),

228

            TLCREATE => Ok(Tmessage::Lcreate(Tlcreate::decode(reader)?)),

229

            TSYMLINK => Ok(Tmessage::Symlink(Tsymlink::decode(reader)?)),

230

            TMKNOD => Ok(Tmessage::Mknod(Tmknod::decode(reader)?)),

231

            TRENAME => Ok(Tmessage::Rename(Trename::decode(reader)?)),

232

            TREADLINK => Ok(Tmessage::Readlink(Treadlink::decode(reader)?)),

233

            TGETATTR => Ok(Tmessage::GetAttr(Tgetattr::decode(reader)?)),

234

            TSETATTR => Ok(Tmessage::SetAttr(Tsetattr::decode(reader)?)),

235

            TXATTRWALK => Ok(Tmessage::XattrWalk(Txattrwalk::decode(reader)?)),

236

            TXATTRCREATE => {

237

                Ok(Tmessage::XattrCreate(Txattrcreate::decode(reader)?))

238

239

            TREADDIR => Ok(Tmessage::Readdir(Treaddir::decode(reader)?)),

240

            TFSYNC => Ok(Tmessage::Fsync(Tfsync::decode(reader)?)),

241

            TLOCK => Ok(Tmessage::Lock(Tlock::decode(reader)?)),

242

            TGETLOCK => Ok(Tmessage::GetLock(Tgetlock::decode(reader)?)),

243

            TLINK => Ok(Tmessage::Link(Tlink::decode(reader)?)),

244

            TMKDIR => Ok(Tmessage::Mkdir(Tmkdir::decode(reader)?)),

245

            TRENAMEAT => Ok(Tmessage::RenameAt(Trenameat::decode(reader)?)),

246

            TUNLINKAT => Ok(Tmessage::UnlinkAt(Tunlinkat::decode(reader)?)),

247

            _ => Err(std::io::Error::new(

248

                std::io::ErrorKind::InvalidData,

249

                "invalid message type",

250

)),

251

252

253

254

255

/// A message sent from a 9P server to a 9P client in response to a request from

256

/// that client.  Encapsulates a full frame.

257

#[derive(Debug)]

258

#[repr(u8)]

259

pub enum Rmessage {

260

    Version(Rversion) = RVERSION,

261

    Flush = RFLUSH,

262

    Walk(Rwalk) = RWALK,

263

    Read(Rread) = RREAD,

264

    Write(Rwrite) = RWRITE,

265

    Clunk = RCLUNK,

266

    Remove = RREMOVE,

267

    Attach(Rattach) = RATTACH,

268

    Auth(Rauth) = RAUTH,

269

    Statfs(Rstatfs) = RSTATFS,

270

    Lopen(Rlopen) = RLOPEN,

271

    Lcreate(Rlcreate) = RLCREATE,

272

    Symlink(Rsymlink) = RSYMLINK,

273

    Mknod(Rmknod) = RMKNOD,

274

    Rename = RRENAME,

275

    Readlink(Rreadlink) = RREADLINK,

276

    GetAttr(Rgetattr) = RGETATTR,

277

    SetAttr = RSETATTR,

278

    XattrWalk(Rxattrwalk) = RXATTRWALK,

279

    XattrCreate = RXATTRCREATE,

280

    Readdir(Rreaddir) = RREADDIR,

281

    Fsync = RFSYNC,

282

    Lock(Rlock) = RLOCK,

283

    GetLock(Rgetlock) = RGETLOCK,

284

    Link = RLINK,

285

    Mkdir(Rmkdir) = RMKDIR,

286

    RenameAt = RRENAMEAT,

287

    UnlinkAt = RUNLINKAT,

288

    Lerror(Rlerror) = RLERROR,

289

290

291

impl Framer for Rmessage {

292

    fn message_type(&self) -> u8 {

293

        match self {

294

            Rmessage::Version(_) => RVERSION,

295

            Rmessage::Flush => RFLUSH,

296

            Rmessage::Walk(_) => RWALK,

297

            Rmessage::Read(_) => RREAD,

298

            Rmessage::Write(_) => RWRITE,

299

            Rmessage::Clunk => RCLUNK,

300

            Rmessage::Remove => RREMOVE,

301

            Rmessage::Attach(_) => RATTACH,

302

            Rmessage::Auth(_) => RAUTH,

303

            Rmessage::Statfs(_) => RSTATFS,

304

            Rmessage::Lopen(_) => RLOPEN,

305

            Rmessage::Lcreate(_) => RLCREATE,

306

            Rmessage::Symlink(_) => RSYMLINK,

307

            Rmessage::Mknod(_) => RMKNOD,

308

            Rmessage::Rename => RRENAME,

309

            Rmessage::Readlink(_) => RREADLINK,

310

            Rmessage::GetAttr(_) => RGETATTR,

311

            Rmessage::SetAttr => RSETATTR,

312

            Rmessage::XattrWalk(_) => RXATTRWALK,

313

            Rmessage::XattrCreate => RXATTRCREATE,

314

            Rmessage::Readdir(_) => RREADDIR,

315

            Rmessage::Fsync => RFSYNC,

316

            Rmessage::Lock(_) => RLOCK,

317

            Rmessage::GetLock(_) => RGETLOCK,

318

            Rmessage::Link => RLINK,

319

            Rmessage::Mkdir(_) => RMKDIR,

320

            Rmessage::RenameAt => RRENAMEAT,

321

            Rmessage::UnlinkAt => RUNLINKAT,

322

            Rmessage::Lerror(_) => RLERROR,

323

324

325

326

    fn byte_size(&self) -> u32 {

327

        match self {

328

            Rmessage::Version(msg) => msg.byte_size(),

329

            Rmessage::Flush => 0,

330

            Rmessage::Walk(msg) => msg.byte_size(),

331

            Rmessage::Read(msg) => msg.byte_size(),

332

            Rmessage::Write(msg) => msg.byte_size(),

333

            Rmessage::Clunk => 0,

334

            Rmessage::Remove => 0,

335

            Rmessage::Attach(msg) => msg.byte_size(),

336

            Rmessage::Auth(msg) => msg.byte_size(),

337

            Rmessage::Statfs(msg) => msg.byte_size(),

338

            Rmessage::Lopen(msg) => msg.byte_size(),

339

            Rmessage::Lcreate(msg) => msg.byte_size(),

340

            Rmessage::Symlink(msg) => msg.byte_size(),

341

            Rmessage::Mknod(msg) => msg.byte_size(),

342

            Rmessage::Rename => 0,

343

            Rmessage::Readlink(msg) => msg.byte_size(),

344

            Rmessage::GetAttr(msg) => msg.byte_size(),

345

            Rmessage::SetAttr => 0,

346

            Rmessage::XattrWalk(msg) => msg.byte_size(),

347

            Rmessage::XattrCreate => 0,

348

            Rmessage::Readdir(msg) => msg.byte_size(),

349

            Rmessage::Fsync => 0,

350

            Rmessage::Lock(msg) => msg.byte_size(),

351

            Rmessage::GetLock(msg) => msg.byte_size(),

352

            Rmessage::Link => 0,

353

            Rmessage::Mkdir(msg) => msg.byte_size(),

354

            Rmessage::RenameAt => 0,

355

            Rmessage::UnlinkAt => 0,

356

            Rmessage::Lerror(msg) => msg.byte_size(),

357

358

359

360

    fn encode<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {

361

        match self {

362

            Rmessage::Version(msg) => msg.encode(writer),

363

            Rmessage::Flush => Ok(()),

364

            Rmessage::Walk(msg) => msg.encode(writer),

365

            Rmessage::Read(msg) => msg.encode(writer),

366

            Rmessage::Write(msg) => msg.encode(writer),

367

            Rmessage::Clunk => Ok(()),

368

            Rmessage::Remove => Ok(()),

369

            Rmessage::Attach(msg) => msg.encode(writer),

370

            Rmessage::Auth(msg) => msg.encode(writer),

371

            Rmessage::Statfs(msg) => msg.encode(writer),

372

            Rmessage::Lopen(msg) => msg.encode(writer),

373

            Rmessage::Lcreate(msg) => msg.encode(writer),

374

            Rmessage::Symlink(msg) => msg.encode(writer),

375

            Rmessage::Mknod(msg) => msg.encode(writer),

376

            Rmessage::Rename => Ok(()),

377

            Rmessage::Readlink(msg) => msg.encode(writer),

378

            Rmessage::GetAttr(msg) => msg.encode(writer),

379

            Rmessage::SetAttr => Ok(()),

380

            Rmessage::XattrWalk(msg) => msg.encode(writer),

381

            Rmessage::XattrCreate => Ok(()),

382

            Rmessage::Readdir(msg) => msg.encode(writer),

383

            Rmessage::Fsync => Ok(()),

384

            Rmessage::Lock(msg) => msg.encode(writer),

385

            Rmessage::GetLock(msg) => msg.encode(writer),

386

            Rmessage::Link => Ok(()),

387

            Rmessage::Mkdir(msg) => msg.encode(writer),

388

            Rmessage::RenameAt => Ok(()),

389

            Rmessage::UnlinkAt => Ok(()),

390

            Rmessage::Lerror(msg) => msg.encode(writer),

391

392

393

394

    fn decode<R: std::io::Read>(

395

        reader: &mut R,

396

        ty: u8,

397

    ) -> std::io::Result<Self> {

398

        match ty {

399

            RVERSION => Ok(Rmessage::Version(Rversion::decode(reader)?)),

400

            RFLUSH => Ok(Rmessage::Flush),

401

            RWALK => Ok(Rmessage::Walk(Rwalk::decode(reader)?)),

402

            RREAD => Ok(Rmessage::Read(Rread::decode(reader)?)),

403

            RWRITE => Ok(Rmessage::Write(Rwrite::decode(reader)?)),

404

            RCLUNK => Ok(Rmessage::Clunk),

405

            RREMOVE => Ok(Rmessage::Remove),

406

            RATTACH => Ok(Rmessage::Attach(Rattach::decode(reader)?)),

407

            RAUTH => Ok(Rmessage::Auth(Rauth::decode(reader)?)),

408

            RSTATFS => Ok(Rmessage::Statfs(Rstatfs::decode(reader)?)),

409

            RLOPEN => Ok(Rmessage::Lopen(Rlopen::decode(reader)?)),

410

            RLCREATE => Ok(Rmessage::Lcreate(Rlcreate::decode(reader)?)),

411

            RSYMLINK => Ok(Rmessage::Symlink(Rsymlink::decode(reader)?)),

412

            RMKNOD => Ok(Rmessage::Mknod(Rmknod::decode(reader)?)),

413

            RRENAME => Ok(Rmessage::Rename),

414

            RREADLINK => Ok(Rmessage::Readlink(Rreadlink::decode(reader)?)),

415

            RGETATTR => Ok(Rmessage::GetAttr(Rgetattr::decode(reader)?)),

416

            RSETATTR => Ok(Rmessage::SetAttr),

417

            RXATTRWALK => Ok(Rmessage::XattrWalk(Rxattrwalk::decode(reader)?)),

418

            RXATTRCREATE => Ok(Rmessage::XattrCreate),

419

            RREADDIR => Ok(Rmessage::Readdir(Rreaddir::decode(reader)?)),

420

            RFSYNC => Ok(Rmessage::Fsync),

421

            RLOCK => Ok(Rmessage::Lock(Rlock::decode(reader)?)),

422

            RGETLOCK => Ok(Rmessage::GetLock(Rgetlock::decode(reader)?)),

423

            RLINK => Ok(Rmessage::Link),

424

            RMKDIR => Ok(Rmessage::Mkdir(Rmkdir::decode(reader)?)),

425

            RRENAMEAT => Ok(Rmessage::RenameAt),

426

            RUNLINKAT => Ok(Rmessage::UnlinkAt),

427

            RLERROR => Ok(Rmessage::Lerror(Rlerror::decode(reader)?)),

428

            _ => Err(std::io::Error::new(

429

                std::io::ErrorKind::InvalidData,

430

                "invalid message type",

431

)),

432

433

434

435

436

#[derive(Debug, Clone)]

437

pub struct Server<T>

438

where

439

    T: Clone,

440

441

    inner: T,

442

443

444

impl<T> Server<T>

445

where

446

    T: Clone,

447

448

    pub fn new(inner: T) -> Self {

449

        Self { inner }

450

451

452

453

impl<T> Protocol for Server<T>

454

where

455

    T: NineP200L + Clone,

456

457

    type Error = jetstream_rpc::Error;

458

    type Request = Tmessage;

459

    type Response = Rmessage;

460

461

    const VERSION: &'static str = "9P2000.L";

462

463

    const NAME: &'static str = "9p";

464

465

466

impl<T> jetstream_rpc::server::Server for Server<T>

467

where

468

    T: NineP200L + Clone,

469

470

    async fn rpc(

471

        &mut self,

472

        _context: Context,

473

        frame: Frame<Self::Request>,

474

    ) -> Result<Frame<Self::Response>, Self::Error> {

475

        let Frame { msg, tag } = frame;

476

        let rmsg = match msg {

477

            Tmessage::Version(ref version) => self

478

                .inner

479

                .version(tag, version)

480

                .await

481

                .map(Rmessage::Version),

482

            Tmessage::Flush(ref flush) => {

483

                self.inner.flush(tag, flush).await.and(Ok(Rmessage::Flush))

484

485

            Tmessage::Walk(ref walk) => {

486

                self.inner.walk(tag, walk).await.map(Rmessage::Walk)

487

488

            Tmessage::Read(ref read) => {

489

                self.inner.read(tag, read).await.map(Rmessage::Read)

490

491

            Tmessage::Write(ref write) => {

492

                self.inner.write(tag, write).await.map(Rmessage::Write)

493

494

            Tmessage::Clunk(ref clunk) => {

495

                self.inner.clunk(tag, clunk).await.and(Ok(Rmessage::Clunk))

496

497

            Tmessage::Remove(ref remove) => self

498

                .inner

499

                .remove(tag, remove)

500

                .await

501

                .and(Ok(Rmessage::Remove)),

502

            Tmessage::Attach(ref attach) => {

503

                self.inner.attach(tag, attach).await.map(Rmessage::Attach)

504

505

            Tmessage::Auth(ref auth) => {

506

                self.inner.auth(tag, auth).await.map(Rmessage::Auth)

507

508

            Tmessage::Statfs(ref statfs) => {

509

                self.inner.statfs(tag, statfs).await.map(Rmessage::Statfs)

510

511

            Tmessage::Lopen(ref lopen) => {

512

                self.inner.lopen(tag, lopen).await.map(Rmessage::Lopen)

513

514

            Tmessage::Lcreate(ref lcreate) => self

515

                .inner

516

                .lcreate(tag, lcreate)

517

                .await

518

                .map(Rmessage::Lcreate),

519

            Tmessage::Symlink(ref symlink) => self

520

                .inner

521

                .symlink(tag, symlink)

522

                .await

523

                .map(Rmessage::Symlink),

524

            Tmessage::Mknod(ref mknod) => {

525

                self.inner.mknod(tag, mknod).await.map(Rmessage::Mknod)

526

527

            Tmessage::Rename(ref rename) => self

528

                .inner

529

                .rename(tag, rename)

530

                .await

531

                .and(Ok(Rmessage::Rename)),

532

            Tmessage::Readlink(ref readlink) => self

533

                .inner

534

                .readlink(tag, readlink)

535

                .await

536

                .map(Rmessage::Readlink),

537

            Tmessage::GetAttr(ref get_attr) => self

538

                .inner

539

                .get_attr(tag, get_attr)

540

                .await

541

                .map(Rmessage::GetAttr),

542

            Tmessage::SetAttr(ref set_attr) => self

543

                .inner

544

                .set_attr(tag, set_attr)

545

                .await

546

                .and(Ok(Rmessage::SetAttr)),

547

            Tmessage::XattrWalk(ref xattr_walk) => self

548

                .inner

549

                .xattr_walk(tag, xattr_walk)

550

                .await

551

                .map(Rmessage::XattrWalk),

552

            Tmessage::XattrCreate(ref xattr_create) => self

553

                .inner

554

                .xattr_create(tag, xattr_create)

555

                .await

556

                .and(Ok(Rmessage::XattrCreate)),

557

            Tmessage::Readdir(ref readdir) => self

558

                .inner

559

                .readdir(tag, readdir)

560

                .await

561

                .map(Rmessage::Readdir),

562

            Tmessage::Fsync(ref fsync) => {

563

                self.inner.fsync(tag, fsync).await.and(Ok(Rmessage::Fsync))

564

565

            Tmessage::Lock(ref lock) => {

566

                self.inner.lock(tag, lock).await.map(Rmessage::Lock)

567

568

            Tmessage::GetLock(ref get_lock) => self

569

                .inner

570

                .get_lock(tag, get_lock)

571

                .await

572

                .map(Rmessage::GetLock),

573

            Tmessage::Link(ref link) => {

574

                self.inner.link(tag, link).await.and(Ok(Rmessage::Link))

575

576

            Tmessage::Mkdir(ref mkdir) => {

577

                self.inner.mkdir(tag, mkdir).await.map(Rmessage::Mkdir)

578

579

            Tmessage::RenameAt(ref rename_at) => self

580

                .inner

581

                .rename_at(tag, rename_at)

582

                .await

583

                .and(Ok(Rmessage::RenameAt)),

584

            Tmessage::UnlinkAt(ref unlink_at) => self

585

                .inner

586

                .unlink_at(tag, unlink_at)

587

                .await

588

                .and(Ok(Rmessage::UnlinkAt)),

589

};

590

        match rmsg {

591

            Ok(msg) => Ok(Frame { tag, msg }),

592

            Err(e) => Ok(Frame {

593

                tag,

594

                msg: Rmessage::Lerror(error_to_rmessage(&e)),

595

}),

596

597

598