[API Implementation]: SafeFileHandle overloads for SetCreationTime, SetLastAccessTime, SetLastWriteTime

src/libraries/Common/src/Interop/OSX/Interop.libc.cs

@@ -27,5 +27,22 @@ internal struct AttrList
         internal static unsafe partial int setattrlist(string path, AttrList* attrList, void* attrBuf, nint attrBufSize, CULong options);
 
         internal const uint FSOPT_NOFOLLOW = 0x00000001;
+        [LibraryImport(Libraries.libc, EntryPoint = "fsetattrlist", SetLastError = true)]
+        private static unsafe partial int fsetattrlist(int fd, AttrList* attrList, void* attrBuf, nint attrBufSize, CULong options);
+
+        internal static unsafe int fsetattrlist(SafeHandle handle, AttrList* attrList, void* attrBuf, nint attrBufSize, CULong options)
+        {
+            bool refAdded = false;
+            try
+            {
+                handle.DangerousAddRef(ref refAdded);
+                return fsetattrlist(handle.DangerousGetHandle().ToInt32(), attrList, attrBuf, attrBufSize, options);
+            }
+            finally
+            {
+                if (refAdded)
+                    handle.DangerousRelease();
+            }
+        }
     }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.LChflags.cs

@@ -17,6 +17,9 @@ internal enum UserFlags : uint
         [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_LChflags", StringMarshalling = StringMarshalling.Utf8, SetLastError = true)]
         internal static partial int LChflags(string path, uint flags);
 
+        [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_FChflags", SetLastError = true)]
+        internal static partial int FChflags(SafeHandle fd, uint flags);
+
         internal static readonly bool CanSetHiddenFlag = (LChflagsCanSetHiddenFlag() != 0);
 
         [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_LChflagsCanSetHiddenFlag")]

src/libraries/Common/src/Interop/Unix/System.Native/Interop.UTimensat.cs

@@ -24,5 +24,8 @@ internal struct TimeSpec
         /// </returns>
         [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_UTimensat", StringMarshalling = StringMarshalling.Utf8, SetLastError = true)]
         internal static unsafe partial int UTimensat(string path, TimeSpec* times);
+
+        [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_FUTimens", SetLastError = true)]
+        internal static unsafe partial int FUTimens(SafeHandle fd, TimeSpec* times);
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.BY_HANDLE_FILE_INFORMATION.cs

@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct BY_HANDLE_FILE_INFORMATION
+        {
+            internal uint dwFileAttributes;
+            internal FILE_TIME ftCreationTime;
+            internal FILE_TIME ftLastAccessTime;
+            internal FILE_TIME ftLastWriteTime;
+            internal uint dwVolumeSerialNumber;
+            internal uint nFileSizeHigh;
+            internal uint nFileSizeLow;
+            internal uint nNumberOfLinks;
+            internal uint nFileIndexHigh;
+            internal uint nFileIndexLow;
+        }
+    }
+}

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GetFileInformationByHandle.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool GetFileInformationByHandle(SafeFileHandle hFile, out BY_HANDLE_FILE_INFORMATION lpFileInformation);
+    }
+}

src/libraries/System.IO.FileSystem/tests/Base/AllGetSetAttributes.cs

@@ -25,12 +25,14 @@ public void InvalidParameters()
         [Theory, MemberData(nameof(TrailingCharacters))]
         public void SetAttributes_MissingFile(char trailingChar)
         {
+            if (!CanBeReadOnly) return;
             Assert.Throws<FileNotFoundException>(() => SetAttributes(GetTestFilePath() + trailingChar, FileAttributes.ReadOnly));
         }
 
         [Theory, MemberData(nameof(TrailingCharacters))]
         public void SetAttributes_MissingDirectory(char trailingChar)
         {
+            if (!CanBeReadOnly) return;
             Assert.Throws<DirectoryNotFoundException>(() => SetAttributes(Path.Combine(GetTestFilePath(), "file" + trailingChar), FileAttributes.ReadOnly));
         }
 

src/libraries/System.IO.FileSystem/tests/Base/BaseGetSetAttributes.cs

@@ -7,6 +7,7 @@ namespace System.IO.Tests
 {
     public abstract class BaseGetSetAttributes : FileSystemTest
     {
+        protected abstract bool CanBeReadOnly { get; }
         protected abstract FileAttributes GetAttributes(string path);
         protected abstract void SetAttributes(string path, FileAttributes attributes);
 

src/libraries/System.IO.FileSystem/tests/Base/BaseGetSetTimes.cs

@@ -28,6 +28,9 @@ public abstract class BaseGetSetTimes<T> : FileSystemTest
 
         protected abstract T CreateSymlink(string path, string pathToTarget);
 
+        // When the item is a link, indicates whether the .NET API will get/set the link itself, or its target. 
+        protected virtual bool ApiTargetsLink => true;
+
         protected T CreateSymlinkToItem(T item)
         {
             // Creates a Symlink to 'item' (target may or may not exist)
@@ -37,6 +40,7 @@ protected T CreateSymlinkToItem(T item)
 
         protected abstract string GetItemPath(T item);
 
+        // requiresRoundtripping defines whether to convert DateTimeFormat 'a' to 'b' and then back to 'a' to verify the DateTimeFormat-conversion
         public abstract IEnumerable<TimeFunction> TimeFunctions(bool requiresRoundtripping = false);
 
         public class TimeFunction : Tuple<SetTime, GetTime, DateTimeKind>
@@ -52,17 +56,27 @@ public static TimeFunction Create(SetTime setter, GetTime getter, DateTimeKind k
             public SetTime Setter => Item1;
             public GetTime Getter => Item2;
             public DateTimeKind Kind => Item3;
+
+            public override string ToString()
+            {
+                return $"TimeFunction DateTimeKind.{Kind} Setter: {Setter.Method.Name} Getter: {Getter.Method.Name}";
+            }
         }
 
-        private void SettingUpdatesPropertiesCore(T item)
+        private void SettingUpdatesPropertiesCore(T item, T? linkTarget = default)
         {
             Assert.All(TimeFunctions(requiresRoundtripping: true), (function) =>
             {
+                bool isLink = linkTarget is not null;
+
                 // Checking that milliseconds are not dropped after setter.
                 // Emscripten drops milliseconds in Browser
                 DateTime dt = new DateTime(2014, 12, 1, 12, 3, 3, LowTemporalResolution ? 0 : 321, function.Kind);
                 function.Setter(item, dt);
-                DateTime result = function.Getter(item);
+
+                T getTarget = !isLink || ApiTargetsLink ? item : linkTarget;
+                DateTime result = function.Getter(getTarget);
+
                 Assert.Equal(dt, result);
                 Assert.Equal(dt.ToLocalTime(), result.ToLocalTime());
 
@@ -102,7 +116,7 @@ public void SettingUpdatesPropertiesWhenReadOnly()
         [PlatformSpecific(~TestPlatforms.Browser)] // Browser is excluded as it doesn't support symlinks
         [InlineData(false)]
         [InlineData(true)]
-        public void SettingUpdatesPropertiesOnSymlink(bool targetExists)
+        public void SettingPropertiesOnSymlink(bool targetExists)
         {
             // This test is in this class since it needs all of the time functions.
             // This test makes sure that the times are set on the symlink itself.
@@ -119,25 +133,37 @@ public void SettingUpdatesPropertiesOnSymlink(bool targetExists)
             T link = CreateSymlinkToItem(target);
             if (!targetExists)
             {
-                SettingUpdatesPropertiesCore(link);
+                // Don't check when settings update the target.
+                if (ApiTargetsLink)
+                {
+                    SettingUpdatesPropertiesCore(link, target);
+                }
             }
             else
             {
-                // Get the target's initial times
-                IEnumerable<TimeFunction> timeFunctions = TimeFunctions(requiresRoundtripping: true);
-                DateTime[] initialTimes = timeFunctions.Select((funcs) => funcs.Getter(target)).ToArray();
+                // When properties update link, verify the target properties don't change.
+                IEnumerable<TimeFunction>? timeFunctions = null;
+                DateTime[]? initialTimes = null;
+                if (ApiTargetsLink)
+                {
+                    timeFunctions = TimeFunctions(requiresRoundtripping: true);
+                    initialTimes = timeFunctions.Select((funcs) => funcs.Getter(target)).ToArray();
+                }
 
-                SettingUpdatesPropertiesCore(link);
+                SettingUpdatesPropertiesCore(link, target);
 
-                // Ensure that we have the latest times.
-                if (target is FileSystemInfo fsi)
+                // Ensure target properties haven't changed.
+                if (ApiTargetsLink)
                 {
-                    fsi.Refresh();
+                    // Ensure that we have the latest times.
+                    if (target is FileSystemInfo fsi)
+                    {
+                        fsi.Refresh();
+                    }
+
+                    DateTime[] updatedTimes = timeFunctions.Select((funcs) => funcs.Getter(target)).ToArray();
+                    Assert.Equal(initialTimes, updatedTimes);
                 }
-
-                // Ensure the target's times haven't changed.
-                DateTime[] updatedTimes = timeFunctions.Select((funcs) => funcs.Getter(target)).ToArray();
-                Assert.Equal(initialTimes, updatedTimes);
             }
         }
 

src/libraries/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs

@@ -8,14 +8,21 @@ namespace System.IO.Tests
     // Tests that are valid for File and FileInfo
     public abstract class FileGetSetAttributes : BaseGetSetAttributes
     {
-        [Theory]
-        [InlineData(FileAttributes.ReadOnly)]
-        [InlineData(FileAttributes.Normal)]
+        [Fact]
         [PlatformSpecific(TestPlatforms.AnyUnix)]
-        public void SettingAttributes_Unix(FileAttributes attributes)
+        public void SettingAttributes_Unix_Normal()
         {
             string path = CreateItem();
-            AssertSettingAttributes(path, attributes);
+            AssertSettingAttributes(path, FileAttributes.Normal);
+        }
+
+        [Fact]
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        public void SettingAttributes_Unix_ReadOnly()
+        {
+            if (!CanBeReadOnly) return;
+            string path = CreateItem();
+            AssertSettingAttributes(path, FileAttributes.ReadOnly);
         }
 
         [Theory]
@@ -28,20 +35,29 @@ public void SettingAttributes_OSXAndFreeBSD(FileAttributes attributes)
         }
 
         [Theory]
-        [InlineData(FileAttributes.ReadOnly)]
         [InlineData(FileAttributes.Hidden)]
         [InlineData(FileAttributes.System)]
         [InlineData(FileAttributes.Archive)]
         [InlineData(FileAttributes.Normal)]
         [InlineData(FileAttributes.Temporary)]
-        [InlineData(FileAttributes.ReadOnly | FileAttributes.Hidden)]
         [PlatformSpecific(TestPlatforms.Windows)]
         public void SettingAttributes_Windows(FileAttributes attributes)
         {
             string path = CreateItem();
             AssertSettingAttributes(path, attributes);
         }
 
+        [Theory]
+        [InlineData(FileAttributes.ReadOnly)]
+        [InlineData(FileAttributes.ReadOnly | FileAttributes.Hidden)]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        public void SettingAttributes_Windows_ReadOnly(FileAttributes attributes)
+        {
+            if (!CanBeReadOnly) return;
+            string path = CreateItem();
+            AssertSettingAttributes(path, attributes);
+        }
+
         private void AssertSettingAttributes(string path, FileAttributes attributes)
         {
             SetAttributes(path, attributes);

src/libraries/System.IO.FileSystem/tests/DirectoryInfo/GetSetAttributes.cs

@@ -15,6 +15,7 @@ protected override string CreateItem(string path = null, [CallerMemberName] stri
         protected override DirectoryInfo CreateInfo(string path) => new DirectoryInfo(path);
         protected override void DeleteItem(string path) => Directory.Delete(path);
         protected override bool IsDirectory => true;
+        protected override bool CanBeReadOnly => true;
 
         [Theory]
         [InlineData(FileAttributes.ReadOnly)]

src/libraries/System.IO.FileSystem/tests/File/GetSetAttributes.cs

@@ -9,6 +9,7 @@ public class File_GetSetAttributes : BaseGetSetAttributes
     {
         protected override FileAttributes GetAttributes(string path) => File.GetAttributes(path);
         protected override void SetAttributes(string path, FileAttributes attributes) => File.SetAttributes(path, attributes);
+        protected override bool CanBeReadOnly => false;
 
         // Getting only throws for File, not FileInfo
         [Theory, MemberData(nameof(TrailingCharacters))]

src/libraries/System.IO.FileSystem/tests/File/GetSetAttributes_SafeFileHandle.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class GetSetAttributes_SafeFileHandle : FileGetSetAttributes
+    {
+        protected virtual SafeFileHandle OpenFileHandle(string path, FileAccess fileAccess) =>
+            File.OpenHandle(
+                path,
+                FileMode.OpenOrCreate,
+                fileAccess,
+                FileShare.None);
+
+        protected override bool CanBeReadOnly => false;
+
+        protected override FileAttributes GetAttributes(string path)
+        {
+            using SafeFileHandle fileHandle = OpenFileHandle(path, FileAccess.Read);
+            return File.GetAttributes(fileHandle);
+        }
+
+        protected override void SetAttributes(string path, FileAttributes attributes)
+        {
+            using SafeFileHandle fileHandle = OpenFileHandle(path, FileAccess.ReadWrite);
+            File.SetAttributes(fileHandle, attributes);
+        }
+
+        [Fact]
+        public void NullArgumentValidation()
+        {
+            Assert.Throws<ArgumentNullException>("fileHandle", static () => File.GetAttributes(default(SafeFileHandle)!));
+            Assert.Throws<ArgumentNullException>("fileHandle", static () => File.SetAttributes(default(SafeFileHandle)!, (FileAttributes)0));
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/File/GetSetAttributesCommon.cs → src/libraries/System.IO.FileSystem/tests/File/GetSetAttributes_String.cs

@@ -4,9 +4,10 @@
 namespace System.IO.Tests
 {
     // Concrete class to run common file attributes tests on the File class
-    public class File_GetSetAttributesCommon : FileGetSetAttributes
+    public sealed class File_GetSetAttributes_String : FileGetSetAttributes
     {
         protected override FileAttributes GetAttributes(string path) => File.GetAttributes(path);
         protected override void SetAttributes(string path, FileAttributes attributes) => File.SetAttributes(path, attributes);
+        protected override bool CanBeReadOnly => true;
     }
 }