just breaking stuff, don't mind me

FabianLars · FabianLars · commit 0f2e4089fa85 · 2024-11-20T19:06:05.000+01:00
diff --git a/.changes/fix-fs-scope-escape-paths.md b/.changes/fix-fs-scope-escape-paths.md
@@ -1,5 +1,6 @@
 ---
-fs: patch
+fs: minor
+persisted-scope: minor
 ---
 
-Paths given to the `Scope` methods are now correctly escaped, preventing issues with paths containing `[]`.
+**Breaking Change:** Replaced the custom `tauri_plugin_fs::Scope` struct with `tauri::fs::Scope`.
diff --git a/plugins/dialog/src/commands.rs b/plugins/dialog/src/commands.rs
@@ -143,7 +143,7 @@ pub(crate) async fn open<R: Runtime>(
                     for folder in folders {
                         if let Ok(path) = folder.clone().into_path() {
                             if let Some(s) = window.try_fs_scope() {
-                                s.allow_directory(&path, options.recursive);
+                                let _ = s.allow_directory(&path, options.recursive);
                             }
                             tauri_scope.allow_directory(&path, options.directory)?;
                         }
@@ -157,7 +157,7 @@ pub(crate) async fn open<R: Runtime>(
                 if let Some(folder) = &folder {
                     if let Ok(path) = folder.clone().into_path() {
                         if let Some(s) = window.try_fs_scope() {
-                            s.allow_directory(&path, options.recursive);
+                            let _ = s.allow_directory(&path, options.recursive);
                         }
                         tauri_scope.allow_directory(&path, options.directory)?;
                     }
@@ -175,7 +175,7 @@ pub(crate) async fn open<R: Runtime>(
             for file in files {
                 if let Ok(path) = file.clone().into_path() {
                     if let Some(s) = window.try_fs_scope() {
-                        s.allow_file(&path);
+                        let _ = s.allow_file(&path);
                     }
 
                     tauri_scope.allow_file(&path)?;
@@ -190,7 +190,7 @@ pub(crate) async fn open<R: Runtime>(
         if let Some(file) = &file {
             if let Ok(path) = file.clone().into_path() {
                 if let Some(s) = window.try_fs_scope() {
-                    s.allow_file(&path);
+                    let _ = s.allow_file(&path);
                 }
                 tauri_scope.allow_file(&path)?;
             }
@@ -232,7 +232,7 @@ pub(crate) async fn save<R: Runtime>(
     if let Some(p) = &path {
         if let Ok(path) = p.clone().into_path() {
             if let Some(s) = window.try_fs_scope() {
-                s.allow_file(&path);
+                let _ = s.allow_file(&path);
             }
             tauri_scope.allow_file(&path)?;
         }
diff --git a/plugins/fs/build.rs b/plugins/fs/build.rs
@@ -7,7 +7,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-#[path = "src/entryraw.rs"]
+#[path = "src/scope.rs"]
 #[allow(dead_code)]
 mod scope;
 
diff --git a/plugins/fs/src/commands.rs b/plugins/fs/src/commands.rs
@@ -22,7 +22,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use crate::{scope::Entry, Error, FsExt, SafeFilePath};
+use crate::{scope::Entry, Error, SafeFilePath};
 
 #[derive(Debug, thiserror::Error)]
 pub enum CommandError {
@@ -999,6 +999,8 @@ pub fn resolve_path<R: Runtime>(
         path
     };
 
+    let fs_scope = webview.state::<crate::Scope>();
+
     let scope = tauri::scope::fs::Scope::new(
         webview,
         &FsScope::Scope {
@@ -1014,31 +1016,19 @@ pub fn resolve_path<R: Runtime>(
                 .filter_map(|e| e.path.clone())
                 .chain(command_scope.denies().iter().filter_map(|e| e.path.clone()))
                 .collect(),
-            require_literal_leading_dot: webview.fs_scope().require_literal_leading_dot,
+            require_literal_leading_dot: fs_scope.require_literal_leading_dot,
         },
     )?;
 
-    let fs_scope = webview.fs_scope();
-
     let require_literal_leading_dot = fs_scope.require_literal_leading_dot.unwrap_or(cfg!(unix));
 
-    if fs_scope
-        .scope
-        .as_ref()
-        .map(|s| is_forbidden(s, &path, require_literal_leading_dot))
-        .unwrap_or(false)
+    if is_forbidden(&fs_scope.scope, &path, require_literal_leading_dot)
         || is_forbidden(&scope, &path, require_literal_leading_dot)
     {
         return Err(CommandError::Plugin(Error::PathForbidden(path)));
     }
 
-    if fs_scope
-        .scope
-        .as_ref()
-        .map(|s| s.is_allowed(&path))
-        .unwrap_or(false)
-        || scope.is_allowed(&path)
-    {
+    if fs_scope.scope.is_allowed(&path) || scope.is_allowed(&path) {
         Ok(path)
     } else {
         Err(CommandError::Plugin(Error::PathForbidden(path)))
diff --git a/plugins/fs/src/entryraw.rs b/plugins/fs/src/entryraw.rs
diff --git a/plugins/fs/src/lib.rs b/plugins/fs/src/lib.rs
@@ -23,7 +23,6 @@ mod commands;
 mod config;
 #[cfg(not(target_os = "android"))]
 mod desktop;
-mod entryraw;
 mod error;
 mod file_path;
 #[cfg(target_os = "android")]
@@ -40,7 +39,6 @@ pub use desktop::Fs;
 pub use mobile::Fs;
 
 pub use error::Error;
-pub use scope::{Event as ScopeEvent, Scope};
 
 pub use file_path::FilePath;
 pub use file_path::SafeFilePath;
@@ -353,8 +351,8 @@ impl ScopeObject for scope::Entry {
         raw: Value,
     ) -> std::result::Result<Self, Self::Error> {
         let path = serde_json::from_value(raw.into()).map(|raw| match raw {
-            entryraw::EntryRaw::Value(path) => path,
-            entryraw::EntryRaw::Object { path } => path,
+            scope::EntryRaw::Value(path) => path,
+            scope::EntryRaw::Object { path } => path,
         })?;
 
         match app.path().parse(path) {
@@ -366,21 +364,26 @@ impl ScopeObject for scope::Entry {
     }
 }
 
+pub(crate) struct Scope {
+    pub(crate) scope: tauri::fs::Scope,
+    pub(crate) require_literal_leading_dot: Option<bool>,
+}
+
 pub trait FsExt<R: Runtime> {
-    fn fs_scope(&self) -> &Scope;
-    fn try_fs_scope(&self) -> Option<&Scope>;
+    fn fs_scope(&self) -> tauri::fs::Scope;
+    fn try_fs_scope(&self) -> Option<tauri::fs::Scope>;
 
     /// Cross platform file system APIs that also support manipulating Android files.
     fn fs(&self) -> &Fs<R>;
 }
 
 impl<R: Runtime, T: Manager<R>> FsExt<R> for T {
-    fn fs_scope(&self) -> &Scope {
-        self.state::<Scope>().inner()
+    fn fs_scope(&self) -> tauri::fs::Scope {
+        self.state::<Scope>().scope.clone()
     }
 
-    fn try_fs_scope(&self) -> Option<&Scope> {
-        self.try_state::<Scope>().map(|s| s.inner())
+    fn try_fs_scope(&self) -> Option<tauri::fs::Scope> {
+        self.try_state::<Scope>().map(|s| s.scope.clone())
     }
 
     fn fs(&self) -> &Fs<R> {
@@ -425,7 +428,7 @@ pub fn init<R: Runtime>() -> TauriPlugin<R, Option<config::Config>> {
                     .config()
                     .as_ref()
                     .and_then(|c| c.require_literal_leading_dot),
-                scope: Some(tauri::fs::Scope::new(app, &FsScope::default())?),
+                scope: tauri::fs::Scope::new(app, &FsScope::default())?,
             };
 
             #[cfg(target_os = "android")]
@@ -449,9 +452,9 @@ pub fn init<R: Runtime>() -> TauriPlugin<R, Option<config::Config>> {
                 let scope = app.fs_scope();
                 for path in paths {
                     if path.is_file() {
-                        scope.allow_file(path);
+                        let _ = scope.allow_file(path);
                     } else {
-                        scope.allow_directory(path, true);
+                        let _ = scope.allow_directory(path, true);
                     }
                 }
             }
diff --git a/plugins/fs/src/scope.rs b/plugins/fs/src/scope.rs
@@ -2,126 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use std::{
-    collections::HashSet,
-    path::{Path, PathBuf},
-};
+use std::path::PathBuf;
+
+use serde::Deserialize;
 
 #[derive(Debug)]
 pub struct Entry {
     pub path: Option<PathBuf>,
 }
 
-pub type EventId = u32;
-
-/// Scope change event.
-#[derive(Debug, Clone)]
-pub enum Event {
-    /// A path has been allowed.
-    PathAllowed(PathBuf),
-    /// A path has been forbidden.
-    PathForbidden(PathBuf),
-}
-
-#[derive(Default)]
-pub struct Scope {
-    // TODO: Remove Option in v2, just used to keep Default
-    pub(crate) scope: Option<tauri::fs::Scope>,
-    pub(crate) require_literal_leading_dot: Option<bool>,
-}
-
-impl Scope {
-    /// Extend the allowed patterns with the given directory.
-    ///
-    /// After this function has been called, the frontend will be able to use the Tauri API to read
-    /// the directory and all of its files. If `recursive` is `true`, subdirectories will be accessible too.
-    // TODO: Return Result
-    pub fn allow_directory<P: AsRef<Path>>(&self, path: P, recursive: bool) {
-        if let Some(scope) = &self.scope {
-            let _ = scope.allow_directory(path, recursive);
-        }
-    }
-
-    /// Extend the allowed patterns with the given file path.
-    ///
-    /// After this function has been called, the frontend will be able to use the Tauri API to read the contents of this file.
-    // TODO: Return Result
-    pub fn allow_file<P: AsRef<Path>>(&self, path: P) {
-        if let Some(scope) = &self.scope {
-            let _ = scope.allow_file(path);
-        }
-    }
-
-    /// Set the given directory path to be forbidden by this scope.
-    ///
-    /// **Note:** this takes precedence over allowed paths, so its access gets denied **always**.
-    // TODO: Return Result
-    pub fn forbid_directory<P: AsRef<Path>>(&self, path: P, recursive: bool) {
-        if let Some(scope) = &self.scope {
-            let _ = scope.forbid_directory(path, recursive);
-        }
-    }
-
-    /// Set the given file path to be forbidden by this scope.
-    ///
-    /// **Note:** this takes precedence over allowed paths, so its access gets denied **always**.
-    // TODO: Return Result
-    pub fn forbid_file<P: AsRef<Path>>(&self, path: P) {
-        if let Some(scope) = &self.scope {
-            let _ = scope.forbid_file(path);
-        }
-    }
-
-    /// List of allowed paths.
-    #[deprecated(since = "2.1.0", note = "use `allowed_patterns` instead")]
-    pub fn allowed(&self) -> Vec<PathBuf> {
-        self.scope
-            .as_ref()
-            .map(|s| s.allowed_patterns().clone())
-            .unwrap_or_default()
-            .iter()
-            .map(|p| PathBuf::from(p.as_str()))
-            .collect()
-    }
-
-    /// List of allowed patterns. Note that this does not include paths defined in capabilites.
-    pub fn allowed_patterns(&self) -> HashSet<tauri::fs::Pattern> {
-        self.scope
-            .as_ref()
-            .map(|s| s.allowed_patterns().clone())
-            .unwrap_or_default()
-    }
-
-    /// List of forbidden paths.
-    #[deprecated(since = "2.1.0", note = "use `forbidden_patterns` instead")]
-    pub fn forbidden(&self) -> Vec<PathBuf> {
-        self.scope
-            .as_ref()
-            .map(|s| s.forbidden_patterns().clone())
-            .unwrap_or_default()
-            .iter()
-            .map(|p| PathBuf::from(p.as_str()))
-            .collect()
-    }
-
-    /// List of forbidden patterns. Note that this does not include paths defined in capabilites.
-    pub fn forbidden_patterns(&self) -> HashSet<tauri::fs::Pattern> {
-        self.scope
-            .as_ref()
-            .map(|s| s.forbidden_patterns())
-            .unwrap_or_default()
-    }
-
-    /// Listen to an event on this scope.
-    /// Silently fails and returns `0` until v3 if `Scope` was constructed manually instead of getting it via `app.fs_scope()`.
-    pub fn listen<F: Fn(&Event) + Send + 'static>(&self, f: F) -> EventId {
-        if let Some(scope) = &self.scope {
-            scope.listen(move |e| match e {
-                tauri::fs::Event::PathAllowed(p) => f(&Event::PathAllowed(p.to_owned())),
-                tauri::fs::Event::PathForbidden(p) => f(&Event::PathForbidden(p.to_owned())),
-            })
-        } else {
-            0
-        }
-    }
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub(crate) enum EntryRaw {
+    Value(PathBuf),
+    Object { path: PathBuf },
 }
diff --git a/plugins/persisted-scope/src/lib.rs b/plugins/persisted-scope/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ pub(crate) async fn open<R: Runtime>(`
`143`	`143`	`for folder in folders {`
`144`	`144`	`if let Ok(path) = folder.clone().into_path() {`
`145`	`145`	`if let Some(s) = window.try_fs_scope() {`
`146`		`- s.allow_directory(&path, options.recursive);`
	`146`	`+ let _ = s.allow_directory(&path, options.recursive);`
`147`	`147`	`}`
`148`	`148`	`tauri_scope.allow_directory(&path, options.directory)?;`
`149`	`149`	`}`
`@@ -157,7 +157,7 @@ pub(crate) async fn open<R: Runtime>(`
`157`	`157`	`if let Some(folder) = &folder {`
`158`	`158`	`if let Ok(path) = folder.clone().into_path() {`
`159`	`159`	`if let Some(s) = window.try_fs_scope() {`
`160`		`- s.allow_directory(&path, options.recursive);`
	`160`	`+ let _ = s.allow_directory(&path, options.recursive);`
`161`	`161`	`}`
`162`	`162`	`tauri_scope.allow_directory(&path, options.directory)?;`
`163`	`163`	`}`
`@@ -175,7 +175,7 @@ pub(crate) async fn open<R: Runtime>(`
`175`	`175`	`for file in files {`
`176`	`176`	`if let Ok(path) = file.clone().into_path() {`
`177`	`177`	`if let Some(s) = window.try_fs_scope() {`
`178`		`- s.allow_file(&path);`
	`178`	`+ let _ = s.allow_file(&path);`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`tauri_scope.allow_file(&path)?;`
`@@ -190,7 +190,7 @@ pub(crate) async fn open<R: Runtime>(`
`190`	`190`	`if let Some(file) = &file {`
`191`	`191`	`if let Ok(path) = file.clone().into_path() {`
`192`	`192`	`if let Some(s) = window.try_fs_scope() {`
`193`		`- s.allow_file(&path);`
	`193`	`+ let _ = s.allow_file(&path);`
`194`	`194`	`}`
`195`	`195`	`tauri_scope.allow_file(&path)?;`
`196`	`196`	`}`
`@@ -232,7 +232,7 @@ pub(crate) async fn save<R: Runtime>(`
`232`	`232`	`if let Some(p) = &path {`
`233`	`233`	`if let Ok(path) = p.clone().into_path() {`
`234`	`234`	`if let Some(s) = window.try_fs_scope() {`
`235`		`- s.allow_file(&path);`
	`235`	`+ let _ = s.allow_file(&path);`
`236`	`236`	`}`
`237`	`237`	`tauri_scope.allow_file(&path)?;`
`238`	`238`	`}`