Tar: Only treat reparse points marked as junctions or symlinks as actual tar symlinks

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

@@ -24,6 +24,21 @@ internal static SafeFindHandle FindFirstFile(string fileName, ref WIN32_FIND_DAT
             return FindFirstFileExPrivate(fileName, FINDEX_INFO_LEVELS.FindExInfoBasic, ref data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, 0);
         }
 
+        internal static void GetFindData(string fullPath, bool isDirectory, bool ignoreAccessDenied, ref WIN32_FIND_DATA findData)
+        {
+            using SafeFindHandle handle = FindFirstFile(Path.TrimEndingDirectorySeparator(fullPath), ref findData);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                // File not found doesn't make much sense coming from a directory.
+                if (isDirectory && errorCode == Errors.ERROR_FILE_NOT_FOUND)
+                    errorCode = Errors.ERROR_PATH_NOT_FOUND;
+                if (ignoreAccessDenied && errorCode == Errors.ERROR_ACCESS_DENIED)
+                    return;
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode, fullPath);
+            }
+        }
+
         internal enum FINDEX_INFO_LEVELS : uint
         {
             FindExInfoStandard = 0x0u,

src/libraries/Common/tests/System/IO/ReparsePointUtilities.cs

@@ -13,6 +13,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.IO.Enumeration;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -115,6 +116,38 @@ public static bool CreateJunction(string junctionPath, string targetPath)
         return RunProcess(CreateProcessStartInfo("cmd", "/c", "mklink", "/J", junctionPath, targetPath));
     }
 
+    /// <summary>
+    /// Retrieves the first appexeclink in this machine, if any.
+    /// </summary>
+    /// <returns>A string that represents a path to an appexeclink, if found, or null if not.</returns>
+    public static string? GetAppExecLinkPath()
+    {
+        string localAppDataPath = Environment.GetEnvironmentVariable("LOCALAPPDATA");
+        if (localAppDataPath is null)
+        {
+            return null;
+        }
+
+        string windowsAppsDir = Path.Join(localAppDataPath, "Microsoft", "WindowsApps");
+
+        if (!Directory.Exists(windowsAppsDir))
+        {
+            return null;
+        }
+
+        var opts = new EnumerationOptions { RecurseSubdirectories = true };
+
+        return new FileSystemEnumerable<string?>(
+            windowsAppsDir,
+            (ref FileSystemEntry entry) => entry.ToFullPath(),
+            opts)
+        {
+            ShouldIncludePredicate = (ref FileSystemEntry entry) =>
+                FileSystemName.MatchesWin32Expression("*.exe", entry.FileName) &&
+                (entry.Attributes & FileAttributes.ReparsePoint) != 0
+        }.FirstOrDefault();
+    }
+
     public static void Mount(string volumeName, string mountPoint)
     {
         if (volumeName[volumeName.Length - 1] != Path.DirectorySeparatorChar)

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

@@ -45,7 +45,14 @@
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs" Link="Common\Interop\Windows\Interop.Errors.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.CreateHardLink.cs" Link="Common\Interop\Windows\Kernel32\Interop.CreateHardLink.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_TIME.cs" Link="Common\Interop\Windows\Kernel32\Interop.FILE_TIME.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FindFirstFileEx.cs" Link="Common\Interop\Windows\Kernel32\Interop.FindFirstFileEx.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FileOperations.cs" Link="Common\Interop\Windows\Kernel32\Interop.FileOperations.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FindClose.cs" Link="Common\Interop\Windows\Kernel32\Interop.FindClose.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FormatMessage.cs" Link="Common\Interop\Windows\Kernel32\Interop.FormatMessage.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.MAX_PATH.cs" Link="Common\Interop\Windows\Kernel32\Interop.MAX_PATH.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.WIN32_FIND_DATA.cs" Link="Common\Interop\Windows\Kernel32\Interop.WIN32_FIND_DATA.cs" />
+    <Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeFindHandle.Windows.cs" Link="Common\Microsoft\Win32\SafeHandles\SafeFindHandle.Windows.cs" />
     <Compile Include="$(CommonPath)System\IO\Archiving.Utils.Windows.cs" Link="Common\System\IO\Archiving.Utils.Windows.cs" />
     <Compile Include="$(CommonPath)System\IO\PathInternal.Windows.cs" Link="Common\System\IO\PathInternal.Windows.cs" />
     <Compile Include="$(CommonPath)System\IO\Win32Marshal.cs" Link="Common\System\IO\Win32Marshal.cs" />

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHelpers.cs

@@ -215,6 +215,9 @@ internal static TarEntryType GetCorrectTypeFlagForFormat(TarEntryFormat format,
             return entryType;
         }
 
+        // Chooses the compatible regular file entry type for the specified format.
+        internal static TarEntryType GetRegularFileEntryTypeForFormat(TarEntryFormat format) => format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+
         /// <summary>Parses a byte span that represents an ASCII string containing a number in octal base.</summary>
         internal static T ParseOctal<T>(ReadOnlySpan<byte> buffer) where T : struct, INumber<T>
         {

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarWriter.Unix.cs

@@ -4,8 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace System.Formats.Tar
 {
@@ -33,7 +31,7 @@ private TarEntry ConstructEntryForWriting(string fullPath, string entryName, Fil
                 Interop.Sys.FileTypes.S_IFCHR => TarEntryType.CharacterDevice,
                 Interop.Sys.FileTypes.S_IFIFO => TarEntryType.Fifo,
                 Interop.Sys.FileTypes.S_IFLNK => TarEntryType.SymbolicLink,
-                Interop.Sys.FileTypes.S_IFREG => Format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile,
+                Interop.Sys.FileTypes.S_IFREG => TarHelpers.GetRegularFileEntryTypeForFormat(Format),
                 Interop.Sys.FileTypes.S_IFDIR => TarEntryType.Directory,
                 _ => throw new IOException(SR.Format(SR.TarUnsupportedFile, fullPath)),
             };

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarWriter.Windows.cs

@@ -3,8 +3,6 @@
 
 using System.Diagnostics;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace System.Formats.Tar
 {
@@ -21,18 +19,33 @@ private TarEntry ConstructEntryForWriting(string fullPath, string entryName, Fil
 
             FileAttributes attributes = File.GetAttributes(fullPath);
 
+            bool isDirectory = (attributes & FileAttributes.Directory) != 0;
+
             TarEntryType entryType;
             if ((attributes & FileAttributes.ReparsePoint) != 0)
             {
-                entryType = TarEntryType.SymbolicLink;
+                Interop.Kernel32.WIN32_FIND_DATA data = default;
+                Interop.Kernel32.GetFindData(fullPath, isDirectory, ignoreAccessDenied: false, ref data);
+
+                if (data.dwReserved0 is Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_SYMLINK or
+                                        Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_MOUNT_POINT)
+                {
+                    entryType = TarEntryType.SymbolicLink;
+                }
+                else
+                {
+                    // All other reparse points are not supported since they cannot be
+                    // represented in a tar file using the existing entry types.
+                    throw new IOException(SR.Format(SR.TarUnsupportedFile, fullPath));
+                }
             }
-            else if ((attributes & FileAttributes.Directory) != 0)
+            else if (isDirectory)
             {
                 entryType = TarEntryType.Directory;
             }
             else if ((attributes & (FileAttributes.Normal | FileAttributes.Archive)) != 0)
             {
-                entryType = Format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+                entryType = TarHelpers.GetRegularFileEntryTypeForFormat(Format);
             }
             else
             {

src/libraries/System.Formats.Tar/tests/Manual/ManualTests.cs

@@ -38,7 +38,7 @@ public void WriteEntry_LongFileSize(TarEntryFormat entryFormat, long size, bool
 
         using (TarWriter writer = new(s, leaveOpen: true))
         {
-            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, entryFormat is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile, "foo");
+            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, GetRegularFileEntryTypeForFormat(entryFormat), "foo");
             writeEntry.DataStream = new SimulatedDataStream(size);
             writer.WriteEntry(writeEntry);
         }

src/libraries/System.Formats.Tar/tests/Manual/ManualTestsAsync.cs

@@ -27,7 +27,7 @@ public async Task WriteEntry_LongFileSizeAsync(TarEntryFormat entryFormat, long
 
         await using (TarWriter writer = new(s, leaveOpen: true))
         {
-            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, entryFormat is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile, "foo");
+            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, GetRegularFileEntryTypeForFormat(entryFormat), "foo");
             writeEntry.DataStream = new SimulatedDataStream(size);
             await writer.WriteEntryAsync(writeEntry);
         }

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

@@ -78,6 +78,8 @@
     <Compile Include="TarFile\TarFile.ExtractToDirectory.File.Tests.Windows.cs" />
     <Compile Include="TarFile\TarFile.ExtractToDirectoryAsync.File.Tests.Windows.cs" />
     <Compile Include="TarWriter\TarWriter.File.Base.Windows.cs" />
+    <Compile Include="TarWriter\TarWriter.WriteEntry.File.Tests.Windows.cs" />
+    <Compile Include="TarWriter\TarWriter.WriteEntryAsync.File.Tests.Windows.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Common\Interop\Windows\Interop.BOOL.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs" Link="Common\Interop\Windows\Interop.Errors.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />

src/libraries/System.Formats.Tar/tests/TarReader/TarReader.File.Async.Tests.Base.cs

@@ -224,7 +224,7 @@ protected async Task Read_Archive_Many_Small_Files_Async_Internal(TarEntryFormat
                     int directoriesCount = entries.Count(e => e.EntryType == TarEntryType.Directory);
                     Assert.Equal(10, directoriesCount);
 
-                    TarEntryType actualEntryType = format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+                    TarEntryType actualEntryType = GetRegularFileEntryTypeForFormat(format);
 
                     for (int i = 0; i < 10; i++)
                     {
@@ -423,7 +423,7 @@ private void VerifyRegularFileEntry(TarEntry file, TarEntryFormat format, string
                 Assert.Equal(expectedContents, contents);
             }
 
-            TarEntryType expectedEntryType = format == TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+            TarEntryType expectedEntryType = GetRegularFileEntryTypeForFormat(format);
             Assert.Equal(expectedEntryType, file.EntryType);
 
             Assert.Equal(AssetGid, file.Gid);

src/libraries/System.Formats.Tar/tests/TarReader/TarReader.File.Tests.Base.cs

@@ -201,7 +201,7 @@ protected void Read_Archive_Many_Small_Files_Internal(TarEntryFormat format, Tes
             int directoriesCount = entries.Count(e => e.EntryType == TarEntryType.Directory);
             Assert.Equal(10, directoriesCount);
 
-            TarEntryType actualEntryType = format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+            TarEntryType actualEntryType = GetRegularFileEntryTypeForFormat(format);
 
             for (int i = 0; i < 10; i++)
             {
@@ -382,7 +382,7 @@ private void VerifyRegularFileEntry(TarEntry file, TarEntryFormat format, string
                 Assert.Equal(expectedContents, contents);
             }
 
-            TarEntryType expectedEntryType = format == TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+            TarEntryType expectedEntryType = GetRegularFileEntryTypeForFormat(format);
             Assert.Equal(expectedEntryType, file.EntryType);
 
             Assert.Equal(AssetGid, file.Gid);

src/libraries/System.Formats.Tar/tests/TarTestsBase.cs

@@ -479,6 +479,8 @@ protected static TarEntryType GetTarEntryTypeForTarEntryFormat(TarEntryType entr
             return entryType;
         }
 
+        protected static TarEntryType GetRegularFileEntryTypeForFormat(TarEntryFormat format) => format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+
         protected static TarEntry InvokeTarEntryCreationConstructor(TarEntryFormat targetFormat, TarEntryType entryType, string entryName)
             => targetFormat switch
             {

src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.WriteEntry.File.Tests.Windows.cs

@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using Microsoft.DotNet.XUnitExtensions;
+using Xunit;
+using Xunit.Sdk;
+
+namespace System.Formats.Tar.Tests;
+
+public partial class TarWriter_WriteEntry_File_Tests : TarWriter_File_Base
+{
+    [Theory]
+    [InlineData(TarEntryFormat.V7)]
+    [InlineData(TarEntryFormat.Ustar)]
+    [InlineData(TarEntryFormat.Pax)]
+    [InlineData(TarEntryFormat.Gnu)]
+    public void Add_Junction_As_SymbolicLink(TarEntryFormat format)
+    {
+        using TempDirectory root = new TempDirectory();
+        string targetName = "TargetDirectory";
+        string junctionName = "JunctionDirectory";
+        string targetPath = Path.Join(root.Path, targetName);
+        string junctionPath = Path.Join(root.Path, junctionName);
+
+        Directory.CreateDirectory(targetPath);
+
+        Assert.True(MountHelper.CreateJunction(junctionPath, targetPath));
+        DirectoryInfo junctionInfo = new(junctionPath);
+
+        using MemoryStream archive = new MemoryStream();
+        using (TarWriter writer = new TarWriter(archive, format, leaveOpen: true))
+        {
+            writer.WriteEntry(fileName: junctionPath, entryName: junctionPath);
+        }
+
+        archive.Position = 0;
+        using (TarReader reader = new TarReader(archive))
+        {
+            TarEntry entry = reader.GetNextEntry();
+            Assert.Equal(format, entry.Format);
+
+            Assert.NotNull(entry);
+            Assert.Equal(junctionPath, entry.Name);
+            Assert.Equal(targetPath, entry.LinkName);
+            Assert.Equal(TarEntryType.SymbolicLink, entry.EntryType);
+            Assert.Null(entry.DataStream);
+
+            VerifyPlatformSpecificMetadata(junctionPath, entry);
+
+            Assert.Null(reader.GetNextEntry());
+        }
+    }
+
+    [ConditionalTheory]
+    [InlineData(TarEntryFormat.V7)]
+    [InlineData(TarEntryFormat.Ustar)]
+    [InlineData(TarEntryFormat.Pax)]
+    [InlineData(TarEntryFormat.Gnu)]
+    public void Add_Unsupported_ReparsePoints_Throws(TarEntryFormat format)
+    {
+        string? appExecLinkPath = MountHelper.GetAppExecLinkPath();
+        if (appExecLinkPath == null)
+        {
+            throw new SkipTestException("Could not find an appexeclink in this machine.");
+        }
+
+        using MemoryStream archive = new MemoryStream();
+        using TarWriter writer = new TarWriter(archive, format);
+        Assert.Throws<IOException>(() => writer.WriteEntry(fileName: appExecLinkPath, "UnsupportedAppExecLink"));
+    }
+}

src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.WriteEntry.File.Tests.cs

@@ -95,7 +95,7 @@ public void Add_File(TarEntryFormat format)
                 Assert.NotNull(entry);
                 Assert.Equal(format, entry.Format);
                 Assert.Equal(fileName, entry.Name);
-                TarEntryType expectedEntryType = format is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+                TarEntryType expectedEntryType = GetRegularFileEntryTypeForFormat(format);
                 Assert.Equal(expectedEntryType, entry.EntryType);
                 Assert.True(entry.Length > 0);
                 Assert.NotNull(entry.DataStream);

src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.WriteEntry.Tests.cs

@@ -337,7 +337,7 @@ private void WriteLongNameCore(TarEntryFormat format, string maxPathComponent)
             MemoryStream ms = new();
             using (TarWriter writer = new(ms, true))
             {
-                TarEntryType entryType = format == TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile;
+                TarEntryType entryType = GetRegularFileEntryTypeForFormat(format);
                 entry = InvokeTarEntryCreationConstructor(format, entryType, maxPathComponent);
                 writer.WriteEntry(entry);
 
@@ -469,7 +469,7 @@ public static IEnumerable<object[]> WriteEntry_UsingTarEntry_FromTarReader_IntoT
         {
             foreach (var entryFormat in new[] { TarEntryFormat.V7, TarEntryFormat.Ustar, TarEntryFormat.Pax, TarEntryFormat.Gnu })
             {
-                foreach (var entryType in new[] { entryFormat == TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile, TarEntryType.Directory, TarEntryType.SymbolicLink })
+                foreach (var entryType in new[] { GetRegularFileEntryTypeForFormat(entryFormat), TarEntryType.Directory, TarEntryType.SymbolicLink })
                 {
                     foreach (bool unseekableStream in new[] { false, true })
                     {
@@ -520,7 +520,7 @@ public void WriteEntry_FileSizeOverLegacyLimit_Throws(TarEntryFormat entryFormat
             using Stream s = unseekableStream ? new WrappedStream(ms, ms.CanRead, ms.CanWrite, canSeek: false) : ms;
 
             using TarWriter writer = new(s);
-            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, entryFormat is TarEntryFormat.V7 ? TarEntryType.V7RegularFile : TarEntryType.RegularFile, "foo");
+            TarEntry writeEntry = InvokeTarEntryCreationConstructor(entryFormat, GetRegularFileEntryTypeForFormat(entryFormat), "foo");
             writeEntry.DataStream = new SimulatedDataStream(FileSizeOverLimit);
 
             Assert.Equal(FileSizeOverLimit, writeEntry.Length);