/// <summary> /// Constructor with a FileInfo object to an existing file. /// </summary> /// <param name="fileInfo"></param> /// <param name="options"></param> public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null) { fileInfo.CheckNotNull(nameof(fileInfo)); options = options ?? new ReaderOptions { LeaveStreamOpen = false }; using (var stream = fileInfo.OpenRead()) { if (ZipArchive.IsZipFile(stream, null)) { return(ZipArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { return(SevenZipArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { return(GZipArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream, options)) { return(RarArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { return(TarArchive.Open(fileInfo, options)); } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip"); } }
public static bool EnsureValidArchives(string filePath) { return(ZipArchive.IsZipFile(filePath) || RarArchive.IsRarFile(filePath) || SevenZipArchive.IsSevenZipFile(filePath) || TarArchive.IsTarFile(filePath)); }
/// <summary> /// Opens an Archive for random access /// </summary> /// <param name="stream"></param> /// <param name="readerOptions"></param> /// <returns></returns> public static IArchive Open(Stream stream, ReaderOptions readerOptions = null) { stream.CheckNotNull(nameof(stream)); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } readerOptions = readerOptions ?? new ReaderOptions(); stream.Seek(0, SeekOrigin.Begin); stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(GZipArchive.Open(stream, readerOptions)); } stream.Seek(0, SeekOrigin.Begin); stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(TarArchive.Open(stream, readerOptions)); } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip"); }
private CompressionType GetCompressionType(string sourceFile) { if (SevenZipArchive.IsSevenZipFile(sourceFile)) { return(CompressionType.Sevenzip); } if (ZipArchive.IsZipFile(sourceFile)) { return(CompressionType.Zip); } if (GZipArchive.IsGZipFile(sourceFile) && Path.GetExtension(sourceFile).ToLower() == ".gz") { return(CompressionType.Gzip); } if (RarArchive.IsRarFile(sourceFile)) { return(CompressionType.Rar); } if (TarArchive.IsTarFile(sourceFile) && Path.GetExtension(sourceFile).ToLower() == ".tar") { return(CompressionType.Tar); } return(CompressionType.None); }
/// <summary> /// Opens a Reader for Non-seeking usage /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IReader Open(Stream stream, ReaderOptions options = null) { stream.CheckNotNull(nameof(stream)); options = options != null ?options: new ReaderOptions() { LeaveStreamOpen = false }; RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); rewindableStream.Rewind(false); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.GZip)); } rewindableStream.Rewind(true); return(GZipReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (TarArchive.IsTarFile(rewindableStream)) { rewindableStream.Rewind(true); return(TarReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ"); }
/// <summary> /// Opens a TarReader for Non-seeking usage with a single volume /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static TarReader Open(Stream stream, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, CompressionType.GZip, options)); } throw new InvalidFormatException("Not a tar file."); } rewindableStream.Rewind(false); if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, CompressionType.BZip2, options)); } throw new InvalidFormatException("Not a tar file."); } rewindableStream.Rewind(true); return(new TarReader(rewindableStream, CompressionType.None, options)); }
public static TarReader Open(Stream stream, Options options) { Utility.CheckNotNull(stream, "stream"); RewindableStream stream2 = new RewindableStream(stream); stream2.StartRecording(); if (GZipArchive.IsGZipFile(stream2)) { stream2.Rewind(false); GZipStream stream3 = new GZipStream(stream2, CompressionMode.Decompress); if (!TarArchive.IsTarFile(stream3)) { throw new InvalidFormatException("Not a tar file."); } stream2.Rewind(true); return(new TarReader(stream2, CompressionType.GZip, options)); } stream2.Rewind(false); if (BZip2Stream.IsBZip2(stream2)) { stream2.Rewind(false); BZip2Stream stream4 = new BZip2Stream(stream2, CompressionMode.Decompress, false, false); if (!TarArchive.IsTarFile(stream4)) { throw new InvalidFormatException("Not a tar file."); } stream2.Rewind(true); return(new TarReader(stream2, CompressionType.BZip2, options)); } stream2.Rewind(true); return(new TarReader(stream2, CompressionType.None, options)); }
private static bool IsArchive(Stream stream, out ArchiveType?type) { type = null; stream.CheckNotNull(nameof(stream)); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } if (ZipArchive.IsZipFile(stream, null)) { type = ArchiveType.Zip; } stream.Seek(0, SeekOrigin.Begin); if (type == null) { if (SevenZipArchive.IsSevenZipFile(stream)) { type = ArchiveType.SevenZip; } stream.Seek(0, SeekOrigin.Begin); } if (type == null) { if (GZipArchive.IsGZipFile(stream)) { type = ArchiveType.GZip; } stream.Seek(0, SeekOrigin.Begin); } if (type == null) { if (RarArchive.IsRarFile(stream)) { type = ArchiveType.Rar; } stream.Seek(0, SeekOrigin.Begin); } if (type == null) { if (TarArchive.IsTarFile(stream)) { type = ArchiveType.Tar; } stream.Seek(0, SeekOrigin.Begin); } if (type == null) //test multipartzip as it could find zips in other non compressed archive types? { if (ZipArchive.IsZipMulti(stream)) //test the zip (last) file of a multipart zip { type = ArchiveType.Zip; } stream.Seek(0, SeekOrigin.Begin); } return(type != null); }
/// <summary> /// Opens a Reader for Non-seeking usage /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IReader Open(Stream stream, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (ZipArchive.IsZipFile(rewindableStream, null)) { rewindableStream.Rewind(true); return(ZipReader.Open(rewindableStream, null, options)); } rewindableStream.Rewind(false); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, CompressionType.GZip, options)); } rewindableStream.Rewind(true); return(GZipReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, CompressionType.BZip2, options)); } } rewindableStream.Rewind(false); if (TarArchive.IsTarFile(rewindableStream)) { rewindableStream.Rewind(true); return(TarReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (RarArchive.IsRarFile(rewindableStream, options)) { rewindableStream.Rewind(true); return(RarReader.Open(rewindableStream, options)); } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar"); }
public static IReader Open(Stream stream, Options options) { Utility.CheckNotNull(stream, "stream"); RewindableStream stream2 = new RewindableStream(stream); stream2.StartRecording(); if (ZipArchive.IsZipFile(stream2, null)) { stream2.Rewind(true); return(ZipReader.Open(stream2, null, options)); } stream2.Rewind(false); if (GZipArchive.IsGZipFile(stream2)) { stream2.Rewind(false); GZipStream stream3 = new GZipStream(stream2, CompressionMode.Decompress); if (TarArchive.IsTarFile(stream3)) { stream2.Rewind(true); return(new TarReader(stream2, CompressionType.GZip, options)); } stream2.Rewind(true); return(GZipReader.Open(stream2, options)); } stream2.Rewind(false); if (BZip2Stream.IsBZip2(stream2)) { stream2.Rewind(false); BZip2Stream stream4 = new BZip2Stream(stream2, CompressionMode.Decompress, false, false); if (TarArchive.IsTarFile(stream4)) { stream2.Rewind(true); return(new TarReader(stream2, CompressionType.BZip2, options)); } } stream2.Rewind(false); if (TarArchive.IsTarFile(stream2)) { stream2.Rewind(true); return(TarReader.Open(stream2, options)); } stream2.Rewind(false); if (!RarArchive.IsRarFile(stream2, options)) { throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar"); } stream2.Rewind(true); return(RarReader.Open(stream2, options)); }
public static IArchive Open(Stream stream, Options options = 1) { stream.CheckNotNull("stream"); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } stream.Seek(0L, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Seek(0L, SeekOrigin.Begin); return(TarArchive.Open(stream, options)); } stream.Seek(0L, SeekOrigin.Begin); throw new InvalidOperationException("Cannot determine compressed stream type."); }
/// <summary> /// Opens a TarReader for Non-seeking usage with a single volume /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static TarReader Open(Stream stream, ReaderOptions options = null) { stream.CheckNotNull(nameof(stream)); options = options ?? new ReaderOptions(); RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.GZip)); } throw new InvalidFormatException("Not a tar file."); } rewindableStream.Rewind(false); if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.BZip2)); } throw new InvalidFormatException("Not a tar file."); } rewindableStream.Rewind(false); if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.LZip)); } throw new InvalidFormatException("Not a tar file."); } rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.None)); }
/// <summary> /// Opens an Archive for random access /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } if (ZipArchive.IsZipFile(stream, null)) { stream.Seek(0, SeekOrigin.Begin); return(ZipArchive.Open(stream, options, null)); } #if RAR stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream, Options.LookForHeader | Options.KeepStreamsOpen)) { stream.Seek(0, SeekOrigin.Begin); return(RarArchive.Open(stream, options)); } #endif #if TAR stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(TarArchive.Open(stream, options)); } #endif #if SEVENZIP stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(SevenZipArchive.Open(stream, options)); } #endif #if GZIP stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(GZipArchive.Open(stream, options)); } #endif throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip"); }
/// <summary> /// Constructor with a FileInfo object to an existing file. /// </summary> /// <param name="fileInfo"></param> /// <param name="options"></param> public static IArchive Open(FileInfo fileInfo, Options options) { fileInfo.CheckNotNull("fileInfo"); using (var stream = fileInfo.OpenRead()) { if (ZipArchive.IsZipFile(stream, null)) { stream.Dispose(); return(ZipArchive.Open(fileInfo, options, null)); } #if RAR stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream, Options.LookForHeader | Options.KeepStreamsOpen)) { stream.Dispose(); return(RarArchive.Open(fileInfo, options)); } #endif #if TAR stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Dispose(); return(TarArchive.Open(fileInfo, options)); } #endif #if SEVENZIP stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Dispose(); return(SevenZipArchive.Open(fileInfo, options)); } #endif #if GZIP stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Dispose(); return(GZipArchive.Open(fileInfo, options)); } #endif throw new InvalidOperationException("Cannot determine compressed stream type."); } }
public static bool TryOpen(Stream stream, ReaderOptions readerOptions, ArchiveTypeMask archiveTypes, out IArchive archive) { stream.CheckNotNull("stream"); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } readerOptions = readerOptions ?? new ReaderOptions(); if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(stream, null)) { stream.Seek(0, SeekOrigin.Begin); archive = ZipArchive.Open(stream, readerOptions); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.SevenZip) && SevenZipArchive.IsSevenZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); archive = SevenZipArchive.Open(stream, readerOptions); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); archive = GZipArchive.Open(stream, readerOptions); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(stream, readerOptions)) { stream.Seek(0, SeekOrigin.Begin); archive = RarArchive.Open(stream, readerOptions); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(stream)) { stream.Seek(0, SeekOrigin.Begin); archive = TarArchive.Open(stream, readerOptions); return(true); } archive = null; return(false); }
public static bool isSupportedArchive(string filePath) { FileInfo fileInfo = new FileInfo(filePath); try { using (var stream = fileInfo.OpenRead()) { if (ZipArchive.IsZipFile(stream, null)) { stream.Dispose(); return(true); } stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Dispose(); return(true); } stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Dispose(); return(true); } stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream, Options.None)) { stream.Dispose(); return(true); } stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Dispose(); return(true); } return(false); } } catch (Exception) { return(false); } }
public static bool TryOpen(FileInfo fileInfo, ReaderOptions options, ArchiveTypeMask archiveTypes, out IArchive archive) { fileInfo.CheckNotNull("fileInfo"); options = options ?? new ReaderOptions { LeaveStreamOpen = false }; using (var stream = fileInfo.OpenRead()) { if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(stream, null)) { archive = ZipArchive.Open(fileInfo, options); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.SevenZip) && SevenZipArchive.IsSevenZipFile(stream)) { archive = SevenZipArchive.Open(fileInfo, options); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(stream)) { archive = GZipArchive.Open(fileInfo, options); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(stream, options)) { archive = RarArchive.Open(fileInfo, options); return(true); } stream.Seek(0, SeekOrigin.Begin); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(stream)) { archive = TarArchive.Open(fileInfo, options); return(true); } } archive = null; return(false); }
/// <summary> /// Opens an Archive for random access /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); if (!stream.CanRead || !stream.CanSeek) { throw new ArgumentException("Stream should be readable and seekable"); } if (ZipArchive.IsZipFile(stream, null)) { stream.Seek(0, SeekOrigin.Begin); return(ZipArchive.Open(stream, options, null)); } stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(RarArchive.Open(stream, options)); } stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(TarArchive.Open(stream, options)); } stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(SevenZipArchive.Open(stream, options)); } stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return(GZipArchive.Open(stream, options)); } throw new InvalidOperationException("Cannot determine compressed stream type."); }
/// <summary> /// Constructor with a FileInfo object to an existing file. /// </summary> /// <param name="fileInfo"></param> /// <param name="options"></param> public static IArchive Open(FileInfo fileInfo, Options options) { //fileInfo.CheckNotNull("fileInfo"); Utility.CheckNotNull(fileInfo, "fileInfo"); using (var stream = fileInfo.OpenRead()) { if (ZipArchive.IsZipFile(stream, null)) { stream.Dispose(); return(ZipArchive.Open(fileInfo, options, null)); } stream.Seek(0, SeekOrigin.Begin); if (TarArchive.IsTarFile(stream)) { stream.Dispose(); return(TarArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Dispose(); return(SevenZipArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (GZipArchive.IsGZipFile(stream)) { stream.Dispose(); return(GZipArchive.Open(fileInfo, options)); } stream.Seek(0, SeekOrigin.Begin); if (RarArchive.IsRarFile(stream, Options.LookForHeader | Options.KeepStreamsOpen)) { stream.Dispose(); return(RarArchive.Open(fileInfo, options)); } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip"); } }
public ArchiveTypes IsArchive(string path) { var type = ArchiveTypes.None; if (RarArchive.IsRarFile(path)) { type = ArchiveTypes.RAR; } if (ZipArchive.IsZipFile(path)) { type = ArchiveTypes.Zip; } if (SevenZipArchive.IsSevenZipFile(path)) { type = ArchiveTypes.SevenZip; } if (TarArchive.IsTarFile(path)) { type = ArchiveTypes.Deflate; } return(type); }
public static IReader Open(Stream stream, Options options = 1) { stream.CheckNotNull("stream"); RewindableStream stream2 = new RewindableStream(stream); stream2.StartRecording(); stream2.Rewind(false); if (BZip2Stream.IsBZip2(stream2)) { stream2.Rewind(false); if (TarArchive.IsTarFile(new BZip2Stream(stream2, CompressionMode.Decompress, false, false))) { stream2.Rewind(true); return(new TarReader(stream2, CompressionType.BZip2, options)); } } stream2.Rewind(false); if (!TarArchive.IsTarFile(stream2)) { throw new InvalidOperationException("Cannot determine compressed stream type."); } stream2.Rewind(true); return(TarReader.Open(stream2, options)); }
/// <summary> /// Opens a Reader for Non-seeking usage /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IReader Open(Stream stream, ReaderOptions options = null) { stream.CheckNotNull("stream"); options = options ?? new ReaderOptions() { LeaveStreamOpen = false }; RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (ZipArchive.IsZipFile(rewindableStream, options.Password)) { rewindableStream.Rewind(true); return(ZipReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.GZip)); } rewindableStream.Rewind(true); return(GZipReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, true); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.BZip2)); } } rewindableStream.Rewind(false); if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.LZip)); } } rewindableStream.Rewind(false); if (RarArchive.IsRarFile(rewindableStream, options)) { rewindableStream.Rewind(true); return(RarReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (TarArchive.IsTarFile(rewindableStream)) { rewindableStream.Rewind(true); return(TarReader.Open(rewindableStream, options)); } rewindableStream.Rewind(false); if (XZStream.IsXZStream(rewindableStream)) { rewindableStream.Rewind(true); XZStream testStream = new XZStream(rewindableStream); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return(new TarReader(rewindableStream, options, CompressionType.Xz)); } } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ"); }
public static bool isArchive(FileInfo file) { //FIXME This is broken and detects .gba ROMs as stuff return(GZipArchive.IsGZipFile(file) || RarArchive.IsRarFile(file) || SevenZipArchive.IsSevenZipFile(file) || TarArchive.IsTarFile(file) || ZipArchive.IsZipFile(file)); }
public static bool TryOpen(Stream stream, ReaderOptions options, ArchiveTypeMask archiveTypes, out IReader reader) { stream.CheckNotNull("stream"); options = options ?? new ReaderOptions() { LeaveStreamOpen = false }; RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(rewindableStream, options.Password)) { rewindableStream.Rewind(true); reader = ZipReader.Open(rewindableStream, options); return(true); } rewindableStream.Rewind(false); if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); reader = new TarReader(rewindableStream, options, CompressionType.GZip); return(true); } rewindableStream.Rewind(true); reader = GZipReader.Open(rewindableStream, options); return(true); } rewindableStream.Rewind(false); if (archiveTypes.HasFlag(ArchiveTypeMask.BZip2) && BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); reader = new TarReader(rewindableStream, options, CompressionType.BZip2); return(true); } } rewindableStream.Rewind(false); if (archiveTypes.HasFlag(ArchiveTypeMask.LZip) && LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); reader = new TarReader(rewindableStream, options, CompressionType.LZip); return(true); } } rewindableStream.Rewind(false); if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(rewindableStream, options)) { rewindableStream.Rewind(true); reader = RarReader.Open(rewindableStream, options); return(true); } rewindableStream.Rewind(false); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(rewindableStream)) { rewindableStream.Rewind(true); reader = TarReader.Open(rewindableStream, options); return(true); } rewindableStream.Rewind(false); if (XZStream.IsXZStream(rewindableStream)) { rewindableStream.Rewind(true); XZStream testStream = new XZStream(rewindableStream); if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); reader = new TarReader(rewindableStream, options, CompressionType.Xz); return(true); } } reader = null; return(false); }