Add a UserDetail::read_only method

If it returns True, then the storage backend should not allow any
destructive operations.

Implement this method in the cap-ftpd example for unftp-sbe-fs.

crates/unftp-sbe-fs/examples/cap-ftpd-worker.rs

@@ -31,6 +31,7 @@ mod auth {
     pub struct User {
         username: String,
         home: Option<PathBuf>,
+        read_only: bool,
     }
 
     #[derive(Deserialize, Clone, Debug)]
@@ -40,20 +41,24 @@ mod auth {
             username: String,
             password: Option<String>,
             home: Option<PathBuf>,
+            #[serde(default)]
+            read_only: bool,
         },
     }
 
     #[derive(Clone, Debug)]
     struct UserCreds {
         pub password: Option<String>,
         pub home: Option<PathBuf>,
+        pub read_only: bool,
     }
 
     impl User {
-        fn new(username: &str, home: &Option<PathBuf>) -> Self {
+        fn new(username: &str, home: &Option<PathBuf>, read_only: bool) -> Self {
             User {
                 username: username.to_owned(),
                 home: home.clone(),
+                read_only,
             }
         }
     }
@@ -65,6 +70,10 @@ mod auth {
                 Some(p) => Some(p.as_path()),
             }
         }
+
+        fn read_only(&self) -> bool {
+            self.read_only
+        }
     }
 
     impl fmt::Display for User {
@@ -99,7 +108,12 @@ mod auth {
 
         fn list_entry_to_map_entry(user_info: Credentials) -> Result<(String, UserCreds), Box<dyn std::error::Error>> {
             let map_entry = match user_info {
-                Credentials::Plaintext { username, password, home } => (username.clone(), UserCreds { password, home }),
+                Credentials::Plaintext {
+                    username,
+                    password,
+                    home,
+                    read_only,
+                } => (username.clone(), UserCreds { password, home, read_only }),
             };
             Ok(map_entry)
         }
@@ -125,7 +139,7 @@ mod auth {
                 let pass_check_result = match &creds.password {
                     Some(ref given_password) => {
                         if Self::check_password(given_password, &actual_creds.password).is_ok() {
-                            Some(Ok(User::new(username, &actual_creds.home)))
+                            Some(Ok(User::new(username, &actual_creds.home, actual_creds.read_only)))
                         } else {
                             Some(Err(AuthenticationError::BadPassword))
                         }
@@ -137,7 +151,7 @@ mod auth {
                     None => Err(AuthenticationError::BadPassword),
                     Some(pass_res) => {
                         if pass_res.is_ok() {
-                            Ok(User::new(username, &actual_creds.home))
+                            Ok(User::new(username, &actual_creds.home, actual_creds.read_only))
                         } else {
                             pass_res
                         }

crates/unftp-sbe-fs/src/lib.rs

@@ -153,12 +153,15 @@ impl<User: UserDetail> StorageBackend<User> for Filesystem {
 
     async fn put<P: AsRef<Path> + Send, R: tokio::io::AsyncRead + Send + Sync + 'static + Unpin>(
         &self,
-        _user: &User,
+        user: &User,
         bytes: R,
         path: P,
         start_pos: u64,
     ) -> Result<u64> {
         // TODO: Add permission checks
+        if user.read_only() {
+            return Err(Error::new(ErrorKind::PermissionDenied, "Write access denied"));
+        }
 
         let path = strip_prefixes(path.as_ref());
         let mut oo = cap_std::fs::OpenOptions::new();
@@ -176,31 +179,47 @@ impl<User: UserDetail> StorageBackend<User> for Filesystem {
     }
 
     #[tracing_attributes::instrument]
-    async fn del<P: AsRef<Path> + Send + Debug>(&self, _user: &User, path: P) -> Result<()> {
+    async fn del<P: AsRef<Path> + Send + Debug>(&self, user: &User, path: P) -> Result<()> {
+        if user.read_only() {
+            return Err(Error::new(ErrorKind::PermissionDenied, "Write access denied"));
+        }
+
         let path = strip_prefixes(path.as_ref());
         cap_fs::remove_file(self.root_fd.clone(), path)
             .await
             .map_err(|error: std::io::Error| error.into())
     }
 
     #[tracing_attributes::instrument]
-    async fn rmd<P: AsRef<Path> + Send + Debug>(&self, _user: &User, path: P) -> Result<()> {
+    async fn rmd<P: AsRef<Path> + Send + Debug>(&self, user: &User, path: P) -> Result<()> {
+        if user.read_only() {
+            return Err(Error::new(ErrorKind::PermissionDenied, "Write access denied"));
+        }
+
         let path = strip_prefixes(path.as_ref());
         cap_fs::remove_dir(self.root_fd.clone(), path)
             .await
             .map_err(|error: std::io::Error| error.into())
     }
 
     #[tracing_attributes::instrument]
-    async fn mkd<P: AsRef<Path> + Send + Debug>(&self, _user: &User, path: P) -> Result<()> {
+    async fn mkd<P: AsRef<Path> + Send + Debug>(&self, user: &User, path: P) -> Result<()> {
+        if user.read_only() {
+            return Err(Error::new(ErrorKind::PermissionDenied, "Write access denied"));
+        }
+
         let path = strip_prefixes(path.as_ref());
         cap_fs::create_dir(self.root_fd.clone(), path)
             .await
             .map_err(|error: std::io::Error| error.into())
     }
 
     #[tracing_attributes::instrument]
-    async fn rename<P: AsRef<Path> + Send + Debug>(&self, _user: &User, from: P, to: P) -> Result<()> {
+    async fn rename<P: AsRef<Path> + Send + Debug>(&self, user: &User, from: P, to: P) -> Result<()> {
+        if user.read_only() {
+            return Err(Error::new(ErrorKind::PermissionDenied, "Write access denied"));
+        }
+
         let from = from.as_ref().strip_prefix("/").unwrap_or(from.as_ref());
         let to = to.as_ref().strip_prefix("/").unwrap_or(to.as_ref());
 

src/auth/user.rs

@@ -27,6 +27,11 @@ pub trait UserDetail: Send + Sync + Display + Debug {
     fn home(&self) -> Option<&Path> {
         None
     }
+
+    /// Should the user have read-only access, regardless of the Unix file permissions?
+    fn read_only(&self) -> bool {
+        false
+    }
 }
 
 /// DefaultUser is a default implementation of the `UserDetail` trait that doesn't hold any user