starred/sharpcompress
1
0
Fork 0
mirror of https://github.com/adamhathcock/sharpcompress.git synced 2026-02-04 05:25:00 +00:00
Code Issues 975 Packages Projects Releases 20 Wiki Activity

Create proper options objects to remove flags from API

Browse Source
This commit is contained in:
Adam Hathcock
2016-09-27 10:14:08 +01:00
parent 06e3486ec4
commit c4fde80c5e
49 changed files with 525 additions and 619 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/SharpCompress/Archives/AbstractArchive.cs
View File

@@ -20,31 +20,33 @@ namespace SharpCompress.Archives
public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
protected string Password { get; private set; }
protected ReaderOptions ReaderOptions { get; }
private bool disposed;
#if !NO_FILE
internal AbstractArchive(ArchiveType type, FileInfo fileInfo, Options options, string password)
internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
{
Type = type;
Password = password;
if (!fileInfo.Exists)
{
throw new ArgumentException("File does not exist: " + fileInfo.FullName);
}
options = (Options) FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo, options));
ReaderOptions = readerOptions;
readerOptions.LeaveOpenStream = false;
lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo));
lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
}
protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file, Options options);
protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
#endif
internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, Options options, string password)
internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
{
Type = type;
Password = password;
lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams), options));
ReaderOptions = readerOptions;
lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
}
@@ -102,15 +104,13 @@ namespace SharpCompress.Archives
/// </summary>
public virtual long TotalUncompressSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }
protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams, Options options);
protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }
IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }
private bool disposed;
public virtual void Dispose()
{
if (!disposed)

17
src/SharpCompress/Archives/AbstractWritableArchive.cs
View File

@@ -3,6 +3,8 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using SharpCompress.Common;
using SharpCompress.Readers;
using SharpCompress.Writers;
namespace SharpCompress.Archives
{
@@ -21,14 +23,14 @@ namespace SharpCompress.Archives
{
}
internal AbstractWritableArchive(ArchiveType type, Stream stream, Options options)
: base(type, stream.AsEnumerable(), options, null)
internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
: base(type, stream.AsEnumerable(), readerFactoryOptions)
{
}
#if !NO_FILE
internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, Options options)
: base(type, fileInfo, options, null)
internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
: base(type, fileInfo, readerFactoryOptions)
{
}
#endif
@@ -112,11 +114,11 @@ namespace SharpCompress.Archives
return false;
}
public void SaveTo(Stream stream, CompressionInfo compressionType)
public void SaveTo(Stream stream, WriterOptions options)
{
//reset streams of new entries
newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
SaveTo(stream, compressionType, OldEntries, newEntries);
SaveTo(stream, options, OldEntries, newEntries);
}
protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
@@ -132,8 +134,7 @@ namespace SharpCompress.Archives
protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
bool closeStream);
protected abstract void SaveTo(Stream stream, CompressionInfo compressionType,
IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
public override void Dispose()
{

46
src/SharpCompress/Archives/ArchiveFactory.cs
View File

@@ -6,6 +6,7 @@ using SharpCompress.Archives.SevenZip;
using SharpCompress.Archives.Tar;
using SharpCompress.Archives.Zip;
using SharpCompress.Common;
using SharpCompress.Readers;
namespace SharpCompress.Archives
{
@@ -15,44 +16,44 @@ namespace SharpCompress.Archives
/// Opens an Archive for random access
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <param name="readerOptions"></param>
/// <returns></returns>
public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
if (!stream.CanRead || !stream.CanSeek)
{
throw new ArgumentException("Stream should be readable and seekable");
}
readerOptions = readerOptions ?? new ReaderOptions();
if (ZipArchive.IsZipFile(stream, null))
{
stream.Seek(0, SeekOrigin.Begin);
return ZipArchive.Open(stream, options, null);
return ZipArchive.Open(stream, readerOptions);
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return SevenZipArchive.Open(stream, options);
return SevenZipArchive.Open(stream, readerOptions);
}
stream.Seek(0, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return GZipArchive.Open(stream, options);
return GZipArchive.Open(stream, readerOptions);
}
stream.Seek(0, SeekOrigin.Begin);
if (RarArchive.IsRarFile(stream, options))
if (RarArchive.IsRarFile(stream, readerOptions))
{
stream.Seek(0, SeekOrigin.Begin);
return RarArchive.Open(stream, options);
return RarArchive.Open(stream, readerOptions);
}
stream.Seek(0, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return TarArchive.Open(stream, options);
return TarArchive.Open(stream, readerOptions);
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
}
@@ -82,33 +83,15 @@ namespace SharpCompress.Archives
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
public static IArchive Open(string filePath)
{
return Open(filePath, Options.None);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
public static IArchive Open(FileInfo fileInfo)
{
return Open(fileInfo, Options.None);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static IArchive Open(string filePath, Options options)
public static IArchive Open(string filePath, ReaderOptions options = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options);
return Open(new FileInfo(filePath), options ?? new ReaderOptions());
}
/// <summary>
@@ -116,15 +99,16 @@ namespace SharpCompress.Archives
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static IArchive Open(FileInfo fileInfo, Options options)
public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
{
fileInfo.CheckNotNull("fileInfo");
options = options ?? new ReaderOptions();
using (var stream = fileInfo.OpenRead())
{
if (ZipArchive.IsZipFile(stream, null))
{
stream.Dispose();
return ZipArchive.Open(fileInfo, options, null);
return ZipArchive.Open(fileInfo, options);
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))

70
src/SharpCompress/Archives/GZip/GZipArchive.cs
View File

@@ -6,6 +6,7 @@ using SharpCompress.Common;
using SharpCompress.Common.GZip;
using SharpCompress.Readers;
using SharpCompress.Readers.GZip;
using SharpCompress.Writers;
using SharpCompress.Writers.GZip;
namespace SharpCompress.Archives.GZip
@@ -13,67 +14,37 @@ namespace SharpCompress.Archives.GZip
public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
{
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
public static GZipArchive Open(string filePath)
{
return Open(filePath, Options.None);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
public static GZipArchive Open(FileInfo fileInfo)
{
return Open(fileInfo, Options.None);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static GZipArchive Open(string filePath, Options options)
/// <param name="readerOptions"></param>
public static GZipArchive Open(string filePath, ReaderOptions readerOptions = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options);
return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static GZipArchive Open(FileInfo fileInfo, Options options)
/// <param name="readerOptions"></param>
public static GZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
{
fileInfo.CheckNotNull("fileInfo");
return new GZipArchive(fileInfo, options);
return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
}
#endif
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
public static GZipArchive Open(Stream stream)
/// <param name="readerOptions"></param>
public static GZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
return Open(stream, Options.None);
}
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
public static GZipArchive Open(Stream stream, Options options)
{
stream.CheckNotNull("stream");
return new GZipArchive(stream, options);
return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
}
public static GZipArchive Create()
@@ -88,14 +59,14 @@ namespace SharpCompress.Archives.GZip
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
internal GZipArchive(FileInfo fileInfo, Options options)
internal GZipArchive(FileInfo fileInfo, ReaderOptions options)
: base(ArchiveType.GZip, fileInfo, options)
{
}
protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file, Options options)
protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
{
return new GZipVolume(file, options).AsEnumerable();
return new GZipVolume(file, ReaderOptions).AsEnumerable();
}
public static bool IsGZipFile(string filePath)
@@ -124,7 +95,7 @@ namespace SharpCompress.Archives.GZip
{
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
{
SaveTo(stream);
SaveTo(stream, new WriterOptions(CompressionType.GZip));
}
}
#endif
@@ -159,7 +130,7 @@ namespace SharpCompress.Archives.GZip
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
internal GZipArchive(Stream stream, Options options)
internal GZipArchive(Stream stream, ReaderOptions options)
: base(ArchiveType.GZip, stream, options)
{
}
@@ -169,11 +140,6 @@ namespace SharpCompress.Archives.GZip
{
}
public void SaveTo(Stream stream)
{
SaveTo(stream, CompressionType.GZip);
}
protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
bool closeStream)
{
@@ -184,7 +150,7 @@ namespace SharpCompress.Archives.GZip
return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
}
protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
protected override void SaveTo(Stream stream, WriterOptions options,
IEnumerable<GZipArchiveEntry> oldEntries,
IEnumerable<GZipArchiveEntry> newEntries)
{
@@ -205,9 +171,9 @@ namespace SharpCompress.Archives.GZip
}
}
protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams)
{
return new GZipVolume(streams.First(), options).AsEnumerable();
return new GZipVolume(streams.First(), ReaderOptions).AsEnumerable();
}
protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)

4
src/SharpCompress/Archives/IWritableArchive.cs
View File

@@ -1,6 +1,6 @@
using System;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Writers;
namespace SharpCompress.Archives
{
@@ -10,6 +10,6 @@ namespace SharpCompress.Archives
IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);
void SaveTo(Stream stream, CompressionInfo compressionType);
void SaveTo(Stream stream, WriterOptions options);
}
}

33
src/SharpCompress/Archives/IWritableArchiveExtensions.cs
View File

@@ -2,18 +2,12 @@
using System;
#endif
using System.IO;
using SharpCompress.Common;
using SharpCompress.Writers;
namespace SharpCompress.Archives
{
public static class IWritableArchiveExtensions
{
public static void SaveTo(this IWritableArchive writableArchive,
Stream stream, CompressionType compressionType)
{
writableArchive.SaveTo(stream, new CompressionInfo {Type = compressionType});
}
#if !NO_FILE
public static void AddEntry(this IWritableArchive writableArchive,
@@ -28,33 +22,16 @@ namespace SharpCompress.Archives
fileInfo.LastWriteTime);
}
public static void SaveTo(this IWritableArchive writableArchive,
string filePath, CompressionType compressionType)
public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
{
writableArchive.SaveTo(new FileInfo(filePath), new CompressionInfo {Type = compressionType});
writableArchive.SaveTo(new FileInfo(filePath), options);
}
public static void SaveTo(this IWritableArchive writableArchive,
FileInfo fileInfo, CompressionType compressionType)
public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
{
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
{
writableArchive.SaveTo(stream, new CompressionInfo {Type = compressionType});
}
}
public static void SaveTo(this IWritableArchive writableArchive,
string filePath, CompressionInfo compressionInfo)
{
writableArchive.SaveTo(new FileInfo(filePath), compressionInfo);
}
public static void SaveTo(this IWritableArchive writableArchive,
FileInfo fileInfo, CompressionInfo compressionInfo)
{
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
{
writableArchive.SaveTo(stream, compressionInfo);
writableArchive.SaveTo(stream, options);
}
}

21
src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
View File

@@ -2,10 +2,10 @@
#if !NO_FILE
using System.Collections.Generic;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Common.Rar;
using SharpCompress.Common.Rar.Headers;
using SharpCompress.IO;
using SharpCompress.Readers;
namespace SharpCompress.Archives.Rar
{
@@ -14,30 +14,27 @@ namespace SharpCompress.Archives.Rar
/// </summary>
internal class FileInfoRarArchiveVolume : RarVolume
{
internal FileInfoRarArchiveVolume(FileInfo fileInfo, string password, Options options)
: base(StreamingMode.Seekable, fileInfo.OpenRead(), password, FixOptions(options))
internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options)
: base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options))
{
FileInfo = fileInfo;
FileParts = base.GetVolumeFileParts().ToReadOnly();
FileParts = GetVolumeFileParts().ToReadOnly();
}
private static Options FixOptions(Options options)
private static ReaderOptions FixOptions(ReaderOptions options)
{
//make sure we're closing streams with fileinfo
if (options.HasFlag(Options.KeepStreamsOpen))
{
options = (Options) FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
options.LeaveOpenStream = false;
return options;
}
internal ReadOnlyCollection<RarFilePart> FileParts { get; private set; }
internal ReadOnlyCollection<RarFilePart> FileParts { get; }
internal FileInfo FileInfo { get; private set; }
internal FileInfo FileInfo { get; }
internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader)
{
return new FileInfoRarFilePart(this, markHeader, fileHeader, FileInfo);
return new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
}
internal override IEnumerable<RarFilePart> ReadFileParts()

6
src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
View File

@@ -7,13 +7,13 @@ namespace SharpCompress.Archives.Rar
{
internal class FileInfoRarFilePart : SeekableFilePart
{
internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, MarkHeader mh, FileHeader fh, FileInfo fi)
: base(mh, fh, volume.Stream, volume.Password)
internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string password, MarkHeader mh, FileHeader fh, FileInfo fi)
: base(mh, fh, volume.Stream, password)
{
FileInfo = fi;
}
internal FileInfo FileInfo { get; private set; }
internal FileInfo FileInfo { get; }
internal override string FilePartName
{

71
src/SharpCompress/Archives/Rar/RarArchive.cs
View File

@@ -17,20 +17,19 @@ namespace SharpCompress.Archives.Rar
#if !NO_FILE
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
/// <param name="password"></param>
internal RarArchive(FileInfo fileInfo, Options options, string password)
: base(ArchiveType.Rar, fileInfo, options, password)
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
internal RarArchive(FileInfo fileInfo, ReaderOptions options)
: base(ArchiveType.Rar, fileInfo, options)
{
}
protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file, Options options)
protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
{
return RarArchiveVolumeFactory.GetParts(file, Password, options);
return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
}
#endif
@@ -39,9 +38,8 @@ namespace SharpCompress.Archives.Rar
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
/// <param name="password"></param>
internal RarArchive(IEnumerable<Stream> streams, Options options, string password)
: base(ArchiveType.Rar, streams, options, password)
internal RarArchive(IEnumerable<Stream> streams, ReaderOptions options)
: base(ArchiveType.Rar, streams, options)
{
}
@@ -50,16 +48,16 @@ namespace SharpCompress.Archives.Rar
return RarArchiveEntryFactory.GetEntries(this, volumes);
}
protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
{
return RarArchiveVolumeFactory.GetParts(streams, Password, options);
return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
}
protected override IReader CreateReaderForSolidExtraction()
{
var stream = Volumes.First().Stream;
stream.Position = 0;
return RarReader.Open(stream, Password);
return RarReader.Open(stream, ReaderOptions);
}
public override bool IsSolid { get { return Volumes.First().IsSolidArchive; } }
@@ -68,16 +66,15 @@ namespace SharpCompress.Archives.Rar
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static RarArchive Open(string filePath, Options options = Options.None, string password = null)
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static RarArchive Open(string filePath, ReaderOptions options = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options, password);
return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
}
/// <summary>
@@ -85,11 +82,10 @@ namespace SharpCompress.Archives.Rar
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static RarArchive Open(FileInfo fileInfo, Options options = Options.None, string password = null)
public static RarArchive Open(FileInfo fileInfo, ReaderOptions options = null)
{
fileInfo.CheckNotNull("fileInfo");
return new RarArchive(fileInfo, options, password);
return new RarArchive(fileInfo, options ?? new ReaderOptions());
}
#endif
@@ -98,11 +94,10 @@ namespace SharpCompress.Archives.Rar
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static RarArchive Open(Stream stream, Options options = Options.KeepStreamsOpen, string password = null)
public static RarArchive Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
return Open(stream.AsEnumerable(), options, password);
return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
}
/// <summary>
@@ -110,11 +105,10 @@ namespace SharpCompress.Archives.Rar
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static RarArchive Open(IEnumerable<Stream> streams, Options options = Options.KeepStreamsOpen, string password = null)
public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions options = null)
{
streams.CheckNotNull("streams");
return new RarArchive(streams, options, password);
return new RarArchive(streams, options ?? new ReaderOptions());
}
#if !NO_FILE
@@ -135,17 +129,12 @@ namespace SharpCompress.Archives.Rar
}
}
#endif
public static bool IsRarFile(Stream stream)
{
return IsRarFile(stream, Options.None);
}
public static bool IsRarFile(Stream stream, Options options)
public static bool IsRarFile(Stream stream, ReaderOptions options = null)
{
try
{
var headerFactory = new RarHeaderFactory(StreamingMode.Seekable, options);
var headerFactory = new RarHeaderFactory(StreamingMode.Seekable, options ?? new ReaderOptions());
var markHeader = headerFactory.ReadHeaders(stream).FirstOrDefault() as MarkHeader;
return markHeader != null && markHeader.IsValid();
}

12
src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
View File

@@ -3,7 +3,7 @@ using System.Collections.Generic;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Common.Rar;
using SharpCompress.Readers;
#if !NO_FILE
using System.Linq;
using System.Text;
@@ -14,7 +14,7 @@ namespace SharpCompress.Archives.Rar
{
internal static class RarArchiveVolumeFactory
{
internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, string password, Options options)
internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
{
foreach (Stream s in streams)
{
@@ -22,15 +22,15 @@ namespace SharpCompress.Archives.Rar
{
throw new ArgumentException("Stream is not readable and seekable");
}
StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, password, options);
StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
yield return part;
}
}
#if !NO_FILE
internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, string password, Options options)
internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
{
FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, password, options);
FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
yield return part;
if (!part.ArchiveHeader.ArchiveHeaderFlags.HasFlag(ArchiveFlags.VOLUME))
@@ -42,7 +42,7 @@ namespace SharpCompress.Archives.Rar
//we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
while (fileInfo != null && fileInfo.Exists)
{
part = new FileInfoRarArchiveVolume(fileInfo, password, options);
part = new FileInfoRarArchiveVolume(fileInfo, options);
fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
yield return part;

8
src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
View File

@@ -1,16 +1,16 @@
using System.Collections.Generic;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Common.Rar;
using SharpCompress.Common.Rar.Headers;
using SharpCompress.IO;
using SharpCompress.Readers;
namespace SharpCompress.Archives.Rar
{
internal class StreamRarArchiveVolume : RarVolume
{
internal StreamRarArchiveVolume(Stream stream, string password, Options options)
: base(StreamingMode.Seekable, stream, password, options)
internal StreamRarArchiveVolume(Stream stream, ReaderOptions options)
: base(StreamingMode.Seekable, stream, options)
{
}
@@ -21,7 +21,7 @@ namespace SharpCompress.Archives.Rar
internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader)
{
return new SeekableFilePart(markHeader, fileHeader, Stream, Password);
return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
}
}
}

69
src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
View File

@@ -14,81 +14,48 @@ namespace SharpCompress.Archives.SevenZip
private ArchiveDatabase database;
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
public static SevenZipArchive Open(string filePath)
{
return Open(filePath, Options.None);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
public static SevenZipArchive Open(FileInfo fileInfo)
{
return Open(fileInfo, Options.None);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static SevenZipArchive Open(string filePath, Options options)
/// <param name="readerOptions"></param>
public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options);
return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static SevenZipArchive Open(FileInfo fileInfo, Options options)
/// <param name="readerOptions"></param>
public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions)
{
fileInfo.CheckNotNull("fileInfo");
return new SevenZipArchive(fileInfo, options);
return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
}
#endif
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
public static SevenZipArchive Open(Stream stream)
/// <param name="readerOptions"></param>
public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
return Open(stream, Options.None);
}
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
public static SevenZipArchive Open(Stream stream, Options options)
{
stream.CheckNotNull("stream");
return new SevenZipArchive(stream, options);
return new SevenZipArchive(stream, readerOptions);
}
#if !NO_FILE
internal SevenZipArchive(FileInfo fileInfo, Options options)
: base(ArchiveType.SevenZip, fileInfo, options, null)
internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
: base(ArchiveType.SevenZip, fileInfo, readerOptions)
{
}
protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file, Options options)
protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
{
if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
{
options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
return new SevenZipVolume(file.OpenRead(), options).AsEnumerable();
return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
}
public static bool IsSevenZipFile(string filePath)
@@ -109,8 +76,8 @@ namespace SharpCompress.Archives.SevenZip
}
#endif
internal SevenZipArchive(Stream stream, Options options)
: base(ArchiveType.SevenZip, stream.AsEnumerable(), options, null)
internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
: base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
{
}
@@ -119,7 +86,7 @@ namespace SharpCompress.Archives.SevenZip
{
}
protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
{
foreach (Stream s in streams)
{
@@ -127,7 +94,7 @@ namespace SharpCompress.Archives.SevenZip
{
throw new ArgumentException("Stream is not readable and seekable");
}
SevenZipVolume volume = new SevenZipVolume(s, options);
SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
yield return volume;
}
}
@@ -202,7 +169,7 @@ namespace SharpCompress.Archives.SevenZip
private CFileItem currentItem;
internal SevenZipReader(SevenZipArchive archive)
: base(Options.KeepStreamsOpen, ArchiveType.SevenZip)
: base(new ReaderOptions(), ArchiveType.SevenZip)
{
this.archive = archive;
}

88
src/SharpCompress/Archives/Tar/TarArchive.cs
View File

@@ -8,6 +8,7 @@ using SharpCompress.Common.Tar.Headers;
using SharpCompress.IO;
using SharpCompress.Readers;
using SharpCompress.Readers.Tar;
using SharpCompress.Writers;
using SharpCompress.Writers.Tar;
namespace SharpCompress.Archives.Tar
@@ -15,67 +16,39 @@ namespace SharpCompress.Archives.Tar
public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
{
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
public static TarArchive Open(string filePath)
{
return Open(filePath, Options.None);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
public static TarArchive Open(FileInfo fileInfo)
{
return Open(fileInfo, Options.None);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static TarArchive Open(string filePath, Options options)
/// <param name="readerOptions"></param>
public static TarArchive Open(string filePath, ReaderOptions readerOptions = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options);
return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static TarArchive Open(FileInfo fileInfo, Options options)
/// <param name="readerOptions"></param>
public static TarArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
{
fileInfo.CheckNotNull("fileInfo");
return new TarArchive(fileInfo, options);
return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
}
#endif
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
public static TarArchive Open(Stream stream)
/// <param name="readerOptions"></param>
public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
return Open(stream, Options.None);
}
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
public static TarArchive Open(Stream stream, Options options)
{
stream.CheckNotNull("stream");
return new TarArchive(stream, options);
return new TarArchive(stream, readerOptions ?? new ReaderOptions());
}
#if !NO_FILE
@@ -113,23 +86,20 @@ namespace SharpCompress.Archives.Tar
#if !NO_FILE
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
internal TarArchive(FileInfo fileInfo, Options options)
: base(ArchiveType.Tar, fileInfo, options)
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="readerOptions"></param>
internal TarArchive(FileInfo fileInfo, ReaderOptions readerOptions)
: base(ArchiveType.Tar, fileInfo, readerOptions)
{
}
protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file, Options options)
protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
{
if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
{
options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
return new TarVolume(file.OpenRead(), options).AsEnumerable();
return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
}
#endif
@@ -137,9 +107,9 @@ namespace SharpCompress.Archives.Tar
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
internal TarArchive(Stream stream, Options options)
: base(ArchiveType.Tar, stream, options)
/// <param name="readerOptions"></param>
internal TarArchive(Stream stream, ReaderOptions readerOptions)
: base(ArchiveType.Tar, stream, readerOptions)
{
}
@@ -148,9 +118,9 @@ namespace SharpCompress.Archives.Tar
{
}
protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
{
return new TarVolume(streams.First(), options).AsEnumerable();
return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
}
protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
@@ -208,11 +178,11 @@ namespace SharpCompress.Archives.Tar
closeStream);
}
protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
protected override void SaveTo(Stream stream, WriterOptions options,
IEnumerable<TarArchiveEntry> oldEntries,
IEnumerable<TarArchiveEntry> newEntries)
{
using (var writer = new TarWriter(stream, compressionInfo))
using (var writer = new TarWriter(stream, new TarWriterOptions(options)))
{
foreach (var entry in oldEntries.Concat(newEntries)
.Where(x => !x.IsDirectory))

99
src/SharpCompress/Archives/Zip/ZipArchive.cs
View File

@@ -8,6 +8,7 @@ using SharpCompress.Common.Zip.Headers;
using SharpCompress.Compressors.Deflate;
using SharpCompress.Readers;
using SharpCompress.Readers.Zip;
using SharpCompress.Writers;
using SharpCompress.Writers.Zip;
namespace SharpCompress.Archives.Zip
@@ -23,73 +24,37 @@ namespace SharpCompress.Archives.Zip
public CompressionLevel DeflateCompressionLevel { get; set; }
#if !NO_FILE
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="password"></param>
public static ZipArchive Open(string filePath, string password = null)
{
return Open(filePath, Options.None, password);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="password"></param>
public static ZipArchive Open(FileInfo fileInfo, string password = null)
{
return Open(fileInfo, Options.None, password);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static ZipArchive Open(string filePath, Options options, string password = null)
/// <param name="readerOptions"></param>
public static ZipArchive Open(string filePath, ReaderOptions readerOptions = null)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options, password);
return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static ZipArchive Open(FileInfo fileInfo, Options options, string password = null)
/// <param name="readerOptions"></param>
public static ZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
{
fileInfo.CheckNotNull("fileInfo");
return new ZipArchive(fileInfo, options, password);
return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
}
#endif
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
/// <param name="password"></param>
public static ZipArchive Open(Stream stream, string password = null)
/// <param name="readerOptions"></param>
public static ZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
return Open(stream, Options.None, password);
}
/// <summary>
/// Takes a seekable Stream as a source
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <param name="password"></param>
public static ZipArchive Open(Stream stream, Options options, string password = null)
{
stream.CheckNotNull("stream");
return new ZipArchive(stream, options, password);
return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
}
#if !NO_FILE
@@ -136,25 +101,20 @@ namespace SharpCompress.Archives.Zip
#if !NO_FILE
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
/// <param name="password"></param>
internal ZipArchive(FileInfo fileInfo, Options options, string password = null)
: base(ArchiveType.Zip, fileInfo, options)
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="readerOptions"></param>
internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
: base(ArchiveType.Zip, fileInfo, readerOptions)
{
headerFactory = new SeekableZipHeaderFactory(password);
headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
}
protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file, Options options)
protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
{
if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
{
options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
return new ZipVolume(file.OpenRead(), options).AsEnumerable();
return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
}
#endif
@@ -167,17 +127,16 @@ namespace SharpCompress.Archives.Zip
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <param name="password"></param>
internal ZipArchive(Stream stream, Options options, string password = null)
: base(ArchiveType.Zip, stream, options)
/// <param name="readerOptions"></param>
internal ZipArchive(Stream stream, ReaderOptions readerOptions)
: base(ArchiveType.Zip, stream, readerOptions)
{
headerFactory = new SeekableZipHeaderFactory(password);
headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
}
protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
{
return new ZipVolume(streams.First(), options).AsEnumerable();
return new ZipVolume(streams.First(), ReaderOptions).AsEnumerable();
}
protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
@@ -209,18 +168,18 @@ namespace SharpCompress.Archives.Zip
}
}
protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
protected override void SaveTo(Stream stream, WriterOptions options,
IEnumerable<ZipArchiveEntry> oldEntries,
IEnumerable<ZipArchiveEntry> newEntries)
{
using (var writer = new ZipWriter(stream, compressionInfo, string.Empty))
using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
{
foreach (var entry in oldEntries.Concat(newEntries)
.Where(x => !x.IsDirectory))
{
using (var entryStream = entry.OpenEntryStream())
{
writer.Write(entry.Key, entryStream, entry.LastModifiedTime, string.Empty);
writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
}
}
}

30
src/SharpCompress/Common/CompressionInfo.cs
View File

@@ -1,30 +0,0 @@
using SharpCompress.Compressors.Deflate;
namespace SharpCompress.Common
{
/// <summary>
/// Detailed compression properties when saving.
/// </summary>
public class CompressionInfo
{
public CompressionInfo()
{
DeflateCompressionLevel = CompressionLevel.Default;
}
/// <summary>
/// The algorthm to use. Must be valid for the format type.
/// </summary>
public CompressionType Type { get; set; }
/// <summary>
/// When CompressionType.Deflate is used, this property is referenced. Defaults to CompressionLevel.Default.
/// </summary>
public CompressionLevel DeflateCompressionLevel { get; set; }
public static implicit operator CompressionInfo(CompressionType compressionType)
{
return new CompressionInfo {Type = compressionType};
}
}
}

6
src/SharpCompress/Common/GZip/GZipVolume.cs
View File

@@ -1,18 +1,20 @@
using System.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common.GZip
{
public class GZipVolume : Volume
{
public GZipVolume(Stream stream, Options options)
public GZipVolume(Stream stream, ReaderOptions options)
: base(stream, options)
{
}
#if !NO_FILE
public GZipVolume(FileInfo fileInfo, Options options)
public GZipVolume(FileInfo fileInfo, ReaderOptions options)
: base(fileInfo.OpenRead(), options)
{
options.LeaveOpenStream = false;
}
#endif

23
src/SharpCompress/Common/Options.cs
View File

@@ -1,23 +0,0 @@
using System;
namespace SharpCompress.Common
{
[Flags]
public enum Options
{
/// <summary>
/// No options specified
/// </summary>
None = 0,
/// <summary>
/// SharpCompress will keep the supplied streams open
/// </summary>
KeepStreamsOpen = 1,
/// <summary>
/// Look for RarArchive (Check for self-extracting archives or cases where RarArchive isn't at the start of the file)
/// </summary>
LookForHeader = 2
}
}

17
src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
View File

@@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.IO;
using SharpCompress.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common.Rar.Headers
{
@@ -9,21 +10,19 @@ namespace SharpCompress.Common.Rar.Headers
{
private const int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
internal RarHeaderFactory(StreamingMode mode, Options options, string password = null)
internal RarHeaderFactory(StreamingMode mode, ReaderOptions options)
{
StreamingMode = mode;
Options = options;
Password = password;
}
private Options Options { get; }
public string Password { get; private set; }
private ReaderOptions Options { get; }
internal StreamingMode StreamingMode { get; }
internal bool IsEncrypted { get; private set; }
internal IEnumerable<RarHeader> ReadHeaders(Stream stream)
{
if (Options.HasFlag(Options.LookForHeader))
if (Options.LookForHeader)
{
stream = CheckSFX(stream);
}
@@ -91,7 +90,7 @@ namespace SharpCompress.Common.Rar.Headers
}
catch (Exception e)
{
if (!Options.HasFlag(Options.KeepStreamsOpen))
if (!Options.LeaveOpenStream)
{
#if NET35
reader.Close();
@@ -117,11 +116,11 @@ namespace SharpCompress.Common.Rar.Headers
private RarHeader ReadNextHeader(Stream stream)
{
#if !NO_CRYPTO
var reader = new RarCryptoBinaryReader(stream, Password);
var reader = new RarCryptoBinaryReader(stream, Options.Password);
if (IsEncrypted)
{
if (Password == null)
if (Options.Password == null)
{
throw new CryptographicException("Encrypted Rar archive has no password specified.");
}
@@ -223,7 +222,7 @@ namespace SharpCompress.Common.Rar.Headers
else
{
#if !NO_CRYPTO
fh.PackedStream = new RarCryptoWrapper(ms, Password, fh.Salt);
fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.Salt);
#else
throw new NotSupportedException("RarCrypto not supported");
#endif

8
src/SharpCompress/Common/Rar/RarVolume.cs
View File

@@ -4,6 +4,7 @@ using System.IO;
using System.Linq;
using SharpCompress.Common.Rar.Headers;
using SharpCompress.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common.Rar
{
@@ -14,15 +15,12 @@ namespace SharpCompress.Common.Rar
{
private readonly RarHeaderFactory headerFactory;
internal RarVolume(StreamingMode mode, Stream stream, string password, Options options)
internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options)
: base(stream, options)
{
headerFactory = new RarHeaderFactory(mode, options, password);
Password = password;
headerFactory = new RarHeaderFactory(mode, options);
}
internal string Password { get; private set; }
internal StreamingMode Mode { get { return headerFactory.StreamingMode; } }
internal abstract IEnumerable<RarFilePart> ReadFileParts();

6
src/SharpCompress/Common/SevenZip/SevenZipVolume.cs
View File

@@ -1,11 +1,13 @@
using System.IO;
using SharpCompress.Archives;
using SharpCompress.Readers;
namespace SharpCompress.Common.SevenZip
{
public class SevenZipVolume : Volume
{
public SevenZipVolume(Stream stream, Options options)
: base(stream, options)
public SevenZipVolume(Stream stream, ReaderOptions readerFactoryOptions)
: base(stream, readerFactoryOptions)
{
}
}

5
src/SharpCompress/Common/Tar/TarVolume.cs
View File

@@ -1,11 +1,12 @@
using System.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common.Tar
{
public class TarVolume : Volume
{
public TarVolume(Stream stream, Options options)
: base(stream, options)
public TarVolume(Stream stream, ReaderOptions readerOptions)
: base(stream, readerOptions)
{
}
}

9
src/SharpCompress/Common/Volume.cs
View File

@@ -1,5 +1,6 @@
using System.IO;
using SharpCompress.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common
{
@@ -7,15 +8,15 @@ namespace SharpCompress.Common
{
private readonly Stream actualStream;
internal Volume(Stream stream, Options options)
internal Volume(Stream stream, ReaderOptions readerFactoryOptions)
{
actualStream = stream;
Options = options;
ReaderOptions = readerFactoryOptions;
}
internal Stream Stream { get { return new NonDisposingStream(actualStream); } }
internal Options Options { get; }
protected ReaderOptions ReaderOptions { get; }
/// <summary>
/// RarArchive is the first volume of a multi-part archive.
@@ -32,7 +33,7 @@ namespace SharpCompress.Common
public void Dispose()
{
if (!Options.HasFlag(Options.KeepStreamsOpen) && !disposed)
if (!ReaderOptions.LeaveOpenStream && !disposed)
{
actualStream.Dispose();
disposed = true;

5
src/SharpCompress/Common/Zip/ZipVolume.cs
View File

@@ -1,11 +1,12 @@
using System.IO;
using SharpCompress.Readers;
namespace SharpCompress.Common.Zip
{
public class ZipVolume : Volume
{
public ZipVolume(Stream stream, Options options)
: base(stream, options)
public ZipVolume(Stream stream, ReaderOptions readerOptions)
: base(stream, readerOptions)
{
}

4
src/SharpCompress/Readers/AbstractReader.cs
View File

@@ -23,13 +23,13 @@ namespace SharpCompress.Readers
public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
internal AbstractReader(Options options, ArchiveType archiveType)
internal AbstractReader(ReaderOptions options, ArchiveType archiveType)
{
ArchiveType = archiveType;
Options = options;
}
internal Options Options { get; private set; }
internal ReaderOptions Options { get; private set; }
public ArchiveType ArchiveType { get; }

7
src/SharpCompress/Readers/GZip/GZipReader.cs
View File

@@ -7,7 +7,7 @@ namespace SharpCompress.Readers.GZip
{
public class GZipReader : AbstractReader<GZipEntry, GZipVolume>
{
internal GZipReader(Stream stream, Options options)
internal GZipReader(Stream stream, ReaderOptions options)
: base(options, ArchiveType.GZip)
{
Volume = new GZipVolume(stream, options);
@@ -23,11 +23,10 @@ namespace SharpCompress.Readers.GZip
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static GZipReader Open(Stream stream,
Options options = Options.KeepStreamsOpen)
public static GZipReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
return new GZipReader(stream, options);
return new GZipReader(stream, options ?? new ReaderOptions());
}
#endregion

2
src/SharpCompress/Readers/Rar/MultiVolumeRarReader.cs
View File

@@ -12,7 +12,7 @@ namespace SharpCompress.Readers.Rar
private readonly IEnumerator<Stream> streams;
private Stream tempStream;
internal MultiVolumeRarReader(IEnumerable<Stream> streams, Options options)
internal MultiVolumeRarReader(IEnumerable<Stream> streams, ReaderOptions options)
: base(options)
{
this.streams = streams.GetEnumerator();

20
src/SharpCompress/Readers/Rar/RarReader.cs
View File

@@ -12,11 +12,10 @@ namespace SharpCompress.Readers.Rar
/// </summary>
public abstract class RarReader : AbstractReader<RarReaderEntry, RarVolume>
{
public string Password { get; set; }
private RarVolume volume;
private readonly Unpack pack = new Unpack();
internal RarReader(Options options)
internal RarReader(ReaderOptions options)
: base(options, ArchiveType.Rar)
{
}
@@ -33,9 +32,10 @@ namespace SharpCompress.Readers.Rar
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static RarReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
public static RarReader Open(Stream stream, ReaderOptions options = null)
{
return Open(stream, null, options);
stream.CheckNotNull("stream");
return new SingleVolumeRarReader(stream, options ?? new ReaderOptions());
}
/// <summary>
@@ -44,17 +44,17 @@ namespace SharpCompress.Readers.Rar
/// <param name="streams"></param>
/// <param name="options"></param>
/// <returns></returns>
public static RarReader Open(IEnumerable<Stream> streams, Options options = Options.KeepStreamsOpen)
public static RarReader Open(IEnumerable<Stream> streams, ReaderOptions options = null)
{
streams.CheckNotNull("streams");
return new MultiVolumeRarReader(streams, options);
return new MultiVolumeRarReader(streams, options ?? new ReaderOptions());
}
#endregion
internal override IEnumerable<RarReaderEntry> GetEntries(Stream stream)
{
volume = new RarReaderVolume(stream, Password, Options);
volume = new RarReaderVolume(stream, Options);
foreach (RarFilePart fp in volume.ReadFileParts())
{
ValidateArchive(volume);
@@ -73,11 +73,5 @@ namespace SharpCompress.Readers.Rar
new MultiVolumeReadOnlyStream(
CreateFilePartEnumerableForCurrentEntry().Cast<RarFilePart>(), this)));
}
public static RarReader Open(Stream stream, string password, Options options = Options.KeepStreamsOpen)
{
stream.CheckNotNull("stream");
return new SingleVolumeRarReader(stream, password, options);
}
}
}

5
src/SharpCompress/Readers/Rar/RarReaderVolume.cs
View File

@@ -1,6 +1,5 @@
using System.Collections.Generic;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Common.Rar;
using SharpCompress.Common.Rar.Headers;
using SharpCompress.IO;
@@ -9,8 +8,8 @@ namespace SharpCompress.Readers.Rar
{
public class RarReaderVolume : RarVolume
{
internal RarReaderVolume(Stream stream, string password, Options options)
: base(StreamingMode.Streaming, stream, password, options)
internal RarReaderVolume(Stream stream, ReaderOptions options)
: base(StreamingMode.Streaming, stream, options)
{
}

3
src/SharpCompress/Readers/Rar/SingleVolumeRarReader.cs
View File

@@ -8,10 +8,9 @@ namespace SharpCompress.Readers.Rar
{
private readonly Stream stream;
internal SingleVolumeRarReader(Stream stream, string password, Options options)
internal SingleVolumeRarReader(Stream stream, ReaderOptions options)
: base(options)
{
Password = password;
this.stream = stream;
}

13
src/SharpCompress/Readers/ReaderFactory.cs
View File

@@ -24,16 +24,19 @@ namespace SharpCompress.Readers
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static IReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
public static IReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveOpenStream = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (ZipArchive.IsZipFile(rewindableStream, null))
{
rewindableStream.Rewind(true);
return ZipReader.Open(rewindableStream, null, options);
return ZipReader.Open(rewindableStream, options);
}
rewindableStream.Rewind(false);
if (GZipArchive.IsGZipFile(rewindableStream))
@@ -43,7 +46,7 @@ namespace SharpCompress.Readers
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.GZip, options);
return new TarReader(rewindableStream, options, CompressionType.GZip);
}
rewindableStream.Rewind(true);
return GZipReader.Open(rewindableStream, options);
@@ -57,7 +60,7 @@ namespace SharpCompress.Readers
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.BZip2, options);
return new TarReader(rewindableStream, options, CompressionType.BZip2);
}
}

18
src/SharpCompress/Readers/ReaderOptions.cs Normal file
View File

@@ -0,0 +1,18 @@
using SharpCompress.Common;
namespace SharpCompress.Readers
{
public class ReaderOptions
{
/// <summary>
/// SharpCompress will keep the supplied streams open. Default is true.
/// </summary>
public virtual bool LeaveOpenStream { get; set; } = true;
/// <summary>
/// Look for RarArchive (Check for self-extracting archives or cases where RarArchive isn't at the start of the file)
/// </summary>
public bool LookForHeader { get; set; }
public string Password { get; set; }
}
}

13
src/SharpCompress/Readers/Tar/TarReader.cs
View File

@@ -16,8 +16,7 @@ namespace SharpCompress.Readers.Tar
{
private readonly CompressionType compressionType;
internal TarReader(Stream stream, CompressionType compressionType,
Options options)
internal TarReader(Stream stream, ReaderOptions options, CompressionType compressionType)
: base(options, ArchiveType.Tar)
{
this.compressionType = compressionType;
@@ -58,10 +57,10 @@ namespace SharpCompress.Readers.Tar
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static TarReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
public static TarReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions();
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (GZipArchive.IsGZipFile(rewindableStream))
@@ -71,7 +70,7 @@ namespace SharpCompress.Readers.Tar
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.GZip, options);
return new TarReader(rewindableStream, options, CompressionType.GZip);
}
throw new InvalidFormatException("Not a tar file.");
}
@@ -84,12 +83,12 @@ namespace SharpCompress.Readers.Tar
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.BZip2, options);
return new TarReader(rewindableStream, options, CompressionType.BZip2);
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.None, options);
return new TarReader(rewindableStream, options, CompressionType.None);
}
#endregion

10
src/SharpCompress/Readers/Zip/ZipReader.cs
View File

@@ -10,11 +10,11 @@ namespace SharpCompress.Readers.Zip
{
private readonly StreamingZipHeaderFactory headerFactory;
internal ZipReader(Stream stream, Options options, string password)
internal ZipReader(Stream stream, ReaderOptions options)
: base(options, ArchiveType.Zip)
{
Volume = new ZipVolume(stream, options);
headerFactory = new StreamingZipHeaderFactory(password);
headerFactory = new StreamingZipHeaderFactory(options.Password);
}
public override ZipVolume Volume { get; }
@@ -26,13 +26,11 @@ namespace SharpCompress.Readers.Zip
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <param name="password"></param>
/// <returns></returns>
public static ZipReader Open(Stream stream, string password = null,
Options options = Options.KeepStreamsOpen)
public static ZipReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
return new ZipReader(stream, options, password);
return new ZipReader(stream, options ?? new ReaderOptions());
}
#endregion

12
src/SharpCompress/Writers/Tar/TarWriter.cs
View File

@@ -10,33 +10,33 @@ namespace SharpCompress.Writers.Tar
{
public class TarWriter : AbstractWriter
{
public TarWriter(Stream destination, CompressionInfo compressionInfo, bool leaveOpen = false)
public TarWriter(Stream destination, TarWriterOptions options)
: base(ArchiveType.Tar)
{
if (!destination.CanWrite)
{
throw new ArgumentException("Tars require writable streams.");
}
switch (compressionInfo.Type)
switch (options.CompressionType)
{
case CompressionType.None:
break;
case CompressionType.BZip2:
{
destination = new BZip2Stream(destination, CompressionMode.Compress, leaveOpen);
destination = new BZip2Stream(destination, CompressionMode.Compress, options.LeaveOpenStream);
}
break;
case CompressionType.GZip:
{
destination = new GZipStream(destination, CompressionMode.Compress, leaveOpen);
destination = new GZipStream(destination, CompressionMode.Compress, options.LeaveOpenStream);
}
break;
default:
{
throw new InvalidFormatException("Tar does not support compression: " + compressionInfo.Type);
throw new InvalidFormatException("Tar does not support compression: " + options.CompressionType);
}
}
InitalizeStream(destination, !leaveOpen);
InitalizeStream(destination, !options.LeaveOpenStream);
}
public override void Write(string filename, Stream source, DateTime? modificationTime)

22
src/SharpCompress/Writers/Tar/TarWriterOptions.cs Normal file
View File

@@ -0,0 +1,22 @@
using SharpCompress.Common;
namespace SharpCompress.Writers.Tar
{
public class TarWriterOptions
{
public TarWriterOptions()
{
}
internal TarWriterOptions(WriterOptions readerOptions)
{
LeaveOpenStream = readerOptions.LeaveOpenStream;
CompressionType = readerOptions.CompressionType;
}
public bool LeaveOpenStream { get; set; }
public CompressionType CompressionType { get; set; } = CompressionType.Unknown;
}
}

18
src/SharpCompress/Writers/WriterFactory.cs
View File

@@ -9,33 +9,25 @@ namespace SharpCompress.Writers
{
public static class WriterFactory
{
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionType compressionType, bool leaveOpen = false)
{
return Open(stream, archiveType, new CompressionInfo
{
Type = compressionType
}, leaveOpen);
}
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionInfo compressionInfo, bool leaveOpen = false)
public static IWriter Open(Stream stream, ArchiveType archiveType, WriterOptions writerOptions)
{
switch (archiveType)
{
case ArchiveType.GZip:
{
if (compressionInfo.Type != CompressionType.GZip)
if (writerOptions.CompressionType != CompressionType.GZip)
{
throw new InvalidFormatException("GZip archives only support GZip compression type.");
}
return new GZipWriter(stream, leaveOpen);
return new GZipWriter(stream, writerOptions.LeaveOpenStream);
}
case ArchiveType.Zip:
{
return new ZipWriter(stream, compressionInfo, null, leaveOpen);
return new ZipWriter(stream, new ZipWriterOptions(writerOptions));
}
case ArchiveType.Tar:
{
return new TarWriter(stream, compressionInfo, leaveOpen);
return new TarWriter(stream, new TarWriterOptions(writerOptions));
}
default:
{

27
src/SharpCompress/Writers/WriterOptions.cs Normal file
View File

@@ -0,0 +1,27 @@
using SharpCompress.Common;
using SharpCompress.Compressors.Deflate;
namespace SharpCompress.Writers
{
public class WriterOptions
{
public WriterOptions(CompressionType compressionType)
{
CompressionType = compressionType;
}
public CompressionType CompressionType { get; set; } = CompressionType.Unknown;
public bool LeaveOpenStream { get; set; }
/// <summary>
/// When CompressionType.Deflate is used, this property is referenced. Defaults to CompressionLevel.Default.
/// </summary>
public CompressionLevel DeflateCompressionLevel { get; set; } = CompressionLevel.Default;
public static implicit operator WriterOptions(CompressionType compressionType)
{
return new WriterOptions(compressionType);
}
}
}

47
src/SharpCompress/Writers/Zip/ZipCompressionInfo.cs
View File

@@ -1,47 +0,0 @@
using SharpCompress.Common;
using SharpCompress.Common.Zip;
using SharpCompress.Compressors.Deflate;
namespace SharpCompress.Writers.Zip
{
internal class ZipCompressionInfo
{
internal CompressionLevel DeflateCompressionLevel { get; private set; }
internal ZipCompressionMethod Compression { get; private set; }
public ZipCompressionInfo(CompressionInfo compressionInfo)
{
switch (compressionInfo.Type)
{
case CompressionType.None:
{
Compression = ZipCompressionMethod.None;
}
break;
case CompressionType.Deflate:
{
DeflateCompressionLevel = compressionInfo.DeflateCompressionLevel;
Compression = ZipCompressionMethod.Deflate;
}
break;
case CompressionType.BZip2:
{
Compression = ZipCompressionMethod.BZip2;
}
break;
case CompressionType.LZMA:
{
Compression = ZipCompressionMethod.LZMA;
}
break;
case CompressionType.PPMd:
{
Compression = ZipCompressionMethod.PPMd;
}
break;
default:
throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type);
}
}
}
}

94
src/SharpCompress/Writers/Zip/ZipWriter.cs
View File

@@ -17,19 +17,21 @@ namespace SharpCompress.Writers.Zip
{
public class ZipWriter : AbstractWriter
{
private readonly ZipCompressionInfo zipCompressionInfo;
private readonly CompressionType compressionType;
private readonly CompressionLevel compressionLevel;
private readonly PpmdProperties ppmdProperties = new PpmdProperties(); // Caching properties to speed up PPMd
private readonly List<ZipCentralDirectoryEntry> entries = new List<ZipCentralDirectoryEntry>();
private readonly string zipComment;
private long streamPosition;
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment, bool leaveOpen = false)
public ZipWriter(Stream destination, ZipWriterOptions zipWriterOptions)
: base(ArchiveType.Zip)
{
this.zipComment = zipComment ?? string.Empty;
zipComment = zipWriterOptions.ArchiveComment ?? string.Empty;
zipCompressionInfo = new ZipCompressionInfo(compressionInfo);
InitalizeStream(destination, !leaveOpen);
compressionType = zipWriterOptions.CompressionType;
compressionLevel = zipWriterOptions.DeflateCompressionLevel;
InitalizeStream(destination, !zipWriterOptions.LeaveOpenStream);
}
protected override void Dispose(bool isDisposing)
@@ -39,42 +41,75 @@ namespace SharpCompress.Writers.Zip
uint size = 0;
foreach (ZipCentralDirectoryEntry entry in entries)
{
size += entry.Write(OutputStream, zipCompressionInfo.Compression);
size += entry.Write(OutputStream, ToZipCompressionMethod(compressionType));
}
WriteEndRecord(size);
}
base.Dispose(isDisposing);
}
private static ZipCompressionMethod ToZipCompressionMethod(CompressionType compressionType)
{
switch (compressionType)
{
case CompressionType.None:
{
return ZipCompressionMethod.None;
}
case CompressionType.Deflate:
{
return ZipCompressionMethod.Deflate;
}
case CompressionType.BZip2:
{
return ZipCompressionMethod.BZip2;
}
case CompressionType.LZMA:
{
return ZipCompressionMethod.LZMA;
}
case CompressionType.PPMd:
{
return ZipCompressionMethod.PPMd;
}
default:
throw new InvalidFormatException("Invalid compression method: " + compressionType);
}
}
public override void Write(string entryPath, Stream source, DateTime? modificationTime)
{
Write(entryPath, source, modificationTime, null);
Write(entryPath, source, new ZipWriterEntryOptions()
{
ModificationDateTime = modificationTime
});
}
public void Write(string entryPath, Stream source, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null)
public void Write(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions)
{
using (Stream output = WriteToStream(entryPath, modificationTime, comment, compressionInfo))
using (Stream output = WriteToStream(entryPath, zipWriterEntryOptions))
{
source.TransferTo(output);
}
}
public Stream WriteToStream(string entryPath, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null)
public Stream WriteToStream(string entryPath, ZipWriterEntryOptions options)
{
entryPath = NormalizeFilename(entryPath);
modificationTime = modificationTime ?? DateTime.Now;
comment = comment ?? "";
options.ModificationDateTime = options.ModificationDateTime ?? DateTime.Now;
options.EntryComment = options.EntryComment ?? string.Empty;
var entry = new ZipCentralDirectoryEntry
{
Comment = comment,
Comment = options.EntryComment,
FileName = entryPath,
ModificationTime = modificationTime,
ModificationTime = options.ModificationDateTime,
HeaderOffset = (uint)streamPosition
};
var headersize = (uint)WriteHeader(entryPath, modificationTime, compressionInfo);
var headersize = (uint)WriteHeader(entryPath, options);
streamPosition += headersize;
return new ZipWritingStream(this, OutputStream, entry, compressionInfo);
return new ZipWritingStream(this, OutputStream, entry,
ToZipCompressionMethod(options.CompressionType ?? compressionType),
options.DeflateCompressionLevel ?? compressionLevel);
}
private string NormalizeFilename(string filename)
@@ -90,13 +125,13 @@ namespace SharpCompress.Writers.Zip
return filename.Trim('/');
}
private int WriteHeader(string filename, DateTime? modificationTime, CompressionInfo compressionInfo = null)
private int WriteHeader(string filename, ZipWriterEntryOptions zipWriterEntryOptions)
{
var explicitZipCompressionInfo = compressionInfo != null ? new ZipCompressionInfo(compressionInfo) : zipCompressionInfo;
var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
byte[] encodedFilename = ArchiveEncoding.Default.GetBytes(filename);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.Deflate)
if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate)
{
OutputStream.Write(new byte[] {20, 0}, 0, 2); //older version which is more compatible
}
@@ -108,14 +143,14 @@ namespace SharpCompress.Writers.Zip
if (!OutputStream.CanSeek)
{
flags |= HeaderFlags.UsePostDataDescriptor;
if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.LZMA)
if (explicitZipCompressionInfo == ZipCompressionMethod.LZMA)
{
flags |= HeaderFlags.Bit1; // eos marker
}
}
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo.Compression), 0, 2); // zipping method
OutputStream.Write(DataConverter.LittleEndian.GetBytes(modificationTime.DateTimeToDosTime()), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo), 0, 2); // zipping method
OutputStream.Write(DataConverter.LittleEndian.GetBytes(zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime()), 0, 4);
// zipping date and time
OutputStream.Write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 12);
@@ -157,17 +192,20 @@ namespace SharpCompress.Writers.Zip
private readonly Stream originalStream;
private readonly Stream writeStream;
private readonly ZipWriter writer;
private readonly ZipCompressionInfo compressionInfo;
private readonly ZipCompressionMethod zipCompressionMethod;
private readonly CompressionLevel compressionLevel;
private CountingWritableSubStream counting;
private uint decompressed;
internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry, CompressionInfo compressionInfo)
internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry,
ZipCompressionMethod zipCompressionMethod, CompressionLevel compressionLevel)
{
this.writer = writer;
this.originalStream = originalStream;
this.writer = writer;
this.entry = entry;
this.compressionInfo = compressionInfo == null ? writer.zipCompressionInfo : new ZipCompressionInfo(compressionInfo);
this.zipCompressionMethod = zipCompressionMethod;
this.compressionLevel = compressionLevel;
writeStream = GetWriteStream(originalStream);
}
@@ -185,7 +223,7 @@ namespace SharpCompress.Writers.Zip
{
counting = new CountingWritableSubStream(writeStream);
Stream output = counting;
switch (compressionInfo.Compression)
switch (zipCompressionMethod)
{
case ZipCompressionMethod.None:
{
@@ -193,7 +231,7 @@ namespace SharpCompress.Writers.Zip
}
case ZipCompressionMethod.Deflate:
{
return new DeflateStream(counting, CompressionMode.Compress, compressionInfo.DeflateCompressionLevel,
return new DeflateStream(counting, CompressionMode.Compress, compressionLevel,
true);
}
case ZipCompressionMethod.BZip2:
@@ -219,7 +257,7 @@ namespace SharpCompress.Writers.Zip
}
default:
{
throw new NotSupportedException("CompressionMethod: " + compressionInfo.Compression);
throw new NotSupportedException("CompressionMethod: " + zipCompressionMethod);
}
}
}

19
src/SharpCompress/Writers/Zip/ZipWriterEntryOptions.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
using SharpCompress.Common;
using SharpCompress.Compressors.Deflate;
namespace SharpCompress.Writers.Zip
{
public class ZipWriterEntryOptions
{
public CompressionType? CompressionType { get; set; }
/// <summary>
/// When CompressionType.Deflate is used, this property is referenced. Defaults to CompressionLevel.Default.
/// </summary>
public CompressionLevel? DeflateCompressionLevel { get; set; }
public string EntryComment { get; set; }
public DateTime? ModificationDateTime { get; set; }
}
}

30
src/SharpCompress/Writers/Zip/ZipWriterOptions.cs Normal file
View File

@@ -0,0 +1,30 @@
using SharpCompress.Archives;
using SharpCompress.Common;
using SharpCompress.Compressors.Deflate;
namespace SharpCompress.Writers.Zip
{
public class ZipWriterOptions
{
public ZipWriterOptions()
{
}
internal ZipWriterOptions(WriterOptions options)
{
LeaveOpenStream = options.LeaveOpenStream;
CompressionType = options.CompressionType;
}
public bool LeaveOpenStream { get; set; }
public CompressionType CompressionType { get; set; } = CompressionType.Unknown;
/// <summary>
/// When CompressionType.Deflate is used, this property is referenced. Defaults to CompressionLevel.Default.
/// </summary>
public CompressionLevel DeflateCompressionLevel { get; set; } = CompressionLevel.Default;
public string ArchiveComment { get; set; }
}
}

23
test/SharpCompress.Test/Rar/RarArchiveTests.cs
View File

@@ -3,6 +3,7 @@ using System.Linq;
using SharpCompress.Archives;
using SharpCompress.Archives.Rar;
using SharpCompress.Common;
using SharpCompress.Readers;
using Xunit;
namespace SharpCompress.Test
@@ -33,7 +34,11 @@ namespace SharpCompress.Test
{
ResetScratch();
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
using (var archive = RarArchive.Open(stream, Options.KeepStreamsOpen, password))
using (var archive = RarArchive.Open(stream, new ReaderOptions()
{
Password = password,
LeaveOpenStream = true
}))
{
foreach (var entry in archive.Entries)
{
@@ -56,7 +61,11 @@ namespace SharpCompress.Test
protected void ArchiveFileReadPassword(string archiveName, string password)
{
ResetScratch();
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, archiveName), Options.None, password))
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, archiveName), new ReaderOptions()
{
Password = password,
LeaveOpenStream = true
}))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
@@ -101,7 +110,10 @@ namespace SharpCompress.Test
ResetScratch();
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
{
using (var archive = RarArchive.Open(stream, Options.LookForHeader))
using (var archive = RarArchive.Open(stream, new ReaderOptions()
{
LookForHeader = true
}))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
@@ -197,7 +209,10 @@ namespace SharpCompress.Test
public void Rar_Jpg_ArchiveFileRead()
{
ResetScratch();
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg"), Options.LookForHeader))
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg"), new ReaderOptions()
{
LookForHeader = true
}))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{

9
test/SharpCompress.Test/Rar/RarHeaderFactoryTest.cs
View File

@@ -1,7 +1,7 @@
using System.IO;
using SharpCompress.Common;
using SharpCompress.Common.Rar.Headers;
using SharpCompress.IO;
using SharpCompress.Readers;
using Xunit;
namespace SharpCompress.Test.Rar
@@ -16,7 +16,10 @@ namespace SharpCompress.Test.Rar
public RarHeaderFactoryTest()
{
ResetScratch();
rarHeaderFactory = new RarHeaderFactory(StreamingMode.Seekable, Options.KeepStreamsOpen);
rarHeaderFactory = new RarHeaderFactory(StreamingMode.Seekable, new ReaderOptions()
{
LeaveOpenStream = true
});
}
@@ -33,6 +36,7 @@ namespace SharpCompress.Test.Rar
private void ReadEncryptedFlag(string testArchive, bool isEncrypted)
{
using (var stream = GetReaderStream(testArchive))
{
foreach (var header in rarHeaderFactory.ReadHeaders(stream))
{
if (header.HeaderType == HeaderType.ArchiveHeader)
@@ -41,6 +45,7 @@ namespace SharpCompress.Test.Rar
break;
}
}
}
}
[Fact]

25
test/SharpCompress.Test/Rar/RarReaderTests.cs
View File

@@ -128,7 +128,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
using (var reader = RarReader.Open(stream, password))
using (var reader = RarReader.Open(stream, new ReaderOptions()
{
Password = password
}))
{
while (reader.MoveToNextEntry())
{
@@ -181,7 +184,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Audio_program.rar")))
using (var reader = RarReader.Open(stream, Options.LookForHeader))
using (var reader = RarReader.Open(stream, new ReaderOptions()
{
LookForHeader = true
}))
{
while (reader.MoveToNextEntry())
{
@@ -198,7 +204,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
using (var reader = RarReader.Open(stream, Options.LookForHeader))
using (var reader = RarReader.Open(stream, new ReaderOptions()
{
LookForHeader = true
}))
{
while (reader.MoveToNextEntry())
{
@@ -220,7 +229,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.solid.rar")))
using (var reader = RarReader.Open(stream, Options.LookForHeader))
using (var reader = RarReader.Open(stream, new ReaderOptions()
{
LookForHeader = true
}))
{
while (reader.MoveToNextEntry())
{
@@ -238,7 +250,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.rar")))
using (var reader = RarReader.Open(stream, Options.LookForHeader))
using (var reader = RarReader.Open(stream, new ReaderOptions()
{
LookForHeader = true
}))
{
while (reader.MoveToNextEntry())
{

2
test/SharpCompress.Test/Tar/TarArchiveTests.cs
View File

@@ -139,7 +139,7 @@ namespace SharpCompress.Test
base.ResetScratch();
using (var archive = TarArchive.Open(unmodified))
{
var entry = archive.Entries.Where(x => x.Key.EndsWith("jpg")).Single();
var entry = archive.Entries.Single(x => x.Key.EndsWith("jpg"));
archive.RemoveEntry(entry);
archive.SaveTo(scratchPath, CompressionType.None);
}

4
test/SharpCompress.Test/TestBase.cs
View File

@@ -210,8 +210,8 @@ namespace SharpCompress.Test
protected void CompareArchivesByPath(string file1, string file2)
{
using (var archive1 = ReaderFactory.Open(File.OpenRead(file1), Options.None))
using (var archive2 = ReaderFactory.Open(File.OpenRead(file2), Options.None))
using (var archive1 = ReaderFactory.Open(File.OpenRead(file1)))
using (var archive2 = ReaderFactory.Open(File.OpenRead(file2)))
{
while (archive1.MoveToNextEntry())
{

10
test/SharpCompress.Test/WriterTests.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SharpCompress.Common;
using SharpCompress.IO;
using SharpCompress.Readers;
using SharpCompress.Writers;
@@ -20,7 +21,10 @@ namespace SharpCompress.Test
ResetScratch();
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
{
using (var writer = WriterFactory.Open(stream, type, compressionType, true))
using (var writer = WriterFactory.Open(new NonDisposingStream(stream), type, new WriterOptions(compressionType)
{
LeaveOpenStream = true
}))
{
writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories);
}
@@ -33,9 +37,9 @@ namespace SharpCompress.Test
Path.Combine(TEST_ARCHIVES_PATH, archiveToVerifyAgainst));
using (Stream stream = File.OpenRead(Path.Combine(SCRATCH2_FILES_PATH, archive)))
using (var reader = ReaderFactory.Open(stream))
using (var reader = ReaderFactory.Open(new NonDisposingStream(stream)))
{
reader.WriteAllToDirectory(SCRATCH_FILES_PATH, ExtractOptions.ExtractFullPath);
reader.WriteAllToDirectory(SCRATCH_FILES_PATH, ExtractOptions.ExtractFullPath);
}
VerifyFiles();
}

11
test/SharpCompress.Test/Zip/ZipArchiveTests.cs
View File

@@ -6,6 +6,7 @@ using System.Text;
using SharpCompress.Archives;
using SharpCompress.Archives.Zip;
using SharpCompress.Common;
using SharpCompress.Readers;
using SharpCompress.Writers;
using Xunit;
@@ -295,7 +296,10 @@ namespace SharpCompress.Test
public void Zip_Deflate_WinzipAES_Read()
{
ResetScratch();
using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"), "test"))
using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"), new ReaderOptions()
{
Password = "test"
}))
{
foreach (var entry in reader.Entries.Where(x => !x.IsDirectory))
{
@@ -310,7 +314,10 @@ namespace SharpCompress.Test
public void Zip_BZip2_Pkware_Read()
{
ResetScratch();
using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"), "test"))
using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"), new ReaderOptions()
{
Password = "test"
}))
{
foreach (var entry in reader.Entries.Where(x => !x.IsDirectory))
{

19
test/SharpCompress.Test/Zip/ZipReaderTests.cs
View File

@@ -84,7 +84,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip")))
using (var reader = ZipReader.Open(stream, "test"))
using (var reader = ZipReader.Open(stream, new ReaderOptions()
{
Password = "test"
}))
{
while (reader.MoveToNextEntry())
{
@@ -104,7 +107,7 @@ namespace SharpCompress.Test
ResetScratch();
using (TestStream stream = new TestStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))))
{
using (var reader = ReaderFactory.Open(stream, Options.None))
using (var reader = ReaderFactory.Open(stream))
{
while (reader.MoveToNextEntry())
{
@@ -125,7 +128,7 @@ namespace SharpCompress.Test
ResetScratch();
using (TestStream stream = new TestStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))))
{
var reader = ReaderFactory.Open(stream, Options.None);
var reader = ReaderFactory.Open(stream);
while (reader.MoveToNextEntry())
{
if (!reader.Entry.IsDirectory)
@@ -148,7 +151,10 @@ namespace SharpCompress.Test
Stream stream =
File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH,
"Zip.lzma.winzipaes.zip")))
using (var reader = ZipReader.Open(stream, "test"))
using (var reader = ZipReader.Open(stream, new ReaderOptions()
{
Password = "test"
}))
{
while (reader.MoveToNextEntry())
{
@@ -171,7 +177,10 @@ namespace SharpCompress.Test
{
ResetScratch();
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip")))
using (var reader = ZipReader.Open(stream, "test"))
using (var reader = ZipReader.Open(stream, new ReaderOptions()
{
Password = "test"
}))
{
while (reader.MoveToNextEntry())
{