Add internal junction support to link APIs

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

@@ -10,7 +10,9 @@ internal static partial class Interop
 {
     internal static partial class Kernel32
     {
+        // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/fltkernel/ns-fltkernel-_flt_file_name_information#remarks
         internal const uint FILE_NAME_NORMALIZED = 0x0;
+        internal const uint FILE_NAME_OPENED = 0x8;
 
         // https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew (kernel32)
         [DllImport(Libraries.Kernel32, EntryPoint = "GetFinalPathNameByHandleW", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]

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

@@ -14,24 +14,29 @@ internal static partial class Kernel32
         internal const uint SYMLINK_FLAG_RELATIVE = 1;
 
         // https://msdn.microsoft.com/library/windows/hardware/ff552012.aspx
-        // We don't need all the struct fields; omitting the rest.
         [StructLayout(LayoutKind.Sequential)]
-        internal unsafe struct REPARSE_DATA_BUFFER
+        internal unsafe struct SymbolicLinkReparseBuffer
         {
             internal uint ReparseTag;
             internal ushort ReparseDataLength;
             internal ushort Reserved;
-            internal SymbolicLinkReparseBuffer ReparseBufferSymbolicLink;
+            internal ushort SubstituteNameOffset;
+            internal ushort SubstituteNameLength;
+            internal ushort PrintNameOffset;
+            internal ushort PrintNameLength;
+            internal uint Flags;
+        }
 
-            [StructLayout(LayoutKind.Sequential)]
-            internal struct SymbolicLinkReparseBuffer
-            {
-                internal ushort SubstituteNameOffset;
-                internal ushort SubstituteNameLength;
-                internal ushort PrintNameOffset;
-                internal ushort PrintNameLength;
-                internal uint Flags;
-            }
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct MountPointReparseBuffer
+        {
+            public uint ReparseTag;
+            public ushort ReparseDataLength;
+            public ushort Reserved;
+            public ushort SubstituteNameOffset;
+            public ushort SubstituteNameLength;
+            public ushort PrintNameOffset;
+            public ushort PrintNameLength;
         }
     }
 }

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseJunctions.FileSystem.cs

@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [PlatformSpecific(TestPlatforms.Windows)]
+    public abstract class BaseJunctions_FileSystem : BaseSymbolicLinks
+    {
+        protected DirectoryInfo CreateJunction(string junctionPath, string targetPath)
+        {
+            Assert.True(MountHelper.CreateJunction(junctionPath, targetPath));
+            DirectoryInfo junctionInfo = new(junctionPath);
+            return junctionInfo;
+        }
+
+        protected abstract DirectoryInfo CreateDirectory(string path);
+
+        protected abstract FileSystemInfo ResolveLinkTarget(string junctionPath, bool returnFinalTarget);
+
+        protected abstract void VerifyEnumerateMethods(string junctionPath, string[] expectedFiles, string[] expectedDirectories, string[] expectedEntries);
+
+        protected void VerifyEnumeration(IEnumerable<string> expectedEnumeration, IEnumerable<string> actualEnumeration)
+        {
+            foreach (string expectedItem in expectedEnumeration)
+            {
+                Assert.True(actualEnumeration.Contains(expectedItem));
+            }
+        }
+
+        [Fact]
+        public void Junction_ResolveLinkTarget()
+        {
+            string junctionPath = GetRandomLinkPath();
+            string targetPath = GetRandomDirPath();
+
+            CreateDirectory(targetPath);
+            DirectoryInfo junctionInfo = CreateJunction(junctionPath, targetPath);
+
+            FileSystemInfo? actualTargetInfo = ResolveLinkTarget(junctionPath, returnFinalTarget: false);
+            Assert.True(actualTargetInfo is DirectoryInfo);
+            Assert.Equal(targetPath, actualTargetInfo.FullName);
+            Assert.Equal(targetPath, junctionInfo.LinkTarget);
+        }
+
+        [Fact]
+        public void Junction_EnumerateFileSystemEntries()
+        {
+            // Root
+            string targetPath = GetRandomDirPath();
+            Directory.CreateDirectory(targetPath);
+
+            string fileName = GetRandomFileName();
+            string subDirName = GetRandomDirName();
+            string subFileName = Path.Join(subDirName, GetRandomFileName());
+
+            string filePath = Path.Join(targetPath, fileName);
+            string subDirPath = Path.Join(targetPath, subDirName);
+            string subFilePath = Path.Join(targetPath, subFileName);
+
+            File.Create(filePath).Dispose();
+            Directory.CreateDirectory(subDirPath);
+            File.Create(subFilePath).Dispose();
+
+            string junctionPath = GetRandomLinkPath();
+            CreateJunction(junctionPath, targetPath);
+
+            string jFilePath = Path.Join(junctionPath, fileName);
+            string jSubDirPath = Path.Join(junctionPath, subDirName);
+            string jSubFilePath = Path.Join(junctionPath, subFileName);
+
+            string[] expectedFiles = new[] { jFilePath, jSubFilePath };
+            string[] expectedDirectories = new[] { jSubDirPath };
+            string[] expectedEntries = new[] { jFilePath, jSubDirPath, jSubFilePath };
+
+            VerifyEnumerateMethods(junctionPath, expectedFiles, expectedDirectories, expectedEntries);
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseSymbolicLinks.FileSystem.cs

@@ -460,11 +460,10 @@ private void ResolveLinkTarget_ReturnFinalTarget(string link1Path, string link1T
             Assert.Equal(filePath, finalTarget.FullName);
         }
 
+        // Must call inside a remote executor
         protected void CreateSymbolicLink_PathToTarget_RelativeToLinkPath_Internal(bool createOpposite)
         {
-            string tempCwd = GetRandomDirPath();
-            Directory.CreateDirectory(tempCwd);
-            Directory.SetCurrentDirectory(tempCwd);
+            string tempCwd = GetNewCwdPath();
 
             // Create a dummy file or directory in cwd.
             string fileOrDirectoryInCwd = GetRandomFileName();

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseSymbolicLinks.cs

@@ -1,10 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Buffers;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using Microsoft.Win32.SafeHandles;
 using Xunit;
 
 namespace System.IO.Tests
@@ -36,5 +32,19 @@ protected DirectoryInfo CreateSelfReferencingSymbolicLink()
         protected string GetRandomDirPath()  => Path.Join(ActualTestDirectory.Value, GetRandomDirName());
 
         private Lazy<string> ActualTestDirectory => new Lazy<string>(() => GetTestDirectoryActualCasing());
+
+        /// <summary>
+        /// Changes the current working directory path to a new temporary directory.
+        /// Important: Make sure to call this inside a remote executor to avoid changing the cwd for all tests in same process.
+        /// </summary>
+        /// <returns>The path of the new cwd.</returns>
+        protected string GetNewCwdPath()
+        {
+            string tempCwd = GetRandomDirPath();
+            Directory.CreateDirectory(tempCwd);
+            Directory.SetCurrentDirectory(tempCwd);
+            return tempCwd;
+        }
+
     }
 }

src/libraries/System.IO.FileSystem/tests/Directory/Junctions.cs

@@ -0,0 +1,46 @@
+// 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
+{
+    [PlatformSpecific(TestPlatforms.Windows)]
+    public class Directory_Junctions : BaseJunctions_FileSystem
+    {
+        protected override DirectoryInfo CreateDirectory(string path) =>
+            Directory.CreateDirectory(path);
+
+        protected override FileSystemInfo? ResolveLinkTarget(string junctionPath, bool returnFinalTarget) =>
+            Directory.ResolveLinkTarget(junctionPath, returnFinalTarget);
+
+        protected override void VerifyEnumerateMethods(string junctionPath, string[] expectedFiles, string[] expectedDirectories, string[] expectedEntries)
+        {
+            EnumerationOptions options = new() { RecurseSubdirectories = true };
+
+            VerifyEnumeration(
+                Directory.EnumerateFiles(junctionPath, "*", options),
+                expectedFiles);
+
+            VerifyEnumeration(
+                Directory.EnumerateDirectories(junctionPath, "*", options),
+                expectedDirectories);
+
+            VerifyEnumeration(
+                Directory.EnumerateFileSystemEntries(junctionPath, "*", options),
+                expectedEntries);
+
+            VerifyEnumeration(
+                Directory.GetFiles(junctionPath, "*", options),
+                expectedFiles);
+
+            VerifyEnumeration(
+                Directory.GetDirectories(junctionPath, "*", options),
+                expectedDirectories);
+
+            VerifyEnumeration(
+                Directory.GetFileSystemEntries(junctionPath, "*", options),
+                expectedEntries);
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+// 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
+{
+    [PlatformSpecific(TestPlatforms.Windows)]
+    public class DirectoryInfo_Junctions : BaseJunctions_FileSystem
+    {
+        protected override DirectoryInfo CreateDirectory(string path)
+        {
+            DirectoryInfo dirInfo = new(path);
+            dirInfo.Create();
+            return dirInfo;
+        }
+
+        protected override FileSystemInfo? ResolveLinkTarget(string junctionPath, bool returnFinalTarget) =>
+            new DirectoryInfo(junctionPath).ResolveLinkTarget(returnFinalTarget);
+
+        protected override void VerifyEnumerateMethods(string junctionPath, string[] expectedFiles, string[] expectedDirectories, string[] expectedEntries)
+        {
+            EnumerationOptions options = new() { RecurseSubdirectories = true };
+
+            DirectoryInfo info = new(junctionPath);
+
+            VerifyEnumeration(
+                info.EnumerateFiles("*", options).Select(x => x.FullName),
+                expectedFiles);
+
+            VerifyEnumeration(
+                info.EnumerateDirectories("*", options).Select(x => x.FullName),
+                expectedDirectories);
+
+            VerifyEnumeration(
+                info.EnumerateFileSystemInfos("*", options).Select(x => x.FullName),
+                expectedEntries);
+
+            VerifyEnumeration(
+                info.GetFiles("*", options).Select(x => x.FullName),
+                expectedFiles);
+
+            VerifyEnumeration(
+                info.GetDirectories("*", options).Select(x => x.FullName),
+                expectedDirectories);
+
+            VerifyEnumeration(
+                info.GetFileSystemInfos("*", options).Select(x => x.FullName),
+                expectedEntries);
+        }
+    }
+}