Implement UnixFileMode APIs

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -276,8 +276,6 @@
              Link="Common\Interop\Unix\System.Native\Interop.Access.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Stat.cs"
              Link="Common\Interop\Unix\Interop.Stat.cs" />
-    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Permissions.cs"
-             Link="Common\Interop\Unix\Interop.Permissions.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetEUid.cs"
              Link="Common\Interop\Unix\Interop.GetEUid.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.IsMemberOfGroup.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -763,10 +763,12 @@ private static bool IsExecutable(string fullPath)
                 return false;
             }
 
-            Interop.Sys.Permissions permissions = ((Interop.Sys.Permissions)fileinfo.Mode) & Interop.Sys.Permissions.S_IXUGO;
+            const UnixFileMode allExecute = UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute;
+
+            UnixFileMode permissions = ((UnixFileMode)fileinfo.Mode) & allExecute;
 
             // Avoid checking user/group when permission.
-            if (permissions == Interop.Sys.Permissions.S_IXUGO)
+            if (permissions == allExecute)
             {
                 return true;
             }
@@ -785,11 +787,11 @@ private static bool IsExecutable(string fullPath)
             if (euid == fileinfo.Uid)
             {
                 // We own the file.
-                return (permissions & Interop.Sys.Permissions.S_IXUSR) != 0;
+                return (permissions & UnixFileMode.UserExecute) != 0;
             }
 
-            bool groupCanExecute = (permissions & Interop.Sys.Permissions.S_IXGRP) != 0;
-            bool otherCanExecute = (permissions & Interop.Sys.Permissions.S_IXOTH) != 0;
+            bool groupCanExecute = (permissions & UnixFileMode.GroupExecute) != 0;
+            bool otherCanExecute = (permissions & UnixFileMode.OtherExecute) != 0;
 
             // Avoid group check when group and other have same permissions.
             if (groupCanExecute == otherCanExecute)

src/libraries/System.Formats.Tar/src/System.Formats.Tar.csproj

@@ -59,7 +59,6 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.FChMod.cs" Link="Common\Interop\Unix\System.Native\Interop.FChMod.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Link.cs" Link="Common\Interop\Unix\System.Native\Interop.Link.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.MkFifo.cs" Link="Common\Interop\Unix\System.Native\Interop.MkFifo.cs" />
-    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Permissions.cs" Link="Common\Interop\Unix\Interop.Permissions.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Stat.cs" Link="Common\Interop\Unix\Interop.Stat.cs" />
     <Compile Include="$(CommonPath)System\IO\Archiving.Utils.Unix.cs" Link="Common\System\IO\Archiving.Utils.Unix.cs" />
   </ItemGroup>

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

@@ -59,7 +59,15 @@ public void SymLinksReflectSymLinkAttributes()
             try
             {
                 Assert.Equal(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(path));
-                Assert.NotEqual(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(linkPath));
+                if (OperatingSystem.IsWindows())
+                {
+                    Assert.NotEqual(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(linkPath));   
+                }
+                else
+                {
+                    // On Unix, Get/SetAttributes FileAttributes.ReadOnly operates on the target of the link.
+                    Assert.Equal(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(linkPath));   
+                }
             }
             finally
             {

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

@@ -0,0 +1,217 @@
+// 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.CompilerServices;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public abstract class BaseGetSetUnixFileMode : FileSystemTest
+    {
+        protected abstract UnixFileMode GetMode(string path);
+        protected abstract void SetMode(string path, UnixFileMode mode);
+
+        // When false, the Get API returns (UnixFileMode)(-1) when the file doesn't exist.
+        protected virtual bool GetThrowsWhenDoesntExist => false;
+
+        // The FileSafeHandle APIs require a readable file to open the handle.
+        protected virtual bool GetModeNeedsReadableFile => false;
+
+        // When false, the Get API returns (UnixFileMode)(-1) when the platform is not supported (Windows).
+        protected virtual bool GetModeThrowsPNSE => true;
+
+        // Determines if the derived Test class is for directories or files.
+        protected virtual bool IsDirectory => false;
+
+        // On OSX, directories created under /tmp have same group as /tmp.
+        // Because that group is different from the test user's group, chmod
+        // returns EPERM when trying to setgid on directories, and for files
+        // chmod filters out the bit.
+        // We skip the tests with setgid.
+        private bool CanSetGroup => !PlatformDetection.IsBsdLike;
+
+        private string CreateTestItem(string path = null, [CallerMemberName] string memberName = null, [CallerLineNumber] int lineNumber = 0)
+        {
+            path = path ?? GetTestFilePath(null, memberName, lineNumber);
+            if (IsDirectory)
+            {
+                Directory.CreateDirectory(path);
+            }
+            else
+            {
+                File.Create(path).Dispose();
+            }
+            return path;
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void Get()
+        {
+            string path = CreateTestItem();
+
+            UnixFileMode mode = GetMode(path); // Doesn't throw.
+
+            Assert.NotEqual((UnixFileMode)(-1), mode);
+
+            UnixFileMode required = UnixFileMode.UserRead | UnixFileMode.UserWrite;
+            if (IsDirectory)
+            {
+                required = UnixFileMode.UserExecute;
+            }
+            Assert.True((mode & required) == required);
+
+            if (!PlatformDetection.IsBrowser)
+            {
+                // The umask should prevent this file from being writable by others.
+                Assert.Equal(UnixFileMode.None, mode & UnixFileMode.OtherWrite);
+            }
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix & ~TestPlatforms.Browser)]
+        [Theory]
+        [MemberData(nameof(TestUnixFileModes))]
+        public void SetThenGet(UnixFileMode mode)
+        {
+            if (!CanSetGroup && (mode & UnixFileMode.SetGroup) != 0)
+            {
+                return; // Skip
+            }
+            if (GetModeNeedsReadableFile)
+            {
+                // Ensure the file remains readable.
+                mode |= UnixFileMode.UserRead;
+            }
+
+            string path = CreateTestItem();
+
+            SetMode(path, mode);
+
+            Assert.Equal(mode, GetMode(path));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix & ~TestPlatforms.Browser)]
+        [Theory]
+        [MemberData(nameof(TestUnixFileModes))]
+        public void SetThenGet_SymbolicLink(UnixFileMode mode)
+        {
+            if (!CanSetGroup && (mode & UnixFileMode.SetGroup) != 0)
+            {
+                return; // Skip
+            }
+            if (GetModeNeedsReadableFile)
+            {
+                // Ensure the file remains readable.
+                mode |= UnixFileMode.UserRead;
+            }
+
+            string path = CreateTestItem();
+
+            string linkPath = GetTestFilePath();
+            File.CreateSymbolicLink(linkPath, path);
+
+            SetMode(linkPath, mode);
+
+            Assert.Equal(mode, GetMode(linkPath));
+            Assert.Equal(mode, GetMode(path));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void FileDoesntExist()
+        {
+            string path = GetTestFilePath();
+
+            if (GetThrowsWhenDoesntExist)
+            {
+                Assert.Throws<FileNotFoundException>(() => GetMode(path));
+            }
+            else
+            {
+                Assert.Equal((UnixFileMode)(-1), GetMode(path));
+            }
+            Assert.Throws<FileNotFoundException>(() => SetMode(path, AllAccess));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void FileDoesntExist_SymbolicLink()
+        {
+            string path = GetTestFilePath();
+            string linkPath = GetTestFilePath();
+            File.CreateSymbolicLink(linkPath, path);
+
+            Assert.Throws<FileNotFoundException>(() => SetMode(linkPath, AllAccess));
+
+            if (GetThrowsWhenDoesntExist)
+            {
+                Assert.Throws<FileNotFoundException>(() => GetMode(path));
+            }
+            else
+            {
+                Assert.Equal((UnixFileMode)(-1), GetMode(path));
+            }
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void ParentDirDoesntExist()
+        {
+            string path = Path.Combine(GetTestFilePath(), "dir", "file");
+
+            if (GetThrowsWhenDoesntExist)
+            {
+                Assert.Throws<DirectoryNotFoundException>(() => GetMode(path));
+            }
+            else
+            {
+                Assert.Equal((UnixFileMode)(-1), GetMode(path));
+            }
+            Assert.Throws<DirectoryNotFoundException>(() => SetMode(path, AllAccess));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void NullPath()
+        {
+            Assert.Throws<ArgumentNullException>(() => GetMode(null));
+            Assert.Throws<ArgumentNullException>(() => SetMode(null, AllAccess));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Fact]
+        public void InvalidPath()
+        {
+            Assert.Throws<ArgumentException>(() => GetMode(string.Empty));
+            Assert.Throws<ArgumentException>(() => SetMode(string.Empty, AllAccess));
+        }
+
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
+        [Theory]
+        [InlineData((UnixFileMode)(1 << 12))]
+        public void InvalidMode(UnixFileMode mode)
+        {
+            string path = CreateTestItem();
+
+            Assert.Throws<ArgumentException>(() => SetMode(path, mode));
+        }
+
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [Fact]
+        public void Unsupported()
+        {
+            string path = CreateTestItem();
+
+            Assert.Throws<PlatformNotSupportedException>(() => SetMode(path, AllAccess));
+
+            if (GetModeThrowsPNSE)
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => GetMode(path));
+            }
+            else
+            {
+                Assert.Equal((UnixFileMode)(-1), GetMode(path));
+            }
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory_UnixFileMode.Unix.cs

@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class CreateDirectoryWithUnixFileMode : Directory_CreateDirectory
+    {
+        // Runs base class tests using CreateDirectory method that takes a UnixFileMode.
+        public override DirectoryInfo Create(string path)
+        {
+            return Directory.CreateDirectory(path, AllAccess);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestUnixFileModes))]
+        public void CreateWithUnixFileMode(UnixFileMode mode)
+        {
+            string path = GetRandomDirPath();
+            DirectoryInfo di = Directory.CreateDirectory(path, mode);
+
+            // under Linux the created directory gets mode (mode & ~umask & 01777).
+            // under OSX, it gets (mode & ~umask & 0777).
+            UnixFileMode platformFilter = UnixFileMode.SetGroup | UnixFileMode.SetUser | (PlatformDetection.IsBsdLike ? UnixFileMode.StickyBit : UnixFileMode.None);
+            UnixFileMode expectedMode = mode & ~GetUmask() & ~platformFilter;
+            Assert.Equal(expectedMode, di.UnixFileMode);
+        }
+
+        [Fact]
+        public void CreateDoesntChangeExistingMode()
+        {
+            string path = GetRandomDirPath();
+            DirectoryInfo di = Directory.CreateDirectory(path, AllAccess);
+            UnixFileMode initialMode = di.UnixFileMode;
+
+            DirectoryInfo di2 = Directory.CreateDirectory(path, UnixFileMode.UserRead);
+            Assert.Equal(initialMode, di2.UnixFileMode);
+        }
+
+        [Theory]
+        [InlineData((UnixFileMode)(1 << 12), false)]
+        [InlineData((UnixFileMode)(1 << 12), true)]
+        public void InvalidModeThrows(UnixFileMode mode, bool alreadyExists)
+        {
+            string path = GetRandomDirPath();
+
+            if (alreadyExists)
+            {
+                Directory.CreateDirectory(path);
+            }
+
+            Assert.Throws<ArgumentException>(() => Directory.CreateDirectory(path, mode));
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory_UnixFileMode.Windows.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class CreateDirectoryWithUnixFileMode : FileSystemTest
+    {
+        [Fact]
+        public void NotSupported()
+        {
+            string path = GetRandomDirPath();
+            Assert.Throws<PlatformNotSupportedException>(() => Directory.CreateDirectory(path, UnixFileMode.UserRead));
+        }
+    }
+}