Get Unix file stats with LStat (instead of Stat)

Stat was ignoring symbolic links (and getting stats for the target instead) which caused checks for whether or not a path was a sym link to fail on Unix. Fixes dotnet/corefx#5015
dotnet · Jan 14, 2016 · 75dedd7 · 75dedd7
1 parent 628384e
commit 75dedd7
Show file tree

Hide file tree

Showing 7 changed files with 76 additions and 34 deletions.
diff --git a/src/Common/tests/System/IO/FileCleanupTestBase.cs b/src/Common/tests/System/IO/FileCleanupTestBase.cs
@@ -62,19 +62,6 @@ protected string GetTestFilePath(int? index = null, [CallerMemberName] string me
             return Path.Combine(TestDirectory, GetTestFileName(index, memberName, lineNumber));
         }
 
-        /// <summary>
-        /// Creates a non-empty file
-        /// </summary>
-        /// <param name="path">Path to create the file at</param>
-        protected void CreateNonEmptyFile(string path, int fileSize)
-        {
-            using (var fs = File.Create(path))
-            {
-                var testData = new byte[fileSize];
-                fs.Write(testData, 0, testData.Length);
-            }
-        }
-
         /// <summary>Gets a test file name that is associated with the call site.</summary>
         /// <param name="index">An optional index value to use as a suffix on the file name.  Typically a loop index.</param>
         /// <param name="memberName">The member name of the function calling this method.</param>

diff --git a/src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs b/src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs
@@ -43,8 +43,8 @@ public override void CopyFile(string sourceFullPath, string destFullPath, bool o
             }
 
             // Now copy over relevant read/write/execute permissions from the source to the destination
-            Interop.Sys.FileStatus status;
             // Use Stat (not LStat) since permissions for symbolic links are meaninless and defer to permissions on the target
+            Interop.Sys.FileStatus status;
             Interop.CheckIo(Interop.Sys.Stat(sourceFullPath, out status), sourceFullPath);
             int newMode = status.Mode & (int)Interop.Sys.Permissions.Mask;
             Interop.CheckIo(Interop.Sys.ChMod(destFullPath, newMode), destFullPath);

diff --git a/src/System.IO.FileSystem/tests/File/GetSetAttributes.cs b/src/System.IO.FileSystem/tests/File/GetSetAttributes.cs
@@ -102,24 +102,29 @@ public void WindowsInvalidAttributes(FileAttributes attr)
             Assert.Equal(FileAttributes.Normal, Get(path));
         }
 
-        [Fact]
+        // In some cases (such as when running without elevated privileges,
+        // the symbolic link may fail to create. Only run this test if it creates
+        // links successfully.
+        [ConditionalFact("CanCreateSymbolicLinks")]
         public void SymLinksAreReparsePoints()
         {
             var path = GetTestFilePath();
             var linkPath = GetTestFilePath();
             File.Create(path).Dispose();
-            MountHelper.CreateSymbolicLink(linkPath, path);
-
+            Assert.True(MountHelper.CreateSymbolicLink(linkPath, path));
             Assert.Equal(FileAttributes.ReparsePoint, FileAttributes.ReparsePoint & Get(linkPath));
         }
 
-        [Fact]
+        // In some cases (such as when running without elevated privileges,
+        // the symbolic link may fail to create. Only run this test if it creates
+        // links successfully.
+        [ConditionalFact("CanCreateSymbolicLinks")]
         public void SymLinksDoNotReflectTargetAttributes()
         {
             var path = GetTestFilePath();
             var linkPath = GetTestFilePath();
             File.Create(path).Dispose();
-            MountHelper.CreateSymbolicLink(linkPath, path);
+            Assert.True(MountHelper.CreateSymbolicLink(linkPath, path));
 
             Set(path, FileAttributes.ReadOnly);
 
@@ -130,5 +135,18 @@ public void SymLinksDoNotReflectTargetAttributes()
             Assert.Equal(FileAttributes.ReparsePoint, FileAttributes.ReparsePoint & Get(linkPath));
             Assert.Equal((FileAttributes)0, FileAttributes.ReadOnly & Get(linkPath));
         }
+
+        private static bool CanCreateSymbolicLinks
+        {
+            get
+            {
+                var path = Path.GetTempFileName();
+                var linkPath = path + ".link";
+                var ret = MountHelper.CreateSymbolicLink(linkPath, path);
+                try { File.Delete(path); } catch { }
+                try { File.Delete(linkPath); } catch { }
+                return ret;
+            }
+        }
     }
 }
diff --git a/src/System.IO.FileSystem/tests/FileInfo/Exists.cs b/src/System.IO.FileSystem/tests/FileInfo/Exists.cs
@@ -80,19 +80,35 @@ public void FalseForDirectory()
             Assert.False(di.Exists);
         }
 
-        [Fact]
+        // In some cases (such as when running without elevated privileges,
+        // the symbolic link may fail to create. Only run this test if it creates
+        // links successfully.
+        [ConditionalFact("CanCreateSymbolicLinks")]
         public void SymLinksExistIndependentlyOfTarget()
         {
             var path = GetTestFilePath();
             var linkPath = GetTestFilePath();
             File.Create(path).Dispose();
-            MountHelper.CreateSymbolicLink(linkPath, path);
+            Assert.True(MountHelper.CreateSymbolicLink(linkPath, path));
             File.Delete(path);
 
             var info = new FileInfo(path);
             var linkInfo = new FileInfo(linkPath);
             Assert.True(linkInfo.Exists);
             Assert.False(info.Exists);
         }
+
+        private static bool CanCreateSymbolicLinks
+        {
+            get
+            {
+                var path = Path.GetTempFileName();
+                var linkPath = path + ".link";
+                var ret = MountHelper.CreateSymbolicLink(linkPath, path);
+                try { File.Delete(path); } catch { }
+                try { File.Delete(linkPath); } catch { }
+                return ret;
+            }
+        }
     }
 }
diff --git a/src/System.IO.FileSystem/tests/FileInfo/Length.cs b/src/System.IO.FileSystem/tests/FileInfo/Length.cs
@@ -40,21 +40,39 @@ public void Length_Of_Directory_Throws_FileNotFoundException()
             Assert.Throws<FileNotFoundException>(() => info.Length);
         }
 
-        [Fact]
+        // In some cases (such as when running without elevated privileges,
+        // the symbolic link may fail to create. Only run this test if it creates
+        // links successfully.
+        [ConditionalFact("CanCreateSymbolicLinks")]
         public void SymLinkLength()
         {
             var path = GetTestFilePath();
             var linkPath = GetTestFilePath();
-            CreateNonEmptyFile(path, 500);
-            MountHelper.CreateSymbolicLink(linkPath, path);
+            using (var tempFile = new TempFile(path, 2000))
+            {
+                Assert.True(MountHelper.CreateSymbolicLink(linkPath, path));
+
+                var info = new FileInfo(path);
+                var linkInfo = new FileInfo(linkPath);
+                Assert.Equal(2000, info.Length);
+                // On Windows, sym links report 0 size; on Linux, their size is the length of the path they point to
+                // Confirm that the size we get is not the size of the target file (and that it's less, since our temporary
+                // sym links should never exceed 500 bytes.
+                Assert.True(2000 > linkInfo.Length);
+            }
+        }
 
-            var info = new FileInfo(path);
-            var linkInfo = new FileInfo(linkPath);
-            Assert.Equal(500, info.Length);
-            // On Windows, sym links report 0 size; on Linux, their size is the length of the path they point to
-            // Confirm that the size we get is not the size of the target file (and that it's less, since our temporary
-            // sym links should never exceed 500 bytes.
-            Assert.True(500 > linkInfo.Length);
+        private static bool CanCreateSymbolicLinks
+        {
+            get
+            {
+                var path = Path.GetTempFileName();
+                var linkPath = path + ".link";
+                var ret = MountHelper.CreateSymbolicLink(linkPath, path);
+                try { File.Delete(path); } catch { }
+                try { File.Delete(linkPath); } catch { }
+                return ret;
+            }
         }
     }
 }
diff --git a/src/System.IO.FileSystem/tests/PortedCommon/ReparsePointUtilities.cs b/src/System.IO.FileSystem/tests/PortedCommon/ReparsePointUtilities.cs
@@ -31,7 +31,7 @@ public static class MountHelper
     /// <summary>Creates a symbolic link using command line tools</summary>
     /// <param name="linkPath">The existing file</param>
     /// <param name="targetPath"></param>
-    public static int CreateSymbolicLink(string linkPath, string targetPath)
+    public static bool CreateSymbolicLink(string linkPath, string targetPath)
     {
         Process symLinkProcess = null;
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -46,11 +46,11 @@ public static int CreateSymbolicLink(string linkPath, string targetPath)
         if (symLinkProcess != null)
         {
             symLinkProcess.WaitForExit();
-            return symLinkProcess.ExitCode;
+            return (0 == symLinkProcess.ExitCode);
         }
         else
         {
-            return -1;
+            return false;
         }
     }
 

diff --git a/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj b/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
@@ -164,6 +164,9 @@
     <Compile Include="$(CommonTestPath)\System\IO\FileCleanupTestBase.cs">
       <Link>Common\System\IO\FileCleanupTestBase.cs</Link>
     </Compile>
+    <Compile Include="$(CommonTestPath)\System\IO\TempFile.cs">
+      <Link>Common\System\IO\TempFile.cs</Link>
+    </Compile>
     <!-- Performance Tests -->
     <Compile Include="Performance\Perf.Directory.cs" />
     <Compile Include="Performance\Perf.File.cs" />