#![forbid(unsafe_code)]
use crate::protocol::TargetOs;
use soft_canonicalize::soft_canonicalize;
use std::path::{Component, Path, PathBuf};
use typed_path::{Utf8Component, Utf8UnixPath, Utf8UnixPathBuf};
const EXEC_HINT_EXTS: &[&str] = &["exe", "bat", "cmd", "ps1", "sh", "pl", "py", "rb", "lua"];
#[must_use]
pub fn compute_exec_hint(path: &Path) -> bool {
path.extension()
.and_then(|ext| ext.to_str())
.is_some_and(|ext| EXEC_HINT_EXTS.iter().any(|h| ext.eq_ignore_ascii_case(h)))
}
#[must_use]
#[expect(clippy::fn_params_excessive_bools)]
pub fn final_mode(
source_os: TargetOs,
_target_os: TargetOs,
raw_mode: u32,
is_dir: bool,
exec_hint: bool,
no_perms: bool,
keep_special_bits: bool,
) -> u32 {
if no_perms {
return if is_dir { 0o755 } else { 0o644 };
}
match source_os {
TargetOs::Unix => {
raw_mode & if keep_special_bits { 0o7777 } else { 0o777 }
}
TargetOs::Windows => {
if is_dir || exec_hint {
0o755
} else {
0o644
}
}
}
}
#[must_use]
pub fn rel_path(from_dir: &Utf8UnixPath, to: &Utf8UnixPath) -> Utf8UnixPathBuf {
let from: Vec<_> = from_dir.components().collect();
let to: Vec<_> = to.components().collect();
let common = from
.iter()
.zip(to.iter())
.take_while(|(a, b)| a == b)
.count();
let mut out = Utf8UnixPathBuf::new();
for _ in common..from.len() {
out.push("..");
}
for c in &to[common..] {
out.push(c.as_str());
}
if out.as_str().is_empty() {
out.push(".");
}
out
}
#[must_use]
pub fn rewrite_internal_target(link_rel: &str, target_rel: &str) -> String {
let link_dir = Utf8UnixPath::new(link_rel)
.parent()
.unwrap_or_else(|| Utf8UnixPath::new(""));
rel_path(link_dir, Utf8UnixPath::new(target_rel)).to_string()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LinkClass {
Internal,
ExternalFile,
ExternalDir,
DanglingExternal,
}
#[must_use]
pub fn classify_link(link_path: &Path, target: &str, root: &Path) -> LinkClass {
let resolved = resolve_target(link_path, target);
let Ok(real) = std::fs::canonicalize(&resolved) else {
let normalized =
soft_canonicalize(&resolved).unwrap_or_else(|_| lexical_normalize(&resolved));
return if normalized.starts_with(root) {
LinkClass::Internal
} else {
LinkClass::DanglingExternal
};
};
if real.starts_with(root) {
LinkClass::Internal
} else if real.is_dir() {
LinkClass::ExternalDir
} else {
LinkClass::ExternalFile
}
}
pub(crate) fn resolve_target(link_path: &Path, target: &str) -> PathBuf {
let t = Path::new(target);
if t.is_absolute() {
t.to_path_buf()
} else {
link_path
.parent()
.unwrap_or_else(|| Path::new(""))
.join(t)
}
}
pub(crate) fn lexical_normalize(path: &Path) -> PathBuf {
let mut parts: Vec<Component> = Vec::new();
for component in path.components() {
match component {
Component::ParentDir => {
if matches!(parts.last(), Some(Component::Normal(_))) {
parts.pop();
}
}
Component::CurDir => {}
other => parts.push(other),
}
}
let mut out = PathBuf::new();
for component in parts {
out.push(component.as_os_str());
}
out
}
#[must_use]
pub fn is_lnk_magic(data: &[u8]) -> bool {
data.len() >= 4 && u32::from_le_bytes([data[0], data[1], data[2], data[3]]) == 0x0000_004C
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exec_hint_matches_script_and_binary_extensions() {
for ext in ["exe", "bat", "cmd", "ps1", "sh", "pl", "py", "rb", "lua"] {
assert!(compute_exec_hint(Path::new(&format!("tool.{ext}"))), "{ext}");
assert!(
compute_exec_hint(Path::new(&format!("tool.{}", ext.to_uppercase()))),
"{ext} uppercase"
);
}
assert!(!compute_exec_hint(Path::new("notes.txt")));
assert!(!compute_exec_hint(Path::new("noext")));
assert!(!compute_exec_hint(Path::new("dir/")));
}
#[test]
fn final_mode_unix_source_keeps_bits_clears_high_bits() {
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o4755, false, false, false, false), 0o755);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o2750, false, false, false, false), 0o750);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o1777, true, false, false, false), 0o777);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o640, false, false, false, false), 0o640);
}
#[test]
fn final_mode_archive_keeps_suid_sgid_sticky() {
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o4755, false, false, false, true), 0o4755);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o2750, false, false, false, true), 0o2750);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o1777, true, false, false, true), 0o1777);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o4755, false, false, true, true), 0o644);
}
#[test]
fn final_mode_unix_source_no_perms_explicit_defaults() {
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o600, false, false, true, false), 0o644);
assert_eq!(final_mode(TargetOs::Unix, TargetOs::Unix, 0o777, true, false, true, false), 0o755);
}
#[test]
fn final_mode_windows_source_uses_exec_hint() {
assert_eq!(final_mode(TargetOs::Windows, TargetOs::Unix, 0, false, true, false, false), 0o755);
assert_eq!(final_mode(TargetOs::Windows, TargetOs::Unix, 0, false, false, false, false), 0o644);
assert_eq!(final_mode(TargetOs::Windows, TargetOs::Unix, 0, true, false, false, false), 0o755);
assert_eq!(final_mode(TargetOs::Windows, TargetOs::Unix, 0, false, true, true, false), 0o644);
}
#[test]
fn final_mode_ignores_target_os() {
assert_eq!(
final_mode(TargetOs::Unix, TargetOs::Windows, 0o640, false, false, false, false),
0o640
);
}
#[test]
fn rel_path_descends_and_ascends() {
assert_eq!(
rel_path(Utf8UnixPath::new("a"), Utf8UnixPath::new("a/t.txt")),
Utf8UnixPathBuf::from("t.txt")
);
assert_eq!(
rel_path(Utf8UnixPath::new("a/b"), Utf8UnixPath::new("a/c.txt")),
Utf8UnixPathBuf::from("../c.txt")
);
assert_eq!(
rel_path(Utf8UnixPath::new("a/b"), Utf8UnixPath::new("d/e.txt")),
Utf8UnixPathBuf::from("../../d/e.txt")
);
assert_eq!(
rel_path(Utf8UnixPath::new("a"), Utf8UnixPath::new("a")),
Utf8UnixPathBuf::from(".")
);
assert_eq!(
rel_path(Utf8UnixPath::new(""), Utf8UnixPath::new("x.txt")),
Utf8UnixPathBuf::from("x.txt")
);
}
#[test]
fn rewrite_internal_target_is_dest_relative() {
assert_eq!(rewrite_internal_target("a/link.txt", "a/sub/t.txt"), "sub/t.txt");
assert_eq!(rewrite_internal_target("links/l", "shared/t"), "../shared/t");
assert_eq!(rewrite_internal_target("link.txt", "target.txt"), "target.txt");
assert_eq!(rewrite_internal_target("l", "sub/x"), "sub/x");
}
#[cfg(unix)]
#[test]
fn classify_link_internal_relative_target() {
let root = tempfile::tempdir().unwrap();
let target = root.path().join("sub/t.txt");
std::fs::create_dir(root.path().join("sub")).unwrap();
std::fs::write(&target, b"x").unwrap();
std::os::unix::fs::symlink("sub/t.txt", root.path().join("link.txt")).unwrap();
let root_canonical = root.path().canonicalize().unwrap();
let link = root.path().join("link.txt");
assert_eq!(
classify_link(&link, "sub/t.txt", &root_canonical),
LinkClass::Internal
);
}
#[cfg(unix)]
#[test]
fn classify_link_absolute_target_inside_root_is_internal() {
let root = tempfile::tempdir().unwrap();
std::fs::write(root.path().join("t.txt"), b"x").unwrap();
std::os::unix::fs::symlink(root.path().join("t.txt"), root.path().join("abs.txt")).unwrap();
let root_canonical = root.path().canonicalize().unwrap();
let abs_target = root_canonical.join("t.txt");
assert_eq!(
classify_link(
&root.path().join("abs.txt"),
&abs_target.to_string_lossy(),
&root_canonical
),
LinkClass::Internal
);
}
#[cfg(unix)]
#[test]
fn classify_link_external_file_and_dir() {
let root = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
std::fs::write(outside.path().join("f.txt"), b"x").unwrap();
std::fs::create_dir(outside.path().join("d")).unwrap();
std::os::unix::fs::symlink(outside.path().join("f.txt"), root.path().join("f_link")).unwrap();
std::os::unix::fs::symlink(outside.path().join("d"), root.path().join("d_link")).unwrap();
let root_canonical = root.path().canonicalize().unwrap();
assert_eq!(
classify_link(&root.path().join("f_link"), &outside.path().join("f.txt").to_string_lossy(), &root_canonical),
LinkClass::ExternalFile
);
assert_eq!(
classify_link(&root.path().join("d_link"), &outside.path().join("d").to_string_lossy(), &root_canonical),
LinkClass::ExternalDir
);
}
#[cfg(unix)]
#[test]
fn classify_link_dangling_external_and_internal() {
let root = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
let dangling_out = outside.path().join("missing.txt");
std::os::unix::fs::symlink(&dangling_out, root.path().join("dangling_out")).unwrap();
let root_canonical = root.path().canonicalize().unwrap();
assert_eq!(
classify_link(&root.path().join("dangling_out"), &dangling_out.to_string_lossy(), &root_canonical),
LinkClass::DanglingExternal
);
std::os::unix::fs::symlink("not-yet.txt", root.path().join("dangling_in")).unwrap();
assert_eq!(
classify_link(&root.path().join("dangling_in"), "not-yet.txt", &root_canonical),
LinkClass::Internal
);
}
#[test]
fn lnk_magic_sniffs_header_size() {
assert!(is_lnk_magic(&[0x4C, 0x00, 0x00, 0x00, 0x01]));
assert!(is_lnk_magic(&[0x4C, 0x00, 0x00, 0x00]));
assert!(!is_lnk_magic(&[0x4C, 0x00, 0x00]));
assert!(!is_lnk_magic(b"LNK1"));
assert!(!is_lnk_magic(b""));
}
#[test]
fn lexical_normalize_cancels_parent_dirs() {
assert_eq!(lexical_normalize(Path::new("a/b/../c")), PathBuf::from("a/c"));
assert_eq!(lexical_normalize(Path::new("a/./b")), PathBuf::from("a/b"));
assert_eq!(lexical_normalize(Path::new("a/..")), PathBuf::new());
assert_eq!(lexical_normalize(Path::new("/../x")), PathBuf::from("/x"));
assert_eq!(lexical_normalize(Path::new("/a/../../x")), PathBuf::from("/x"));
assert_eq!(
lexical_normalize(Path::new("/root/sub/../sub/l")),
PathBuf::from("/root/sub/l")
);
}
#[cfg(windows)]
#[test]
fn lexical_normalize_keeps_drive_root() {
assert_eq!(
lexical_normalize(Path::new(r"C:\..\x")),
PathBuf::from(r"C:\x")
);
assert_eq!(
lexical_normalize(Path::new(r"C:\a\..\x")),
PathBuf::from(r"C:\x")
);
}
#[test]
fn target_os_from_os_name() {
assert_eq!(TargetOs::from_os_name("windows"), TargetOs::Windows);
assert_eq!(TargetOs::from_os_name("Windows"), TargetOs::Windows);
assert_eq!(TargetOs::from_os_name("linux"), TargetOs::Unix);
assert_eq!(TargetOs::from_os_name("macos"), TargetOs::Unix);
assert_eq!(TargetOs::from_os_name("darwin"), TargetOs::Unix);
}
}