Update build and mark for 0.28.3

Write ZIP64 End of Central Directory only if needed.

.github/workflows/dotnetcore.yml

@@ -12,7 +12,7 @@ jobs:
     - uses: actions/checkout@v1
     - uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 5.0.101
+        dotnet-version: 5.0.300
     - run: dotnet run -p build/build.csproj
     - uses: actions/upload-artifact@v2
       with:

build/build.csproj

@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Bullseye" Version="3.6.0" />
+    <PackageReference Include="Bullseye" Version="3.7.0" />
     <PackageReference Include="Glob" Version="1.1.8" />
-    <PackageReference Include="SimpleExec" Version="6.4.0" />
+    <PackageReference Include="SimpleExec" Version="7.0.0" />
   </ItemGroup>
 
 </Project>

global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "5.0.101"
+    "version": "5.0.300"
   }
 }

src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs

@@ -63,6 +63,8 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, RelativeOffsetOfEntryHeader, DiskNumberStart);
+
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;

src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs

@@ -53,6 +53,8 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
+
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;

src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs

@@ -66,46 +66,74 @@ namespace SharpCompress.Common.Zip.Headers
         public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
             : base(type, length, dataBytes)
         {
-            Process();
         }
 
-        private void Process()
+        // From the spec, values are only in the extradata if the standard
+        // value is set to 0xFFFFFFFF (or 0xFFFF for the Disk Start Number).
+        // Values, if present, must appear in the following order:
+        // - Original Size
+        // - Compressed Size
+        // - Relative Header Offset
+        // - Disk Start Number
+        public void Process(long uncompressedFileSize, long compressedFileSize, long relativeHeaderOffset, ushort diskNumber)
         {
-            if (DataBytes.Length >= 8)
+            var bytesRequired = ((uncompressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((compressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((relativeHeaderOffset == uint.MaxValue) ? 8 : 0)
+                + ((diskNumber == ushort.MaxValue) ? 4 : 0);
+            var currentIndex = 0;
+
+            if (bytesRequired > DataBytes.Length)
             {
-                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                throw new ArchiveException("Zip64 extended information extra field is not large enough for the required information");
             }
 
-            if (DataBytes.Length >= 16)
+            if (uncompressedFileSize == uint.MaxValue)
             {
-                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            if (DataBytes.Length >= 24)
+            if (compressedFileSize == uint.MaxValue)
             {
-                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            if (DataBytes.Length >= 28)
+            if (relativeHeaderOffset == uint.MaxValue)
             {
-                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
+                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            switch (DataBytes.Length)
+            if (diskNumber == ushort.MaxValue)
             {
-                case 8:
-                case 16:
-                case 24:
-                case 28:
-                    break;
-                default:
-                    throw new ArchiveException($"Unexpected size of of Zip64 extended information extra field: {DataBytes.Length}");
+                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(currentIndex));
             }
         }
 
+        /// <summary>
+        /// Uncompressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long UncompressedSize { get; private set; }
+
+        /// <summary>
+        /// Compressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long CompressedSize { get; private set; }
+
+        /// <summary>
+        /// Relative offset of the entry header. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long RelativeOffsetOfEntryHeader { get; private set; }
+
+        /// <summary>
+        /// Volume number. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFF value.
+        /// </summary>
         public uint VolumeNumber { get; private set; }
     }
 

src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs

@@ -105,6 +105,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal ZipFilePart Part { get; set; }
 
-        internal bool IsZip64 => CompressedSize == uint.MaxValue;
+        internal bool IsZip64 => CompressedSize >= uint.MaxValue;
     }
 }

src/SharpCompress/SharpCompress.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.28.2</VersionPrefix>
-    <AssemblyVersion>0.28.2</AssemblyVersion>
-    <FileVersion>0.28.2</FileVersion>
+    <VersionPrefix>0.28.3</VersionPrefix>
+    <AssemblyVersion>0.28.3</AssemblyVersion>
+    <FileVersion>0.28.3</FileVersion>
     <Authors>Adam Hathcock</Authors>
     <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
@@ -35,7 +35,8 @@
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
     <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
-    <PackageReference Include="System.Memory" Version="4.5.4" />
+    <PackageReference Include="System.Memory" Version="4.5.3" />
+    <PackageReference Include="System.Buffers" Version="4.4.0" />
   </ItemGroup>
 
 </Project>

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -238,13 +238,13 @@ namespace SharpCompress.Writers.Zip
         private void WriteEndRecord(ulong size)
         {
 
-            var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
+            var zip64EndOfCentralDirectoryNeeded = entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
 
             var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
             var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;
 
             Span<byte> intBuf = stackalloc byte[8];
-            if (zip64)
+            if (zip64EndOfCentralDirectoryNeeded)
             {
                 var recordlen = 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8;
 
@@ -281,8 +281,7 @@ namespace SharpCompress.Writers.Zip
                 BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 1);
                 OutputStream.Write(intBuf.Slice(0, 4)); // Number of disks
 
-                streamPosition += recordlen + (4 + 4 + 8 + 4);
-                streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
+                streamPosition += 4 + 8 + recordlen + (4 + 4 + 8 + 4);
             }
 
             // Write normal end of central directory record

tests/SharpCompress.Test/SharpCompress.Test.csproj

@@ -12,7 +12,7 @@
     <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

tests/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -576,5 +576,23 @@ namespace SharpCompress.Test.Zip
                 Assert.Equal(1, count);
             }
         }
+
+        [Fact]
+        public void Zip_Zip64_CompressedSizeExtraOnly_Read()
+        {
+            string zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.zip64.compressedonly.zip");
+
+            using (ZipArchive za = ZipArchive.Open(zipPath))
+            {
+                var firstEntry = za.Entries.First(x => x.Key == "test/test.txt");
+
+                using (var memoryStream = new MemoryStream())
+                using (var firstStream = firstEntry.OpenEntryStream())
+                {
+                    firstStream.CopyTo(memoryStream);
+                    Assert.Equal(15, memoryStream.Length);
+                }
+            }
+        }
     }
 }