Check that paths are not absolute

Author: cruessler

Diff for: gix-path/src/relative_path.rs

@@ -38,6 +38,8 @@ impl RelativePath {
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
+    #[error("A RelativePath is not allowed to be absolute")]
+    IsAbsolute,
     #[error(transparent)]
     ContainsInvalidComponent(#[from] gix_validate::path::component::Error),
     #[error(transparent)]
@@ -51,6 +53,11 @@ impl<'a> TryFrom<&'a str> for &'a RelativePath {
         use std::path::Path;
 
         let path: &std::path::Path = Path::new(value);
+
+        if path.is_absolute() {
+            return Err(Error::IsAbsolute);
+        }
+
         let options: Options = Default::default();
 
         for component in path.components() {
@@ -68,6 +75,11 @@ impl<'a> TryFrom<&'a BStr> for &'a RelativePath {
 
     fn try_from(value: &'a BStr) -> Result<Self, Self::Error> {
         let path: &std::path::Path = &try_from_bstr(value)?;
+
+        if path.is_absolute() {
+            return Err(Error::IsAbsolute);
+        }
+
         let options: Options = Default::default();
 
         for component in path.components() {
@@ -87,6 +99,10 @@ impl<'a, const N: usize> TryFrom<&'a [u8; N]> for &'a RelativePath {
     fn try_from(value: &'a [u8; N]) -> Result<Self, Self::Error> {
         let path: &std::path::Path = try_from_byte_slice(value)?;
 
+        if path.is_absolute() {
+            return Err(Error::IsAbsolute);
+        }
+
         let options: Options = Default::default();
 
         for component in path.components() {
@@ -105,6 +121,10 @@ impl<'a> TryFrom<&'a BString> for &'a RelativePath {
     fn try_from(value: &'a BString) -> Result<Self, Self::Error> {
         let path: &std::path::Path = &try_from_bstr(value.as_bstr())?;
 
+        if path.is_absolute() {
+            return Err(Error::IsAbsolute);
+        }
+
         let options: Options = Default::default();
 
         for component in path.components() {
@@ -131,3 +151,33 @@ impl AsRef<[u8]> for RelativePath {
         self.inner.as_bytes()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn absolute_paths_return_err() {
+        let path_str: &str = "/refs/heads";
+        let path_bstr: &BStr = path_str.into();
+        let path_u8: &[u8; 11] = b"/refs/heads";
+        let path_bstring: BString = "/refs/heads".into();
+
+        assert!(matches!(
+            TryInto::<&RelativePath>::try_into(path_str),
+            Err(Error::IsAbsolute)
+        ));
+        assert!(matches!(
+            TryInto::<&RelativePath>::try_into(path_bstr),
+            Err(Error::IsAbsolute)
+        ));
+        assert!(matches!(
+            TryInto::<&RelativePath>::try_into(path_u8),
+            Err(Error::IsAbsolute)
+        ));
+        assert!(matches!(
+            TryInto::<&RelativePath>::try_into(&path_bstring),
+            Err(Error::IsAbsolute)
+        ));
+    }
+}

Diff for: gix-ref/src/store/file/overlay_iter.rs

@@ -296,12 +296,6 @@ impl<'a> IterInfo<'a> {
 
     fn from_prefix(base: &'a Path, prefix: &'a RelativePath, precompose_unicode: bool) -> std::io::Result<Self> {
         let prefix_path = gix_path::from_bstr(prefix);
-        if prefix_path.is_absolute() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                "prefix must be a relative path, like 'refs/heads/'",
-            ));
-        }
         let iter_root = base.join(&prefix_path);
         if prefix.ends_with(b"/") {
             Ok(IterInfo::BaseAndIterRoot {