use mlua::{Lua, Table, Value};
pub fn is_windows_style(path: &str) -> bool {
path.contains('\\') || (!path.contains('/') && drive(path).is_some())
}
fn restyle(canonical: String, windows: bool) -> String {
if windows {
canonical.replace('/', "\\")
} else {
canonical
}
}
fn drive(path: &str) -> Option<usize> {
let mut chars = path.chars();
(chars.next().is_some_and(|c| c.is_ascii_alphabetic()) && chars.next() == Some(':'))
.then_some(2)
}
pub fn split_root(path: &str) -> (String, String) {
let canonical = path.replace('\\', "/");
let root_len = if canonical.starts_with("//") {
2
} else {
match drive(&canonical) {
Some(d) if canonical[d..].starts_with('/') => d + 1,
Some(d) => d,
None if canonical.starts_with('/') => 1,
None => 0,
}
};
let (root, rest) = canonical.split_at(root_len);
(root.to_string(), rest.to_string())
}
fn components(rest: &str) -> Vec<&str> {
let mut parts: Vec<&str> = Vec::new();
for segment in rest.split('/') {
if segment.is_empty() || (segment == "." && !parts.is_empty()) {
continue;
}
parts.push(segment);
}
parts
}
fn root_is_anchor(root: &str) -> bool {
!root.is_empty() && !(root.len() == 2 && root.ends_with(':'))
}
pub fn is_absolute(path: &str) -> bool {
root_is_anchor(&split_root(path).0)
}
pub fn basename(path: &str) -> String {
let (_, rest) = split_root(path);
match components(&rest).last() {
Some(name) if *name != "." && *name != ".." => (*name).to_string(),
_ => String::new(),
}
}
pub fn dirname(path: &str) -> String {
let windows = is_windows_style(path);
let (root, rest) = split_root(path);
let parts = components(&rest);
let out = match parts.split_last() {
Some((_, parent)) if parent.is_empty() && root.is_empty() => ".".into(),
Some((_, parent)) => format!("{root}{}", parent.join("/")),
None if root.is_empty() => ".".into(),
None => root,
};
restyle(out, windows)
}
fn extension(path: &str) -> Option<String> {
match basename(path).rsplit_once('.') {
Some((stem, ext)) if !stem.is_empty() => Some(ext.to_string()),
_ => None,
}
}
pub fn join(segments: &[String]) -> String {
let windows = segments
.iter()
.find(|s| !s.is_empty())
.is_some_and(|s| is_windows_style(s));
let mut out = String::new();
for segment in segments {
if segment.is_empty() {
continue;
}
let canonical = segment.replace('\\', "/");
if out.is_empty() {
out.push_str(&canonical);
} else {
let bare_drive = out.len() == 2 && drive(&out).is_some();
if !out.ends_with('/') && !bare_drive {
out.push('/');
}
out.push_str(canonical.trim_start_matches('/'));
}
}
restyle(out, windows)
}
pub fn normalize(path: &str) -> String {
let windows = is_windows_style(path);
let (root, rest) = split_root(path);
let rooted = !root.is_empty();
let anchored = root_is_anchor(&root);
let mut parts: Vec<&str> = Vec::new();
for segment in components(&rest) {
match segment {
"." => {}
".." => {
if parts.last().is_some_and(|p| *p != "..") {
parts.pop();
} else if !anchored {
parts.push("..");
}
}
other => parts.push(other),
}
}
let joined = parts.join("/");
let out = match (rooted, joined.is_empty()) {
(true, _) => format!("{root}{joined}"),
(false, true) => ".".into(),
(false, false) if !split_root(&joined).0.is_empty() => format!("./{joined}"),
(false, false) => joined,
};
restyle(out, windows)
}
pub(crate) fn create_path_table(lua: &Lua) -> mlua::Result<Table> {
let path = lua.create_table()?;
path.set(
"join",
lua.create_function(|_, segments: mlua::Variadic<String>| Ok(join(&segments)))?,
)?;
path.set(
"basename",
lua.create_function(|_, path: String| Ok(basename(&path)))?,
)?;
path.set(
"dirname",
lua.create_function(|_, path: String| Ok(dirname(&path)))?,
)?;
path.set(
"extension",
lua.create_function(|lua, path: String| match extension(&path) {
Some(ext) => Ok(Value::String(lua.create_string(ext)?)),
None => Ok(Value::Nil),
})?,
)?;
path.set(
"normalize",
lua.create_function(|_, path: String| Ok(normalize(&path)))?,
)?;
path.set(
"is_absolute",
lua.create_function(|_, path: String| Ok(is_absolute(&path)))?,
)?;
Ok(path)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn components_split_like_posix() {
assert_eq!(basename("/a/b/c.txt"), "c.txt");
assert_eq!(basename("/a/b/"), "b");
assert_eq!(basename("plain"), "plain");
assert_eq!(basename("/"), "");
assert_eq!(dirname("/a/b/c"), "/a/b");
assert_eq!(dirname("/a/b/"), "/a");
assert_eq!(dirname("/c"), "/");
assert_eq!(dirname("c"), ".");
assert_eq!(dirname("/"), "/");
assert_eq!(extension("a/b.tar.gz").as_deref(), Some("gz"));
assert_eq!(extension("a/.env"), None);
assert_eq!(extension("a/no_ext"), None);
}
#[test]
fn windows_paths_are_understood() {
assert_eq!(basename(r"C:\Users\ada\file.txt"), "file.txt");
assert_eq!(basename(r"C:\Users\ada\"), "ada");
assert_eq!(dirname(r"C:\Users\ada"), r"C:\Users");
assert_eq!(dirname(r"C:\Users"), r"C:\");
assert_eq!(dirname(r"C:\"), r"C:\");
assert_eq!(extension(r"C:\a\b.TXT").as_deref(), Some("TXT"));
assert!(is_absolute(r"C:\Users"));
assert!(is_absolute("C:/Users"));
assert!(is_absolute(r"\\server\share"));
assert!(is_absolute(r"\windows-root-relative"));
assert!(!is_absolute("C:relative"));
assert!(!is_absolute(r"relative\file"));
assert_eq!(basename(r"C:\a/b\c.txt"), "c.txt");
}
#[test]
fn join_never_discards_the_base() {
let s = |v: &[&str]| -> Vec<String> { v.iter().map(|s| s.to_string()).collect() };
assert_eq!(join(&s(&["/srv", "app", "file.txt"])), "/srv/app/file.txt");
assert_eq!(join(&s(&["/srv/", "/app/"])), "/srv/app/");
assert_eq!(join(&s(&["/srv", "/etc/passwd"])), "/srv/etc/passwd");
assert_eq!(join(&s(&["a", "", "b"])), "a/b");
assert_eq!(join(&s(&["/"])), "/");
assert_eq!(
join(&s(&[r"C:\Users", "ada", "x.txt"])),
r"C:\Users\ada\x.txt"
);
assert_eq!(join(&s(&[r"C:\srv", r"\etc\passwd"])), r"C:\srv\etc\passwd");
assert_eq!(join(&s(&["C:", "x"])), "C:x");
assert_eq!(join(&s(&["C:", "..", "x"])), r"C:..\x");
assert!(!is_absolute(&join(&s(&["C:", "x"]))));
assert_eq!(normalize(&join(&s(&["C:", "..", "x"]))), r"C:..\x");
assert_eq!(join(&s(&["C:x", "y"])), r"C:x\y");
}
#[test]
fn degenerate_inputs_hold_up() {
assert_eq!(join(&[]), "");
assert_eq!(join(&["".into(), "".into()]), "");
assert_eq!(basename(""), "");
assert_eq!(dirname(""), ".");
assert_eq!(extension(""), None);
assert!(!is_absolute(""));
assert_eq!(normalize("//"), "//");
assert_eq!(normalize("/a/b/"), "/a/b");
assert_eq!(normalize(r"C:\a\"), r"C:\a");
assert_eq!(normalize("C:x"), "C:x");
assert_eq!(dirname(r"C:x"), "C:");
assert_eq!(dirname(r"\\server\share"), r"\\server");
assert_eq!(dirname(r"\\server"), r"\\");
assert_eq!(normalize("///ax/y"), "//ax/y");
assert_eq!(normalize("//C:x/.."), "//");
assert_eq!(basename("//C:x"), "C:x");
assert_eq!(dirname("//C:x/y"), "//C:x");
let attack = format!("/base/{}etc/passwd", "../".repeat(1000));
assert_eq!(normalize(&attack), "/etc/passwd");
let relative_attack = "../".repeat(500) + "x";
assert_eq!(
normalize(&relative_attack),
format!("{}x", "../".repeat(500))
);
}
#[test]
fn normalize_resolves_dots_without_escaping_the_root() {
assert_eq!(normalize("/a/b/../c/./d"), "/a/c/d");
assert_eq!(normalize("/a/../../etc"), "/etc");
assert_eq!(normalize("a//b///c"), "a/b/c");
assert_eq!(normalize("./x"), "x");
assert_eq!(normalize("../x"), "../x");
assert_eq!(normalize("a/.."), ".");
assert_eq!(normalize("/"), "/");
assert_eq!(normalize(""), ".");
assert_eq!(normalize(r"C:\a\..\..\etc"), r"C:\etc");
assert_eq!(normalize(r"C:\a\.\b"), r"C:\a\b");
assert_eq!(normalize(r"C:/mixed\style/x"), r"C:\mixed\style\x");
assert_eq!(normalize(r"\\server\share\..\other"), r"\\server\other");
}
#[test]
fn traversal_is_defeated_in_both_path_styles() {
let under =
|base: &str, untrusted: &str| normalize(&join(&[base.into(), untrusted.into()]));
for (base, sep) in [
("/srv/app", "/"),
(r"C:\srv\app", "\\"),
(r"\\srv\app", "\\"),
] {
let inside = format!("{base}{sep}");
for attack in [
"../../../../etc/passwd",
r"..\..\..\..\etc\passwd",
r"../..\../..\etc/passwd",
"..//..///../x",
"a/../../../../x",
"./../../x",
] {
let out = under(base, attack);
assert!(
!out.starts_with(&inside),
"{base} + {attack:?} must not pass a prefix check: {out}"
);
assert!(
!out.replace('\\', "/").split('/').any(|s| s == ".."),
"{base} + {attack:?} left a `..`: {out}"
);
}
for benign in ["a/b/../c", r"a\b\..\c", "./a/b/../c", "a//b/././../c"] {
assert_eq!(
under(base, benign),
format!("{inside}a{sep}c"),
"{benign:?}"
);
}
assert!(under(base, "/etc/passwd").starts_with(&inside));
assert!(under(base, r"\etc\passwd").starts_with(&inside));
assert!(under(base, "C:/etc").starts_with(&inside));
}
assert_eq!(normalize("/base/.../..a/x"), "/base/.../..a/x");
assert_eq!(normalize("/base/.. /x"), "/base/.. /x");
assert_eq!(normalize(r"C:\base\...\x"), r"C:\base\...\x");
assert_eq!(normalize("/../../etc"), "/etc");
assert_eq!(normalize(r"C:\..\..\etc"), r"C:\etc");
assert_eq!(normalize(r"\\srv\..\..\etc"), r"\\etc");
assert_eq!(normalize(r"\..\..\etc"), r"\etc");
assert_eq!(normalize(r"C:..\x"), r"C:..\x");
assert!(!is_absolute(r"C:..\x"));
}
fn assert_normalize_invariants(input: &str) {
let normalized = normalize(input);
if is_absolute(&normalized) {
assert!(
!normalized
.replace('\\', "/")
.split('/')
.any(|seg| seg == ".."),
"{input:?} -> {normalized:?} kept a dot-dot in an absolute path"
);
}
assert_eq!(
normalize(&normalized),
normalized,
"normalize is not idempotent for {input:?}"
);
assert_eq!(
split_root(&normalized).0,
split_root(input).0,
"{input:?} -> {normalized:?} changed the root"
);
assert_eq!(
is_absolute(&normalized),
is_absolute(input),
"{input:?} -> {normalized:?} changed rootedness"
);
assert!(
input.contains('\\') || !normalized.contains('\\'),
"{input:?} -> {normalized:?} invented a backslash"
);
assert!(
!is_windows_style(input) || !normalized.contains('/'),
"{input:?} -> {normalized:?} mixed separator styles"
);
}
#[test]
fn normalize_holds_for_every_short_path() {
const ALPHABET: [char; 6] = ['/', '\\', '.', ':', 'C', ' '];
const LEN: usize = 6;
let mut input = String::new();
for len in 0..=LEN {
let mut digits = vec![0usize; len];
loop {
input.clear();
input.extend(digits.iter().map(|&d| ALPHABET[d]));
assert_normalize_invariants(&input);
let mut place = len;
let mut wrapped = true;
while place > 0 {
place -= 1;
digits[place] += 1;
if digits[place] < ALPHABET.len() {
wrapped = false;
break;
}
digits[place] = 0;
}
if wrapped {
break;
}
}
}
}
proptest::proptest! {
#[test]
fn prop_normalize_never_leaves_dotdot_and_is_idempotent(
pieces in proptest::collection::vec(
proptest::prelude::prop_oneof![
proptest::prelude::Just("a"),
proptest::prelude::Just("bb"),
proptest::prelude::Just(".."),
proptest::prelude::Just("."),
proptest::prelude::Just(""),
proptest::prelude::Just("/"),
proptest::prelude::Just("\\"),
proptest::prelude::Just("C:"),
proptest::prelude::Just("C:\\"),
proptest::prelude::Just("x/y"),
proptest::prelude::Just("..."),
proptest::prelude::Just("..a"),
proptest::prelude::Just(" "),
],
0..8,
),
separators in proptest::collection::vec(0u8..3, 0..8),
) {
let mut input = String::new();
for (i, piece) in pieces.iter().enumerate() {
input.push_str(piece);
match separators.get(i).copied().unwrap_or(0) {
1 => input.push('/'),
2 => input.push('\\'),
_ => {}
}
}
assert_normalize_invariants(&input);
for base in ["/srv/app", r"C:\srv\app", r"\\srv\app"] {
let under = join(&[base.to_string(), input.clone()]);
assert_normalize_invariants(&under);
proptest::prop_assert!(
is_absolute(&normalize(&under)),
"{:?} under {} lost its root", input, base
);
}
let under_drive = join(&["C:".to_string(), input.clone()]);
assert_normalize_invariants(&under_drive);
proptest::prop_assert!(
!is_absolute(&normalize(&under_drive)),
"{:?} under C: became anchored: {:?}", input, under_drive
);
}
}
}