std::Path parses UNC with forward slashes incorrectly on x86_64-pc-cygwin

[briansmith]

in briansmith/ring#2730 (comment), @500-internal-server-error wrote:

This code:

fn  main() {
   println!("{:?}", std::path::Path::new("//server/path").components());
}

prints Components([RootDir, Normal("server"), Normal("path")]) on x86_64-pc-cygwin and x86_64-unknown-linux-gnu but Components([Prefix(PrefixComponent { raw: "//server/path", parsed: UNC("server", "path") }), RootDir]) on x86_64-pc-windows-gnu. However, the Cygwin runtime will treat it like a Windows UNC path. So it's probably the Rust std::path implementation for Cygwin that is wrong/incomplete.

rustc -vV:

rustc 1.94.0 (4a4ef493e 2026-03-02) (Rev4, Built by MSYS2 project)
binary: rustc
commit-hash: 4a4ef493e3a1488c6e321570238084b38948f6db
commit-date: 2026-03-02
host: x86_64-pc-cygwin
release: 1.94.0
LLVM version: 21.1.8

Interestingly, It seems to parse the backslash form like Windows, which seems like a bug as well; presumably Cygwin shouldn't be accepting backslashes as a path separator.

I noticed that it processes the input r#"//foo/bar"# correctly!

Reading the source code, I speculate that this is related to the 8-byte "prefix" buffer In the prefix parser, as "//server/path" has the third slash as the 9th byte whereas "//foo/bar" has it within 8 bytes.

Edit: I misread the test results. r#"//foo/bar"# is also parsed incorrectly.

Here are several test vectors that you are happy to modify and incorporate under the standard Apache/MIT license. Note that these tests are actually testing a wrapper that replaces path separators with '/' so they can't be used as-is, but these tests are what found the issue.

Details

#[test]
fn join_components_with_forward_slashes_tests() {
    struct Case {
        input: &'static str,
        expected: &'static str,
    }
    const VALID_TEST_CASES: &[Case] = &[
        Case {
            input: r#"/"#,
            expected: "/",
        },
        Case {
            input: r#"//"#,
            expected: "/",
        },
        Case {
            input: r#"\"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "/"
            } else {
                r#"\"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "/"
            } else {
                r#"\\"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "/foo"
            } else {
                r#"\\foo"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\foo\bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//foo/bar/" // UNC with implied root
            } else {
                r#"\\foo\bar"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"//foo"#,
            expected: "/foo", // Redundant slash removed.
        },
        Case {
            input: r#"//foo/bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//foo/bar/" // UNC with implied root
            } else {
                "/foo/bar"
            },
        },
        Case {
            input: r#"\\server\share"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC with implied root
            } else {
                r#"\\server\share"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\server\share\"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC
            } else {
                r#"\\server\share\"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\server\share\foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo" // UNC
            } else {
                r#"\\server\share\foo"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"\\server\share\foo\bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                r#"\\server\share\foo\bar"# // Backslash not interpreted as a separator
            },
        },
        Case {
            // XXX: trailing slash stripped
            input: r#"\\server\share\foo\bar\"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                r#"\\server\share\foo\bar\"# // Backslash not interpreted as a separator
            },
        },
        Case {
            input: r#"//server/share"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC with implied root
            } else {
                r#"/server/share"# // Redundant slash removed.
            },
        },
        Case {
            input: r#"//server/share/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC
            } else {
                r#"/server/share"# // Redundant slash removed. XXX: trailing slash stripped.
            },
        },
        Case {
            input: r#"//server/share/foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo" // UNC
            } else {
                // Redundant slash removed.
                "/server/share/foo"
            },
        },
        Case {
            input: r#"//server/share/foo/bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                r#"/server/share/foo/bar"#
            }, // Redundant slash removed.
        },
        Case {
            // XXX: trailing slash stripped
            input: r#"//server/share/foo/bar/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                r#"/server/share/foo/bar"# // Redundant slash removed.
            },
        },
        Case {
            input: r#"//server\share"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC with implied root
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server\share"#
            },
        },
        Case {
            input: r#"//server\share/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                // XXX: trailing slash stripped.
                r#"/server\share"#
            },
        },
        Case {
            input: r#"//server\share/foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server\share/foo"#
            },
        },
        Case {
            input: r#"//server\share/foo/bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server\share/foo/bar"#
            },
        },
        Case {
            // XXX: trailing slash stripped
            input: r#"//server\share/foo/bar/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server\share/foo/bar"#
            },
        },
        Case {
            input: r#"\\server\share"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC with implied root
            } else {
                // Backslash not interpreted as a separator.
                r#"\\server\share"#
            },
        },
        Case {
            input: r#"\\server\share/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC
            } else {
                // Backslash not interpreted as a separator.
                // XXX: trailing slash stripped.
                r#"\\server\share"#
            },
        },
        Case {
            input: r#"\\server\share/foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo" // UNC
            } else {
                // Backslash not interpreted as a separator.
                r#"\\server\share/foo"#
            },
        },
        Case {
            input: r#"\\server\share/foo/bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                // Backslash not interpreted as a separator.
                r#"\\server\share/foo/bar"#
            },
        },
        Case {
            // XXX: trailing slash stripped
            input: r#"\\server\share/foo/bar/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                // Backslash not interpreted as a separator.
                r#"\\server\share/foo/bar"#
            },
        },
        Case {
            input: r#"//server/share\"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server/share\"#
            },
        },
        Case {
            input: r#"//server/share\foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server/share\foo"#
            },
        },
        Case {
            input: r#"//server/share/foo\bar"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar" // UNC
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server/share/foo\bar"#
            },
        },
        Case {
            // XXX: trailing slash stripped
            input: r#"//server/share\foo/bar/"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "//server/share/foo/bar"
            } else {
                // Redundant slash removed. Backslash not interpreted as a separator.
                r#"/server/share\foo/bar"#
            },
        },
        Case {
            input: r#"C:foo"#,
            expected: "C:foo",
        },
        Case {
            input: r#"C:\foo"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "C:/foo"
            } else {
                r#"C:\foo"# // Backslash not interpreted as a separator.
            },
        },
        Case {
            input: r#"C:/foo"#,
            expected: "C:/foo",
        },
        Case {
            input: r#"a\b"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "a/b"
            } else {
                r#"a\b"# // Backslash not interpreted as a separator.
            },
        },
        Case {
            input: r#"/a/b"#,
            expected: "/a/b",
        },
        Case {
            input: r#"\a\b"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "/a/b"
            } else {
                r#"\a\b"# // Backslash not interpreted as a separator.
            },
        },
        Case {
            input: r#".\b"#,
            expected: if TARGET_SUPPORTS_UNCS_AND_BACKSLASHES {
                "./b"
            } else {
                r#".\b"# // Backslash not interpreted as a separator.
            },
        },
        Case {
            input: r#"../b"#,
            expected: "../b",
        },
        Case {
            input: r#"a/../b"#,
            expected: "a/../b",
        },
        Case {
            // XXX: Trailing slash is skipped.
            input: r#"a/./b/"#,
            expected: "a/b",
        },
    ];

    let failures = VALID_TEST_CASES
        .iter()
        .filter_map(|Case { input, expected }| {
            let actual = join_components_with_forward_slashes(Path::new(input)).unwrap();
            if actual == AsRef::<OsStr>::as_ref(expected) {
                None
            } else {
                Some((input, actual, expected))
            }
        })
        .collect::<Vec<_>>();
    assert_eq!(failures, &[]);
}

[briansmith]

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

Line 8 in 9e0a42c

path_separator_bytes!(b'/', b'\\');

backslash isn't a path separator on Cygwin, right?

[briansmith]

Here are the inputs we found were parsed incorrectly as non-UNC paths when they should be parsed as UNC paths:

• "//foo/bar"
• "//server/share"
• "//server/share/"
• "//server/share/foo"
• "//server/share/foo/bar"
• "//server/share/foo/bar/".

Earlier I wrote:

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

Line 8 in 9e0a42c

path_separator_bytes!(b'/', b'\');
backslash isn't a path separator on Cygwin, right?

I guess that because Cygwin is going to internally just replace all forward slashes with backslashes before passing the path to Windows, then it will effectively treat backslashes as a path separator, so I guess that part isn't a bug.

[500-internal-server-error]

backslash isn't a path separator on Cygwin, right?

Apparently it is, various tools, e.g., ls, stat, etc. accept it, as do CRT functions, e.g., stat(), etc.

[500-internal-server-error]

Some notes on regarding leading // on Unix systems:

• POSIX.1-2024
• gnulib notes

[500-internal-server-error]

CC platform maintainer: @Berrysoft

[Berrysoft]

It was intended because actually UNC paths and POSIX paths violate on these rules. The current logic is:

• A path without \ is a POSIX path. //server/share is /server/share (in component view, it starts with root /; in string view, it starts with //, and it's still a UNC path).
• A path with at least one \ is a Win32 path. //server/share\foo.txt is \\server\share\foo.txt.
  • However, an invalid UNC path is treated as a POSIX path. \\server is /server.
• A path with a driver letter is of course a Win32 path.

I have to admit that the logic is very annoying. Different APIs of Cygwin don't agree with each other, and it doesn't have to be the same as Win32. I had a hard time to verify these logic through reading the source code of Cygwin and testing the paths with C code (usually with cygwin_conv_path). But I might be wrong on some corner cases.

When you're speaking on the path supports, please try ... For example, a UNC path should treat the root as \\server\share, so pushing ..\foo won't make it as \\server\foo. However, IIRC, Cygwin programs seemed to treat //server/share/../foo the same as //server/foo. That's why I didn't parse it as a UNC path.

Related tests:

rust/library/std/tests/path.rs

Line 1116 in 44e6620

pub fn test_decompositions_cygwin() {

[Berrysoft]

@500-internal-server-error If you want to make a cygwin path without backslashes, I would suggest using std::path::absolute. It calls cygwin_conv_path and converts all Win32 paths to POSIX ones.

[500-internal-server-error]

The original goal was to turn all paths into forward slashes, something like, cygpath -m, turning C:\path\to\somewhere into C:/path/to/somewhere. The original logic also turned /path/to/somewhere into //path/to/somewhere, which works fine on Linux, but not on Cygwin. Trying to fix this issue ran into UNC problems.

[Berrysoft]

Well, you see, turning C:\path into /c/path is also valid on Cygwin, so I think std::path::absolute fits this work well. It calls the Cygwin API and should behave exactly the same as cygpath -u. And you're right, //path/to/somewhere doesn't work fine on Cygwin.

EDIT: cygpath -m is not possible through APIs. You have to determine if it is a Win32 path yourself.