Add Async RAR and more

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -70,24 +70,51 @@ public override long CompressedSize
 
     public Stream OpenEntryStream()
     {
+        RarStream stream;
         if (IsRarV3)
         {
-            return new RarStream(
+            stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
                 new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
 
-        return new RarStream(
-            archive.UnpackV2017.Value,
-            FileHeader,
-            new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-        );
+        stream.Initialize();
+        return stream;
     }
 
-    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult(OpenEntryStream());
+    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
 
     public bool IsComplete
     {

src/SharpCompress/Common/EntryStream.cs

@@ -64,6 +64,11 @@ public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
 
     protected override void Dispose(bool disposing)
     {
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
             SkipEntry();
@@ -81,12 +86,6 @@ protected override void Dispose(bool disposing)
                 lzmaStream.Flush(); //Lzma over reads. Knock it back
             }
         }
-
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
 #if DEBUG_STREAMS
         this.DebugDispose(typeof(EntryStream));
 #endif
@@ -97,6 +96,11 @@ protected override void Dispose(bool disposing)
 #if !NETFRAMEWORK && !NETSTANDARD2_0
     public override async ValueTask DisposeAsync()
     {
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
             await SkipEntryAsync().ConfigureAwait(false);
@@ -114,12 +118,6 @@ public override async ValueTask DisposeAsync()
                 await lzmaStream.FlushAsync().ConfigureAwait(false);
             }
         }
-
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
 #if DEBUG_STREAMS
         this.DebugDispose(typeof(EntryStream));
 #endif
@@ -204,4 +202,11 @@ public override int ReadByte()
 
     public override void Write(byte[] buffer, int offset, int count) =>
         throw new NotSupportedException();
+
+    public override Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    ) => throw new NotSupportedException();
 }

src/SharpCompress/Compressors/Rar/IRarUnpack.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 
 namespace SharpCompress.Compressors.Rar;
@@ -8,6 +10,14 @@ internal interface IRarUnpack
     void DoUnpack(FileHeader fileHeader, Stream readStream, Stream writeStream);
     void DoUnpack();
 
+    Task DoUnpackAsync(
+        FileHeader fileHeader,
+        Stream readStream,
+        Stream writeStream,
+        CancellationToken cancellationToken
+    );
+    Task DoUnpackAsync(CancellationToken cancellationToken);
+
     // eg u/i pause/resume button
     bool Suspended { get; set; }
 

src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs

@@ -150,6 +150,136 @@ public override int Read(byte[] buffer, int offset, int count)
         return totalRead;
     }
 
+    public override async System.Threading.Tasks.Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        System.Threading.CancellationToken cancellationToken
+    )
+    {
+        var totalRead = 0;
+        var currentOffset = offset;
+        var currentCount = count;
+        while (currentCount > 0)
+        {
+            var readSize = currentCount;
+            if (currentCount > maxPosition - currentPosition)
+            {
+                readSize = (int)(maxPosition - currentPosition);
+            }
+
+            var read = await currentStream
+                .ReadAsync(buffer, currentOffset, readSize, cancellationToken)
+                .ConfigureAwait(false);
+            if (read < 0)
+            {
+                throw new EndOfStreamException();
+            }
+
+            currentPosition += read;
+            currentOffset += read;
+            currentCount -= read;
+            totalRead += read;
+            if (
+                ((maxPosition - currentPosition) == 0)
+                && filePartEnumerator.Current.FileHeader.IsSplitAfter
+            )
+            {
+                if (filePartEnumerator.Current.FileHeader.R4Salt != null)
+                {
+                    throw new InvalidFormatException(
+                        "Sharpcompress currently does not support multi-volume decryption."
+                    );
+                }
+                var fileName = filePartEnumerator.Current.FileHeader.FileName;
+                if (!filePartEnumerator.MoveNext())
+                {
+                    throw new InvalidFormatException(
+                        "Multi-part rar file is incomplete.  Entry expects a new volume: "
+                            + fileName
+                    );
+                }
+                InitializeNextFilePart();
+            }
+            else
+            {
+                break;
+            }
+        }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
+        return totalRead;
+    }
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
+    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        System.Threading.CancellationToken cancellationToken = default
+    )
+    {
+        var totalRead = 0;
+        var currentOffset = 0;
+        var currentCount = buffer.Length;
+        while (currentCount > 0)
+        {
+            var readSize = currentCount;
+            if (currentCount > maxPosition - currentPosition)
+            {
+                readSize = (int)(maxPosition - currentPosition);
+            }
+
+            var read = await currentStream
+                .ReadAsync(buffer.Slice(currentOffset, readSize), cancellationToken)
+                .ConfigureAwait(false);
+            if (read < 0)
+            {
+                throw new EndOfStreamException();
+            }
+
+            currentPosition += read;
+            currentOffset += read;
+            currentCount -= read;
+            totalRead += read;
+            if (
+                ((maxPosition - currentPosition) == 0)
+                && filePartEnumerator.Current.FileHeader.IsSplitAfter
+            )
+            {
+                if (filePartEnumerator.Current.FileHeader.R4Salt != null)
+                {
+                    throw new InvalidFormatException(
+                        "Sharpcompress currently does not support multi-volume decryption."
+                    );
+                }
+                var fileName = filePartEnumerator.Current.FileHeader.FileName;
+                if (!filePartEnumerator.MoveNext())
+                {
+                    throw new InvalidFormatException(
+                        "Multi-part rar file is incomplete.  Entry expects a new volume: "
+                            + fileName
+                    );
+                }
+                InitializeNextFilePart();
+            }
+            else
+            {
+                break;
+            }
+        }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
+        return totalRead;
+    }
+#endif
+
     public override bool CanRead => true;
 
     public override bool CanSeek => false;

src/SharpCompress/Compressors/Rar/RarBLAKE2spStream.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
@@ -103,7 +105,7 @@ public BLAKE2SP()
 
     byte[] _hash = { };
 
-    public RarBLAKE2spStream(
+    private RarBLAKE2spStream(
         IRarUnpack unpack,
         FileHeader fileHeader,
         MultiVolumeReadOnlyStream readStream
@@ -121,6 +123,29 @@ MultiVolumeReadOnlyStream readStream
         ResetCrc();
     }
 
+    public static RarBLAKE2spStream Create(
+        IRarUnpack unpack,
+        FileHeader fileHeader,
+        MultiVolumeReadOnlyStream readStream
+    )
+    {
+        var stream = new RarBLAKE2spStream(unpack, fileHeader, readStream);
+        stream.Initialize();
+        return stream;
+    }
+
+    public static async Task<RarBLAKE2spStream> CreateAsync(
+        IRarUnpack unpack,
+        FileHeader fileHeader,
+        MultiVolumeReadOnlyStream readStream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var stream = new RarBLAKE2spStream(unpack, fileHeader, readStream);
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
+
     protected override void Dispose(bool disposing)
     {
 #if DEBUG_STREAMS
@@ -333,4 +358,59 @@ public override int Read(byte[] buffer, int offset, int count)
 
         return result;
     }
+
+    public override async System.Threading.Tasks.Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        System.Threading.CancellationToken cancellationToken
+    )
+    {
+        var result = await base.ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (result != 0)
+        {
+            Update(_blake2sp, new ReadOnlySpan<byte>(buffer, offset, result), result);
+        }
+        else
+        {
+            _hash = Final(_blake2sp);
+            if (!disableCRCCheck && !(GetCrc().SequenceEqual(readStream.CurrentCrc)) && count != 0)
+            {
+                // NOTE: we use the last FileHeader in a multipart volume to check CRC
+                throw new InvalidFormatException("file crc mismatch");
+            }
+        }
+
+        return result;
+    }
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
+    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        System.Threading.CancellationToken cancellationToken = default
+    )
+    {
+        var result = await base.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+        if (result != 0)
+        {
+            Update(_blake2sp, buffer.Span.Slice(0, result), result);
+        }
+        else
+        {
+            _hash = Final(_blake2sp);
+            if (
+                !disableCRCCheck
+                && !(GetCrc().SequenceEqual(readStream.CurrentCrc))
+                && buffer.Length != 0
+            )
+            {
+                // NOTE: we use the last FileHeader in a multipart volume to check CRC
+                throw new InvalidFormatException("file crc mismatch");
+            }
+        }
+
+        return result;
+    }
+#endif
 }