Check that paths are not absolute

Author: cruessler

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,60 @@ impl AsRef<[u8]> for RelativePath {
         self.inner.as_bytes()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(not(windows))]
+    #[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)
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn absolute_paths_return_err() {
+        let path_str: &str = r"c:\refs\heads";
+        let path_bstr: &BStr = path_str.into();
+        let path_u8: &[u8; 11] = r"c:\refs\heads";
+        let path_bstring: BString = r"c:\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)
+        ));
+    }
+}

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 {

gix-ref/tests/refs/file/store/iter.rs

@@ -316,21 +316,6 @@ fn loose_iter_with_broken_refs() -> crate::Result {
     Ok(())
 }
 
-#[test]
-fn loose_iter_with_prefix_wont_allow_absolute_paths() -> crate::Result {
-    let store = store()?;
-    #[cfg(not(windows))]
-    let abs_path = "/hello";
-    #[cfg(windows)]
-    let abs_path = r"c:\hello";
-
-    match store.loose_iter_prefixed(abs_path.try_into().unwrap()) {
-        Ok(_) => unreachable!("absolute paths aren't allowed"),
-        Err(err) => assert_eq!(err.to_string(), "prefix must be a relative path, like 'refs/heads/'"),
-    }
-    Ok(())
-}
-
 #[test]
 fn loose_iter_with_prefix() -> crate::Result {
     let prefix_with_slash = b"refs/heads/";
@@ -526,21 +511,6 @@ fn overlay_iter_reproduce_1928() -> crate::Result {
     Ok(())
 }
 
-#[test]
-fn overlay_iter_with_prefix_wont_allow_absolute_paths() -> crate::Result {
-    let store = store_with_packed_refs()?;
-    #[cfg(not(windows))]
-    let abs_path = "/hello";
-    #[cfg(windows)]
-    let abs_path = r"c:\hello";
-
-    match store.iter()?.prefixed(abs_path.try_into().unwrap()) {
-        Ok(_) => unreachable!("absolute paths aren't allowed"),
-        Err(err) => assert_eq!(err.to_string(), "prefix must be a relative path, like 'refs/heads/'"),
-    }
-    Ok(())
-}
-
 #[test]
 fn overlay_prefixed_iter() -> crate::Result {
     use gix_ref::Target::*;