Ensure that Dir::metadata etc. return full metadata values.

Use windows-by-handle functionality when we have it, or do a manual open
if we don't.

Author: sunfishcode

cap-primitives/src/windows/fs/metadata_ext.rs

@@ -67,8 +67,25 @@ impl MetadataExt {
     ///
     /// [`std::fs::Metadata::volume_serial_number`]: https://doc.rust-lang.org/std/os/windows/fs/trait.MetadataExt.html#tymethod.volume_serial_number
     #[inline]
+    #[allow(unused_mut)]
     pub(crate) fn from_just_metadata(std: &fs::Metadata) -> Self {
-        Self::from_parts(std, None, None, None)
+        let (mut volume_serial_number, mut number_of_links, mut file_index) = (None, None, None);
+
+        #[cfg(windows_by_handle)]
+        {
+            use std::os::windows::fs::MetadataExt;
+            if let Some(some) = std.volume_serial_number() {
+                volume_serial_number = Some(some);
+            }
+            if let Some(some) = std.number_of_links() {
+                number_of_links = Some(some);
+            }
+            if let Some(some) = std.file_index() {
+                file_index = Some(some);
+            }
+        }
+
+        Self::from_parts(std, volume_serial_number, number_of_links, file_index)
     }
 
     #[inline]

cap-primitives/src/windows/fs/stat_unchecked.rs

@@ -1,17 +1,49 @@
+#[cfg(windows_by_handle)]
 use super::get_path::concatenate_or_return_absolute;
 use crate::fs::{FollowSymlinks, Metadata};
 use std::{fs, io, path::Path};
+use winapi::um::winbase::{FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT};
+#[cfg(not(windows_by_handle))]
+use {
+    crate::fs::{open_unchecked, OpenOptions},
+    std::os::windows::fs::OpenOptionsExt,
+};
 
 /// *Unsandboxed* function similar to `stat`, but which does not perform sandboxing.
 pub(crate) fn stat_unchecked(
     start: &fs::File,
     path: &Path,
     follow: FollowSymlinks,
 ) -> io::Result<Metadata> {
-    let full_path = concatenate_or_return_absolute(start, path)?;
-    match follow {
-        FollowSymlinks::Yes => fs::metadata(full_path),
-        FollowSymlinks::No => fs::symlink_metadata(full_path),
+    // When we have `windows_by_handle`, we just call `fs::metadata` etc. and it
+    // has everything.
+    #[cfg(windows_by_handle)]
+    {
+        let full_path = concatenate_or_return_absolute(start, path)?;
+        match follow {
+            FollowSymlinks::Yes => fs::metadata(full_path),
+            FollowSymlinks::No => fs::symlink_metadata(full_path),
+        }
+        .map(Metadata::from_just_metadata)
+    }
+
+    // Otherwise, attempt to open the file to get the metadata that way, as
+    // that gives us all the info.
+    #[cfg(not(windows_by_handle))]
+    {
+        let mut opts = OpenOptions::new();
+        opts.access_mode(0);
+        match follow {
+            FollowSymlinks::Yes => {
+                opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS);
+                opts.follow(FollowSymlinks::Yes);
+            }
+            FollowSymlinks::No => {
+                opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
+                opts.follow(FollowSymlinks::No);
+            }
+        }
+        let file = open_unchecked(start, path, &opts)?;
+        Metadata::from_file(&file)
     }
-    .map(Metadata::from_just_metadata)
 }

tests/metadata-ext.rs

@@ -3,8 +3,8 @@
 #[macro_use]
 mod sys_common;
 
-use cap_fs_ext::MetadataExt;
-use sys_common::io::tmpdir;
+use cap_fs_ext::{DirExt, MetadataExt};
+use sys_common::{io::tmpdir, symlink_supported};
 
 #[test]
 fn test_metadata_ext() {
@@ -14,6 +14,10 @@ fn test_metadata_ext() {
     let tmpdir_metadata = check!(tmpdir.dir_metadata());
     let a_metadata = check!(a.metadata());
     let b_metadata = check!(b.metadata());
+    let a_dir_metadata = check!(tmpdir.metadata("a"));
+    let b_dir_metadata = check!(tmpdir.metadata("b"));
+    let a_symlink_metadata = check!(tmpdir.symlink_metadata("a"));
+    let b_symlink_metadata = check!(tmpdir.symlink_metadata("b"));
 
     // The directory and files inside it should be on the same device.
     assert_eq!(tmpdir_metadata.dev(), a_metadata.dev());
@@ -32,4 +36,49 @@ fn test_metadata_ext() {
     check!(tmpdir.hard_link("b", &tmpdir, "c"));
     let b_metadata = check!(b.metadata());
     assert_eq!(b_metadata.nlink(), 2);
+
+    // Check that the metadata has dev/nlink/ino.
+    tmpdir_metadata.dev();
+    tmpdir_metadata.nlink();
+    tmpdir_metadata.ino();
+    a_metadata.dev();
+    a_metadata.nlink();
+    a_metadata.ino();
+    b_metadata.dev();
+    b_metadata.nlink();
+    b_metadata.ino();
+    a_dir_metadata.dev();
+    a_dir_metadata.nlink();
+    a_dir_metadata.ino();
+    b_dir_metadata.dev();
+    b_dir_metadata.nlink();
+    b_dir_metadata.ino();
+    a_symlink_metadata.dev();
+    a_symlink_metadata.nlink();
+    a_symlink_metadata.ino();
+    b_symlink_metadata.dev();
+    b_symlink_metadata.nlink();
+    b_symlink_metadata.ino();
+
+    if symlink_supported() {
+        check!(DirExt::symlink_file(&*tmpdir, "b", "d"));
+        let d_metadata = check!(tmpdir.metadata("d"));
+        let d_symlink_metadata = check!(tmpdir.symlink_metadata("d"));
+
+        d_metadata.dev();
+        d_metadata.nlink();
+        d_metadata.ino();
+        d_symlink_metadata.dev();
+        d_symlink_metadata.nlink();
+        d_symlink_metadata.ino();
+
+        assert_ne!(
+            (d_symlink_metadata.ino(), d_symlink_metadata.dev()),
+            (b_metadata.ino(), b_metadata.dev())
+        );
+        assert_eq!(
+            (d_metadata.ino(), d_metadata.dev()),
+            (b_metadata.ino(), b_metadata.dev())
+        );
+    }
 }