Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

workspace: Fix trust scope paths when connecting to Windows hosts from Unix (#63102)

Xin Zhao5504e87bfdaa
diff --git a/crates/path/src/path.rs b/crates/path/src/path.rs
index 58381bcdd9b..75f03b2af34 100644
--- a/crates/path/src/path.rs
+++ b/crates/path/src/path.rs
@@ -311,7 +311,7 @@ impl PathStyle {
})
}
- pub fn starts_with<P: AsRef<Path>>(&self, path: P, prefix: P) -> bool {
+ pub fn starts_with(&self, path: impl AsRef<Path>, prefix: impl AsRef<Path>) -> bool {
iter_after(
self.components(path.as_ref()),
self.components(prefix.as_ref()),
diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs
index 86bb621874d..d1f9c97db84 100644
--- a/crates/project/src/trusted_worktrees.rs
+++ b/crates/project/src/trusted_worktrees.rs
@@ -287,6 +287,7 @@ impl TrustedWorktreesStore {
let mut new_trusted_single_file_worktrees = HashSet::default();
let mut new_trusted_other_worktrees = HashSet::default();
let mut new_trusted_abs_paths = HashSet::default();
+ let path_style = worktree_store.read(cx).path_style();
for trusted_path in trusted_paths.iter().chain(
self.trusted_paths
.remove(&weak_worktree_store)
@@ -337,9 +338,9 @@ impl TrustedWorktreesStore {
}
new_trusted_other_worktrees.retain(|(worktree_abs_path, _)| {
- new_trusted_abs_paths
- .iter()
- .all(|new_trusted_path| !worktree_abs_path.starts_with(new_trusted_path))
+ new_trusted_abs_paths.iter().all(|new_trusted_path| {
+ !path_style.starts_with(worktree_abs_path, new_trusted_path)
+ })
});
if !new_trusted_other_worktrees.is_empty() {
new_trusted_single_file_worktrees.clear();
@@ -366,7 +367,7 @@ impl TrustedWorktreesStore {
let restricted_worktree_path = worktree.read(cx).abs_path();
let retain = (!is_file || new_trusted_other_worktrees.is_empty())
&& new_trusted_abs_paths.iter().all(|new_trusted_path| {
- !restricted_worktree_path.starts_with(new_trusted_path)
+ !path_style.starts_with(&restricted_worktree_path, new_trusted_path)
});
if !retain {
trusted_paths.insert(PathTrust::Worktree(*restricted_worktree));
@@ -472,6 +473,7 @@ impl TrustedWorktreesStore {
return false;
};
let worktree_path = worktree.read(cx).abs_path();
+ let path_style = worktree.read(cx).path_style();
// Zed opened an "internal" directory: e.g. a tmp dir for `keymap_editor.rs` needs.
if !worktree.read(cx).is_visible() {
log::debug!("Skipping worktree trust checks for not visible {worktree_path:?}");
@@ -496,7 +498,7 @@ impl TrustedWorktreesStore {
}
// * Single files are auto-approved when something else (not a single file) was approved on this host already.
- // * If parent path is trusted already, this worktree is stusted also.
+ // * If parent path is trusted already, this worktree is trusted also.
//
// See module documentation for details on trust level.
if let Some(trusted_paths) = self.trusted_paths.get(&weak_worktree_store) {
@@ -506,11 +508,11 @@ impl TrustedWorktreesStore {
.worktree_for_id(*worktree_id, cx)
.is_some_and(|worktree| {
let worktree = worktree.read(cx);
- worktree_path.starts_with(&worktree.abs_path())
+ path_style.starts_with(&worktree_path, &worktree.abs_path())
|| (is_file && !worktree.is_single_file())
}),
PathTrust::AbsPath(trusted_path) => {
- is_file || worktree_path.starts_with(trusted_path)
+ is_file || path_style.starts_with(&worktree_path, trusted_path)
}
})
});
diff --git a/crates/project/tests/integration/trusted_worktrees.rs b/crates/project/tests/integration/trusted_worktrees.rs
index 5974a32ca8c..7b21b766b05 100644
--- a/crates/project/tests/integration/trusted_worktrees.rs
+++ b/crates/project/tests/integration/trusted_worktrees.rs
@@ -955,3 +955,121 @@ async fn test_invisible_worktree_stores_do_not_affect_trust(cx: &mut TestAppCont
"only visible worktrees should be restricted"
);
}
+
+#[gpui::test]
+async fn test_windows_style_abs_path_trust_from_unix_client(cx: &mut TestAppContext) {
+ use gpui::AppContext as _;
+ use project::worktree_store::WorktreeIdCounter;
+ use rpc::{AnyProtoClient, NoopProtoClient, proto};
+ use util::paths::PathStyle;
+ use worktree::Worktree;
+
+ init_test(cx);
+
+ let client = AnyProtoClient::new(NoopProtoClient::new());
+ let worktree_store = cx.update(|cx| {
+ cx.new(|_| {
+ WorktreeStore::remote(
+ true,
+ client.clone(),
+ 1,
+ PathStyle::Windows,
+ WorktreeIdCounter::default(),
+ )
+ })
+ });
+
+ let make_worktree = |id: u64, name: &str, abs_path: &str, cx: &mut TestAppContext| {
+ let metadata = proto::WorktreeMetadata {
+ id,
+ root_name: name.to_string(),
+ visible: true,
+ abs_path: abs_path.to_string(),
+ root_repo_common_dir: None,
+ root_repo_is_linked_worktree: false,
+ };
+ let worktree = cx.update(|cx| {
+ Worktree::remote(
+ 1,
+ clock::ReplicaId::new(1),
+ metadata,
+ client.clone(),
+ PathStyle::Windows,
+ cx,
+ )
+ });
+ worktree.update(cx, |worktree, _| {
+ worktree
+ .as_remote()
+ .unwrap()
+ .update_from_remote(proto::UpdateWorktree {
+ project_id: 1,
+ worktree_id: id,
+ abs_path: abs_path.to_string(),
+ root_name: name.to_string(),
+ updated_entries: vec![proto::Entry {
+ id: 1,
+ is_dir: true,
+ path: "".to_string(),
+ inode: 1,
+ mtime: Some(proto::Timestamp {
+ seconds: 0,
+ nanos: 0,
+ }),
+ is_ignored: false,
+ is_hidden: false,
+ is_external: false,
+ is_fifo: false,
+ size: None,
+ canonical_path: None,
+ is_unloaded: false,
+ }],
+ removed_entries: vec![],
+ scan_id: 1,
+ is_last_update: true,
+ updated_repositories: vec![],
+ removed_repositories: vec![],
+ root_repo_common_dir: None,
+ root_repo_is_linked_worktree: false,
+ });
+ });
+ cx.run_until_parked();
+ worktree
+ };
+
+ let worktree_t1 = make_worktree(1, "t1", r"C:\Users\me\dev\wt\t1", cx);
+ let worktree_t2 = make_worktree(2, "t2", r"C:\Users\me\dev\wt\t2", cx);
+ let t1_id = worktree_t1.read_with(cx, |worktree, _| worktree.id());
+ let t2_id = worktree_t2.read_with(cx, |worktree, _| worktree.id());
+ worktree_store.update(cx, |store, cx| {
+ store.add(&worktree_t1, cx);
+ store.add(&worktree_t2, cx);
+ });
+ assert!(
+ !worktree_t1.read_with(cx, |worktree, _| worktree.is_single_file()),
+ "t1 must be a folder worktree for this test to be meaningful"
+ );
+
+ let trusted_worktrees = init_trust_global(worktree_store.clone(), cx);
+
+ assert!(
+ !trusted_worktrees.update(cx, |store, cx| store.can_trust(&worktree_store, t1_id, cx)),
+ "t1 should be restricted by default"
+ );
+
+ trusted_worktrees.update(cx, |store, cx| {
+ store.trust(
+ &worktree_store,
+ HashSet::from_iter([
+ PathTrust::Worktree(t1_id),
+ PathTrust::AbsPath(PathBuf::from(r"C:\Users\me\dev\wt")),
+ ]),
+ cx,
+ );
+ });
+
+ assert!(
+ trusted_worktrees.update(cx, |store, cx| store.can_trust(&worktree_store, t2_id, cx)),
+ "t2 should be auto-trusted by the trusted parent scope C:\\Users\\me\\dev\\wt"
+ );
+}
diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs
index 10179861370..467a9a356ce 100644
--- a/crates/workspace/src/security_modal.rs
+++ b/crates/workspace/src/security_modal.rs
@@ -7,7 +7,9 @@ use std::{
};
use collections::{HashMap, HashSet};
-use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ScrollHandle, WeakEntity};
+use gpui::{
+ DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ScrollHandle, Task, WeakEntity,
+};
use project::{
WorktreeId,
@@ -22,13 +24,14 @@ use ui::{
};
use ui_input::InputField;
-use util::paths::PathStyle;
+use util::{ResultExt, paths::PathStyle};
use crate::{DismissDecision, ModalView, ToggleWorktreeSecurity};
pub struct SecurityModal {
restricted_paths: HashMap<WorktreeId, RestrictedPath>,
home_dir: Option<PathBuf>,
+ _home_dir_task: Task<()>,
trust_parents: bool,
worktree_store: WeakEntity<WorktreeStore>,
remote_host: Option<RemoteHostLocation>,
@@ -90,7 +93,8 @@ impl Render for SecurityModal {
format!("Unrecognized Projects ({})", restricted_count).into()
};
- let trust_label = self.build_trust_label();
+ let path_style = self.path_style(cx);
+ let trust_label = self.build_trust_label(path_style);
// The editable trust-scope field is shown only when a single project is
// being prompted for (Delta opens one worktree per thread).
@@ -138,7 +142,7 @@ impl Render for SecurityModal {
self.restricted_paths.values().filter_map(
|restricted_path| {
let abs_path = if restricted_path.is_file {
- restricted_path.abs_path.parent()
+ path_style.parent(&restricted_path.abs_path)
} else {
Some(restricted_path.abs_path.as_ref())
}?;
@@ -147,21 +151,21 @@ impl Render for SecurityModal {
match &remote_host.user_name {
Some(user_name) => format!(
"{} ({}@{})",
- self.shorten_path(abs_path)
+ self.shorten_path(abs_path, path_style)
.display(),
user_name,
remote_host.host_identifier
),
None => format!(
"{} ({})",
- self.shorten_path(abs_path)
+ self.shorten_path(abs_path, path_style)
.display(),
remote_host.host_identifier
),
}
}
None => self
- .shorten_path(abs_path)
+ .shorten_path(abs_path, path_style)
.display()
.to_string(),
};
@@ -309,10 +313,19 @@ impl SecurityModal {
pub fn new(
worktree_store: WeakEntity<WorktreeStore>,
remote_host: Option<impl Into<RemoteHostLocation>>,
+ home_dir_task: Task<Option<PathBuf>>,
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let trust_path_input = cx.new(|cx| InputField::new(window, cx, "Folder to trust"));
+ let task = cx.spawn(async |this, cx| {
+ let home_dir = home_dir_task.await;
+ this.update(cx, |this, cx| {
+ this.home_dir = home_dir;
+ cx.notify();
+ })
+ .log_err();
+ });
let mut this = Self {
worktree_store,
remote_host: remote_host.map(|host| host.into()),
@@ -320,7 +333,8 @@ impl SecurityModal {
focus_handle: cx.focus_handle(),
project_list_scroll_handle: ScrollHandle::new(),
trust_parents: false,
- home_dir: std::env::home_dir(),
+ home_dir: None,
+ _home_dir_task: task,
trusted: None,
trust_path_input,
};
@@ -329,7 +343,11 @@ impl SecurityModal {
// Pre-fill with the single project's parent folder (today's static
// scope), read-only until the checkbox is ticked.
if let Some(project) = this.single_trustable_path() {
- let default_scope = project.parent().unwrap_or(&project).to_path_buf();
+ let path_style = this.path_style(cx);
+ let default_scope = path_style
+ .parent(&project)
+ .unwrap_or(&project)
+ .to_path_buf();
this.trust_path_input.update(cx, |field, cx| {
field.set_text(&default_scope.to_string_lossy(), window, cx);
});
@@ -340,7 +358,7 @@ impl SecurityModal {
this
}
- fn build_trust_label(&self) -> Option<Cow<'static, str>> {
+ fn build_trust_label(&self, path_style: PathStyle) -> Option<Cow<'static, str>> {
let mut has_restricted_files = false;
let available_parents = self
.restricted_paths
@@ -349,7 +367,7 @@ impl SecurityModal {
has_restricted_files |= restricted_path.is_file;
!restricted_path.is_file
})
- .filter_map(|restricted_path| restricted_path.abs_path.parent())
+ .filter_map(|restricted_path| path_style.parent(&restricted_path.abs_path))
.collect::<SmallVec<[_; 2]>>();
match available_parents.len() {
0 => {
@@ -361,18 +379,27 @@ impl SecurityModal {
}
1 => Some(Cow::Owned(format!(
"Trust all projects in the {:} folder",
- self.shorten_path(available_parents[0]).display()
+ self.shorten_path(available_parents[0], path_style)
+ .display()
))),
_ => Some(Cow::Borrowed("Trust all projects in the parent folders")),
}
}
- fn shorten_path<'a>(&self, path: &'a Path) -> Cow<'a, Path> {
+ fn path_style(&self, cx: &App) -> PathStyle {
+ self.worktree_store
+ .upgrade()
+ .map(|store| store.read(cx).path_style())
+ .unwrap_or_else(PathStyle::local)
+ }
+
+ fn shorten_path<'a>(&self, path: &'a Path, path_style: PathStyle) -> Cow<'a, Path> {
match &self.home_dir {
- Some(home_dir) => path
- .strip_prefix(home_dir)
- .map(|stripped| Path::new("~").join(stripped))
- .map(Cow::Owned)
+ Some(home_dir) => path_style
+ .strip_prefix(path, home_dir)
+ .ok()
+ .and_then(|stripped| path_style.join("~", stripped))
+ .map(|joined| Cow::Owned(PathBuf::from(joined)))
.unwrap_or(Cow::Borrowed(path)),
None => Cow::Borrowed(path),
}
@@ -389,11 +416,7 @@ impl SecurityModal {
return Ok(None);
};
let typed = self.trust_path_input.read(cx).text(cx);
- let path_style = self
- .worktree_store
- .upgrade()
- .map(|store| store.read(cx).path_style())
- .unwrap_or_else(PathStyle::local);
+ let path_style = self.path_style(cx);
validate_trust_scope(&typed, &project, self.home_dir.as_deref(), path_style).map(Some)
}
@@ -422,13 +445,14 @@ impl SecurityModal {
if let Some(scope) = scope_override {
paths_to_trust.insert(PathTrust::AbsPath(scope));
} else {
+ let path_style = self.path_style(cx);
paths_to_trust.extend(self.restricted_paths.values().filter_map(
|restricted_paths| {
if restricted_paths.is_file {
None
} else {
let parent_abs_path =
- restricted_paths.abs_path.parent()?.to_owned();
+ path_style.parent(&restricted_paths.abs_path)?.to_owned();
Some(PathTrust::AbsPath(parent_abs_path))
}
},
@@ -511,23 +535,33 @@ fn validate_trust_scope(
if trimmed.is_empty() {
return Err("Enter a folder to trust".into());
}
+ if home_dir.is_none() && trimmed.starts_with('~') {
+ return Err("Home directory not available".into());
+ }
let expanded = match (trimmed.strip_prefix('~'), home_dir) {
- (Some(rest), Some(home_dir)) => home_dir.join(
- rest.strip_prefix(path_style.primary_separator())
- .unwrap_or(rest),
- ),
+ (Some(rest), Some(home_dir)) => {
+ let rest = rest.trim_start_matches(path_style.separators_ch());
+ if path_style == PathStyle::local() {
+ home_dir.join(rest)
+ } else {
+ path_style
+ .join_path_preserving_components(home_dir, rest)
+ .map_err(|error| SharedString::from(error.to_string()))?
+ }
+ }
_ => PathBuf::from(trimmed),
};
if !path_style.is_absolute(&expanded) {
return Err("Enter an absolute folder path".into());
}
- if !project.starts_with(&expanded) {
+
+ if !path_style.starts_with(project, expanded.as_path()) {
return Err("Must be a parent folder of the project".into());
}
Ok(expanded)
}
-#[cfg(all(test, unix))]
+#[cfg(test)]
mod tests {
use super::*;
@@ -561,6 +595,61 @@ mod tests {
);
}
+ #[test]
+ fn accepts_windows_style_ancestor() {
+ let project = Path::new(r"C:\Users\me\dev\wt\t1");
+ let style = PathStyle::Windows;
+
+ assert_eq!(
+ validate_trust_scope(r"C:\Users\me\dev\wt", project, None, style).unwrap(),
+ PathBuf::from(r"C:\Users\me\dev\wt"),
+ );
+
+ assert!(validate_trust_scope(r"C:\Users\me", project, None, style).is_ok());
+
+ assert_eq!(
+ validate_trust_scope(r"C:\Users\me\dev\wt\t1", project, None, style).unwrap(),
+ PathBuf::from(r"C:\Users\me\dev\wt\t1")
+ );
+
+ // Drive letters are matched case-insensitively.
+ assert_eq!(
+ validate_trust_scope(r"c:\Users\me\dev\wt", project, None, style).unwrap(),
+ PathBuf::from(r"c:\Users\me\dev\wt")
+ );
+ }
+
+ #[test]
+ fn rejects_windows_style_non_ancestor() {
+ let project = Path::new(r"C:\Users\me\dev\wt\t1");
+ let style = PathStyle::Windows;
+ assert!(validate_trust_scope(r"C:\Users\other", project, None, style).is_err());
+ // Relative paths are not absolute.
+ assert!(validate_trust_scope(r"dev\wt", project, None, style).is_err());
+ // Deeper than the project is not an ancestor.
+ assert!(validate_trust_scope(r"C:\Users\me\dev\wt\t1\sub", project, None, style).is_err());
+ // A prefix that is not a component boundary is not an ancestor.
+ assert!(
+ validate_trust_scope(
+ r"C:\Users\me\dev\wt",
+ Path::new(r"C:\Users\me\dev\wt2"),
+ None,
+ style,
+ )
+ .is_err()
+ );
+
+ assert!(
+ validate_trust_scope(
+ r"\\server",
+ Path::new(r"\\server\share\project"),
+ None,
+ style
+ )
+ .is_err()
+ );
+ }
+
#[test]
fn expands_leading_tilde() {
let home = Path::new("/Users/me");
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index d1dc10081ab..6ddb3431056 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -9089,8 +9089,20 @@ impl Workspace {
.remote_connection_options(cx)
.map(RemoteHostLocation::from);
let worktree_store = project.worktree_store().downgrade();
+ let home_dir_task = if project.is_local() {
+ Task::ready(std::env::home_dir())
+ } else {
+ let resolve_task = project.resolve_abs_path("~", cx);
+ cx.spawn(async |_, _| {
+ let resolved_path = resolve_task
+ .await
+ .and_then(|path| path.into_abs_path())
+ .map(PathBuf::from);
+ resolved_path
+ })
+ };
self.toggle_modal(window, cx, |window, cx| {
- SecurityModal::new(worktree_store, remote_host, window, cx)
+ SecurityModal::new(worktree_store, remote_host, home_dir_task, window, cx)
});
}
}