Merge pull request #109 from thunderstore-io/fix/archive-permissions

Preserve unix file mode for files copied into package zips

Author: FrankTheBoxMonster

ThunderstoreCLI.Tests/ThunderstoreCLI.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net7.0;net6.0</TargetFrameworks>
+        <TargetFramework>net8.0</TargetFramework>
         <RollForward>Major</RollForward>
         <LangVersion>11</LangVersion>
         <IsPackable>false</IsPackable>

ThunderstoreCLI/Commands/BuildCommand.cs

@@ -1,4 +1,6 @@
+using System.Buffers;
 using System.IO.Compression;
+using System.Runtime.Versioning;
 using System.Text;
 using ThunderstoreCLI.Configuration;
 using ThunderstoreCLI.Models;
@@ -9,16 +11,57 @@ namespace ThunderstoreCLI.Commands;
 
 public static class BuildCommand
 {
-    public class ArchivePlan
+    private abstract class EntryData
     {
-        public Config Config { get; protected set; }
-        public bool HasWarnings { get; protected set; }
-        public bool HasErrors { get; protected set; }
+        private EntryData() { }
 
-        protected Dictionary<string, Func<byte[]>> plan;
-        protected Dictionary<string, string> duplicateMap;
-        protected HashSet<string> directories;
-        protected HashSet<string> files;
+        public sealed class FromFile : EntryData
+        {
+            private string _filePath;
+
+            public FromFile(string path)
+            {
+                _filePath = path;
+            }
+
+            public override Stream GetStream() => File.OpenRead(_filePath);
+
+            [UnsupportedOSPlatform("windows")]
+            public override UnixFileMode GetUnixFileMode() => File.GetUnixFileMode(_filePath);
+        }
+
+        public sealed class FromMemory : EntryData
+        {
+            private byte[] _data;
+            private UnixFileMode _fileMode;
+
+            public FromMemory(byte[] data, UnixFileMode fileMode)
+            {
+                _data = data;
+                _fileMode = fileMode;
+            }
+
+            public override Stream GetStream() => new MemoryStream(_data, false);
+
+            public override UnixFileMode GetUnixFileMode() => _fileMode;
+        }
+
+        public abstract Stream GetStream();
+
+        [UnsupportedOSPlatform("windows")]
+        public abstract UnixFileMode GetUnixFileMode();
+    }
+
+    private class ArchivePlan
+    {
+        public Config Config { get; }
+        public bool HasWarnings { get; private set; }
+        public bool HasErrors { get; private set; }
+
+        private readonly Dictionary<string, EntryData> plan;
+        private readonly Dictionary<string, string> duplicateMap;
+        private readonly HashSet<string> directories;
+        private readonly HashSet<string> files;
 
         public ArchivePlan(Config config)
         {
@@ -29,28 +72,27 @@ public ArchivePlan(Config config)
             files = new();
         }
 
-        public void AddPlan(string path, Func<byte[]> dataGetter)
+        public void AddPlan(string path, EntryData dataGetter)
         {
             var key = path.ToLowerInvariant();
 
             var directoryKeys = new HashSet<string>();
             var pathParts = key;
-            var lastSeparatorIndex = pathParts.LastIndexOf("/");
+            var lastSeparatorIndex = pathParts.LastIndexOf('/');
             while (lastSeparatorIndex > 0)
             {
                 pathParts = pathParts.Substring(0, lastSeparatorIndex);
                 directoryKeys.Add(pathParts);
-                lastSeparatorIndex = pathParts.LastIndexOf("/");
+                lastSeparatorIndex = pathParts.LastIndexOf('/');
             }
 
-            if (duplicateMap.ContainsKey(key))
+            if (duplicateMap.TryGetValue(key, out var duplicatePath))
             {
-                var duplicatePath = duplicateMap[key];
                 if (duplicatePath != path)
                 {
                     Write.Error(
                         "Case mismatch!",
-                        $"A file target was added twice to the build with different casing, which is not allowed!",
+                        "A file target was added twice to the build with different casing, which is not allowed!",
                         $"Previously: {White(Dim($"/{duplicatePath}"))}",
                         $"Now: {White(Dim($"/{path}"))}"
                     );
@@ -98,7 +140,7 @@ public void AddPlan(string path, Func<byte[]> dataGetter)
             }
         }
 
-        public Dictionary<string, Func<byte[]>>.Enumerator GetEnumerator()
+        public Dictionary<string, EntryData>.Enumerator GetEnumerator()
         {
             return plan.GetEnumerator();
         }
@@ -152,9 +194,9 @@ public static int DoBuild(Config config)
 
         Write.Header("Planning for files to include in build");
 
-        plan.AddPlan("icon.png", () => File.ReadAllBytes(iconPath));
-        plan.AddPlan("README.md", () => File.ReadAllBytes(readmePath));
-        plan.AddPlan("manifest.json", () => Encoding.UTF8.GetBytes(SerializeManifest(config)));
+        plan.AddPlan("icon.png", new EntryData.FromFile(iconPath));
+        plan.AddPlan("README.md", new EntryData.FromFile(readmePath));
+        plan.AddPlan("manifest.json", new EntryData.FromMemory(Encoding.UTF8.GetBytes(SerializeManifest(config)), (UnixFileMode)0b110_110_100)); // rw-rw-r--
 
         if (config.BuildConfig.CopyPaths is not null)
         {
@@ -181,21 +223,19 @@ public static int DoBuild(Config config)
         {
             using (var archive = new ZipArchive(outputFile, ZipArchiveMode.Create))
             {
-                var isWindows = OperatingSystem.IsWindows();
                 foreach (var entry in plan)
                 {
                     Write.Light($"Writing /{entry.Key}");
                     var archiveEntry = archive.CreateEntry(entry.Key, CompressionLevel.Optimal);
-                    if (!isWindows)
-                    {
-                        // https://github.com/dotnet/runtime/issues/17912#issuecomment-641594638
-                        // modifed solution to use a constant instead of a string conversion
-                        archiveEntry.ExternalAttributes |= 0b110110100 << 16; // rw-rw-r-- permissions
-                    }
-                    using (var writer = new BinaryWriter(archiveEntry.Open()))
+                    if (!OperatingSystem.IsWindows())
                     {
-                        writer.Write(entry.Value());
+                        // windows-created archives do not use these bits as unix file mode, so we should not set them there
+                        archiveEntry.ExternalAttributes |= (int)entry.Value.GetUnixFileMode() << 16;
                     }
+
+                    using var entryStream = archiveEntry.Open();
+                    using var dataStream = entry.Value.GetStream();
+                    dataStream.CopyTo(entryStream);
                 }
             }
         }
@@ -214,7 +254,7 @@ public static int DoBuild(Config config)
         }
     }
 
-    public static bool AddPathToArchivePlan(ArchivePlan plan, string sourcePath, string destinationPath)
+    private static bool AddPathToArchivePlan(ArchivePlan plan, string sourcePath, string destinationPath)
     {
         var basePath = plan.Config.GetProjectRelativePath(sourcePath);
         if (Directory.Exists(basePath))
@@ -226,7 +266,7 @@ public static bool AddPathToArchivePlan(ArchivePlan plan, string sourcePath, str
             foreach (string filename in Directory.EnumerateFiles(basePath, "*.*", SearchOption.AllDirectories))
             {
                 var targetPath = FormatArchivePath($"{destDirectory}{filename[(basePath.Length + 1)..]}");
-                plan.AddPlan(targetPath, () => File.ReadAllBytes(filename));
+                plan.AddPlan(targetPath, new EntryData.FromFile(filename));
             }
             return true;
         }
@@ -236,13 +276,13 @@ public static bool AddPathToArchivePlan(ArchivePlan plan, string sourcePath, str
             {
                 var filename = Path.GetFileName(basePath);
                 var targetPath = FormatArchivePath($"{destinationPath}{filename}");
-                plan.AddPlan(targetPath, () => File.ReadAllBytes(basePath));
+                plan.AddPlan(targetPath, new EntryData.FromFile(basePath));
                 return true;
             }
             else
             {
                 var targetPath = FormatArchivePath(destinationPath);
-                plan.AddPlan(targetPath, () => File.ReadAllBytes(basePath));
+                plan.AddPlan(targetPath, new EntryData.FromFile(basePath));
                 return true;
             }
         }
@@ -254,16 +294,15 @@ public static bool AddPathToArchivePlan(ArchivePlan plan, string sourcePath, str
     }
 
     // For crossplatform compat, Windows is more restrictive
-    public static char[] GetInvalidFileNameChars() => new char[]
-    {
+    private static SearchValues<char> InvalidFileNameChars { get; } = SearchValues.Create(new[] {
         '\"', '<', '>', '|', '\0',
-        (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10,
-        (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20,
-        (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30,
-        (char)31, ':', '*', '?', '\\', '/'
-    };
+        (char) 1, (char) 2, (char) 3, (char) 4, (char) 5, (char) 6, (char) 7, (char) 8, (char) 9, (char) 10,
+        (char) 11, (char) 12, (char) 13, (char) 14, (char) 15, (char) 16, (char) 17, (char) 18, (char) 19, (char) 20,
+        (char) 21, (char) 22, (char) 23, (char) 24, (char) 25, (char) 26, (char) 27, (char) 28, (char) 29, (char) 30,
+        (char) 31, ':', '*', '?', '\\', '/'
+    });
 
-    public static string FormatArchivePath(string path, bool validate = true)
+    private static string FormatArchivePath(string path, bool validate = true)
     {
         var result = path.Replace('\\', '/');
 
@@ -283,15 +322,15 @@ public static string FormatArchivePath(string path, bool validate = true)
         {
             foreach (var entry in result.Split("/"))
             {
-                if (string.IsNullOrWhiteSpace(entry.Replace(".", "")) || entry.IndexOfAny(GetInvalidFileNameChars()) > -1)
+                if (string.IsNullOrWhiteSpace(entry.Replace(".", "")) || entry.AsSpan().ContainsAny(InvalidFileNameChars))
                     throw new CommandException($"Invalid path defined for a zip entry. Parsed: {result}, Original: {path}");
             }
         }
 
         return result;
     }
 
-    public static string SerializeManifest(Config config)
+    private static string SerializeManifest(Config config)
     {
         var dependencies = config.PackageConfig.Dependencies ?? new Dictionary<string, string>();
         var manifest = new PackageManifestV1()

ThunderstoreCLI/ThunderstoreCLI.csproj

@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFrameworks>net7.0;net6.0</TargetFrameworks>
+        <TargetFramework>net8.0</TargetFramework>
         <LangVersion>11</LangVersion>
         <RollForward>Major</RollForward>
         <RootNamespace>ThunderstoreCLI</RootNamespace>