Implement UnixFileMode APIs

src/libraries/Common/src/System/IO/FileSystem.DirectoryCreation.Windows.cs

@@ -13,6 +13,11 @@ namespace System.IO
 {
     internal static partial class FileSystem
     {
+        public static void CreateDirectory(string fullPath, UnixFileMode unixCreateMode)
+        {
+            throw new PlatformNotSupportedException(SR.PlatformNotSupported_UnixFileMode);
+        }
+
         public static unsafe void CreateDirectory(string fullPath, byte[]? securityDescriptor = null)
         {
             // We can save a bunch of work if the directory we want to create already exists.  This also

src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs

@@ -11,6 +11,29 @@ namespace Microsoft.Win32.SafeHandles
 {
     public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
     {
+        private const UnixFileMode PermissionMask =
+            UnixFileMode.UserRead |
+            UnixFileMode.UserWrite |
+            UnixFileMode.UserExecute |
+            UnixFileMode.GroupRead |
+            UnixFileMode.GroupWrite |
+            UnixFileMode.GroupExecute |
+            UnixFileMode.OtherRead |
+            UnixFileMode.OtherWrite |
+            UnixFileMode.OtherExecute;
+
+        // If the file gets created a new, we'll select the permissions for it.  Most Unix utilities by default use 666 (read and
+        // write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
+        // a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
+        // actual permissions will typically be less than what we select here.
+        internal const UnixFileMode DefaultCreateMode =
+            UnixFileMode.UserRead |
+            UnixFileMode.UserWrite |
+            UnixFileMode.GroupRead |
+            UnixFileMode.GroupWrite |
+            UnixFileMode.OtherRead |
+            UnixFileMode.OtherWrite;
+
         internal static bool DisableFileLocking { get; } = OperatingSystem.IsBrowser() // #40065: Emscripten does not support file locking
             || AppContextConfigHelper.GetBooleanConfig("System.IO.DisableFileLocking", "DOTNET_SYSTEM_IO_DISABLEFILELOCKING", defaultValue: false);
 
@@ -164,35 +187,23 @@ public override bool IsInvalid
             }
         }
 
-        // If the file gets created a new, we'll select the permissions for it.  Most Unix utilities by default use 666 (read and
-        // write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
-        // a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
-        // actual permissions will typically be less than what we select here.
-        private const Interop.Sys.Permissions DefaultOpenPermissions =
-                Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR |
-                Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP |
-                Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH;
-
         // Specialized Open that returns the file length and permissions of the opened file.
         // This information is retrieved from the 'stat' syscall that must be performed to ensure the path is not a directory.
-        internal static SafeFileHandle OpenReadOnly(string fullPath, FileOptions options, out long fileLength, out Interop.Sys.Permissions filePermissions)
+        internal static SafeFileHandle OpenReadOnly(string fullPath, FileOptions options, out long fileLength, out UnixFileMode filePermissions)
         {
-            SafeFileHandle handle = Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read, options, preallocationSize: 0, DefaultOpenPermissions, out fileLength, out filePermissions, null);
+            SafeFileHandle handle = Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read, options, preallocationSize: 0, DefaultCreateMode, out fileLength, out filePermissions, null);
             Debug.Assert(fileLength >= 0);
             return handle;
         }
 
-        internal static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize,
-                                            Interop.Sys.Permissions openPermissions = DefaultOpenPermissions,
+        internal static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize, UnixFileMode? unixCreateMode = null,
                                             Func<Interop.ErrorInfo, Interop.Sys.OpenFlags, string, Exception?>? createOpenException = null)
         {
-            return Open(fullPath, mode, access, share, options, preallocationSize, openPermissions, out _, out _, createOpenException);
+            return Open(fullPath, mode, access, share, options, preallocationSize, unixCreateMode ?? DefaultCreateMode, out _, out _, createOpenException);
         }
 
-        private static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize,
-                                            Interop.Sys.Permissions openPermissions,
-                                            out long fileLength,
-                                            out Interop.Sys.Permissions filePermissions,
+        private static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize, UnixFileMode openPermissions,
+                                            out long fileLength, out UnixFileMode filePermissions,
                                             Func<Interop.ErrorInfo, Interop.Sys.OpenFlags, string, Exception?>? createOpenException = null)
         {
             // Translate the arguments into arguments for an open call.
@@ -305,7 +316,7 @@ private static Interop.Sys.OpenFlags PreOpenConfigurationFromOptions(FileMode mo
         }
 
         private bool Init(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize,
-                          out long fileLength, out Interop.Sys.Permissions filePermissions)
+                          out long fileLength, out UnixFileMode filePermissions)
         {
             Interop.Sys.FileStatus status = default;
             bool statusHasValue = false;
@@ -334,7 +345,7 @@ private bool Init(string path, FileMode mode, FileAccess access, FileShare share
                 }
 
                 fileLength = status.Size;
-                filePermissions = (Interop.Sys.Permissions)(status.Mode & (int)Interop.Sys.Permissions.Mask);
+                filePermissions = (UnixFileMode)(status.Mode & (int)PermissionMask);
             }
 
             IsAsync = (options & FileOptions.Asynchronous) != 0;

src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs

@@ -35,8 +35,10 @@ internal bool TryGetCachedLength(out long cachedLength)
             return _lengthCanBeCached && cachedLength >= 0;
         }
 
-        internal static unsafe SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        internal static unsafe SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize, UnixFileMode? unixCreateMode = null)
         {
+            Debug.Assert(!unixCreateMode.HasValue);
+
             using (DisableMediaInsertionPrompt.Create())
             {
                 // we don't use NtCreateFile as there is no public and reliable way

src/libraries/System.Private.CoreLib/src/Resources/Strings.resx

@@ -3088,6 +3088,9 @@
   <data name="PlatformNotSupported_StrongNameSigning" xml:space="preserve">
     <value>Strong-name signing is not supported on this platform.</value>
   </data>
+  <data name="PlatformNotSupported_UnixFileMode" xml:space="preserve">
+    <value>Unix file modes are not supported on this platform.</value>
+  </data>
   <data name="PlatformNotSupported_OverlappedIO" xml:space="preserve">
     <value>This API is specific to the way in which Windows handles asynchronous I/O, and is not supported on this platform.</value>
   </data>
@@ -3748,6 +3751,9 @@
   <data name="Arg_InvalidFileAttrs" xml:space="preserve">
     <value>Invalid File or Directory attributes value.</value>
   </data>
+  <data name="Arg_InvalidUnixFileMode" xml:space="preserve">
+    <value>Invalid UnixFileMode value.</value>
+  </data>
   <data name="Arg_Path2IsRooted" xml:space="preserve">
     <value>Second path fragment must not be a drive or UNC name.</value>
   </data>

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -461,6 +461,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\StringWriter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\TextReader.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\TextWriter.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\UnixFileMode.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\UnmanagedMemoryAccessor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\UnmanagedMemoryStream.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\UnmanagedMemoryStreamWrapper.cs" />

src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Enumeration;
+using System.Runtime.Versioning;
 
 namespace System.IO
 {
@@ -34,6 +35,18 @@ public static DirectoryInfo CreateDirectory(string path)
             return new DirectoryInfo(path, fullPath, isNormalized: true);
         }
 
+        [UnsupportedOSPlatform("windows")]
+        public static DirectoryInfo CreateDirectory(string path, UnixFileMode unixCreateMode)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            string fullPath = Path.GetFullPath(path);
+
+            FileSystem.CreateDirectory(fullPath, unixCreateMode);
+
+            return new DirectoryInfo(path, fullPath, isNormalized: true);
+        }
+
         // Tests if the given path refers to an existing DirectoryInfo on disk.
         public static bool Exists([NotNullWhen(true)] string? path)
         {

src/libraries/System.Private.CoreLib/src/System/IO/File.cs

@@ -220,6 +220,22 @@ public static FileAttributes GetAttributes(string path)
         public static void SetAttributes(string path, FileAttributes fileAttributes)
             => FileSystem.SetAttributes(Path.GetFullPath(path), fileAttributes);
 
+        [UnsupportedOSPlatform("windows")]
+        public static UnixFileMode GetUnixFileMode(string path)
+            => FileSystem.GetUnixFileMode(Path.GetFullPath(path));
+
+        [UnsupportedOSPlatform("windows")]
+        public static UnixFileMode GetUnixFileMode(SafeFileHandle fileHandle)
+            => FileSystem.GetUnixFileMode(fileHandle);
+
+        [UnsupportedOSPlatform("windows")]
+        public static void SetUnixFileMode(string path, UnixFileMode mode)
+            => FileSystem.SetUnixFileMode(Path.GetFullPath(path), mode);
+
+        [UnsupportedOSPlatform("windows")]
+        public static void SetUnixFileMode(SafeFileHandle fileHandle, UnixFileMode mode)
+            => FileSystem.SetUnixFileMode(fileHandle, mode);
+
         public static FileStream OpenRead(string path)
             => new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
 

src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.Unix.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
 
 namespace System.IO
 {
@@ -399,6 +400,47 @@ internal long GetLength(ReadOnlySpan<char> path, bool continueOnError = false)
             return EntryExists ? _fileCache.Size : 0;
         }
 
+        internal UnixFileMode GetUnixFileMode(ReadOnlySpan<char> path, bool continueOnError = false)
+            => GetUnixFileMode(handle: null, path, continueOnError);
+
+        internal UnixFileMode GetUnixFileMode(SafeFileHandle handle, bool continueOnError = false)
+            => GetUnixFileMode(handle, handle.Path, continueOnError);
+
+        private UnixFileMode GetUnixFileMode(SafeFileHandle? handle, ReadOnlySpan<char> path, bool continueOnError = false)
+        {
+            EnsureCachesInitialized(handle, path, continueOnError);
+
+            if (!EntryExists)
+                return (UnixFileMode)(-1);
+
+            return (UnixFileMode)(_fileCache.Mode & (int)FileSystem.ValidUnixFileModes);
+        }
+
+        internal void SetUnixFileMode(string path, UnixFileMode mode)
+            => SetUnixFileMode(handle: null, path, mode);
+
+        internal void SetUnixFileMode(SafeFileHandle handle, UnixFileMode mode)
+            => SetUnixFileMode(handle, handle.Path, mode);
+
+        private void SetUnixFileMode(SafeFileHandle? handle, string? path, UnixFileMode mode)
+        {
+            if ((mode & ~FileSystem.ValidUnixFileModes) != 0)
+            {
+                throw new ArgumentException(SR.Arg_InvalidUnixFileMode, "UnixFileMode");
+            }
+
+            EnsureCachesInitialized(handle, path);
+
+            if (!EntryExists)
+                FileSystemInfo.ThrowNotFound(path);
+
+            int rv = handle is not null ? Interop.Sys.FChMod(handle, (int)mode) :
+                                          Interop.Sys.ChMod(path!, (int)mode);
+            Interop.CheckIo(rv, path);
+
+            InvalidateCaches();
+        }
+
         // Tries to refresh the lstat cache (_fileCache).
         // This method should not throw. Instead, we store the results, and we will throw when the user attempts to access any of the properties when there was a failure
         internal void RefreshCaches(ReadOnlySpan<char> path)

src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs

@@ -203,14 +203,14 @@ public FileStream(string path, FileStreamOptions options)
             FileStreamHelpers.SerializationGuard(options.Access);
 
             _strategy = FileStreamHelpers.ChooseStrategy(
-                this, path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize);
+                this, path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize, options.UnixCreateMode);
         }
 
         private FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
         {
             FileStreamHelpers.ValidateArguments(path, mode, access, share, bufferSize, options, preallocationSize);
 
-            _strategy = FileStreamHelpers.ChooseStrategy(this, path, mode, access, share, bufferSize, options, preallocationSize);
+            _strategy = FileStreamHelpers.ChooseStrategy(this, path, mode, access, share, bufferSize, options, preallocationSize, unixCreateMode: null);
         }
 
         [Obsolete("FileStream.Handle has been deprecated. Use FileStream's SafeFileHandle property instead.")]

src/libraries/System.Private.CoreLib/src/System/IO/FileStreamOptions.cs

@@ -1,6 +1,8 @@
 // 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.Versioning;
+
 namespace System.IO
 {
     public sealed class FileStreamOptions
@@ -11,6 +13,7 @@ public sealed class FileStreamOptions
         private FileOptions _options;
         private long _preallocationSize;
         private int _bufferSize = FileStream.DefaultBufferSize;
+        private UnixFileMode? _unixCreateMode;
 
         /// <summary>
         /// One of the enumeration values that determines how to open or create the file.
@@ -109,5 +112,31 @@ public int BufferSize
             get => _bufferSize;
             set => _bufferSize = value >= 0 ? value : throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_NeedNonNegNum);
         }
+
+        /// <summary>
+        /// Unix file mode used when a new file is created.
+        /// </summary>
+        public UnixFileMode? UnixCreateMode
+        {
+            get
+            {
+                return _unixCreateMode;
+            }
+            [UnsupportedOSPlatform("windows")]
+            set
+            {
+                if (OperatingSystem.IsWindows())
+                {
+                    throw new PlatformNotSupportedException(SR.PlatformNotSupported_UnixFileMode);
+                }
+
+                if (value.HasValue && ((value & ~FileSystem.ValidUnixFileModes) != 0))
+                {
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
+                }
+
+                _unixCreateMode = value;
+            }
+        }
     }
 }