private static void InitCompressionStreamCreators()
{
if (ZipEngine.compressionStreamCreators == null)
{
ZipEngine.compressionStreamCreators = new
Dictionary <ZipCompressionMethod, Converter <Stream, Stream> >();
ZipEngine.decompressionStreamCreators = new
Dictionary <ZipCompressionMethod, Converter <Stream, Stream> >();
ZipEngine.RegisterCompressionStreamCreator(
ZipCompressionMethod.Store,
CompressionMode.Compress,
delegate(Stream stream) {
return(stream);
});
ZipEngine.RegisterCompressionStreamCreator(
ZipCompressionMethod.Deflate,
CompressionMode.Compress,
delegate(Stream stream) {
return(new DeflateStream(stream, CompressionMode.Compress, true));
});
ZipEngine.RegisterCompressionStreamCreator(
ZipCompressionMethod.Store,
CompressionMode.Decompress,
delegate(Stream stream) {
return(stream);
});
ZipEngine.RegisterCompressionStreamCreator(
ZipCompressionMethod.Deflate,
CompressionMode.Decompress,
delegate(Stream stream) {
return(new DeflateStream(stream, CompressionMode.Decompress, true));
});
}
}
/// <summary>
/// Registers a delegate that can create a warpper stream for
/// compressing or uncompressing the data of a source stream.
/// </summary>
/// <param name="compressionMethod">Compression method being registered.</param>
/// <param name="compressionMode">Indicates registration for ether
/// compress or decompress mode.</param>
/// <param name="creator">Delegate being registered.</param>
/// <remarks>
/// For compression, the delegate accepts a stream that writes to the archive
/// and returns a wrapper stream that compresses bytes as they are written.
/// For decompression, the delegate accepts a stream that reads from the archive
/// and returns a wrapper stream that decompresses bytes as they are read.
/// This wrapper stream model follows the design used by
/// System.IO.Compression.DeflateStream, and indeed that class is used
/// to implement the Deflate compression method by default.
/// <para>To unregister a delegate, call this method again and pass
/// null for the delegate parameter.</para>
/// </remarks>
/// <example>
/// When the ZipEngine class is initialized, the Deflate compression method
/// is automatically registered like this:
/// <code>
/// ZipEngine.RegisterCompressionStreamCreator(
/// ZipCompressionMethod.Deflate,
/// CompressionMode.Compress,
/// delegate(Stream stream) {
/// return new DeflateStream(stream, CompressionMode.Compress, true);
/// });
/// ZipEngine.RegisterCompressionStreamCreator(
/// ZipCompressionMethod.Deflate,
/// CompressionMode.Decompress,
/// delegate(Stream stream) {
/// return new DeflateStream(stream, CompressionMode.Decompress, true);
/// });
/// </code></example>
internal static void RegisterCompressionStreamCreator(
ZipCompressionMethod compressionMethod,
CompressionMode compressionMode,
Converter <Stream, Stream> creator)
{
ZipEngine.InitCompressionStreamCreators();
if (compressionMode == CompressionMode.Compress)
{
ZipEngine.compressionStreamCreators[compressionMethod] = creator;
}
else
{
ZipEngine.decompressionStreamCreators[compressionMethod] = creator;
}
}
/// <summary>
/// Creates a new instance of the zip engine.
/// </summary>
internal ZipEngine()
: base()
{
ZipEngine.InitCompressionStreamCreators();
}
/// <summary>
/// Unpacks a single file from an archive or archive chain.
/// </summary>
private void UnpackOneFile(
IUnpackStreamContext streamContext,
ZipFileHeader header,
ref Stream archiveStream)
{
ZipFileInfo fileInfo = null;
Stream fileStream = null;
try
{
Converter <Stream, Stream> compressionStreamCreator;
if (!ZipEngine.decompressionStreamCreators.TryGetValue(
header.compressionMethod, out compressionStreamCreator))
{
// Silently skip files of an unsupported compression method.
return;
}
long compressedSize;
long uncompressedSize;
long localHeaderOffset;
int archiveNumber;
uint crc;
header.GetZip64Fields(
out compressedSize,
out uncompressedSize,
out localHeaderOffset,
out archiveNumber,
out crc);
if (this.currentArchiveNumber != archiveNumber + 1)
{
if (archiveStream != null)
{
streamContext.CloseArchiveReadStream(
this.currentArchiveNumber,
String.Empty,
archiveStream);
archiveStream = null;
this.OnProgress(ArchiveProgressType.FinishArchive);
this.currentArchiveName = null;
}
this.currentArchiveNumber = (short)(archiveNumber + 1);
this.currentArchiveBytesProcessed = 0;
this.currentArchiveTotalBytes = 0;
archiveStream = this.OpenArchive(
streamContext, this.currentArchiveNumber);
FileStream archiveFileStream = archiveStream as FileStream;
this.currentArchiveName = (archiveFileStream != null ?
Path.GetFileName(archiveFileStream.Name) : null);
this.currentArchiveTotalBytes = archiveStream.Length;
this.currentArchiveNumber--;
this.OnProgress(ArchiveProgressType.StartArchive);
this.currentArchiveNumber++;
}
archiveStream.Seek(localHeaderOffset, SeekOrigin.Begin);
ZipFileHeader localHeader = new ZipFileHeader();
if (!localHeader.Read(archiveStream, false) ||
!ZipEngine.AreFilePathsEqual(localHeader.fileName, header.fileName))
{
string msg = "Could not read file: " + header.fileName;
throw new ZipException(msg);
}
fileInfo = header.ToZipFileInfo();
fileStream = streamContext.OpenFileWriteStream(
fileInfo.FullName,
fileInfo.Length,
fileInfo.LastWriteTime);
if (fileStream != null)
{
this.currentFileName = header.fileName;
this.currentFileBytesProcessed = 0;
this.currentFileTotalBytes = fileInfo.Length;
this.currentArchiveNumber--;
this.OnProgress(ArchiveProgressType.StartFile);
this.currentArchiveNumber++;
this.UnpackFileBytes(
streamContext,
fileInfo.FullName,
fileInfo.CompressedLength,
fileInfo.Length,
header.crc32,
fileStream,
compressionStreamCreator,
ref archiveStream);
}
}
finally
{
if (fileStream != null)
{
streamContext.CloseFileWriteStream(
fileInfo.FullName,
fileStream,
fileInfo.Attributes,
fileInfo.LastWriteTime);
this.currentArchiveNumber--;
this.OnProgress(ArchiveProgressType.FinishFile);
this.currentArchiveNumber++;
}
}
}