public WorkItem(int size,
IonicCustomMod.Zlib.CompressionLevel compressLevel,
CompressionStrategy strategy,
int ix)
{
this.buffer= new byte[size];
// alloc 5 bytes overhead for every block (margin of safety= 2)
int n = size + ((size / 32768)+1) * 5 * 2;
this.compressed = new byte[n];
this.compressor = new ZlibCodec();
this.compressor.InitializeDeflate(compressLevel, false);
this.compressor.OutputBuffer = this.compressed;
this.compressor.InputBuffer = this.buffer;
this.index = ix;
}
/// <summary>
/// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
/// </summary>
/// <remarks>
///
/// <para>
/// This method applies the criteria set in the FileSelector instance (as described in
/// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile. Using this
/// method, for example, you can retrieve all entries from the given ZipFile that
/// have filenames ending in .txt.
/// </para>
///
/// <para>
/// Normally, applications would not call this method directly. This method is used
/// by the ZipFile class.
/// </para>
///
/// <para>
/// This overload allows the selection of ZipEntry instances from the ZipFile to be restricted
/// to entries contained within a particular directory in the ZipFile.
/// </para>
///
/// <para>
/// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
/// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
/// description of the syntax of the SelectionCriteria string.
/// </para>
///
/// </remarks>
///
/// <param name="zip">The ZipFile from which to retrieve entries.</param>
///
/// <param name="directoryPathInArchive">
/// the directory in the archive from which to select entries. If null, then
/// all directories in the archive are used.
/// </param>
///
/// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
public ICollection<IonicCustomMod.Zip.ZipEntry> SelectEntries(IonicCustomMod.Zip.ZipFile zip, string directoryPathInArchive)
{
if (zip == null)
throw new ArgumentNullException("zip");
var list = new List<IonicCustomMod.Zip.ZipEntry>();
// workitem 8559
string slashSwapped = (directoryPathInArchive == null) ? null : directoryPathInArchive.Replace("/", "\\");
// workitem 9174
if (slashSwapped != null)
{
while (slashSwapped.EndsWith("\\"))
slashSwapped = slashSwapped.Substring(0, slashSwapped.Length - 1);
}
foreach (IonicCustomMod.Zip.ZipEntry e in zip)
{
if (directoryPathInArchive == null || (Path.GetDirectoryName(e.FileName) == directoryPathInArchive)
|| (Path.GetDirectoryName(e.FileName) == slashSwapped)) // workitem 8559
if (this.Evaluate(e))
list.Add(e);
}
return list;
}
private bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
bool result = _Criterion.Evaluate(entry);
return result;
}
/// <summary>
/// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
/// </summary>
/// <remarks>
///
/// <para>
/// This method applies the criteria set in the FileSelector instance (as described in
/// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile. Using this
/// method, for example, you can retrieve all entries from the given ZipFile that
/// have filenames ending in .txt.
/// </para>
///
/// <para>
/// Normally, applications would not call this method directly. This method is used
/// by the ZipFile class.
/// </para>
///
/// <para>
/// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
/// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
/// description of the syntax of the SelectionCriteria string.
/// </para>
///
/// </remarks>
///
/// <param name="zip">The ZipFile from which to retrieve entries.</param>
///
/// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
public ICollection<IonicCustomMod.Zip.ZipEntry> SelectEntries(IonicCustomMod.Zip.ZipFile zip)
{
if (zip == null)
throw new ArgumentNullException("zip");
var list = new List<IonicCustomMod.Zip.ZipEntry>();
foreach (IonicCustomMod.Zip.ZipEntry e in zip)
{
if (this.Evaluate(e))
list.Add(e);
}
return list;
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
FileAttributes fileAttrs = entry.Attributes;
return _Evaluate(fileAttrs);
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
bool result = Left.Evaluate(entry);
switch (Conjunction)
{
case LogicalConjunction.AND:
if (result)
result = Right.Evaluate(entry);
break;
case LogicalConjunction.OR:
if (!result)
result = Right.Evaluate(entry);
break;
case LogicalConjunction.XOR:
result ^= Right.Evaluate(entry);
break;
}
return result;
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
DateTime x;
switch (Which)
{
case WhichTime.atime:
x = entry.AccessedTime;
break;
case WhichTime.mtime:
x = entry.ModifiedTime;
break;
case WhichTime.ctime:
x = entry.CreationTime;
break;
default: throw new ArgumentException("??time");
}
return _Evaluate(x);
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
bool result = (ObjectType == 'D')
? entry.IsDirectory
: !entry.IsDirectory;
if (Operator != ComparisonOperator.EqualTo)
result = !result;
return result;
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
return _Evaluate(entry.UncompressedSize);
}
internal override bool Evaluate(IonicCustomMod.Zip.ZipEntry entry)
{
// swap forward slashes in the entry.FileName for backslashes
string transformedFileName = entry.FileName.Replace("/", "\\");
return _Evaluate(transformedFileName);
}
internal abstract bool Evaluate(IonicCustomMod.Zip.ZipEntry entry);
/// <summary>
/// Prepare the given stream for output - wrap it in a CountingStream, and
/// then in a CRC stream, and an encryptor and deflator as appropriate.
/// </summary>
/// <remarks>
/// <para>
/// Previously this was used in ZipEntry.Write(), but in an effort to
/// introduce some efficiencies in that method I've refactored to put the
/// code inline. This method still gets called by ZipOutputStream.
/// </para>
/// </remarks>
internal void PrepOutputStream(Stream s,
long streamLength,
out CountingStream outputCounter,
out Stream encryptor,
out Stream compressor,
out IonicCustomMod.Crc.CrcCalculatorStream output)
{
TraceWriteLine("PrepOutputStream: e({0}) comp({1}) crypto({2}) zf({3})",
FileName,
CompressionLevel,
Encryption,
_container.Name);
// Wrap a counting stream around the raw output stream:
// This is the last thing that happens before the bits go to the
// application-provided stream.
outputCounter = new CountingStream(s);
// Sometimes the incoming "raw" output stream is already a CountingStream.
// Doesn't matter. Wrap it with a counter anyway. We need to count at both
// levels.
if (streamLength != 0L)
{
// Maybe wrap an encrypting stream around that:
// This will happen BEFORE output counting, and AFTER deflation, if encryption
// is used.
encryptor = MaybeApplyEncryption(outputCounter);
// Maybe wrap a compressing Stream around that.
// This will happen BEFORE encryption (if any) as we write data out.
compressor = MaybeApplyCompression(encryptor, streamLength);
}
else
{
encryptor = compressor = outputCounter;
}
// Wrap a CrcCalculatorStream around that.
// This will happen BEFORE compression (if any) as we write data out.
output = new IonicCustomMod.Crc.CrcCalculatorStream(compressor, true);
}
internal void FinishOutputStream(Stream s,
CountingStream entryCounter,
Stream encryptor,
Stream compressor,
IonicCustomMod.Crc.CrcCalculatorStream output)
{
if (output == null) return;
output.Close();
// by calling Close() on the deflate stream, we write the footer bytes, as necessary.
if ((compressor as IonicCustomMod.Zlib.DeflateStream) != null)
compressor.Close();
#if BZIP
else if ((compressor as IonicCustomMod.BZip2.BZip2OutputStream) != null)
compressor.Close();
#if !NETCF
else if ((compressor as IonicCustomMod.BZip2.ParallelBZip2OutputStream) != null)
compressor.Close();
#endif
#endif
#if !NETCF
else if ((compressor as IonicCustomMod.Zlib.ParallelDeflateOutputStream) != null)
compressor.Close();
#endif
encryptor.Flush();
encryptor.Close();
_LengthOfTrailer = 0;
_UncompressedSize = output.TotalBytesSlurped;
#if AESCRYPTO
WinZipAesCipherStream wzacs = encryptor as WinZipAesCipherStream;
if (wzacs != null && _UncompressedSize > 0)
{
s.Write(wzacs.FinalAuthentication, 0, 10);
_LengthOfTrailer += 10;
}
#endif
_CompressedFileDataSize = entryCounter.BytesWritten;
_CompressedSize = _CompressedFileDataSize; // may be adjusted
_Crc32 = output.Crc;
// Set _RelativeOffsetOfLocalHeader now, to allow for re-streaming
StoreRelativeOffset();
}
