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.Formats.Tar/src/System/Formats/Tar/TarEntry.Unix.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using Microsoft.Win32.SafeHandles;
+using System.IO;
 
 namespace System.Formats.Tar
 {
@@ -53,7 +54,9 @@ partial void SetModeOnFile(SafeFileHandle handle, string destinationFileName)
  // If the permissions weren't set at all, don't write the file's permissions.
  if (permissions != 0)
  {
- Interop.CheckIo(Interop.Sys.FChMod(handle, permissions), destinationFileName);
+#pragma warning disable CA1416 // Validate platform compatibility
+ File.SetUnixFileMode(handle, (UnixFileMode)permissions);
+#pragma warning disable CA1416
  }
  }
  }

src/libraries/System.IO.Compression.ZipFile/src/System/IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.Unix.cs

@@ -22,7 +22,9 @@ static partial void ExtractExternalAttributes(FileStream fs, ZipArchiveEntry ent
  // include the permissions, or was made on Windows.
  if (permissions != 0)
  {
- Interop.CheckIo(Interop.Sys.FChMod(fs.SafeFileHandle, permissions), fs.Name);
+#pragma warning disable CA1416 // Validate platform compatibility
+ File.SetUnixFileMode(fs.SafeFileHandle, (UnixFileMode)permissions);
+#pragma warning restore CA1416
  }
  }
  }

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));
+ }
+ }
+ }
+}