public WorkItem(int size, Alienlab.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; }
void LNSF_SaveProgress(object sender, Alienlab.Zip.SaveProgressEventArgs e) { switch (e.EventType) { case ZipProgressEventType.Saving_Started: _numEntriesSaved = 0; _txrx.Send("status saving started..."); _pb1Set = false; break; case ZipProgressEventType.Saving_BeforeWriteEntry: _numEntriesSaved++; if (_numEntriesSaved % 64 == 0) _txrx.Send(String.Format("status Compressing {0}", e.CurrentEntry.FileName)); if (!_pb1Set) { _txrx.Send(String.Format("pb 1 max {0}", e.EntriesTotal)); _pb1Set = true; } break; case ZipProgressEventType.Saving_EntryBytesRead: Assert.IsTrue(e.BytesTransferred <= e.TotalBytesToTransfer); break; case ZipProgressEventType.Saving_AfterWriteEntry: _txrx.Send("pb 1 step"); break; case ZipProgressEventType.Saving_Completed: _txrx.Send("status Save completed"); _pb1Set = false; _txrx.Send("pb 1 max 1"); _txrx.Send("pb 1 value 1"); break; } }
/// <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<Alienlab.Zip.ZipEntry> SelectEntries(Alienlab.Zip.ZipFile zip, string directoryPathInArchive) { if (zip == null) throw new ArgumentNullException("zip"); var list = new List<Alienlab.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 (Alienlab.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; }
/// <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<Alienlab.Zip.ZipEntry> SelectEntries(Alienlab.Zip.ZipFile zip) { if (zip == null) throw new ArgumentNullException("zip"); var list = new List<Alienlab.Zip.ZipEntry>(); foreach (Alienlab.Zip.ZipEntry e in zip) { if (this.Evaluate(e)) list.Add(e); } return list; }
private bool Evaluate(Alienlab.Zip.ZipEntry entry) { bool result = _Criterion.Evaluate(entry); return result; }
internal override bool Evaluate(Alienlab.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(Alienlab.Zip.ZipEntry entry) { FileAttributes fileAttrs = entry.Attributes; return _Evaluate(fileAttrs); }
internal override bool Evaluate(Alienlab.Zip.ZipEntry entry) { bool result = (ObjectType == 'D') ? entry.IsDirectory : !entry.IsDirectory; if (Operator != ComparisonOperator.EqualTo) result = !result; return result; }
internal override bool Evaluate(Alienlab.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(Alienlab.Zip.ZipEntry entry) { return _Evaluate(entry.UncompressedSize); }
internal override bool Evaluate(Alienlab.Zip.ZipEntry entry) { // swap forward slashes in the entry.FileName for backslashes string transformedFileName = entry.FileName.Replace("/", "\\"); return _Evaluate(transformedFileName); }
internal abstract bool Evaluate(Alienlab.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 Alienlab.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 Alienlab.Crc.CrcCalculatorStream(compressor, true); }
internal void FinishOutputStream(Stream s, CountingStream entryCounter, Stream encryptor, Stream compressor, Alienlab.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 Alienlab.Zlib.DeflateStream) != null) compressor.Close(); #if BZIP else if ((compressor as Alienlab.BZip2.BZip2OutputStream) != null) compressor.Close(); #if !NETCF else if ((compressor as Alienlab.BZip2.ParallelBZip2OutputStream) != null) compressor.Close(); #endif #endif #if !NETCF else if ((compressor as Alienlab.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(); }
private void _ZOS_z64Over65534Entries (Zip64Option z64option, EncryptionAlgorithm encryption, Alienlab.Zlib.CompressionLevel compression) { TestContext.WriteLine("_ZOS_z64Over65534Entries hello: {0}", DateTime.Now.ToString("G")); int fileCount = _rnd.Next(14616) + 65536; //int fileCount = _rnd.Next(146) + 5536; TestContext.WriteLine("entries: {0}", fileCount); var txrxLabel = String.Format("ZOS #{0} 64({3}) E({1}) C({2})", fileCount, encryption.ToString(), compression.ToString(), z64option.ToString()); TestContext.WriteLine("label: {0}", txrxLabel); string zipFileToCreate = String.Format("ZOS.Zip64.over65534.{0}.{1}.{2}.zip", z64option.ToString(), encryption.ToString(), compression.ToString()); TestContext.WriteLine("zipFileToCreate: {0}", zipFileToCreate); _txrx = TestUtilities.StartProgressMonitor(zipFileToCreate, txrxLabel, "starting up..."); TestContext.WriteLine("generating {0} entries ", fileCount); _txrx.Send("pb 0 max 3"); // 2 stages: Write, Count, Verify _txrx.Send("pb 0 value 0"); string password = Path.GetRandomFileName(); string statusString = String.Format("status Encryption:{0} Compression:{1}", encryption.ToString(), compression.ToString()); _txrx.Send(statusString); int dirCount = 0; using (FileStream fs = File.Create(zipFileToCreate)) { using (var output = new ZipOutputStream(fs)) { _txrx.Send("test " + txrxLabel); System.Threading.Thread.Sleep(400); _txrx.Send("pb 1 max " + fileCount); _txrx.Send("pb 1 value 0"); output.Password = password; output.Encryption = encryption; output.CompressionLevel = compression; output.EnableZip64 = z64option; for (int k = 0; k < fileCount; k++) { if (_rnd.Next(7) == 0) { // make it a directory string entryName = String.Format("{0:D4}/", k); output.PutNextEntry(entryName); dirCount++; } else { string entryName = String.Format("{0:D4}.txt", k); output.PutNextEntry(entryName); // only a few entries are non-empty if (_rnd.Next(18) == 0) { var block = TestUtilities.GenerateRandomAsciiString(); string content = String.Format("This is the content for entry #{0}.\n", k); int n = _rnd.Next(4) + 1; for (int j=0; j < n; j++) content+= block; byte[] buffer = Encoding.ASCII.GetBytes(content); output.Write(buffer, 0, buffer.Length); } } if (k % 1024 == 0) _txrx.Send(String.Format("status saving ({0}/{1}) {2:N0}%", k, fileCount, ((double)k) / (0.01 * fileCount))); else if (k % 256 == 0) _txrx.Send("pb 1 value " + k); } } } _txrx.Send("pb 1 max 1"); _txrx.Send("pb 1 value 1"); _txrx.Send("pb 0 step"); System.Threading.Thread.Sleep(400); TestContext.WriteLine("Counting entries ... " + DateTime.Now.ToString("G")); _txrx.Send("status Counting entries..."); Assert.AreEqual<int> (fileCount - dirCount, TestUtilities.CountEntries(zipFileToCreate), "{0}: The zip file created has the wrong number of entries.", zipFileToCreate); _txrx.Send("pb 0 step"); System.Threading.Thread.Sleep(140); // basic verify. The output is really large, so we pass emitOutput=false . _txrx.Send("status Verifying..."); TestContext.WriteLine("Verifying ... " + DateTime.Now.ToString("G")); _numExtracted = 0; _numFilesToExtract = fileCount; _txrx.Send("pb 1 max " + fileCount); System.Threading.Thread.Sleep(200); _txrx.Send("pb 1 value 0"); BasicVerifyZip(zipFileToCreate, password, false, Streams_ExtractProgress); _txrx.Send("pb 0 step"); System.Threading.Thread.Sleep(800); TestContext.WriteLine("Done ... " + DateTime.Now.ToString("G")); }