Merge branch 'master' into adam/zstd

Configure Dependabot for NuGet updates

.config/dotnet-tools.json

@@ -3,10 +3,11 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "0.28.1",
+      "version": "1.1.2",
       "commands": [
-        "dotnet-csharpier"
-      ]
+        "csharpier"
+      ],
+      "rollForward": false
     }
   }
 }

.github/dependabot.yml

@@ -1,6 +1,13 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions" # search for actions - there are other options available
-    directory: "/" # search in .github/workflows under root `/`
+  - package-ecosystem: "github-actions"
+    directory: "/" 
     schedule:
-      interval: "weekly" # check for action update every week
+      interval: "weekly"
+
+  - package-ecosystem: "nuget"
+    directory: "/"    # change to "/src/YourProject" if .csproj files are in subfolders
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    # optional: target-branch: "master"

AGENTS.md

@@ -0,0 +1,64 @@
+---
+description: 'Guidelines for building C# applications'
+applyTo: '**/*.cs'
+---
+
+# C# Development
+
+## C# Instructions
+- Always use the latest version C#, currently C# 13 features.
+- Write clear and concise comments for each function.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+
+## Naming Conventions
+
+- Follow PascalCase for component names, method names, and public members.
+- Use camelCase for private fields and local variables.
+- Prefix interface names with "I" (e.g., IUserService).
+
+## Code Formatting
+
+- Use CSharpier for all code formatting to ensure consistent style across the project.
+- Install CSharpier globally: `dotnet tool install -g csharpier`
+- Format files with: `dotnet csharpier format .`
+- Configure your IDE to format on save using CSharpier.
+- CSharpier configuration can be customized via `.csharpierrc` file in the project root.
+- Trust CSharpier's opinionated formatting decisions to maintain consistency.
+
+## Project Setup and Structure
+
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 9 including environment-specific settings.
+
+## Nullable Reference Types
+
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.

Directory.Packages.props

@@ -1,18 +1,20 @@
 <Project>
   <ItemGroup>
-    <PackageVersion Include="Bullseye" Version="5.0.0" />
-    <PackageVersion Include="FluentAssertions" Version="6.12.0" />
+    <PackageVersion Include="Bullseye" Version="6.0.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.2.0" />
     <PackageVersion Include="Glob" Version="1.1.9" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
     <PackageVersion Include="SimpleExec" Version="12.0.0" />
-    <PackageVersion Include="System.Memory" Version="4.5.5" />
+    <PackageVersion Include="System.Buffers" Version="4.6.1" />
+    <PackageVersion Include="System.Memory" Version="4.6.3" />
     <PackageVersion Include="System.Text.Encoding.CodePages" Version="8.0.0" />
-    <PackageVersion Include="xunit" Version="2.9.0" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
-    <PackageVersion Include="xunit.SkippableFact" Version="1.4.13" />
-    <PackageVersion Include="ZstdSharp.Port" Version="0.8.1" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.SkippableFact" Version="1.5.23" />
+    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>
 </Project>

FORMATS.md

@@ -15,6 +15,7 @@
 | Tar                    | None                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.GZip               | DEFLATE                                           | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.BZip2              | BZip2                                             | Both                | TarArchive      | TarReader  | TarWriter (3) |
+| Tar.Zstandard          | ZStandard                                         | Decompress          | TarArchive      | TarReader  | N/A |
 | Tar.LZip               | LZMA                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
@@ -41,6 +42,7 @@ For those who want to directly compress/decompress bits. The single file formats
 | ADCStream       | Decompress          |
 | LZipStream      | Both                |
 | XZStream        | Decompress          |
+| ZStandardStream | Decompress          |
 
 ## Archive Formats vs Compression
 

README.md

@@ -1,6 +1,6 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
@@ -20,10 +20,12 @@ In general, I recommend GZip (Deflate)/BZip2 (BZip)/LZip (LZMA) as the simplicit
 
 Zip is okay, but it's a very hap-hazard format and the variation in headers and implementations makes it hard to get correct. Uses Deflate by default but supports a lot of compression methods.
 
-RAR is not recommended as it's a propriatory format and the compression is closed source. Use Tar/LZip for LZMA
+RAR is not recommended as it's a proprietary format and the compression is closed source. Use Tar/LZip for LZMA
 
 7Zip and XZ both are overly complicated. 7Zip does not support streamable formats. XZ has known holes explained here: (http://www.nongnu.org/lzip/xz_inadequate.html) Use Tar/LZip for LZMA compression instead.
 
+ZStandard is an efficient format that works well for streaming with a flexible compression level to tweak the speed/performance trade off you are looking for.  We currently only implement decompression for ZStandard but as we leverage the [ZstdSharp](https://github.com/oleg-st/ZstdSharp) library one could likely add compression support without much trouble (PRs are welcome!).
+
 ## A Simple Request
 
 Hi everyone. I hope you're using SharpCompress and finding it useful. Please give me feedback on what you'd like to see changed especially as far as usability goes. New feature suggestions are always welcome as well. I would also like to know what projects SharpCompress is being used in. I like seeing how it is used to give me ideas for future versions. Thanks!
@@ -40,6 +42,7 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 * 7Zip writing
 * Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
+* ZStandard writing
 
 ## Version Log
 

SharpCompress.sln

@@ -20,6 +20,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		.editorconfig = .editorconfig
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
+		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
 	EndProjectSection
 EndProject
 Global

SharpCompress.sln.DotSettings

@@ -15,17 +15,17 @@
 	
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">Basic Clean</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/APPLY_ON_COMPLETION/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Named</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Positional</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOR/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOREACH/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_WHILE/@EntryValue">Required</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_LINQ_QUERY/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARGUMENT/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_FOR_STMT/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_PARAMETER/@EntryValue">True</s:Boolean>
@@ -42,7 +42,7 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_IFELSE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_USING_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_WHILE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">False</s:Boolean>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
@@ -50,12 +50,12 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_EMBEDDED_STATEMENT_ON_SAME_LINE/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
 	
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">False</s:Boolean>
 	
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AFTER_TYPECAST_PARENTHESES/@EntryValue">False</s:Boolean>
@@ -67,13 +67,13 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_BEFORE_TYPEOF_PARENTHESES/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/STICK_COMMENT/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_ALWAYS</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_EXTENDS_LIST_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LINES/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVarWhenEvident</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVarWhenEvident</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVar</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVar</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVar</s:String>
 	
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
@@ -122,6 +122,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CustomTools/CustomToolsData/@EntryValue"></s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>

USAGE.md

@@ -71,18 +71,34 @@ using (var archive = ZipArchive.Create())
 memoryStream.Position = 0;
 ```
 
-### Extract all files from a Rar file to a directory using RarArchive
+### Extract all files from a rar file to a directory using RarArchive
+
+Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed.
+It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`.
+Alternatively, use `IArchive.WriteToDirectory`.
+
+```C#
+using (var archive = RarArchive.Open("Test.rar"))
+{
+    using (var reader = archive.ExtractAllEntries())
+    {
+        reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
+}
+```
+
+### Iterate over all files from a Rar file using RarArchive
 
 ```C#
 using (var archive = RarArchive.Open("Test.rar"))
 {
     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
     {
-        entry.WriteToDirectory("D:\\temp", new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
+        Console.WriteLine($"{entry.Key}: {entry.Size} bytes");
     }
 }
 ```

build/Program.cs

@@ -15,7 +15,7 @@ const string Publish = "publish";
 
 Target(
     Clean,
-    ForEach("**/bin", "**/obj"),
+    ["**/bin", "**/obj"],
     dir =>
     {
         IEnumerable<string> GetDirectories(string d)
@@ -44,14 +44,14 @@ Target(
     () =>
     {
         Run("dotnet", "tool restore");
-        Run("dotnet", "csharpier --check .");
+        Run("dotnet", "csharpier check .");
     }
 );
-Target(Restore, DependsOn(Format), () => Run("dotnet", "restore"));
+Target(Restore, [Format], () => Run("dotnet", "restore"));
 
 Target(
     Build,
-    DependsOn(Restore),
+    [Restore],
     () =>
     {
         Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release --no-restore");
@@ -60,8 +60,8 @@ Target(
 
 Target(
     Test,
-    DependsOn(Build),
-    ForEach("net8.0", "net462"),
+    [Build],
+    ["net8.0", "net48"],
     framework =>
     {
         IEnumerable<string> GetFiles(string d)
@@ -69,7 +69,7 @@ Target(
             return Glob.Files(".", d);
         }
 
-        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net462")
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net48")
         {
             return;
         }
@@ -83,13 +83,13 @@ Target(
 
 Target(
     Publish,
-    DependsOn(Test),
+    [Test],
     () =>
     {
         Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
     }
 );
 
-Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
+Target("default", [Publish], () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args);

build/build.csproj

@@ -1,14 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
-
   <ItemGroup>
     <PackageReference Include="Bullseye" />
     <PackageReference Include="Glob" />
-    <PackageReference Include="SimpleExec"  />
+    <PackageReference Include="SimpleExec" />
   </ItemGroup>
-
 </Project>

build/packages.lock.json

@@ -4,9 +4,9 @@
     "net8.0": {
       "Bullseye": {
         "type": "Direct",
-        "requested": "[5.0.0, )",
-        "resolved": "5.0.0",
-        "contentHash": "bqyt+m17ym+5aN45C5oZRAjuLDt8jKiCm/ys1XfymIXSkrTFwvI/QsbY3ucPSHDz7SF7uON7B57kXFv5H2k1ew=="
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw=="
       },
       "Glob": {
         "type": "Direct",
@@ -14,31 +14,11 @@
         "resolved": "1.1.9",
         "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
       },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Direct",
-        "requested": "[8.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "8.0.0",
-          "Microsoft.SourceLink.Common": "8.0.0"
-        }
-      },
       "SimpleExec": {
         "type": "Direct",
         "requested": "[12.0.0, )",
         "resolved": "12.0.0",
         "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       }
     }
   }

src/SharpCompress/Algorithms/Adler32.cs

@@ -141,7 +141,7 @@ internal static class Adler32 // From https://github.com/SixLabors/ImageSharp/bl
             4,
             3,
             2,
-            1 // tap2
+            1, // tap2
         };
 #endif
 

src/SharpCompress/Archives/AbstractArchive.cs

@@ -53,7 +53,7 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
     {
         if (!stream.CanSeek || !stream.CanRead)
         {
-            throw new ArgumentException("Archive streams must be Readable and Seekable");
+            throw new ArchiveException("Archive streams must be Readable and Seekable");
         }
         return stream;
     }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -151,7 +151,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     {
         if (!source.CanRead || !source.CanSeek)
         {
-            throw new ArgumentException(
+            throw new ArchiveException(
                 "Streams must be readable and seekable to use the Writing Archive API"
             );
         }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Factories;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
@@ -19,7 +20,7 @@ public static class ArchiveFactory
     public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-
+        stream = new SharpCompressStream(stream, bufferSize: readerOptions.BufferSize);
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
@@ -122,10 +123,7 @@ public static class ArchiveFactory
     )
     {
         using var archive = Open(sourceArchive);
-        foreach (var entry in archive.Entries)
-        {
-            entry.WriteToDirectory(destinationDirectory, options);
-        }
+        archive.WriteToDirectory(destinationDirectory, options);
     }
 
     private static T FindFactory<T>(FileInfo finfo)
@@ -168,14 +166,22 @@ public static class ArchiveFactory
         );
     }
 
-    public static bool IsArchive(string filePath, out ArchiveType? type)
+    public static bool IsArchive(
+        string filePath,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         filePath.CheckNotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type);
+        return IsArchive(s, out type, bufferSize);
     }
 
-    public static bool IsArchive(Stream stream, out ArchiveType? type)
+    public static bool IsArchive(
+        Stream stream,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         type = null;
         stream.CheckNotNull(nameof(stream));
@@ -189,9 +195,10 @@ public static class ArchiveFactory
 
         foreach (var factory in Factory.Factories)
         {
+            var isArchive = factory.IsArchive(stream);
             stream.Position = startPosition;
 
-            if (factory.IsArchive(stream, null))
+            if (isArchive)
             {
                 type = factory.KnownArchiveType;
                 return true;

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
@@ -14,8 +14,11 @@ class AutoArchiveFactory : IArchiveFactory
 
     public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
 
-    public bool IsArchive(Stream stream, string? password = null) =>
-        throw new NotSupportedException();
+    public bool IsArchive(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => throw new NotSupportedException();
 
     public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
 

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -89,6 +89,12 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         stream.CheckNotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new GZipArchive(
             new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
         );
@@ -162,7 +168,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
         if (Entries.Any())
         {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
         return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
     }
@@ -176,7 +182,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
         if (Entries.Count > 1)
         {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
         using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
         foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -17,7 +17,7 @@ public class GZipArchiveEntry : GZipEntry, IArchiveEntry
         {
             part.GetRawStream().Position = part.EntryStartPosition;
         }
-        return Parts.Single().GetCompressedStream();
+        return Parts.Single().GetCompressedStream().NotNull();
     }
 
     #region IArchiveEntry Members

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -58,7 +58,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using SharpCompress.Common;
+using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
@@ -18,10 +19,8 @@ public static class IArchiveExtensions
         ExtractionOptions? options = null
     )
     {
-        foreach (var entry in archive.Entries.Where(x => !x.IsDirectory))
-        {
-            entry.WriteToDirectory(destinationDirectory, options);
-        }
+        using var reader = archive.ExtractAllEntries();
+        reader.WriteAllToDirectory(destinationDirectory, options);
     }
 
     /// <summary>

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar;

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -14,6 +14,7 @@ namespace SharpCompress.Archives.Rar;
 
 public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
+    private bool _disposed;
     internal Lazy<IRarUnpack> UnpackV2017 { get; } =
         new(() => new Compressors.Rar.UnpackV2017.Unpack());
     internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
@@ -25,6 +26,20 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     private RarArchive(SourceStream sourceStream)
         : base(ArchiveType.Rar, sourceStream) { }
 
+    public override void Dispose()
+    {
+        if (!_disposed)
+        {
+            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
+            {
+                unpackV1.Dispose();
+            }
+
+            _disposed = true;
+            base.Dispose();
+        }
+    }
+
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
 
@@ -52,6 +67,16 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 
     protected override IReader CreateReaderForSolidExtraction()
     {
+        if (this.IsMultipartVolume())
+        {
+            var streams = Volumes.Select(volume =>
+            {
+                volume.Stream.Position = 0;
+                return volume.Stream;
+            });
+            return RarReader.Open(streams, ReaderOptions);
+        }
+
         var stream = Volumes.First().Stream;
         stream.Position = 0;
         return RarReader.Open(stream, ReaderOptions);
@@ -106,6 +131,12 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     public static RarArchive Open(Stream stream, ReaderOptions? options = null)
     {
         stream.CheckNotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
     }
 

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -42,7 +42,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
         {
             CheckIncomplete();
             return BitConverter.ToUInt32(
-                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc,
+                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc.NotNull(),
                 0
             );
         }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -92,6 +92,12 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         stream.CheckNotNull("stream");
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new SevenZipArchive(
             new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
         );
@@ -194,7 +200,10 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         new SevenZipReader(ReaderOptions, this);
 
     public override bool IsSolid =>
-        Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1;
+        Entries
+            .Where(x => !x.IsDirectory)
+            .GroupBy(x => x.FilePart.Folder)
+            .Any(folder => folder.Count() > 1);
 
     public override long TotalSize =>
         _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -90,6 +90,12 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         stream.CheckNotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new TarArchive(
             new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
         );

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -10,7 +10,7 @@ public class TarArchiveEntry : TarEntry, IArchiveEntry
     internal TarArchiveEntry(TarArchive archive, TarFilePart? part, CompressionType compressionType)
         : base(part, compressionType) => Archive = archive;
 
-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -58,7 +58,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -111,29 +111,51 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         stream.CheckNotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new ZipArchive(
             new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
         );
     }
 
-    public static bool IsZipFile(string filePath, string? password = null) =>
-        IsZipFile(new FileInfo(filePath), password);
+    public static bool IsZipFile(
+        string filePath,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
 
-    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    public static bool IsZipFile(
+        FileInfo fileInfo,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         if (!fileInfo.Exists)
         {
             return false;
         }
         using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password);
+        return IsZipFile(stream, password, bufferSize);
     }
 
-    public static bool IsZipFile(Stream stream, string? password = null)
+    public static bool IsZipFile(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -153,11 +175,20 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    public static bool IsZipMulti(Stream stream, string? password = null)
+    public static bool IsZipMulti(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -196,7 +227,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         if (streams.Count() > 1) //test part 2 - true = multipart not split
         {
             streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password);
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
             streams[1].Position -= 4;
             if (isZip)
             {
@@ -299,7 +330,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
-        stream.Position = 0;
+        ((IStreamStack)stream).StackSeek(0);
         return ZipReader.Open(stream, ReaderOptions, Entries);
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -9,7 +9,7 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
     internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
         : base(part) => Archive = archive;
 
-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
     #region IArchiveEntry Members
 
@@ -18,6 +18,4 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
     public bool IsComplete => true;
 
     #endregion
-
-    public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
 }

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -59,7 +59,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/AssemblyInfo.cs

@@ -1,3 +1,7 @@
 using System;
+using System.Runtime.CompilerServices;
 
-[assembly: CLSCompliant(true)]
+[assembly: CLSCompliant(false)]
+[assembly: InternalsVisibleTo(
+    "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
+)]

src/SharpCompress/BufferPool.cs

@@ -1,33 +0,0 @@
-using System.Buffers;
-
-namespace SharpCompress;
-
-internal static class BufferPool
-{
-    /// <summary>
-    ///     gets a buffer from the pool
-    /// </summary>
-    /// <param name="bufferSize">size of the buffer</param>
-    /// <returns>the buffer</returns>
-    public static byte[] Rent(int bufferSize)
-    {
-#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
-        return ArrayPool<byte>.Shared.Rent(bufferSize);
-#else
-        return new byte[bufferSize];
-#endif
-    }
-
-    /// <summary>
-    ///     returns a buffer to the pool
-    /// </summary>
-    /// <param name="buffer">the buffer to return</param>
-    public static void Return(byte[] buffer)
-    {
-#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
-        ArrayPool<byte>.Shared.Return(buffer);
-#else
-        // no-op
-#endif
-    }
-}

src/SharpCompress/Common/Arc/ArcEntry.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.GZip;
+using SharpCompress.Common.Tar;
+
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntry : Entry
+{
+    private readonly ArcFilePart? _filePart;
+
+    internal ArcEntry(ArcFilePart? filePart)
+    {
+        _filePart = filePart;
+    }
+
+    public override long Crc
+    {
+        get
+        {
+            if (_filePart == null)
+            {
+                return 0;
+            }
+            return _filePart.Header.Crc16;
+        }
+    }
+
+    public override string? Key => _filePart?.Header.Name;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+    public override CompressionType CompressionType =>
+        _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
+
+    public override long Size => throw new NotImplementedException();
+
+    public override DateTime? LastModifiedTime => null;
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => false;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+}

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

@@ -0,0 +1,75 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntryHeader
+{
+    public ArchiveEncoding ArchiveEncoding { get; }
+    public CompressionType CompressionMethod { get; private set; }
+    public string? Name { get; private set; }
+    public long CompressedSize { get; private set; }
+    public DateTime DateTime { get; private set; }
+    public int Crc16 { get; private set; }
+    public long OriginalSize { get; private set; }
+    public long DataStartPosition { get; private set; }
+
+    public ArcEntryHeader(ArchiveEncoding archiveEncoding)
+    {
+        this.ArchiveEncoding = archiveEncoding;
+    }
+
+    public ArcEntryHeader? ReadHeader(Stream stream)
+    {
+        byte[] headerBytes = new byte[29];
+        if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
+        {
+            return null;
+        }
+        DataStartPosition = stream.Position;
+        return LoadFrom(headerBytes);
+    }
+
+    public ArcEntryHeader LoadFrom(byte[] headerBytes)
+    {
+        CompressionMethod = GetCompressionType(headerBytes[1]);
+
+        // Read name
+        int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
+        Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
+
+        int offset = 15;
+        CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
+        offset += 4;
+        uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
+        DateTime = ConvertToDateTime(rawDateTime);
+        offset += 4;
+        Crc16 = BitConverter.ToUInt16(headerBytes, offset);
+        offset += 2;
+        OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
+        return this;
+    }
+
+    private CompressionType GetCompressionType(byte value)
+    {
+        return value switch
+        {
+            1 or 2 => CompressionType.None,
+            3 => CompressionType.RLE90,
+            4 => CompressionType.Squeezed,
+            5 or 6 or 7 or 8 => CompressionType.Crunched,
+            9 => CompressionType.Squashed,
+            10 => CompressionType.Crushed,
+            11 => CompressionType.Distilled,
+            _ => CompressionType.Unknown,
+        };
+    }
+
+    public static DateTime ConvertToDateTime(long rawDateTime)
+    {
+        // Convert Unix timestamp to DateTime (UTC)
+        return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
+    }
+}

src/SharpCompress/Common/Arc/ArcFilePart.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.GZip;
+using SharpCompress.Common.Tar;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.Compressors.Lzw;
+using SharpCompress.Compressors.RLE90;
+using SharpCompress.Compressors.Squeezed;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Arc;
+
+public class ArcFilePart : FilePart
+{
+    private readonly Stream? _stream;
+
+    internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
+        : base(localArcHeader.ArchiveEncoding)
+    {
+        _stream = seekableStream;
+        Header = localArcHeader;
+    }
+
+    internal ArcEntryHeader Header { get; set; }
+
+    internal override string? FilePartName => Header.Name;
+
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionMethod)
+            {
+                case CompressionType.None:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.CompressedSize
+                    );
+                    break;
+                case CompressionType.RLE90:
+                    compressedStream = new RunLength90Stream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Squeezed:
+                    compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Crunched:
+                    compressedStream = new ArcLzwStream(_stream, (int)Header.CompressedSize, true);
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionMethod
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream.NotNull();
+    }
+
+    internal override Stream? GetRawStream() => _stream;
+}

src/SharpCompress/Common/Arc/ArcVolume.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Common.Arc;
+
+public class ArcVolume : Volume
+{
+    public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+        : base(stream, readerOptions, index) { }
+}

src/SharpCompress/Common/ArchiveException.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ArchiveException : Exception
-{
-    public ArchiveException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/ArchiveType.cs

@@ -6,5 +6,6 @@ public enum ArchiveType
     Zip,
     Tar,
     SevenZip,
-    GZip
+    GZip,
+    Arc,
 }

src/SharpCompress/Common/CompressionType.cs

@@ -21,5 +21,12 @@ public enum CompressionType
     Reduce2,
     Reduce3,
     Reduce4,
-    Explode
+    Explode,
+    Squeezed,
+    RLE90,
+    Crunched,
+    Squashed,
+    Crushed,
+    Distilled,
+    ZStandard,
 }

src/SharpCompress/Common/CryptographicException.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class CryptographicException : Exception
-{
-    public CryptographicException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/EntryStream.cs

@@ -1,11 +1,33 @@
 using System;
 using System.IO;
+using System.IO.Compression;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
-public class EntryStream : Stream
+public class EntryStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private readonly IReader _reader;
     private readonly Stream _stream;
     private bool _completed;
@@ -15,6 +37,9 @@ public class EntryStream : Stream
     {
         _reader = reader;
         _stream = stream;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(EntryStream));
+#endif
     }
 
     /// <summary>
@@ -32,11 +57,28 @@ public class EntryStream : Stream
         {
             SkipEntry();
         }
+
+        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
+        if (_stream is IStreamStack ss)
+        {
+            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            {
+                deflateStream.Flush(); //Deflate over reads. Knock it back
+            }
+            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            {
+                lzmaStream.Flush(); //Lzma over reads. Knock it back
+            }
+        }
+
         if (_isDisposed)
         {
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
         base.Dispose(disposing);
         _stream.Dispose();
     }
@@ -53,7 +95,7 @@ public class EntryStream : Stream
 
     public override long Position
     {
-        get => throw new NotSupportedException();
+        get => _stream.Position; //throw new NotSupportedException();
         set => throw new NotSupportedException();
     }
 

src/SharpCompress/Common/ExtractionException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ExtractionException : Exception
-{
-    public ExtractionException(string message)
-        : base(message) { }
-
-    public ExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/FilePart.cs

@@ -11,7 +11,7 @@ public abstract class FilePart
     internal abstract string? FilePartName { get; }
     public int Index { get; set; }
 
-    internal abstract Stream GetCompressedStream();
+    internal abstract Stream? GetCompressedStream();
     internal abstract Stream? GetRawStream();
     internal bool Skipped { get; set; }
 }

src/SharpCompress/Common/IncompleteArchiveException.cs

@@ -1,7 +0,0 @@
-namespace SharpCompress.Common;
-
-public class IncompleteArchiveException : ArchiveException
-{
-    public IncompleteArchiveException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/InvalidFormatException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class InvalidFormatException : ExtractionException
-{
-    public InvalidFormatException(string message)
-        : base(message) { }
-
-    public InvalidFormatException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/MultiVolumeExtractionException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class MultiVolumeExtractionException : ExtractionException
-{
-    public MultiVolumeExtractionException(string message)
-        : base(message) { }
-
-    public MultiVolumeExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/MultipartStreamRequiredException.cs

@@ -1,7 +0,0 @@
-namespace SharpCompress.Common;
-
-public class MultipartStreamRequiredException : ExtractionException
-{
-    public MultipartStreamRequiredException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/Rar/CryptKey5.cs

@@ -17,7 +17,7 @@ internal class CryptKey5 : ICryptKey
     private byte[] _pswCheck = { };
     private byte[] _hashKey = { };
 
-    public CryptKey5(string password, Rar5CryptoInfo rar5CryptoInfo)
+    public CryptKey5(string? password, Rar5CryptoInfo rar5CryptoInfo)
     {
         _password = password ?? "";
         _cryptoInfo = rar5CryptoInfo;

src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs

@@ -1,8 +1,5 @@
 #nullable disable
 
-using System;
-using System.Security.Cryptography;
-using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;

src/SharpCompress/Common/Rar/Headers/FileHeader.cs

@@ -1,9 +1,6 @@
-#nullable disable
-
 using System;
 using System.IO;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.IO;
 #if !Rar2017_64bit
@@ -18,7 +15,7 @@ namespace SharpCompress.Common.Rar.Headers;
 
 internal class FileHeader : RarHeader
 {
-    private byte[] _hash;
+    private byte[]? _hash;
 
     public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
         : base(header, reader, headerType) { }
@@ -319,6 +316,10 @@ internal class FileHeader : RarHeader
 
                     if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
                     {
+                        if (SubData is null)
+                        {
+                            throw new InvalidFormatException();
+                        }
                         RecoverySectors =
                             SubData[8]
                             + (SubData[9] << 8)
@@ -340,12 +341,16 @@ internal class FileHeader : RarHeader
             if (RemainingHeaderBytes(reader) >= 2)
             {
                 var extendedFlags = reader.ReadUInt16();
-                FileLastModifiedTime = ProcessExtendedTimeV4(
-                    extendedFlags,
-                    FileLastModifiedTime,
-                    reader,
-                    0
-                );
+                if (FileLastModifiedTime is not null)
+                {
+                    FileLastModifiedTime = ProcessExtendedTimeV4(
+                        extendedFlags,
+                        FileLastModifiedTime,
+                        reader,
+                        0
+                    );
+                }
+
                 FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
                 FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
                 FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
@@ -377,7 +382,7 @@ internal class FileHeader : RarHeader
             var dosTime = reader.ReadUInt32();
             time = Utility.DosDateToDateTime(dosTime);
         }
-        if ((rmode & 4) == 0)
+        if ((rmode & 4) == 0 && time is not null)
         {
             time = time.Value.AddSeconds(1);
         }
@@ -390,7 +395,11 @@ internal class FileHeader : RarHeader
         }
 
         //10^-7 to 10^-3
-        return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+        if (time is not null)
+        {
+            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+        }
+        return null;
     }
 
     private static string ConvertPathV4(string path)
@@ -406,13 +415,13 @@ internal class FileHeader : RarHeader
         return path;
     }
 
-    public override string ToString() => FileName;
+    public override string ToString() => FileName ?? "FileHeader";
 
     private ushort Flags { get; set; }
 
     private bool HasFlag(ushort flag) => (Flags & flag) == flag;
 
-    internal byte[] FileCrc
+    internal byte[]? FileCrc
     {
         get => _hash;
         private set => _hash = value;
@@ -441,22 +450,22 @@ internal class FileHeader : RarHeader
     public bool IsRedir => RedirType != 0;
     public byte RedirFlags { get; private set; }
     public bool IsRedirDirectory => (RedirFlags & RedirFlagV5.DIRECTORY) != 0;
-    public string RedirTargetName { get; private set; }
+    public string? RedirTargetName { get; private set; }
 
     // unused for UnpackV1 implementation (limitation)
     internal size_t WindowSize { get; private set; }
 
-    internal byte[] R4Salt { get; private set; }
-    internal Rar5CryptoInfo Rar5CryptoInfo { get; private set; }
+    internal byte[]? R4Salt { get; private set; }
+    internal Rar5CryptoInfo? Rar5CryptoInfo { get; private set; }
     private byte HostOs { get; set; }
     internal uint FileAttributes { get; private set; }
     internal long CompressedSize { get; private set; }
     internal long UncompressedSize { get; private set; }
-    internal string FileName { get; private set; }
-    internal byte[] SubData { get; private set; }
+    internal string? FileName { get; private set; }
+    internal byte[]? SubData { get; private set; }
     internal int RecoverySectors { get; private set; }
     internal long DataStartPosition { get; set; }
-    public Stream PackedStream { get; set; }
+    public Stream? PackedStream { get; set; }
 
     public bool IsSplitBefore =>
         IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);

src/SharpCompress/Common/Rar/Headers/Flags.cs

@@ -13,7 +13,7 @@ public enum HeaderType : byte
     Sign,
     NewSub,
     EndArchive,
-    Crypt
+    Crypt,
 }
 
 internal static class HeaderCodeV

src/SharpCompress/Common/Rar/Headers/RarHeader.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
@@ -21,7 +20,7 @@ internal class RarHeader : IRarHeader
         {
             return new RarHeader(reader, isRar5, archiveEncoding);
         }
-        catch (EndOfStreamException)
+        catch (InvalidFormatException)
         {
             return null;
         }

src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs

@@ -1,7 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -160,10 +158,15 @@ public class RarHeaderFactory
                             {
                                 fh.PackedStream = new RarCryptoWrapper(
                                     ms,
-                                    fh.R4Salt is null ? fh.Rar5CryptoInfo.Salt : fh.R4Salt,
                                     fh.R4Salt is null
-                                        ? new CryptKey5(Options.Password!, fh.Rar5CryptoInfo)
-                                        : new CryptKey3(Options.Password!)
+                                        ? fh.Rar5CryptoInfo.NotNull().Salt
+                                        : fh.R4Salt,
+                                    fh.R4Salt is null
+                                        ? new CryptKey5(
+                                            Options.Password,
+                                            fh.Rar5CryptoInfo.NotNull()
+                                        )
+                                        : new CryptKey3(Options.Password)
                                 );
                             }
                         }

src/SharpCompress/Common/Rar/RarEntry.cs

@@ -20,7 +20,7 @@ public abstract class RarEntry : Entry
     /// <summary>
     /// The File's 32 bit CRC Hash
     /// </summary>
-    public override long Crc => BitConverter.ToUInt32(FileHeader.FileCrc, 0);
+    public override long Crc => BitConverter.ToUInt32(FileHeader.FileCrc.NotNull(), 0);
 
     /// <summary>
     /// The path of the file internal to the Rar Archive.
@@ -68,7 +68,7 @@ public abstract class RarEntry : Entry
 
     public bool IsRedir => FileHeader.IsRedir;
 
-    public string RedirTargetName => FileHeader.RedirTargetName;
+    public string? RedirTargetName => FileHeader.RedirTargetName;
 
     public override string ToString() =>
         string.Format(

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -62,7 +62,7 @@ public abstract class RarVolume : Volume
                         if (fh.FileName == "CMT")
                         {
                             var buffer = new byte[fh.CompressedSize];
-                            fh.PackedStream.Read(buffer, 0, buffer.Length);
+                            fh.PackedStream.NotNull().ReadFully(buffer);
                             Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1);
                         }
                     }

src/SharpCompress/Common/ReaderCancelledException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ReaderCancelledException : Exception
-{
-    public ReaderCancelledException(string message)
-        : base(message) { }
-
-    public ReaderCancelledException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -784,7 +784,7 @@ internal class ArchiveReader
                         );
                         break;
                     default:
-                        throw new InvalidOperationException();
+                        throw new InvalidFormatException();
                 }
             }
         }
@@ -843,7 +843,7 @@ internal class ArchiveReader
                 outStream.ReadExact(data, 0, data.Length);
                 if (outStream.ReadByte() >= 0)
                 {
-                    throw new InvalidOperationException("Decoded stream is longer than expected.");
+                    throw new InvalidFormatException("Decoded stream is longer than expected.");
                 }
                 dataVector.Add(data);
 
@@ -854,7 +854,7 @@ internal class ArchiveReader
                         != folder._unpackCrc
                     )
                     {
-                        throw new InvalidOperationException(
+                        throw new InvalidFormatException(
                             "Decoded stream does not match expected CRC."
                         );
                     }
@@ -996,6 +996,11 @@ internal class ArchiveReader
                             numFiles,
                             delegate(int i, uint? attr)
                             {
+                                // Keep the original attribute value because it could potentially get
+                                // modified in the logic that follows. Some callers of the library may
+                                // find the original value useful.
+                                db._files[i].ExtendedAttrib = attr;
+
                                 // Some third party implementations established an unofficial extension
                                 // of the 7z archive format by placing posix file attributes in the high
                                 // bits of the windows file attributes. This makes use of the fact that
@@ -1458,7 +1463,7 @@ internal class ArchiveReader
 #if DEBUG
             Log.WriteLine(_db._files[index].Name);
 #endif
-            if (_db._files[index].CrcDefined)
+            if (_db._files[index].Crc.HasValue)
             {
                 _stream = new CrcCheckStream(_db._files[index].Crc.Value);
             }

src/SharpCompress/Common/SevenZip/CFileItem.cs

@@ -8,18 +8,13 @@ internal class CFileItem
 {
     public long Size { get; internal set; }
     public uint? Attrib { get; internal set; }
+    public uint? ExtendedAttrib { get; internal set; }
     public uint? Crc { get; internal set; }
     public string Name { get; internal set; }
 
     public bool HasStream { get; internal set; }
     public bool IsDir { get; internal set; }
 
-    public bool CrcDefined => Crc != null;
-
-    public bool AttribDefined => Attrib != null;
-
-    public void SetAttrib(uint attrib) => Attrib = attrib;
-
     public DateTime? CTime { get; internal set; }
     public DateTime? ATime { get; internal set; }
     public DateTime? MTime { get; internal set; }

src/SharpCompress/Common/SevenZip/SevenZipEntry.cs

@@ -38,5 +38,8 @@ public class SevenZipEntry : Entry
     public override int? Attrib =>
         FilePart.Header.Attrib.HasValue ? (int?)FilePart.Header.Attrib.Value : null;
 
+    public int? ExtendedAttrib =>
+        FilePart.Header.ExtendedAttrib.HasValue ? (int?)FilePart.Header.ExtendedAttrib.Value : null;
+
     internal override IEnumerable<FilePart> Parts => FilePart.AsEnumerable<FilePart>();
 }

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 using System.Linq;
 using SharpCompress.IO;
@@ -41,7 +40,7 @@ internal class SevenZipFilePart : FilePart
     {
         if (!Header.HasStream)
         {
-            throw new InvalidOperationException("File does not have a stream.");
+            return Stream.Null;
         }
         var folderStream = _database.GetFolderStream(_stream, Folder!, _database.PasswordProvider);
 
@@ -86,7 +85,7 @@ internal class SevenZipFilePart : FilePart
             K_LZMA or K_LZMA2 => CompressionType.LZMA,
             K_PPMD => CompressionType.PPMd,
             K_B_ZIP2 => CompressionType.BZip2,
-            _ => throw new NotImplementedException()
+            _ => throw new InvalidFormatException(),
         };
     }
 

src/SharpCompress/Common/SharpCompressException.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class SharpCompressException : Exception
+{
+    public SharpCompressException() { }
+
+    public SharpCompressException(string message)
+        : base(message) { }
+
+    public SharpCompressException(string message, Exception inner)
+        : base(message, inner) { }
+}
+
+public class ArchiveException(string message) : SharpCompressException(message);
+
+public class IncompleteArchiveException(string message) : ArchiveException(message);
+
+public class CryptographicException(string message) : SharpCompressException(message);
+
+public class ReaderCancelledException(string message) : SharpCompressException(message);
+
+public class ExtractionException : SharpCompressException
+{
+    public ExtractionException() { }
+
+    public ExtractionException(string message)
+        : base(message) { }
+
+    public ExtractionException(string message, Exception inner)
+        : base(message, inner) { }
+}
+
+public class MultipartStreamRequiredException(string message) : ExtractionException(message);
+
+public class MultiVolumeExtractionException(string message) : ExtractionException(message);
+
+public class InvalidFormatException : ExtractionException
+{
+    public InvalidFormatException() { }
+
+    public InvalidFormatException(string message)
+        : base(message) { }
+
+    public InvalidFormatException(string message, Exception inner)
+        : base(message, inner) { }
+}

src/SharpCompress/Common/Tar/Headers/EntryType.cs

@@ -14,5 +14,5 @@ internal enum EntryType : byte
     LongName = (byte)'L',
     SparseFile = (byte)'S',
     VolumeHeader = (byte)'V',
-    GlobalExtendedHeader = (byte)'g'
+    GlobalExtendedHeader = (byte)'g',
 }

src/SharpCompress/Common/Tar/Headers/TarHeader.cs

@@ -216,7 +216,7 @@ internal sealed class TarHeader
 
         if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
         {
-            throw new InvalidOperationException("Buffer is invalid size");
+            throw new InvalidFormatException("Buffer is invalid size");
         }
         return buffer;
     }
@@ -314,7 +314,7 @@ internal sealed class TarHeader
         (byte)' ',
         (byte)' ',
         (byte)' ',
-        (byte)' '
+        (byte)' ',
     };
 
     internal static bool checkChecksum(byte[] buf)

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -4,13 +4,38 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar;
 
-internal class TarReadOnlySubStream : NonDisposingStream
+internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+
+    Stream IStreamStack.BaseStream() => base.Stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private bool _isDisposed;
     private long _amountRead;
 
     public TarReadOnlySubStream(Stream stream, long bytesToRead)
-        : base(stream, throwOnDispose: false) => BytesLeftToRead = bytesToRead;
+        : base(stream, leaveOpen: true, throwOnDispose: false)
+    {
+        BytesLeftToRead = bytesToRead;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(TarReadOnlySubStream));
+#endif
+    }
 
     protected override void Dispose(bool disposing)
     {
@@ -20,7 +45,9 @@ internal class TarReadOnlySubStream : NonDisposingStream
         }
 
         _isDisposed = true;
-
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(TarReadOnlySubStream));
+#endif
         if (disposing)
         {
             // Ensure we read all remaining blocks for this entry.

src/SharpCompress/Common/Volume.cs

@@ -7,16 +7,22 @@ namespace SharpCompress.Common;
 
 public abstract class Volume : IVolume
 {
+    private readonly Stream _baseStream;
     private readonly Stream _actualStream;
 
     internal Volume(Stream stream, ReaderOptions? readerOptions, int index = 0)
     {
         Index = index;
         ReaderOptions = readerOptions ?? new ReaderOptions();
+        _baseStream = stream;
         if (ReaderOptions.LeaveStreamOpen)
         {
-            stream = NonDisposingStream.Create(stream);
+            stream = SharpCompressStream.Create(stream, leaveOpen: true);
         }
+
+        if (stream is IStreamStack ss)
+            ss.SetBuffer(ReaderOptions.BufferSize, true);
+
         _actualStream = stream;
     }
 
@@ -32,7 +38,7 @@ public abstract class Volume : IVolume
 
     public virtual int Index { get; internal set; }
 
-    public string? FileName => (_actualStream as FileStream)?.Name;
+    public string? FileName => (_baseStream as FileStream)?.Name;
 
     /// <summary>
     /// RarArchive is part of a multi-part archive.

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

@@ -123,11 +123,7 @@ internal class DirectoryEntryHeader : ZipFileEntry
 
     public long RelativeOffsetOfEntryHeader { get; set; }
 
-    public uint ExternalFileAttributes { get; set; }
-
     public ushort InternalFileAttributes { get; set; }
 
     public ushort DiskNumberStart { get; set; }
-
-    public string? Comment { get; private set; }
 }

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

@@ -13,5 +13,5 @@ internal enum HeaderFlags : ushort
     EnhancedDeflate = 16,
 
     //Bit 11: Language encoding flag
-    Efs = 2048
+    Efs = 2048,
 }

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

@@ -14,7 +14,7 @@ internal enum ExtraDataType : ushort
     // -Info-ZIP Unicode Path Extra Field
     UnicodePathExtraField = 0x7075,
     Zip64ExtendedInformationExtraField = 0x0001,
-    UnixTimeExtraField = 0x5455
+    UnixTimeExtraField = 0x5455,
 }
 
 internal class ExtraData
@@ -166,10 +166,10 @@ internal sealed class UnixTimeExtraField : ExtraData
                 return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
             }
 
-            var flags = DataBytes[0];
-            var isModifiedTimeSpecified = (flags & 0x01) == 1;
-            var isLastAccessTimeSpecified = (flags & 0x02) == 1;
-            var isCreationTimeSpecified = (flags & 0x04) == 1;
+            var flags = (RecordedTimeFlag)DataBytes[0];
+            var isModifiedTimeSpecified = flags.HasFlag(RecordedTimeFlag.LastModified);
+            var isLastAccessTimeSpecified = flags.HasFlag(RecordedTimeFlag.LastAccessed);
+            var isCreationTimeSpecified = flags.HasFlag(RecordedTimeFlag.Created);
             var currentIndex = 1;
             DateTime? modifiedTime = null;
             DateTime? lastAccessTime = null;
@@ -189,7 +189,7 @@ internal sealed class UnixTimeExtraField : ExtraData
             {
                 if (currentIndex + 4 > DataBytes.Length)
                 {
-                    throw new ArchiveException("Invalid UnicodeExtraTime field");
+                    return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
                 }
 
                 var lastAccessEpochTime = BinaryPrimitives.ReadInt32LittleEndian(
@@ -206,7 +206,7 @@ internal sealed class UnixTimeExtraField : ExtraData
             {
                 if (currentIndex + 4 > DataBytes.Length)
                 {
-                    throw new ArchiveException("Invalid UnicodeExtraTime field");
+                    return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
                 }
 
                 var creationTimeEpochTime = BinaryPrimitives.ReadInt32LittleEndian(
@@ -222,6 +222,15 @@ internal sealed class UnixTimeExtraField : ExtraData
             return Tuple.Create(modifiedTime, lastAccessTime, creationTime);
         }
     }
+
+    [Flags]
+    private enum RecordedTimeFlag
+    {
+        None = 0,
+        LastModified = 1,
+        LastAccessed = 2,
+        Created = 4,
+    }
 }
 
 internal static class LocalEntryHeaderExtraFactory
@@ -229,11 +238,14 @@ internal static class LocalEntryHeaderExtraFactory
     internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData) =>
         type switch
         {
-            ExtraDataType.UnicodePathExtraField
-                => new ExtraUnicodePathExtraField(type, length, extraData),
-            ExtraDataType.Zip64ExtendedInformationExtraField
-                => new Zip64ExtendedInformationExtraField(type, length, extraData),
+            ExtraDataType.UnicodePathExtraField => new ExtraUnicodePathExtraField(
+                type,
+                length,
+                extraData
+            ),
+            ExtraDataType.Zip64ExtendedInformationExtraField =>
+                new Zip64ExtendedInformationExtraField(type, length, extraData),
             ExtraDataType.UnixTimeExtraField => new UnixTimeExtraField(type, length, extraData),
-            _ => new ExtraData(type, length, extraData)
+            _ => new ExtraData(type, length, extraData),
         };
 }

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

@@ -120,4 +120,8 @@ internal abstract class ZipFileEntry : ZipHeader
     internal ZipFilePart? Part { get; set; }
 
     internal bool IsZip64 => CompressedSize >= uint.MaxValue;
+
+    internal uint ExternalFileAttributes { get; set; }
+
+    internal string? Comment { get; set; }
 }

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

@@ -8,5 +8,5 @@ internal enum ZipHeaderType
     DirectoryEnd,
     Split,
     Zip64DirectoryEnd,
-    Zip64DirectoryEndLocator
+    Zip64DirectoryEndLocator,
 }

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

@@ -1,16 +1,37 @@
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
 internal enum CryptoMode
 {
     Encrypt,
-    Decrypt
+    Decrypt,
 }
 
-internal class PkwareTraditionalCryptoStream : Stream
+internal class PkwareTraditionalCryptoStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { return; }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { return; }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private readonly PkwareTraditionalEncryptionData _encryptor;
     private readonly CryptoMode _mode;
     private readonly Stream _stream;
@@ -25,6 +46,10 @@ internal class PkwareTraditionalCryptoStream : Stream
         _encryptor = encryptor;
         _stream = stream;
         _mode = mode;
+
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(PkwareTraditionalCryptoStream));
+#endif
     }
 
     public override bool CanRead => (_mode == CryptoMode.Decrypt);
@@ -100,6 +125,9 @@ internal class PkwareTraditionalCryptoStream : Stream
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(PkwareTraditionalCryptoStream));
+#endif
         base.Dispose(disposing);
         _stream.Dispose();
     }

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
@@ -8,18 +7,13 @@ internal class SeekableZipFilePart : ZipFilePart
 {
     private bool _isLocalHeaderLoaded;
     private readonly SeekableZipHeaderFactory _headerFactory;
-    private readonly DirectoryEntryHeader _directoryEntryHeader;
 
     internal SeekableZipFilePart(
         SeekableZipHeaderFactory headerFactory,
         DirectoryEntryHeader header,
         Stream stream
     )
-        : base(header, stream)
-    {
-        _headerFactory = headerFactory;
-        _directoryEntryHeader = header;
-    }
+        : base(header, stream) => _headerFactory = headerFactory;
 
     internal override Stream GetCompressedStream()
     {
@@ -31,29 +25,13 @@ internal class SeekableZipFilePart : ZipFilePart
         return base.GetCompressedStream();
     }
 
-    internal string? Comment => ((DirectoryEntryHeader)Header).Comment;
-
-    private void LoadLocalHeader()
-    {
-        var hasData = Header.HasData;
-        Header = _headerFactory.GetLocalHeader(BaseStream, ((DirectoryEntryHeader)Header));
-        Header.HasData = hasData;
-    }
+    private void LoadLocalHeader() =>
+        Header = _headerFactory.GetLocalHeader(BaseStream, (DirectoryEntryHeader)Header);
 
     protected override Stream CreateBaseStream()
     {
         BaseStream.Position = Header.DataStartPosition.NotNull();
 
-        if (
-            (Header.CompressedSize == 0)
-            && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
-            && _directoryEntryHeader.HasData
-            && (_directoryEntryHeader.CompressedSize != 0)
-        )
-        {
-            return new ReadOnlySubStream(BaseStream, _directoryEntryHeader.CompressedSize);
-        }
-
         return BaseStream;
     }
 }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -149,6 +149,18 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
         {
             throw new InvalidOperationException();
         }
+
+        // populate fields only known from the DirectoryEntryHeader
+        localEntryHeader.HasData = directoryEntryHeader.HasData;
+        localEntryHeader.ExternalFileAttributes = directoryEntryHeader.ExternalFileAttributes;
+        localEntryHeader.Comment = directoryEntryHeader.Comment;
+
+        if (FlagUtility.HasFlag(localEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
+        {
+            localEntryHeader.Crc = directoryEntryHeader.Crc;
+            localEntryHeader.CompressedSize = directoryEntryHeader.CompressedSize;
+            localEntryHeader.UncompressedSize = directoryEntryHeader.UncompressedSize;
+        }
         return localEntryHeader;
     }
 }

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Net.Sockets;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
@@ -27,12 +26,12 @@ internal sealed class StreamingZipFilePart : ZipFilePart
         );
         if (LeaveStreamOpen)
         {
-            return NonDisposingStream.Create(_decompressionStream);
+            return SharpCompressStream.Create(_decompressionStream, leaveOpen: true);
         }
         return _decompressionStream;
     }
 
-    internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
+    internal BinaryReader FixStreamedFileLocation(ref SharpCompressStream rewindableStream)
     {
         if (Header.IsDirectory)
         {
@@ -50,7 +49,7 @@ internal sealed class StreamingZipFilePart : ZipFilePart
 
             if (_decompressionStream is DeflateStream deflateStream)
             {
-                rewindableStream.Rewind(deflateStream.InputBuffer);
+                ((IStreamStack)rewindableStream).StackSeek(0);
             }
 
             Skipped = true;

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -19,16 +20,24 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
 
     internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream)
     {
-        RewindableStream rewindableStream;
+        if (stream is not SharpCompressStream) //ensure the stream is already a SharpCompressStream. So the buffer/size will already be set
+        {
+            //the original code wrapped this with RewindableStream. Wrap with SharpCompressStream as we can get the buffer size
+            if (stream is SourceStream src)
+            {
+                stream = new SharpCompressStream(
+                    stream,
+                    src.ReaderOptions.LeaveStreamOpen,
+                    bufferSize: src.ReaderOptions.BufferSize
+                );
+            }
+            else
+            {
+                throw new ArgumentException("Stream must be a SharpCompressStream", nameof(stream));
+            }
+        }
+        SharpCompressStream rewindableStream = (SharpCompressStream)stream;
 
-        if (stream is RewindableStream rs)
-        {
-            rewindableStream = rs;
-        }
-        else
-        {
-            rewindableStream = new RewindableStream(stream);
-        }
         while (true)
         {
             ZipHeader? header;
@@ -43,9 +52,8 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 {
                     continue;
                 }
-                reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
-                    ref rewindableStream
-                );
+
+                // removed requirement for FixStreamedFileLocation()
 
                 var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
 
@@ -56,26 +64,32 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 }
                 _lastEntryHeader.Crc = crc;
 
-                // The DataDescriptor can be either 64bit or 32bit
-                var compressed_size = reader.ReadUInt32();
-                var uncompressed_size = reader.ReadUInt32();
-
-                // Check if we have header or 64bit DataDescriptor
+                //attempt 32bit read
+                ulong compSize = reader.ReadUInt32();
+                ulong uncompSize = reader.ReadUInt32();
                 headerBytes = reader.ReadUInt32();
-                var test_header = !(headerBytes == 0x04034b50 || headerBytes == 0x02014b50);
 
-                var test_64bit = ((long)uncompressed_size << 32) | compressed_size;
-                if (test_64bit == _lastEntryHeader.CompressedSize && test_header)
+                //check for zip64 sentinel or unexpected header
+                bool isSentinel = compSize == 0xFFFFFFFF || uncompSize == 0xFFFFFFFF;
+                bool isHeader = headerBytes == 0x04034b50 || headerBytes == 0x02014b50;
+
+                if (!isHeader && !isSentinel)
                 {
-                    _lastEntryHeader.UncompressedSize =
-                        ((long)reader.ReadUInt32() << 32) | headerBytes;
+                    //reshuffle into 64-bit values
+                    compSize = (uncompSize << 32) | compSize;
+                    uncompSize = ((ulong)headerBytes << 32) | reader.ReadUInt32();
                     headerBytes = reader.ReadUInt32();
                 }
-                else
+                else if (isSentinel)
                 {
-                    _lastEntryHeader.UncompressedSize = uncompressed_size;
+                    //standards-compliant zip64 descriptor
+                    compSize = reader.ReadUInt64();
+                    uncompSize = reader.ReadUInt64();
                 }
 
+                _lastEntryHeader.CompressedSize = (long)compSize;
+                _lastEntryHeader.UncompressedSize = (long)uncompSize;
+
                 if (pos.HasValue)
                 {
                     _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
@@ -86,9 +100,9 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 if (_lastEntryHeader.Part is null)
                     continue;
 
-                reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
-                    ref rewindableStream
-                );
+                //reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
+                //    ref rewindableStream
+                //);
 
                 var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
 
@@ -173,16 +187,11 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
                 else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
                 {
-                    var isRecording = rewindableStream.IsRecording;
-                    if (!isRecording)
-                    {
-                        rewindableStream.StartRecording();
-                    }
                     var nextHeaderBytes = reader.ReadUInt32();
+                    ((IStreamStack)rewindableStream).Rewind(sizeof(uint));
 
                     // Check if next data is PostDataDescriptor, streamed file with 0 length
                     header.HasData = !IsHeader(nextHeaderBytes);
-                    rewindableStream.Rewind(!isRecording);
                 }
                 else // We are not streaming and compressed size is 0, we have no data
                 {

src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs

@@ -2,11 +2,32 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Security.Cryptography;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
-internal class WinzipAesCryptoStream : Stream
+internal class WinzipAesCryptoStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private const int BLOCK_SIZE_IN_BYTES = 16;
     private readonly SymmetricAlgorithm _cipher;
     private readonly byte[] _counter = new byte[BLOCK_SIZE_IN_BYTES];
@@ -27,6 +48,10 @@ internal class WinzipAesCryptoStream : Stream
         _stream = stream;
         _totalBytesLeftToRead = length;
 
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(WinzipAesCryptoStream));
+#endif
+
         _cipher = CreateCipher(winzipAesEncryptionData);
 
         var iv = new byte[BLOCK_SIZE_IN_BYTES];
@@ -64,6 +89,9 @@ internal class WinzipAesCryptoStream : Stream
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(WinzipAesCryptoStream));
+#endif
         if (disposing)
         {
             //read out last 10 auth bytes

src/SharpCompress/Common/Zip/WinzipAesKeySize.cs

@@ -4,5 +4,5 @@ internal enum WinzipAesKeySize
 {
     KeySize128 = 1,
     KeySize192 = 2,
-    KeySize256 = 3
+    KeySize256 = 3,
 }

src/SharpCompress/Common/Zip/ZipCompressionMethod.cs

@@ -13,8 +13,8 @@ internal enum ZipCompressionMethod
     Deflate64 = 9,
     BZip2 = 12,
     LZMA = 14,
-    ZStd = 93,
+    ZStandard = 93,
     Xz = 95,
     PPMd = 98,
-    WinzipAes = 0x63 //http://www.winzip.com/aes_info.htm
+    WinzipAes = 0x63, //http://www.winzip.com/aes_info.htm
 }

src/SharpCompress/Common/Zip/ZipEntry.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using SharpCompress.Common.Zip.Headers;
 
 namespace SharpCompress.Common.Zip;
@@ -15,10 +16,19 @@ public class ZipEntry : Entry
             return;
         }
         _filePart = filePart;
+
         LastModifiedTime = Utility.DosDateToDateTime(
             filePart.Header.LastModifiedDate,
             filePart.Header.LastModifiedTime
         );
+
+        var times =
+            filePart.Header.Extra.FirstOrDefault(header =>
+                header.GetType() == typeof(UnixTimeExtraField)
+            ) as UnixTimeExtraField;
+
+        LastAccessedTime = times?.UnicodeTimes.Item2;
+        CreatedTime = times?.UnicodeTimes.Item3;
     }
 
     public override CompressionType CompressionType =>
@@ -36,7 +46,8 @@ public class ZipEntry : Entry
             ZipCompressionMethod.Reduce3 => CompressionType.Reduce3,
             ZipCompressionMethod.Reduce4 => CompressionType.Reduce4,
             ZipCompressionMethod.Explode => CompressionType.Explode,
-            _ => CompressionType.Unknown
+            ZipCompressionMethod.ZStandard => CompressionType.ZStandard,
+            _ => CompressionType.Unknown,
         };
 
     public override long Crc => _filePart?.Header.Crc ?? 0;
@@ -51,9 +62,17 @@ public class ZipEntry : Entry
 
     public override DateTime? LastModifiedTime { get; }
 
-    public override DateTime? CreatedTime => null;
+    /// <inheritdoc/>
+    /// <remarks>
+    /// The returned time is UTC, not local.
+    /// </remarks>
+    public override DateTime? CreatedTime { get; }
 
-    public override DateTime? LastAccessedTime => null;
+    /// <inheritdoc/>
+    /// <remarks>
+    /// The returned time is UTC, not local.
+    /// </remarks>
+    public override DateTime? LastAccessedTime { get; }
 
     public override DateTime? ArchivedTime => null;
 
@@ -65,4 +84,8 @@ public class ZipEntry : Entry
     public override bool IsSplitAfter => false;
 
     internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+
+    public override int? Attrib => (int?)_filePart?.Header.ExternalFileAttributes;
+
+    public string? Comment => _filePart?.Header.Comment;
 }

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -13,8 +13,8 @@ using SharpCompress.Compressors.PPMd;
 using SharpCompress.Compressors.Reduce;
 using SharpCompress.Compressors.Shrink;
 using SharpCompress.Compressors.Xz;
+using SharpCompress.Compressors.ZStandard;
 using SharpCompress.IO;
-using ZstdSharp;
 
 namespace SharpCompress.Common.Zip;
 
@@ -45,7 +45,7 @@ internal abstract class ZipFilePart : FilePart
         );
         if (LeaveStreamOpen)
         {
-            return NonDisposingStream.Create(decompressionStream);
+            return SharpCompressStream.Create(decompressionStream, leaveOpen: true);
         }
         return decompressionStream;
     }
@@ -70,17 +70,12 @@ internal abstract class ZipFilePart : FilePart
         {
             case ZipCompressionMethod.None:
             {
-                if (stream is ReadOnlySubStream)
+                if (Header.CompressedSize is 0)
                 {
-                    return stream;
+                    return new DataDescriptorStream(stream);
                 }
 
-                if (Header.CompressedSize > 0)
-                {
-                    return new ReadOnlySubStream(stream, Header.CompressedSize);
-                }
-
-                return new DataDescriptorStream(stream);
+                return stream;
             }
             case ZipCompressionMethod.Shrink:
             {
@@ -152,7 +147,7 @@ internal abstract class ZipFilePart : FilePart
             {
                 return new XZStream(stream);
             }
-            case ZipCompressionMethod.ZStd:
+            case ZipCompressionMethod.ZStandard:
             {
                 return new DecompressionStream(stream);
             }
@@ -218,7 +213,7 @@ internal abstract class ZipFilePart : FilePart
             ) || Header.IsZip64
         )
         {
-            plainStream = NonDisposingStream.Create(plainStream); //make sure AES doesn't close
+            plainStream = SharpCompressStream.Create(plainStream, leaveOpen: true); //make sure AES doesn't close
         }
         else
         {

src/SharpCompress/Compressors/ADC/ADCStream.cs

@@ -1,4 +1,4 @@
-//
+//
 // ADC.cs
 //
 // Author:
@@ -28,14 +28,35 @@
 
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.ADC;
 
 /// <summary>
 /// Provides a forward readable only stream that decompresses ADC data
 /// </summary>
-public sealed class ADCStream : Stream
+public sealed class ADCStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     /// <summary>
     /// This stream holds the compressed data
     /// </summary>
@@ -74,6 +95,9 @@ public sealed class ADCStream : Stream
         }
 
         _stream = stream;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(ADCStream));
+#endif
     }
 
     public override bool CanRead => _stream.CanRead;
@@ -99,6 +123,9 @@ public sealed class ADCStream : Stream
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(ADCStream));
+#endif
         base.Dispose(disposing);
     }
 

src/SharpCompress/Compressors/ArcLzw/ArcLzwStream.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using SharpCompress.Compressors.RLE90;
+using SharpCompress.Compressors.Squeezed;
+using SharpCompress.IO;
+
+public partial class ArcLzwStream : Stream, IStreamStack
+{
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
+    private Stream _stream;
+    private bool _processed;
+    private bool _useCrunched;
+    private int _compressedSize;
+
+    private const int BITS = 12;
+    private const int CRUNCH_BITS = 12;
+    private const int SQUASH_BITS = 13;
+    private const int INIT_BITS = 9;
+    private const ushort FIRST = 257;
+    private const ushort CLEAR = 256;
+
+    private ushort oldcode;
+    private byte finchar;
+    private int n_bits;
+    private ushort maxcode;
+    private ushort[] prefix = new ushort[8191];
+    private byte[] suffix = new byte[8191];
+    private bool clearFlag;
+    private Stack<byte> stack = new Stack<byte>();
+    private ushort freeEnt;
+    private ushort maxcodemax;
+
+    public ArcLzwStream(Stream stream, int compressedSize, bool useCrunched = true)
+    {
+        _stream = stream;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(ArcLzwStream));
+#endif
+        _useCrunched = useCrunched;
+        _compressedSize = compressedSize;
+
+        oldcode = 0;
+        finchar = 0;
+        n_bits = 0;
+        maxcode = 0;
+        clearFlag = false;
+        freeEnt = FIRST;
+        maxcodemax = 0;
+    }
+
+    private ushort? GetCode(BitReader reader)
+    {
+        if (clearFlag || freeEnt > maxcode)
+        {
+            if (freeEnt > maxcode)
+            {
+                n_bits++;
+                maxcode = (n_bits == BITS) ? maxcodemax : (ushort)((1 << n_bits) - 1);
+            }
+            if (clearFlag)
+            {
+                clearFlag = false;
+                n_bits = INIT_BITS;
+                maxcode = (ushort)((1 << n_bits) - 1);
+            }
+        }
+        return (ushort?)reader.ReadBits(n_bits);
+    }
+
+    public List<byte> Decompress(byte[] input, bool useCrunched)
+    {
+        var result = new List<byte>();
+        int bits = useCrunched ? CRUNCH_BITS : SQUASH_BITS;
+
+        if (useCrunched)
+        {
+            if (input[0] != BITS)
+            {
+                throw new InvalidDataException($"File packed with {input[0]}, expected {BITS}.");
+            }
+
+            input = input.Skip(1).ToArray();
+        }
+
+        maxcodemax = (ushort)(1 << bits);
+        clearFlag = false;
+        n_bits = INIT_BITS;
+        maxcode = (ushort)((1 << n_bits) - 1);
+
+        for (int i = 0; i < 256; i++)
+        {
+            suffix[i] = (byte)i;
+        }
+
+        var reader = new BitReader(input);
+        freeEnt = FIRST;
+
+        if (GetCode(reader) is ushort old)
+        {
+            oldcode = old;
+            finchar = (byte)oldcode;
+            result.Add(finchar);
+        }
+
+        while (GetCode(reader) is ushort code)
+        {
+            if (code == CLEAR)
+            {
+                Array.Clear(prefix, 0, prefix.Length);
+                clearFlag = true;
+                freeEnt = (ushort)(FIRST - 1);
+
+                if (GetCode(reader) is ushort c)
+                {
+                    code = c;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            ushort incode = code;
+
+            if (code >= freeEnt)
+            {
+                stack.Push(finchar);
+                code = oldcode;
+            }
+
+            while (code >= 256)
+            {
+                stack.Push(suffix[code]);
+                code = prefix[code];
+            }
+
+            finchar = suffix[code];
+            stack.Push(finchar);
+
+            while (stack.Count > 0)
+            {
+                result.Add(stack.Pop());
+            }
+            code = freeEnt;
+            if (code < maxcodemax)
+            {
+                prefix[code] = oldcode;
+                suffix[code] = finchar;
+                freeEnt = (ushort)(code + 1);
+            }
+
+            oldcode = incode;
+        }
+
+        return result;
+    }
+
+    // Stream base class implementation
+    public override bool CanRead => true;
+    public override bool CanSeek => false;
+    public override bool CanWrite => false;
+    public override long Length => throw new NotImplementedException();
+    public override long Position
+    {
+        get => _stream.Position;
+        set => throw new NotImplementedException();
+    }
+
+    public override void Flush() => throw new NotImplementedException();
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        if (_processed)
+        {
+            return 0;
+        }
+        _processed = true;
+        var data = new byte[_compressedSize];
+        _stream.Read(data, 0, _compressedSize);
+        var decoded = Decompress(data, _useCrunched);
+        var result = decoded.Count();
+        if (_useCrunched)
+        {
+            var unpacked = RLE.UnpackRLE(decoded.ToArray());
+            unpacked.CopyTo(buffer, 0);
+            result = unpacked.Count;
+        }
+        else
+        {
+            decoded.CopyTo(buffer, 0);
+        }
+        return result;
+    }
+
+    public override long Seek(long offset, SeekOrigin origin) =>
+        throw new NotImplementedException();
+
+    public override void SetLength(long value) => throw new NotImplementedException();
+
+    public override void Write(byte[] buffer, int offset, int count) =>
+        throw new NotImplementedException();
+
+    protected override void Dispose(bool disposing)
+    {
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(ArcLzwStream));
+#endif
+        base.Dispose(disposing);
+    }
+}

src/SharpCompress/Compressors/ArcLzw/BitReader.cs

@@ -0,0 +1,56 @@
+using System;
+
+public partial class ArcLzwStream
+{
+    public class BitReader
+    {
+        private readonly byte[] data;
+        private int bitPosition;
+        private int bytePosition;
+
+        public BitReader(byte[] inputData)
+        {
+            data = inputData;
+            bitPosition = 0;
+            bytePosition = 0;
+        }
+
+        public int? ReadBits(int bitCount)
+        {
+            if (bitCount <= 0 || bitCount > 16)
+                throw new ArgumentOutOfRangeException(
+                    nameof(bitCount),
+                    "Bit count must be between 1 and 16"
+                );
+
+            if (bytePosition >= data.Length)
+                return null;
+
+            int result = 0;
+            int bitsRead = 0;
+
+            while (bitsRead < bitCount)
+            {
+                if (bytePosition >= data.Length)
+                    return null;
+
+                int bitsAvailable = 8 - bitPosition;
+                int bitsToRead = Math.Min(bitCount - bitsRead, bitsAvailable);
+
+                int mask = (1 << bitsToRead) - 1;
+                result |= ((data[bytePosition] >> bitPosition) & mask) << bitsRead;
+
+                bitPosition += bitsToRead;
+                bitsRead += bitsToRead;
+
+                if (bitPosition >= 8)
+                {
+                    bitPosition = 0;
+                    bytePosition++;
+                }
+            }
+
+            return (ushort)result;
+        }
+    }
+}

src/SharpCompress/Compressors/BZip2/BZip2Constants.cs

@@ -555,6 +555,6 @@ internal class BZip2Constants
         858,
         364,
         936,
-        638
+        638,
     };
 }

src/SharpCompress/Compressors/BZip2/BZip2Stream.cs

@@ -1,10 +1,31 @@
-using System;
+using System;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.BZip2;
 
-public sealed class BZip2Stream : Stream
+public sealed class BZip2Stream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private readonly Stream stream;
     private bool isDisposed;
 
@@ -16,6 +37,9 @@ public sealed class BZip2Stream : Stream
     /// <param name="decompressConcatenated">Decompress Concatenated</param>
     public BZip2Stream(Stream stream, CompressionMode compressionMode, bool decompressConcatenated)
     {
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(BZip2Stream));
+#endif
         Mode = compressionMode;
         if (Mode == CompressionMode.Compress)
         {
@@ -36,6 +60,9 @@ public sealed class BZip2Stream : Stream
             return;
         }
         isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(BZip2Stream));
+#endif
         if (disposing)
         {
             stream.Dispose();

src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 /*
  * Copyright 2001,2004-2005 The Apache Software Foundation
@@ -37,8 +38,28 @@ namespace SharpCompress.Compressors.BZip2;
   * start of the BZIP2 stream to make it compatible with other PGP programs.
   */
 
-internal class CBZip2InputStream : Stream
+internal class CBZip2InputStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => bsStream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private static void Cadvise()
     {
         //System.out.Println("CRC Error");
@@ -164,6 +185,10 @@ internal class CBZip2InputStream : Stream
         ll8 = null;
         tt = null;
         BsSetStream(zStream);
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(CBZip2InputStream));
+#endif
+
         Initialize(true);
         InitBlock();
         SetupBlock();
@@ -176,6 +201,9 @@ internal class CBZip2InputStream : Stream
             return;
         }
         isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(CBZip2InputStream));
+#endif
         base.Dispose(disposing);
         bsStream?.Dispose();
     }
@@ -542,9 +570,14 @@ internal class CBZip2InputStream : Stream
             {
                 j++;
             }
-            selectorMtf[i] = (char)j;
+            if (i < BZip2Constants.MAX_SELECTORS)
+            {
+                selectorMtf[i] = (char)j;
+            }
         }
 
+        nSelectors = Math.Min(nSelectors, BZip2Constants.MAX_SELECTORS);
+
         /* Undo the MTF values for the selectors. */
         {
             var pos = new char[BZip2Constants.N_GROUPS];

src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 /*
  * Copyright 2001,2004-2005 The Apache Software Foundation
@@ -38,8 +39,28 @@ namespace SharpCompress.Compressors.BZip2;
   * start of the BZIP2 stream to make it compatible with other PGP programs.
   */
 
-internal sealed class CBZip2OutputStream : Stream
+internal sealed class CBZip2OutputStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => bsStream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private const int SETMASK = (1 << 21);
     private const int CLEARMASK = (~SETMASK);
     private const int GREATER_ICOST = 15;
@@ -334,6 +355,10 @@ internal sealed class CBZip2OutputStream : Stream
 
         BsSetStream(inStream);
 
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(CBZip2OutputStream));
+#endif
+
         workFactor = 50;
         if (inBlockSize > 9)
         {
@@ -450,6 +475,9 @@ internal sealed class CBZip2OutputStream : Stream
             Finish();
 
             disposed = true;
+#if DEBUG_STREAMS
+            this.DebugDispose(typeof(CBZip2OutputStream));
+#endif
             Dispose();
             bsStream?.Dispose();
             bsStream = null;
@@ -1829,7 +1857,7 @@ internal sealed class CBZip2OutputStream : Stream
         88573,
         265720,
         797161,
-        2391484
+        2391484,
     };
 
     private void AllocateCompressStructures()

src/SharpCompress/Compressors/BZip2/CRC.cs

@@ -288,7 +288,7 @@ internal class CRC
         unchecked((int)0xbcb4666d),
         unchecked((int)0xb8757bda),
         unchecked((int)0xb5365d03),
-        unchecked((int)0xb1f740b4)
+        unchecked((int)0xb1f740b4),
     };
 
     public CRC() => InitialiseCRC();

src/SharpCompress/Compressors/CompressionMode.cs

@@ -3,5 +3,5 @@ namespace SharpCompress.Compressors;
 public enum CompressionMode
 {
     Compress = 0,
-    Decompress = 1
+    Decompress = 1,
 }

src/SharpCompress/Compressors/Deflate/DeflateManager.cs

@@ -106,7 +106,7 @@ internal sealed partial class DeflateManager
         5,
         5,
         5,
-        0
+        0,
     };
 
     // extra bits for each distance code
@@ -141,7 +141,7 @@ internal sealed partial class DeflateManager
         12,
         12,
         13,
-        13
+        13,
     };
 
     internal enum BlockState
@@ -149,14 +149,14 @@ internal sealed partial class DeflateManager
         NeedMore = 0, // block not completed, need more input or more output
         BlockDone, // block flush performed
         FinishStarted, // finish started, need only more output at next deflate
-        FinishDone // finish done, accept no more input or output
+        FinishDone, // finish done, accept no more input or output
     }
 
     internal enum DeflateFlavor
     {
         Store,
         Fast,
-        Slow
+        Slow,
     }
 
     private const int MEM_LEVEL_MAX = 9;
@@ -214,7 +214,7 @@ internal sealed partial class DeflateManager
                 new Config(8, 16, 128, 128, DeflateFlavor.Slow),
                 new Config(8, 32, 128, 256, DeflateFlavor.Slow),
                 new Config(32, 128, 258, 1024, DeflateFlavor.Slow),
-                new Config(32, 258, 258, 4096, DeflateFlavor.Slow)
+                new Config(32, 258, 258, 4096, DeflateFlavor.Slow),
             };
 
         private static readonly Config[] Table;
@@ -233,7 +233,7 @@ internal sealed partial class DeflateManager
         "insufficient memory",
         "buffer error",
         "incompatible version",
-        ""
+        "",
     };
 
     // preset dictionary flag in zlib header
@@ -1793,7 +1793,7 @@ internal sealed partial class DeflateManager
             DeflateFlavor.Store => DeflateNone,
             DeflateFlavor.Fast => DeflateFast,
             DeflateFlavor.Slow => DeflateSlow,
-            _ => DeflateFunction
+            _ => DeflateFunction,
         };
 
     internal int SetParams(CompressionLevel level, CompressionStrategy strategy)

src/SharpCompress/Compressors/Deflate/DeflateStream.cs

@@ -27,11 +27,33 @@
 using System;
 using System.IO;
 using System.Text;
+using System.Threading;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
 
-public class DeflateStream : Stream
+public class DeflateStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _baseStream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private readonly ZlibBaseStream _baseStream;
     private bool _disposed;
 
@@ -40,7 +62,8 @@ public class DeflateStream : Stream
         CompressionMode mode,
         CompressionLevel level = CompressionLevel.Default,
         Encoding? forceEncoding = null
-    ) =>
+    )
+    {
         _baseStream = new ZlibBaseStream(
             stream,
             mode,
@@ -49,6 +72,11 @@ public class DeflateStream : Stream
             forceEncoding
         );
 
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(DeflateStream));
+#endif
+    }
+
     #region Zlib properties
 
     /// <summary>
@@ -233,6 +261,9 @@ public class DeflateStream : Stream
         {
             if (!_disposed)
             {
+#if DEBUG_STREAMS
+                this.DebugDispose(typeof(DeflateStream));
+#endif
                 if (disposing)
                 {
                     _baseStream?.Dispose();
@@ -290,6 +321,7 @@ public class DeflateStream : Stream
         {
             throw new ObjectDisposedException("DeflateStream");
         }
+
         return _baseStream.Read(buffer, offset, count);
     }
 

src/SharpCompress/Compressors/Deflate/FlushType.cs

@@ -39,5 +39,5 @@ public enum FlushType
     Full,
 
     /// <summary>Signals the end of the compression/decompression stream.</summary>
-    Finish
+    Finish,
 }

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -30,11 +30,32 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Text;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
 
-public class GZipStream : Stream
+public class GZipStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => BaseStream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     internal static readonly DateTime UNIX_EPOCH = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
     private string? _comment;
@@ -62,6 +83,9 @@ public class GZipStream : Stream
     )
     {
         BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, encoding);
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(GZipStream));
+#endif
         _encoding = encoding;
     }
 
@@ -210,6 +234,9 @@ public class GZipStream : Stream
                     Crc32 = BaseStream.Crc32;
                 }
                 _disposed = true;
+#if DEBUG_STREAMS
+                this.DebugDispose(typeof(GZipStream));
+#endif
             }
         }
         finally

src/SharpCompress/Compressors/Deflate/InfTree.cs

@@ -1615,7 +1615,7 @@ internal sealed class InfTree
         79,
         0,
         9,
-        255
+        255,
     };
 
     //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_td'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
@@ -1716,7 +1716,7 @@ internal sealed class InfTree
         193,
         192,
         5,
-        24577
+        24577,
     };
 
     // Tables for deflate from PKZIP's appnote.txt.
@@ -1753,7 +1753,7 @@ internal sealed class InfTree
         227,
         258,
         0,
-        0
+        0,
     };
 
     // see note #13 above about 258
@@ -1790,7 +1790,7 @@ internal sealed class InfTree
         5,
         0,
         112,
-        112
+        112,
     };
 
     //UPGRADE_NOTE: Final was removed from the declaration of 'cpdist'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
@@ -1825,7 +1825,7 @@ internal sealed class InfTree
         8193,
         12289,
         16385,
-        24577
+        24577,
     };
 
     //UPGRADE_NOTE: Final was removed from the declaration of 'cpdext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
@@ -1860,7 +1860,7 @@ internal sealed class InfTree
         12,
         12,
         13,
-        13
+        13,
     };
 
     // If BMAX needs to be larger than 16, then h and x[] should be uLong.

src/SharpCompress/Compressors/Deflate/Inflate.cs

@@ -93,7 +93,7 @@ internal sealed class InflateBlocks
         2,
         14,
         1,
-        15
+        15,
     };
 
     internal ZlibCodec _codec; // pointer back to this zlib stream
@@ -815,7 +815,7 @@ internal sealed class InflateBlocks
         CODES = 6, // processing fixed or dynamic block
         DRY = 7, // output remaining window bytes
         DONE = 8, // finished last block, done
-        BAD = 9 // ot a data error--stuck here
+        BAD = 9, // ot a data error--stuck here
     }
 
     #endregion
@@ -842,7 +842,7 @@ internal static class InternalInflateConstants
         0x00001fff,
         0x00003fff,
         0x00007fff,
-        0x0000ffff
+        0x0000ffff,
     };
 }
 
@@ -2054,7 +2054,7 @@ internal sealed class InflateManager
         CHECK2 = 10, // two check bytes to go
         CHECK1 = 11, // one check byte to go
         DONE = 12, // finished check, done
-        BAD = 13 // got an error--stay here
+        BAD = 13, // got an error--stay here
     }
 
     #endregion

src/SharpCompress/Compressors/Deflate/Tree.cs

@@ -95,7 +95,7 @@ internal sealed partial class DeflateManager
             2,
             14,
             1,
-            15
+            15,
         };
 
         // The lengths of the bit length codes are sent in order of decreasing
@@ -618,7 +618,7 @@ internal sealed partial class DeflateManager
             29,
             29,
             29,
-            29
+            29,
         };
 
         internal static readonly sbyte[] LengthCode =
@@ -878,7 +878,7 @@ internal sealed partial class DeflateManager
             27,
             27,
             27,
-            28
+            28,
         };
 
         internal static readonly int[] LengthBase =
@@ -911,7 +911,7 @@ internal sealed partial class DeflateManager
             160,
             192,
             224,
-            0
+            0,
         };
 
         internal static readonly int[] DistanceBase =
@@ -945,7 +945,7 @@ internal sealed partial class DeflateManager
             8192,
             12288,
             16384,
-            24576
+            24576,
         };
 
         internal short[] dyn_tree; // the dynamic tree

src/SharpCompress/Compressors/Deflate/Zlib.cs

@@ -62,8 +62,8 @@
 //
 // -----------------------------------------------------------------------
 
-using System;
 using System.IO;
+using SharpCompress.Common;
 
 namespace SharpCompress.Compressors.Deflate;
 
@@ -143,7 +143,7 @@ public enum CompressionLevel
     /// <summary>
     /// A synonym for BestCompression.
     /// </summary>
-    Level9 = BestCompression
+    Level9 = BestCompression,
 }
 
 /// <summary>
@@ -171,13 +171,13 @@ public enum CompressionStrategy
     /// Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no
     /// string matching.
     /// </summary>
-    HuffmanOnly = 2
+    HuffmanOnly = 2,
 }
 
 /// <summary>
 /// A general purpose exception class for exceptions in the Zlib library.
 /// </summary>
-public class ZlibException : Exception
+public class ZlibException : SharpCompressException
 {
     /// <summary>
     /// The ZlibException class captures exception information generated
@@ -859,7 +859,7 @@ internal sealed class StaticTree
         99,
         8,
         227,
-        8
+        8,
     };
 
     internal static readonly short[] distTreeCodes =
@@ -923,7 +923,7 @@ internal sealed class StaticTree
         7,
         5,
         23,
-        5
+        5,
     };
 
     // extra bits for each bit length code
@@ -947,7 +947,7 @@ internal sealed class StaticTree
         0,
         2,
         3,
-        7
+        7,
     };
 
     internal static readonly StaticTree Literals;

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -32,6 +32,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
 
@@ -39,11 +40,31 @@ internal enum ZlibStreamFlavor
 {
     ZLIB = 1950,
     DEFLATE = 1951,
-    GZIP = 1952
+    GZIP = 1952,
 }
 
-internal class ZlibBaseStream : Stream
+internal class ZlibBaseStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     protected internal ZlibCodec _z; // deferred init... new ZlibCodec();
 
     protected internal StreamMode _streamMode = StreamMode.Undefined;
@@ -87,6 +108,10 @@ internal class ZlibBaseStream : Stream
 
         _encoding = encoding;
 
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(ZlibBaseStream));
+#endif
+
         // workitem 7159
         if (flavor == ZlibStreamFlavor.GZIP)
         {
@@ -334,6 +359,9 @@ internal class ZlibBaseStream : Stream
             return;
         }
         isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(ZlibBaseStream));
+#endif
         base.Dispose(disposing);
         if (disposing)
         {
@@ -354,7 +382,13 @@ internal class ZlibBaseStream : Stream
         }
     }
 
-    public override void Flush() => _stream.Flush();
+    public override void Flush()
+    {
+        _stream.Flush();
+        //rewind the buffer
+        ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
+        z.AvailableBytesIn = 0;
+    }
 
     public override Int64 Seek(Int64 offset, SeekOrigin origin) =>
         throw new NotSupportedException();
@@ -634,6 +668,13 @@ internal class ZlibBaseStream : Stream
             crc.SlurpBlock(buffer, offset, rc);
         }
 
+        if (rc == ZlibConstants.Z_STREAM_END && z.AvailableBytesIn != 0 && !_wantCompress)
+        {
+            //rewind the buffer
+            ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
+            z.AvailableBytesIn = 0;
+        }
+
         return rc;
     }
 
@@ -655,6 +696,6 @@ internal class ZlibBaseStream : Stream
     {
         Writer,
         Reader,
-        Undefined
+        Undefined,
     }
 }

src/SharpCompress/Compressors/Deflate/ZlibConstants.cs

@@ -60,7 +60,6 @@
 //
 // -----------------------------------------------------------------------
 
-
 namespace SharpCompress.Compressors.Deflate;
 
 /// <summary>