Handle win32 separator & prefixes for cygwin paths

Author: Berrysoft

library/std/src/path.rs

@@ -299,8 +299,8 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Says whether the first byte after the prefix is a separator.
-fn has_physical_root(s: &[u8], prefix: Option<Prefix<'_>>) -> bool {
-    let path = if let Some(p) = prefix { &s[p.len()..] } else { s };
+fn has_physical_root(s: &[u8], prefix: Option<Prefix<'_>>, pre_prefix_len: usize) -> bool {
+    let path = if let Some(p) = prefix { &s[p.len() + pre_prefix_len..] } else { s };
     !path.is_empty() && is_sep_byte(path[0])
 }
 
@@ -600,6 +600,9 @@ pub struct Components<'a> {
     // The prefix as it was originally parsed, if any
     prefix: Option<Prefix<'a>>,
 
+    // The length of `./` in `//./` on Cygwin
+    pre_prefix_len: usize,
+
     // true if path *physically* has a root separator; for most Windows
     // prefixes, it may have a "logical" root separator for the purposes of
     // normalization, e.g., \\server\share == \\server\share\.
@@ -643,7 +646,7 @@ impl<'a> Components<'a> {
     // how long is the prefix, if any?
     #[inline]
     fn prefix_len(&self) -> usize {
-        self.prefix.as_ref().map(Prefix::len).unwrap_or(0)
+        self.prefix.as_ref().map(Prefix::len).unwrap_or(0) + self.pre_prefix_len
     }
 
     #[inline]
@@ -989,7 +992,14 @@ impl FusedIterator for Components<'_> {}
 impl<'a> PartialEq for Components<'a> {
     #[inline]
     fn eq(&self, other: &Components<'a>) -> bool {
-        let Components { path: _, front: _, back: _, has_physical_root: _, prefix: _ } = self;
+        let Components {
+            path: _,
+            front: _,
+            back: _,
+            has_physical_root: _,
+            prefix: _,
+            pre_prefix_len: _,
+        } = self;
 
         // Fast path for exact matches, e.g. for hashmap lookups.
         // Don't explicitly compare the prefix or has_physical_root fields since they'll
@@ -999,6 +1009,7 @@ impl<'a> PartialEq for Components<'a> {
             && self.back == State::Body
             && other.back == State::Body
             && self.prefix_verbatim() == other.prefix_verbatim()
+            && self.pre_prefix_len == other.pre_prefix_len
         {
             // possible future improvement: this could bail out earlier if there were a
             // reverse memcmp/bcmp comparing back to front
@@ -1315,8 +1326,17 @@ impl PathBuf {
             need_sep = false
         }
 
+        let need_clear = if cfg!(target_os = "cygwin") {
+            // If path is absolute and its prefix is none, it is like `/foo`,
+            // and will be handled below.
+            path.prefix().is_some()
+        } else {
+            // On Unix: prefix is always None.
+            path.is_absolute() || path.prefix().is_some()
+        };
+
         // absolute `path` replaces `self`
-        if path.is_absolute() || path.prefix().is_some() {
+        if need_clear {
             self.inner.truncate(0);
 
         // verbatim paths need . and .. removed
@@ -2862,11 +2882,15 @@ impl Path {
     /// [`CurDir`]: Component::CurDir
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn components(&self) -> Components<'_> {
-        let prefix = parse_prefix(self.as_os_str());
+        let (pre_prefix_len, prefix) = match parse_prefix(self.as_os_str()) {
+            Some((pre_prefix_len, prefix)) => (pre_prefix_len, Some(prefix)),
+            None => (0, None),
+        };
         Components {
             path: self.as_u8_slice(),
             prefix,
-            has_physical_root: has_physical_root(self.as_u8_slice(), prefix),
+            pre_prefix_len,
+            has_physical_root: has_physical_root(self.as_u8_slice(), prefix, pre_prefix_len),
             front: State::Prefix,
             back: State::Body,
         }
@@ -3330,9 +3354,9 @@ impl Hash for Path {
     fn hash<H: Hasher>(&self, h: &mut H) {
         let bytes = self.as_u8_slice();
         let (prefix_len, verbatim) = match parse_prefix(&self.inner) {
-            Some(prefix) => {
+            Some((pre_prefix_len, prefix)) => {
                 prefix.hash(h);
-                (prefix.len(), prefix.is_verbatim())
+                (prefix.len() + pre_prefix_len, prefix.is_verbatim())
             }
             None => (0, false),
         };
@@ -3615,6 +3639,9 @@ impl Error for NormalizeError {}
 /// paths, this is currently equivalent to calling
 /// [`GetFullPathNameW`][windows-path].
 ///
+/// On Cygwin, this is currently equivalent to calling [`cygwin_conv_path`][cygwin-path]
+/// with mode `CCP_WIN_A_TO_POSIX`.
+///
 /// Note that these [may change in the future][changes].
 ///
 /// # Errors
@@ -3667,11 +3694,36 @@ impl Error for NormalizeError {}
 /// # fn main() {}
 /// ```
 ///
+/// ## Cygwin paths
+///
+/// ```
+/// # #[cfg(target_os = "cygwin")]
+/// fn main() -> std::io::Result<()> {
+///     use std::path::{self, Path};
+///
+///     // Relative to absolute
+///     let absolute = path::absolute("foo/./bar")?;
+///     assert!(absolute.ends_with(r"foo/bar"));
+///
+///     // Windows absolute to absolute
+///     let absolute = path::absolute(r"C:\foo//test\..\./bar.rs")?;
+///     assert!(absolute.ends_with("/c/foo/bar.rs"));
+///
+///     // POSIX absolute to absolute
+///     let absolute = path::absolute("/foo//test/.././bar.rs")?;
+///     assert_eq!(absolute, Path::new("/foo//test/.././bar.rs"));
+///     Ok(())
+/// }
+/// # #[cfg(not(target_os = "cygwin"))]
+/// # fn main() {}
+/// ```
+///
 /// Note that this [may change in the future][changes].
 ///
 /// [changes]: io#platform-specific-behavior
 /// [posix-semantics]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13
 /// [windows-path]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfullpathnamew
+/// [cygwin-path]: https://cygwin.com/cygwin-api/func-cygwin-conv-path.html
 #[stable(feature = "absolute_path", since = "1.79.0")]
 pub fn absolute<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
     let path = path.as_ref();

library/std/src/sys/path/cygwin.rs

@@ -0,0 +1,65 @@
+use crate::ffi::OsString;
+use crate::os::unix::ffi::OsStringExt;
+use crate::path::{Path, PathBuf};
+use crate::sys::common::small_c_string::run_path_with_cstr;
+use crate::sys::cvt;
+use crate::{io, ptr};
+
+#[inline]
+pub fn is_sep_byte(b: u8) -> bool {
+    b == b'/' || b == b'\\'
+}
+
+/// Cygwin allways prefers `/` over `\`, and it always converts all `/` to `\`
+/// internally when calling Win32 APIs. Therefore, the server component of path
+/// `\\?\UNC\localhost/share` is `localhost/share` on Win32, but `localhost`
+/// on Cygwin.
+#[inline]
+pub fn is_verbatim_sep(b: u8) -> bool {
+    b == b'/' || b == b'\\'
+}
+
+pub use super::windows_prefix::parse_prefix;
+
+pub const MAIN_SEP_STR: &str = "/";
+pub const MAIN_SEP: char = '/';
+
+unsafe extern "C" {
+    // Doc: https://cygwin.com/cygwin-api/func-cygwin-conv-path.html
+    // Src: https://github.com/cygwin/cygwin/blob/718a15ba50e0d01c79800bd658c2477f9a603540/winsup/cygwin/path.cc#L3902
+    // Safety:
+    // * `what` should be `CCP_WIN_A_TO_POSIX` here
+    // * `from` is null-terminated UTF-8 path
+    // * `to` is buffer, the buffer size is `size`.
+    //
+    // Converts a path to an absolute POSIX path, no matter the input is Win32 path or POSIX path.
+    fn cygwin_conv_path(
+        what: libc::c_uint,
+        from: *const libc::c_char,
+        to: *mut u8,
+        size: libc::size_t,
+    ) -> libc::ssize_t;
+}
+
+const CCP_WIN_A_TO_POSIX: libc::c_uint = 2;
+
+/// Make a POSIX path absolute.
+pub(crate) fn absolute(path: &Path) -> io::Result<PathBuf> {
+    run_path_with_cstr(path, &|path| {
+        let conv = CCP_WIN_A_TO_POSIX;
+        let size = cvt(unsafe { cygwin_conv_path(conv, path.as_ptr(), ptr::null_mut(), 0) })?;
+        // If success, size should not be 0.
+        debug_assert!(size >= 1);
+        let size = size as usize;
+        let mut buffer = Vec::with_capacity(size);
+        cvt(unsafe { cygwin_conv_path(conv, path.as_ptr(), buffer.as_mut_ptr(), size) })?;
+        unsafe {
+            buffer.set_len(size - 1);
+        }
+        Ok(PathBuf::from(OsString::from_vec(buffer)))
+    })
+}
+
+pub(crate) fn is_absolute(path: &Path) -> bool {
+    path.has_root()
+}

library/std/src/sys/path/mod.rs

@@ -1,6 +1,7 @@
 cfg_if::cfg_if! {
     if #[cfg(target_os = "windows")] {
         mod windows;
+        mod windows_prefix;
         pub use windows::*;
     } else if #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] {
         mod sgx;
@@ -11,6 +12,10 @@ cfg_if::cfg_if! {
     } else if #[cfg(target_os = "uefi")] {
         mod uefi;
         pub use uefi::*;
+    } else if #[cfg(target_os = "cygwin")] {
+        mod cygwin;
+        mod windows_prefix;
+        pub use cygwin::*;
     } else {
         mod unix;
         pub use unix::*;

library/std/src/sys/path/sgx.rs

@@ -13,7 +13,7 @@ pub fn is_verbatim_sep(b: u8) -> bool {
     b == b'/'
 }
 
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
+pub fn parse_prefix(_: &OsStr) -> Option<(usize, Prefix<'_>)> {
     None
 }
 

library/std/src/sys/path/uefi.rs

@@ -17,7 +17,7 @@ pub fn is_verbatim_sep(b: u8) -> bool {
     b == b'\\'
 }
 
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
+pub fn parse_prefix(_: &OsStr) -> Option<(usize, Prefix<'_>)> {
     None
 }
 

library/std/src/sys/path/unix.rs

@@ -13,7 +13,7 @@ pub fn is_verbatim_sep(b: u8) -> bool {
 }
 
 #[inline]
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
+pub fn parse_prefix(_: &OsStr) -> Option<(usize, Prefix<'_>)> {
     None
 }
 

library/std/src/sys/path/unsupported_backslash.rs

@@ -14,7 +14,7 @@ pub fn is_verbatim_sep(b: u8) -> bool {
     b == b'\\'
 }
 
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
+pub fn parse_prefix(_: &OsStr) -> Option<(usize, Prefix<'_>)> {
     None
 }