Implemented PermissionsExt to Windows and added some file attribute private methods in FilePermissions struct (to be decided in PR whether to use or remove)

Author: asder8215

library/std/src/os/windows/fs.rs

@@ -357,6 +357,95 @@ impl OpenOptionsExt for OpenOptions {
     }
 }
 
+/// Windows-specific extensions to [`fs::Permissions`].
+/// # Examples
+///
+/// ```no_run
+/// use std::fs::{File, Permissions};
+/// use std::io::{ErrorKind, Result as IoResult};
+/// use std::os::windows::fs::PermissionsExt;
+///
+/// fn main() -> IoResult<()> {
+///     let name = "test_file_for_permissions";
+///
+///     // make sure file does not exist
+///     let _ = std::fs::remove_file(name);
+///     assert_eq!(
+///         File::open(name).unwrap_err().kind(),
+///         ErrorKind::NotFound,
+///         "file already exists"
+///     );
+///
+///     // readonly and hidden file attributes that we
+///     // want to add to existing file
+///     let my_file_attr = 0x1 | 0x2;
+///
+///     // create new file with specified permissions
+///     {
+///         let file = File::create(name)?;
+///         let mut permissions = file.metadata()?.permissions();
+///         eprintln!("Current file attributes: {:o}", permissions.file_attributes());
+///
+///         // make sure new permissions are not already set
+///         assert!(
+///             permissions.file_attributes() & my_file_attr != my_file_attr,
+///             "file attributes already set"
+///         );
+///
+///         // or use `set_file_attributes` to construct a new Permissions struct
+///         permissions = Permissions::set_file_attributes(permissions.file_attributes() | my_file_attr);
+///
+///         // write new permissions to file
+///         file.set_permissions(permissions)?;
+///     }
+///
+///     let permissions = File::open(name)?.metadata()?.permissions();
+///     eprintln!("New file attributes: {:o}", permissions.mode());
+///
+///     // assert new file attributes were set
+///     assert_eq!(
+///         permissions.mode() & my_file_attr,
+///         my_file_attr,
+///         "new file attributes not set"
+///     );
+///     Ok(())
+/// }
+/// ```
+///
+/// ```no_run
+/// use std::fs::Permissions;
+/// use std::os::windows::fs::PermissionsExt;
+///
+/// // system and archive file attributes
+/// let my_file_attr = 0x4 | 0x20;
+/// let mut permissions = Permissions::set_file_attributes(my_file_attr);
+/// assert_eq!(permissions.mode(), my_file_attr);
+/// ```
+pub trait PermissionsExt: Sealed {
+    /// Returns the file attribute bits.
+    #[unstable(feature = "windows_permissions_ext", issue = "152956")]
+    fn file_attributes(&self) -> u32;
+
+    // QUESTION: Should this be renamed as from_file_attributes()?
+    // and modify the signature of set_file_attributes() to take a
+    // &mut self like how unix uses `set_mode()`?
+    // (Note to self: if we do the above, I need to make changes to
+    // the doc comments).
+    /// Sets the file attribute bits.
+    #[unstable(feature = "windows_permissions_ext", issue = "152956")]
+    fn set_file_attributes(mask: u32) -> Self;
+}
+
+impl PermissionsExt for fs::Permissions {
+    fn file_attributes(&self) {
+        self.as_inner().attrs()
+    }
+
+    fn set_file_attributes(mask: u32) -> Self {
+        Permissions::from_inner(FromInner::from_inner(mask))
+    }
+}
+
 /// Windows-specific extensions to [`fs::Metadata`].
 ///
 /// The data members that this trait exposes correspond to the members

library/std/src/sys/fs/windows.rs

@@ -1162,11 +1162,266 @@ impl FilePermissions {
 
     pub fn set_readonly(&mut self, readonly: bool) {
         if readonly {
-            self.attrs |= c::FILE_ATTRIBUTE_READONLY;
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_READONLY;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_READONLY;
+            }
         } else {
             self.attrs &= !c::FILE_ATTRIBUTE_READONLY;
         }
     }
+
+    fn hidden(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_HIDDEN != 0
+    }
+
+    fn set_hidden(&self, hidden: bool) {
+        if hidden {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_HIDDEN;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_HIDDEN;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_HIDDEN;
+        }
+    }
+
+    fn system(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_SYSTEM != 0
+    }
+
+    fn set_system(&self, system: bool) {
+        if system {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_SYSTEM;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_SYSTEM;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_SYSTEM;
+        }
+    }
+
+    fn archive(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_ARCHIVE != 0
+    }
+
+    fn set_archive(&self, archive: bool) {
+        if archive {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_ARCHIVE;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_ARCHIVE;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_ARCHIVE;
+        }
+    }
+
+    // This file attribute is only valid when used alone
+    // There should be no other file attribute set.
+    fn normal(&self) -> bool {
+        self.attrs == c::FILE_ATTRIBUTE_NORMAL
+    }
+
+    // According to Microsoft docs here:
+    // https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+    // This file attribute is valid only when used alone.
+    // The SetFileAttributes seems to recognize this as a
+    // reset/zero out flag.
+    fn set_normal(&self, normal: bool) {
+        self.attrs = c::FILE_ATTRIBUTE_NORMAL;
+    }
+
+    fn temporary(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_TEMPORARY != 0
+    }
+
+    fn set_temporary(&self, temporary: bool) {
+        if temporary {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_TEMPORARY;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_TEMPORARY;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_TEMPORARY;
+        }
+    }
+
+    fn offline(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_OFFLINE != 0
+    }
+
+    fn set_offline(&self, offline: bool) {
+        if offline {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_OFFLINE;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_OFFLINE;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_OFFLINE;
+        }
+    }
+
+    fn not_content_indexed(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_OFFLINE != 0
+    }
+
+    fn set_not_content_indexed(&self, not_content_indexed: bool) {
+        if not_content_indexed {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+        }
+    }
+
+    // This flag is not supported until Windows 8 and Windows Server 2012
+    // (not supported on Windows Server 2008 R2, Windows 7, Windows Server 2008,
+    // Windows Vista, Windows Server 2003 and Windows XP)
+    fn integrity_stream(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_INTEGRITY_STREAM != 0
+    }
+
+    // This flag is not supported until Windows 8 and Windows Server 2012
+    // (not supported on Windows Server 2008 R2, Windows 7, Windows Server 2008,
+    // Windows Vista, Windows Server 2003 and Windows XP)
+    fn set_integrity_stream(&self, integrity_stream: bool) {
+        if integrity_stream {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_INTEGRITY_STREAM;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_INTEGRITY_STREAM;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_INTEGRITY_STREAM;
+        }
+    }
+
+    // This flag is not supported until Windows 8 and Windows Server 2012
+    // (not supported on Windows Server 2008 R2, Windows 7, Windows Server 2008,
+    // Windows Vista, Windows Server 2003 and Windows XP)
+    fn no_scrub_data(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_NO_SCRUB_DATA != 0
+    }
+
+    // This flag is not supported until Windows 8 and Windows Server 2012
+    // (not supported on Windows Server 2008 R2, Windows 7, Windows Server 2008,
+    // Windows Vista, Windows Server 2003 and Windows XP)
+    fn set_no_scrub_data(&self, no_scrub_data: bool) {
+        if integrity_stream {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_NO_SCRUB_DATA;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_NO_SCRUB_DATA;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_NO_SCRUB_DATA;
+        }
+    }
+
+    // This flag was introduced in Windows 10, version 1703
+    fn pinned(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_PINNED != 0
+    }
+
+    // This flag was introduced in Windows 10, version 1703
+    fn set_pinned(&self, pinned: bool) {
+        if pinned {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_PINNED;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_PINNED;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_PINNED;
+        }
+    }
+
+    // This flag was introduced in Windows 10, version 1703
+    fn unpinned(&self) -> bool {
+        self.attrs & c::FILE_ATTRIBUTE_UNPINNED != 0
+    }
+
+    // This flag was introduced in Windows 10, version 1703
+    fn set_unpinned(&self, unpinned: bool) {
+        if unpinned {
+            // According to SetFileAttributes, any other values
+            // passed to this should override FILE_ATTRIBUTE_NORMAL
+            if self.normal() {
+                self.attrs = c::FILE_ATTRIBUTE_UNPINNED;
+            } else {
+                self.attrs |= c::FILE_ATTRIBUTE_UNPINNED;
+            }
+        } else {
+            self.attrs &= !c::FILE_ATTRIBUTE_UNPINNED;
+        }
+    }
+
+    // We don't have a FILE_ATTRIBUTE_STRICTLY_SEQUENTIAL (aka "SMR Blob")
+    // flag yet in `std/src/sys/pal/windows/c/windows_sys.rs`
+    // This is a flag that is settable by `attrib` command on Windows
+    // Note that this attribute was introduced in Windows 10, version unsure
+    // Also see
+    // - http://justsolve.archiveteam.org/wiki/DOS/Windows_file_attributes
+    // - https://superuser.com/questions/44812/windows-explorers-file-attribute-column-values
+    // fn strictly_sequential(&self) -> bool {
+    //     self.attrs & c::FILE_ATTRIBUTE_STRICTLY_SEQUENTIAL != 0
+    // }
+
+    // fn set_strictly_sequential(&self, pinned: bool) {
+    //     if pinned {
+    //         // According to SetFileAttributes, any other values
+    //         // passed to this should override FILE_ATTRIBUTE_NORMAL
+    //         if self.normal() {
+    //             self.attrs = c::FILE_ATTRIBUTE_STRICTLY_SEQUENTIAL;
+    //         } else {
+    //             self.attrs |= c::FILE_ATTRIBUTE_STRICTLY_SEQUENTIAL;
+    //         }
+    //     } else {
+    //         self.attrs &= !c::FILE_ATTRIBUTE_STRICTLY_SEQUENTIAL;
+    //     }
+    // }
+
+    // No set_recall_on_data_access because that's settable only by the
+    // OS (e.g. OneDrive filter driver)
+    // No encrypted, compressed, device, etc. setter attributes because
+    // reasons mentioned here: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfileattributesa
+    // However, should we have methods that sees if these attributes
+    // are set?
+}
+
+impl FromInner<u32> for FilePermissions {
+    fn from_inner(attr: u32) -> FilePermissions {
+        FilePermissions { attr }
+    }
 }
 
 impl FileTimes {