diff --git a/src/SharpCompress/Archives/Rar/RarArchive.cs b/src/SharpCompress/Archives/Rar/RarArchive.cs index 9fa8e2a1..b2e69588 100644 --- a/src/SharpCompress/Archives/Rar/RarArchive.cs +++ b/src/SharpCompress/Archives/Rar/RarArchive.cs @@ -272,5 +272,22 @@ public class RarArchive : AbstractArchive } } + public static async Task IsRarFileAsync( + Stream stream, + ReaderOptions? options = null, + CancellationToken cancellationToken = default + ) + { + try + { + await MarkHeader.ReadAsync(stream, true, false, cancellationToken).ConfigureAwait(false); + return true; + } + catch + { + return false; + } + } + #endregion } diff --git a/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs b/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs index 9ca0f9b2..b49abcf8 100644 --- a/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs +++ b/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs @@ -1,5 +1,7 @@ using System; using System.IO; +using System.Threading; +using System.Threading.Tasks; namespace SharpCompress.Common.Rar.Headers; @@ -129,4 +131,128 @@ internal class MarkHeader : IRarHeader throw new InvalidFormatException("Rar signature not found"); } + + private static async Task GetByteAsync( + Stream stream, + CancellationToken cancellationToken = default + ) + { + var buffer = new byte[1]; + var bytesRead = await stream.ReadAsync(buffer, 0, 1, cancellationToken).ConfigureAwait(false); + if (bytesRead == 1) + { + return buffer[0]; + } + throw new EndOfStreamException(); + } + + public static async Task ReadAsync( + Stream stream, + bool leaveStreamOpen, + bool lookForHeader, + CancellationToken cancellationToken = default + ) + { + var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0; + try + { + var start = -1; + var b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + while (start <= maxScanIndex) + { + // Rar old signature: 52 45 7E 5E + // Rar4 signature: 52 61 72 21 1A 07 00 + // Rar5 signature: 52 61 72 21 1A 07 01 00 + if (b == 0x52) + { + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b == 0x61) + { + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x72) + { + continue; + } + + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x21) + { + continue; + } + + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x1a) + { + continue; + } + + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x07) + { + continue; + } + + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b == 1) + { + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0) + { + continue; + } + + return new MarkHeader(true); // Rar5 + } + else if (b == 0) + { + return new MarkHeader(false); // Rar4 + } + } + else if (b == 0x45) + { + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x7e) + { + continue; + } + + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + if (b != 0x5e) + { + continue; + } + + throw new InvalidFormatException( + "Rar format version pre-4 is unsupported." + ); + } + } + else + { + b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false); + start++; + } + } + } + catch (Exception e) + { + if (!leaveStreamOpen) + { + stream.Dispose(); + } + throw new InvalidFormatException("Error trying to read rar signature.", e); + } + + throw new InvalidFormatException("Rar signature not found"); + } } diff --git a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs index 902e595f..43522e4e 100644 --- a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs +++ b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs @@ -1,5 +1,7 @@ using System.Collections.Generic; using System.IO; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.IO; using SharpCompress.Readers; @@ -40,6 +42,30 @@ public class RarHeaderFactory } } + public async IAsyncEnumerable ReadHeadersAsync( + Stream stream, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + var markHeader = await MarkHeader + .ReadAsync(stream, Options.LeaveStreamOpen, Options.LookForHeader, cancellationToken) + .ConfigureAwait(false); + _isRar5 = markHeader.IsRar5; + yield return markHeader; + + RarHeader? header; + while ((header = TryReadNextHeader(stream)) != null) + { + yield return header; + if (header.HeaderType == HeaderType.EndArchive) + { + // End of archive marker. RAR does not read anything after this header letting to use third + // party tools to add extra information such as a digital signature to archive. + yield break; + } + } + } + private RarHeader? TryReadNextHeader(Stream stream) { RarCrcBinaryReader reader; diff --git a/src/SharpCompress/Common/Rar/RarVolume.cs b/src/SharpCompress/Common/Rar/RarVolume.cs index 4bb2f84a..101848f6 100644 --- a/src/SharpCompress/Common/Rar/RarVolume.cs +++ b/src/SharpCompress/Common/Rar/RarVolume.cs @@ -3,6 +3,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common.Rar.Headers; using SharpCompress.IO; using SharpCompress.Readers; @@ -26,6 +28,14 @@ public abstract class RarVolume : Volume internal abstract IEnumerable ReadFileParts(); + internal virtual IAsyncEnumerable ReadFilePartsAsync( + CancellationToken cancellationToken = default + ) + { + // Default implementation - derived classes can override for better async support + throw new NotImplementedException("Async read is not supported for this volume type"); + } + internal abstract RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader); internal IEnumerable GetVolumeFileParts() @@ -71,6 +81,53 @@ public abstract class RarVolume : Volume } } + internal async IAsyncEnumerable GetVolumeFilePartsAsync( + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + MarkHeader? lastMarkHeader = null; + await foreach ( + var header in _headerFactory.ReadHeadersAsync(Stream, cancellationToken).ConfigureAwait(false) + ) + { + switch (header.HeaderType) + { + case HeaderType.Mark: + { + lastMarkHeader = (MarkHeader)header; + } + break; + case HeaderType.Archive: + { + ArchiveHeader = (ArchiveHeader)header; + } + break; + case HeaderType.File: + { + var fh = (FileHeader)header; + if (_maxCompressionAlgorithm < fh.CompressionAlgorithm) + { + _maxCompressionAlgorithm = fh.CompressionAlgorithm; + } + + yield return CreateFilePart(lastMarkHeader!, fh); + } + break; + case HeaderType.Service: + { + var fh = (FileHeader)header; + if (fh.FileName == "CMT") + { + var buffer = new byte[fh.CompressedSize]; + fh.PackedStream.NotNull().ReadFully(buffer); + Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1); + } + } + break; + } + } + } + private void EnsureArchiveHeaderLoaded() { if (ArchiveHeader is null) diff --git a/src/SharpCompress/Factories/RarFactory.cs b/src/SharpCompress/Factories/RarFactory.cs index 2986e61b..560b1941 100644 --- a/src/SharpCompress/Factories/RarFactory.cs +++ b/src/SharpCompress/Factories/RarFactory.cs @@ -37,6 +37,14 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade int bufferSize = ReaderOptions.DefaultBufferSize ) => RarArchive.IsRarFile(stream); + /// + public override async Task IsArchiveAsync( + Stream stream, + string? password = null, + int bufferSize = ReaderOptions.DefaultBufferSize, + CancellationToken cancellationToken = default + ) => await RarArchive.IsRarFileAsync(stream, null, cancellationToken).ConfigureAwait(false); + /// public override FileInfo? GetFilePart(int index, FileInfo part1) => RarArchiveVolumeFactory.GetFilePart(index, part1); diff --git a/src/SharpCompress/Readers/AbstractReader.cs b/src/SharpCompress/Readers/AbstractReader.cs index bd35a6e1..8895f25b 100644 --- a/src/SharpCompress/Readers/AbstractReader.cs +++ b/src/SharpCompress/Readers/AbstractReader.cs @@ -17,7 +17,7 @@ public abstract class AbstractReader : IReader where TVolume : Volume { private bool _completed; - private IEnumerator? _entriesForCurrentReadStream; + protected IEnumerator? _entriesForCurrentReadStream; private bool _wroteCurrentEntry; internal AbstractReader(ReaderOptions options, ArchiveType archiveType) @@ -104,7 +104,8 @@ public abstract class AbstractReader : IReader } if (_entriesForCurrentReadStream is null) { - return LoadStreamForReading(RequestInitialStream()); + var loaded = await LoadStreamForReadingAsync(RequestInitialStream(), cancellationToken).ConfigureAwait(false); + return loaded; } if (!_wroteCurrentEntry) { @@ -134,6 +135,25 @@ public abstract class AbstractReader : IReader return _entriesForCurrentReadStream.MoveNext(); } + protected virtual async Task LoadStreamForReadingAsync( + Stream stream, + CancellationToken cancellationToken = default + ) + { + _entriesForCurrentReadStream?.Dispose(); + if (stream is null || !stream.CanRead) + { + throw new MultipartStreamRequiredException( + "File is split into multiple archives: '" + + Entry.Key + + "'. A new readable stream is required. Use Cancel if it was intended." + ); + } + // Default implementation uses sync version + _entriesForCurrentReadStream = GetEntries(stream).GetEnumerator(); + return _entriesForCurrentReadStream.MoveNext(); + } + protected virtual Stream RequestInitialStream() => Volume.NotNull("Volume isn't loaded.").Stream; diff --git a/src/SharpCompress/Readers/Rar/RarReader.cs b/src/SharpCompress/Readers/Rar/RarReader.cs index 9c6de26f..e2ff3d3a 100644 --- a/src/SharpCompress/Readers/Rar/RarReader.cs +++ b/src/SharpCompress/Readers/Rar/RarReader.cs @@ -2,6 +2,8 @@ using System; using System.Collections.Generic; using System.IO; using System.Linq; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.Common.Rar; using SharpCompress.Compressors.Rar; @@ -97,6 +99,46 @@ public abstract class RarReader : AbstractReader } } + protected async IAsyncEnumerable GetEntriesAsync( + Stream stream, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + volume = new RarReaderVolume(stream, Options, 0); + await foreach ( + var fp in volume.ReadFilePartsAsync(cancellationToken).ConfigureAwait(false) + ) + { + ValidateArchive(volume); + yield return new RarReaderEntry(volume.IsSolidArchive, fp); + } + } + + protected override async Task LoadStreamForReadingAsync( + Stream stream, + CancellationToken cancellationToken = default + ) + { + _entriesForCurrentReadStream?.Dispose(); + if (stream is null || !stream.CanRead) + { + throw new MultipartStreamRequiredException( + "File is split into multiple archives: '" + + Entry.Key + + "'. A new readable stream is required. Use Cancel if it was intended." + ); + } + + // Materialize the async enumerable into a list to convert to sync enumerator + var entries = new List(); + await foreach (var entry in GetEntriesAsync(stream, cancellationToken).ConfigureAwait(false)) + { + entries.Add(entry); + } + _entriesForCurrentReadStream = entries.GetEnumerator(); + return _entriesForCurrentReadStream.MoveNext(); + } + protected virtual IEnumerable CreateFilePartEnumerableForCurrentEntry() => Entry.Parts; diff --git a/src/SharpCompress/Readers/Rar/RarReaderVolume.cs b/src/SharpCompress/Readers/Rar/RarReaderVolume.cs index d614260a..eaaf09bf 100644 --- a/src/SharpCompress/Readers/Rar/RarReaderVolume.cs +++ b/src/SharpCompress/Readers/Rar/RarReaderVolume.cs @@ -1,5 +1,6 @@ using System.Collections.Generic; using System.IO; +using System.Threading; using SharpCompress.Common.Rar; using SharpCompress.Common.Rar.Headers; using SharpCompress.IO; @@ -15,4 +16,8 @@ public class RarReaderVolume : RarVolume new NonSeekableStreamFilePart(markHeader, fileHeader, Index); internal override IEnumerable ReadFileParts() => GetVolumeFileParts(); + + internal override IAsyncEnumerable ReadFilePartsAsync( + CancellationToken cancellationToken = default + ) => GetVolumeFilePartsAsync(cancellationToken); }