nfs 0.1.0

A userspace NFSv3 and NFSv4 client library.
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

#![cfg_attr(not(feature = "protocol"), allow(dead_code))]

use std::net::ToSocketAddrs;
use std::time::Duration;

use crate::error::{Error, Result};
use crate::rpc::{Auth, AuthSys, RpcClient};
use crate::v3::proto::FileHandle;
use crate::xdr::{Decode, Decoder, Encode, Encoder};

pub const MOUNT_PROGRAM: u32 = 100005;
pub const MOUNT_VERSION: u32 = 3;
pub const MNTPATHLEN: usize = 1024;
pub const MNTNAMLEN: usize = 255;

const MOUNTPROC3_MNT: u32 = 1;
const MOUNTPROC3_UMNT: u32 = 3;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum MountStatus {
    Ok = 0,
    Perm = 1,
    NoEnt = 2,
    Io = 5,
    Access = 13,
    NotDir = 20,
    Invalid = 22,
    NameTooLong = 63,
    NotSupported = 10004,
    ServerFault = 10006,
    Unknown(u32),
}

impl MountStatus {
    pub fn from_u32(value: u32) -> Self {
        match value {
            0 => Self::Ok,
            1 => Self::Perm,
            2 => Self::NoEnt,
            5 => Self::Io,
            13 => Self::Access,
            20 => Self::NotDir,
            22 => Self::Invalid,
            63 => Self::NameTooLong,
            10004 => Self::NotSupported,
            10006 => Self::ServerFault,
            value => Self::Unknown(value),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MountInfo {
    pub file_handle: FileHandle,
    pub auth_flavors: Vec<u32>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct DirPath<'a>(&'a str);

impl Encode for DirPath<'_> {
    fn encode(&self, encoder: &mut Encoder) -> crate::xdr::Result<()> {
        encoder.write_string(self.0, MNTPATHLEN)
    }
}

#[derive(Debug)]
pub struct MountClient {
    rpc: RpcClient,
}

impl MountClient {
    pub fn connect<A: ToSocketAddrs>(addr: A, auth: AuthSys) -> Result<Self> {
        Self::connect_with_timeout(addr, auth, None)
    }

    pub fn connect_with_timeout<A: ToSocketAddrs>(
        addr: A,
        auth: AuthSys,
        timeout: Option<Duration>,
    ) -> Result<Self> {
        Ok(Self {
            rpc: RpcClient::connect_with_timeout(addr, Auth::sys(auth), timeout)?,
        })
    }

    pub fn set_timeout(&self, timeout: Option<Duration>) -> Result<()> {
        self.rpc.set_timeout(timeout)
    }

    pub fn mount(&mut self, export_path: &str) -> Result<MountInfo> {
        let payload = self.rpc.call(
            MOUNT_PROGRAM,
            MOUNT_VERSION,
            MOUNTPROC3_MNT,
            &DirPath(export_path),
        )?;
        let mut decoder = Decoder::new(&payload);
        let status = MountStatus::from_u32(u32::decode(&mut decoder)?);
        if status != MountStatus::Ok {
            decoder.finish()?;
            return Err(Error::Mount { status });
        }

        let file_handle = FileHandle::decode(&mut decoder)?;
        let auth_flavors = decoder.read_array::<u32>(128)?;
        decoder.finish()?;
        Ok(MountInfo {
            file_handle,
            auth_flavors,
        })
    }

    pub fn unmount(&mut self, export_path: &str) -> Result<()> {
        let payload = self.rpc.call(
            MOUNT_PROGRAM,
            MOUNT_VERSION,
            MOUNTPROC3_UMNT,
            &DirPath(export_path),
        )?;
        let decoder = Decoder::new(&payload);
        decoder.finish()?;
        Ok(())
    }
}