public ZipEntry(ZipEntry entry) { externalFileAttributes = -1; method = CompressionMethod.Deflated; zipFileIndex = -1L; if (entry == null) { throw new ArgumentNullException("entry"); } known = entry.known; name = entry.name; size = entry.size; compressedSize = entry.compressedSize; crc = entry.crc; dosTime = entry.dosTime; method = entry.method; comment = entry.comment; versionToExtract = entry.versionToExtract; versionMadeBy = entry.versionMadeBy; externalFileAttributes = entry.externalFileAttributes; flags = entry.flags; zipFileIndex = entry.zipFileIndex; offset = entry.offset; forceZip64_ = entry.forceZip64_; if (entry.extra != null) { extra = new byte[entry.extra.Length]; Array.Copy(entry.extra, 0, extra, 0, entry.extra.Length); } }
public void Compress(string sourceFilename, string targetFilename, FileMode fileMode, OutArchiveFormat archiveFormat, CompressionMethod compressionMethod, CompressionLevel compressionLevel, ZipEncryptionMethod zipEncryptionMethod, string password, int bufferSize, int preallocationPercent, bool check, Dictionary<string, string> customParameters) { bufferSize *= this._sectorSize; SevenZipCompressor compressor = new SevenZipCompressor(); compressor.FastCompression = true; compressor.ArchiveFormat = archiveFormat; compressor.CompressionMethod = compressionMethod; compressor.CompressionLevel = compressionLevel; compressor.DefaultItemName = Path.GetFileName(sourceFilename); compressor.DirectoryStructure = false; compressor.ZipEncryptionMethod = zipEncryptionMethod; foreach (var pair in customParameters) { compressor.CustomParameters[pair.Key] = pair.Value; } using (FileStream sourceFileStream = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize, Win32.FileFlagNoBuffering | FileOptions.SequentialScan)) { using (FileStream targetFileStream = new FileStream(targetFilename, fileMode, FileAccess.ReadWrite, FileShare.ReadWrite, 8, FileOptions.WriteThrough | Win32.FileFlagNoBuffering)) { this.Compress(compressor, sourceFileStream, targetFileStream, password, preallocationPercent, check, bufferSize); } } }
public ZipEntry(ZipEntry entry) { _externalFileAttributes = -1; _method = CompressionMethod.Deflated; ZipFileIndex = -1L; if (entry == null) { throw new ArgumentNullException(nameof(entry)); } _known = entry._known; Name = entry.Name; _size = entry._size; _compressedSize = entry._compressedSize; _crc = entry._crc; _dosTime = entry._dosTime; _method = entry._method; _comment = entry._comment; _versionToExtract = entry._versionToExtract; _versionMadeBy = entry._versionMadeBy; _externalFileAttributes = entry._externalFileAttributes; Flags = entry.Flags; ZipFileIndex = entry.ZipFileIndex; Offset = entry.Offset; _forceZip64 = entry._forceZip64; if (entry._extra != null) { _extra = new byte[entry._extra.Length]; Array.Copy(entry._extra, 0, _extra, 0, entry._extra.Length); } }
public CsvFile(Stream stream, DataFileMode fileMode, CompressionMethod compression, Encoding encoding, CultureInfo culture) : base(stream, fileMode, compression, encoding, culture) { InitializeMembers(); Open(); }
public RuntimeInfo(CompressionMethod method, int compressionLevel, int size, string password, bool getCrc) { this.method = method; this.compressionLevel = compressionLevel; this.password = password; this.size = size; this.random = false; original = new byte[Size]; if (random) { System.Random rnd = new Random(); rnd.NextBytes(original); } else { for (int i = 0; i < size; ++i) { original[i] = (byte)'A'; } } if (getCrc) { Crc32 crc32 = new Crc32(); crc32.Update(original, 0, size); crc = crc32.Value; } }
protected FormattedDataFile(Stream stream, DataFileMode fileMode, CompressionMethod compression, Encoding encoding, CultureInfo culture) : base(stream, fileMode, compression) { InitializeMembers(); this.encoding = encoding; this.culture = culture; }
public ServerHello(ProtocolVersion ver, byte[] random, byte[] sessionID, CipherSuite suite, CompressionMethod compression, Extension[] extensions) : base(HandshakeType.ServerHello) { _version = ver; _random = random; _sessionID = sessionID; _cipherSuite = suite; _compression = compression; _extensions = extensions; }
/// <summary> /// Is the given compression method/algrithm supported? /// </summary> /// <param name="method"> </param> /// <returns> </returns> public bool SupportsMethod(CompressionMethod method) { ElementList nList = SelectElements(typeof (Method)); foreach (Method m in nList) { if (m.CompressionMethod == method) return true; } return false; }
public Ihdr(UInt32 width, UInt32 height, BitDepth bitDepth, ColorType colorType, CompressionMethod compressionMethod = CompressionMethod.Default, FilterMethod filterMethod = FilterMethod.Default, InterlaceMethod interlaceMethod = InterlaceMethod.None) : base(ChunkType.IHDR) { #region Sanity if(width == 0 || width > Int32.MaxValue) throw new ArgumentOutOfRangeException("width", "width must be greater than 0 and smaller than In32.MaxValue(2^31-1)"); if(height == 0 || height > Int32.MaxValue) throw new ArgumentOutOfRangeException("height", "height must be greater than 0 and smaller than In32.MaxValue(2^31-1)"); BitDepth[] allowedBitDepths; switch (colorType) { case ColorType.Grayscale: if(!(allowedBitDepths = new[] { BitDepth._1, BitDepth._2, BitDepth._4, BitDepth._8, BitDepth._16 }).Contains(bitDepth)) throw new ArgumentOutOfRangeException("bitDepth", String.Format("bitDepth must be one of {0} for colorType {1}", allowedBitDepths.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)), colorType)); break; case ColorType.Rgb: if(!(allowedBitDepths = new[]{BitDepth._8, BitDepth._16}).Contains(bitDepth)) throw new ArgumentOutOfRangeException("bitDepth", String.Format("bitDepth must be one of {0} for colorType {1}", allowedBitDepths.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)), colorType)); break; case ColorType.Palette: if(!(allowedBitDepths = new[] { BitDepth._1, BitDepth._2, BitDepth._4, BitDepth._8}).Contains(bitDepth)) throw new ArgumentOutOfRangeException("bitDepth", String.Format("bitDepth must be one of {0} for colorType {1}", allowedBitDepths.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)), colorType)); break; case ColorType.GrayscaleWithAlpha: if(!(allowedBitDepths = new[] { BitDepth._8, BitDepth._16}).Contains(bitDepth)) throw new ArgumentOutOfRangeException("bitDepth", String.Format("bitDepth must be one of {0} for colorType {1}", allowedBitDepths.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)), colorType)); break; case ColorType.Rgba: if(!(allowedBitDepths = new[] { BitDepth._8, BitDepth._16}).Contains(bitDepth)) throw new ArgumentOutOfRangeException("bitDepth", String.Format("bitDepth must be one of {0} for colorType {1}", allowedBitDepths.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)), colorType)); break; default: throw new ArgumentOutOfRangeException("colorType", String.Format("Unknown colorType: {0}", colorType)); } if(compressionMethod != CompressionMethod.Default) throw new ArgumentOutOfRangeException("compressionMethod", String.Format("Unknown compressionMethod: {0}", compressionMethod)); if(filterMethod != FilterMethod.Default) throw new ArgumentOutOfRangeException("filterMethod", String.Format("Unknown filterMethod: {0}", filterMethod)); var allowedInterlaceMethods = new[] {InterlaceMethod.None, InterlaceMethod.Adam7}; if(!allowedInterlaceMethods.Contains(interlaceMethod)) throw new ArgumentOutOfRangeException("interlaceMethod", String.Format("interlaceMethod must be one of {0}", allowedInterlaceMethods.Aggregate("", (s, bd) => s + bd + ", ", s => s.Trim().Substring(0, s.Length - 2)))); #endregion Width = width; Height = height; BitDepth = bitDepth; ColorType = colorType; CompressionMethod = compressionMethod; FilterMethod = filterMethod; InterlaceMethod = interlaceMethod; }
public ClientHelloMessage(TlsVersion version, byte[] randomBytes, byte[] sessionId, HelloExtension[] extensions, CipherSuite[] cipherSuites, CompressionMethod[] compressionMethods) : base(HandshakeType.ClientHello, version, randomBytes, sessionId, extensions) { SecurityAssert.NotNull(cipherSuites); SecurityAssert.SAssert(cipherSuites.Length >= 2 && cipherSuites.Length <= 0xFFFE); CipherSuites = cipherSuites; SecurityAssert.NotNull(compressionMethods); SecurityAssert.SAssert(compressionMethods.Length >= 1 && cipherSuites.Length <= 0xFF); CompressionMethods = compressionMethods; }
public ZipOutputStream(Stream baseOutputStream, int bufferSize) : base(baseOutputStream, new Deflater(-1, true), bufferSize) { this.entries = new ArrayList(); this.crc = new Crc32(); this.defaultCompressionLevel = -1; this.curMethod = CompressionMethod.Deflated; this.zipComment = new byte[0]; this.crcPatchPos = -1L; this.sizePatchPos = -1L; this.useZip64_ = ICSharpCode.SharpZipLib.Zip.UseZip64.Dynamic; }
public ZipOutputStream(Stream baseOutputStream, int bufferSize) : base(baseOutputStream, new Deflater(-1, true), bufferSize) { _entries = new ArrayList(); _crc = new Crc32(); _defaultCompressionLevel = -1; _curMethod = CompressionMethod.Deflated; _zipComment = new byte[0]; _crcPatchPos = -1L; _sizePatchPos = -1L; _useZip64 = UseZip64.Dynamic; }
public ZipOutputStream(Stream baseOutputStream) : base(baseOutputStream, new Deflater(-1, true)) { entries = new ArrayList(); crc = new Crc32(); defaultCompressionLevel = -1; curMethod = CompressionMethod.Deflated; zipComment = new byte[0]; crcPatchPos = -1L; sizePatchPos = -1L; useZip64_ = UseZip64.Dynamic; }
protected byte[] MakeInMemoryZip(ref byte[] original, CompressionMethod method, int compressionLevel, int size, string password, bool withSeek) { MemoryStream ms; if (withSeek) { ms = new MemoryStream(); } else { ms = new MemoryStreamWithoutSeek(); } using (ZipOutputStream outStream = new ZipOutputStream(ms)) { outStream.Password = password; if (method != CompressionMethod.Stored) { outStream.SetLevel(compressionLevel); // 0 - store only to 9 - means best compression } ZipEntry entry = new ZipEntry("dummyfile.tst"); entry.CompressionMethod = method; outStream.PutNextEntry(entry); if (size > 0) { System.Random rnd = new Random(); original = new byte[size]; rnd.NextBytes(original); // Although this could be written in one chunk doing it in lumps // throws up buffering problems including with encryption the original // source for this change. int index = 0; while (size > 0) { int count = (size > 0x200) ? 0x200 : size; outStream.Write(original, index, count); size -= 0x200; index += count; } } } return ms.ToArray(); }
/// <summary> /// Returns the file extension by stripping of the extension of the /// compressed file, if any. /// </summary> public static void GetExtensionWithoutCompression(Uri uri, out string path, out string extension, out CompressionMethod compressionMethod) { path = GetPathFromUri(uri); extension = Path.GetExtension(path); if (Constants.CompressionExtensions.ContainsKey(extension)) { compressionMethod = Constants.CompressionExtensions[extension]; path = Path.GetFileNameWithoutExtension(path); extension = Path.GetExtension(path); } else { compressionMethod = CompressionMethod.None; } }
public FileFormatDescription GetFileFormatDescription(Uri uri, out string path, out string extension, out CompressionMethod compression) { GetExtensionWithoutCompression(uri, out path, out extension, out compression); // FInd file format with the appropriate extensions FileFormatDescription format = null; foreach (var f in GetFileFormatDescriptions()) { if (StringComparer.InvariantCultureIgnoreCase.Compare(extension, f.Value.DefaultExtension) == 0) { format = f.Value; break; } } return format; }
/// <summary> /// Initializes a new instance of the <see cref="CompressionServerChannelSinkProvider"/> class. /// </summary> /// <param name="properties">Compression sink properties.</param> /// <param name="providerData">The provider data (ignored).</param> public CompressionServerChannelSinkProvider(IDictionary properties, ICollection providerData) { // read in web.config parameters foreach (DictionaryEntry entry in properties) { switch ((string)entry.Key) { case "compressionThreshold": _compressionThreshold = Convert.ToInt32((string)entry.Value); break; case "compressionMethod": _compressionMethod = (CompressionMethod)Enum.Parse(typeof(CompressionMethod), (string)entry.Value); break; default: throw new ArgumentException("Invalid configuration entry: " + (string)entry.Key); } } }
public static byte[] CompressBytes(byte[] data, CompressionLevel CompressionLevel, CompressionMethod CompressionMethod = CompressionMethod.Default ) { Inits.EnsureBinaries(); using (var inStream = new MemoryStream(data)) { using (var outStream = new MemoryStream()) { var compressor = new SevenZipCompressor(); compressor.CompressionLevel = (SevenZip.CompressionLevel)(int)CompressionLevel; compressor.CompressionMethod = (SevenZip.CompressionMethod)(int)CompressionMethod; compressor.ScanOnlyWritable = true; compressor.CompressStream(inStream, outStream); return outStream.ToArray(); } } }
internal ZipEntry(string name, int versionRequiredToExtract, int madeByInfo = 0x33, CompressionMethod method = CompressionMethod.Deflated) { externalFileAttributes = -1; this.method = CompressionMethod.Deflated; zipFileIndex = -1L; if (name == null) { throw new ArgumentNullException("name"); } if (name.Length > 0xffff) { throw new ArgumentException("Name is too long", "name"); } if ((versionRequiredToExtract != 0) && (versionRequiredToExtract < 10)) { throw new ArgumentOutOfRangeException("versionRequiredToExtract"); } DateTime = DateTime.Now; this.name = name; versionMadeBy = (ushort)madeByInfo; versionToExtract = (ushort)versionRequiredToExtract; this.method = method; }
/// <summary> /// Test a <see cref="CompressionMethod">compression method</see> to see if this library /// supports extracting data compressed with that method /// </summary> /// <param name="method">The compression method to test.</param> /// <returns>Returns true if the compression method is supported; false otherwise</returns> public static bool IsCompressionMethodSupported(CompressionMethod method) { return (method == CompressionMethod.Deflated) || (method == CompressionMethod.Stored); }
public ZipUpdate(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod) { command_ = UpdateCommand.Add; entry_ = new ZipEntry(entryName); entry_.CompressionMethod = compressionMethod; dataSource_ = dataSource; }
public ZipUpdate(string fileName, string entryName, CompressionMethod compressionMethod) { command_ = UpdateCommand.Add; entry_ = new ZipEntry(entryName); entry_.CompressionMethod = compressionMethod; filename_ = fileName; }
/// <summary> /// Add a file entry with data. /// </summary> /// <param name="dataSource">The source of the data for this entry.</param> /// <param name="entryName">The name to give to the entry.</param> /// <param name="compressionMethod">The compression method to use.</param> /// <param name="useUnicodeText">Ensure Unicode text is used for name and comments for this entry.</param> public void Add(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod, bool useUnicodeText) { if (dataSource == null) { throw new ArgumentNullException("dataSource"); } if ( entryName == null ) { throw new ArgumentNullException("entryName"); } CheckUpdating(); ZipEntry entry = EntryFactory.MakeFileEntry(entryName, false); entry.IsUnicodeText = useUnicodeText; entry.CompressionMethod = compressionMethod; AddUpdate(new ZipUpdate(dataSource, entry)); }
/// <summary> /// Add a new entry to the archive. /// </summary> /// <param name="fileName">The name of the file to add.</param> /// <param name="compressionMethod">The compression method to use.</param> /// <exception cref="ArgumentNullException">ZipFile has been closed.</exception> /// <exception cref="ArgumentOutOfRangeException">The compression method is not supported.</exception> public void Add(string fileName, CompressionMethod compressionMethod) { if ( fileName == null ) { throw new ArgumentNullException("fileName"); } if ( !ZipEntry.IsCompressionMethodSupported(compressionMethod) ) { throw new ArgumentOutOfRangeException("compressionMethod"); } CheckUpdating(); contentsEdited_ = true; ZipEntry entry = EntryFactory.MakeFileEntry(fileName); entry.CompressionMethod = compressionMethod; AddUpdate(new ZipUpdate(fileName, entry)); }
private static bool ArrayContains(CompressionMethod[] a, CompressionMethod n) { for (int i = 0; i < a.Length; ++i) { if (a[i] == n) return true; } return false; }
/// <summary> /// Starts a new Zip entry. It automatically closes the previous /// entry if present. If the compression method is stored, the entry /// must have a valid size and crc, otherwise all elements (except /// name) are optional, but must be correct if present. If the time /// is not set in the entry, the current time is used. /// </summary> /// <param name="entry"> /// the entry. /// </param> /// <exception cref="System.IO.IOException"> /// if an I/O error occured. /// </exception> /// <exception cref="System.InvalidOperationException"> /// if stream was finished /// </exception> public void PutNextEntry(ZipEntry entry) { if (entries == null) { throw new InvalidOperationException("ZipOutputStream was finished"); } CompressionMethod method = entry.CompressionMethod; int flags = 0; switch (method) { case CompressionMethod.Stored: if (entry.CompressedSize >= 0) { if (entry.Size < 0) { entry.Size = entry.CompressedSize; } else if (entry.Size != entry.CompressedSize) { throw new ZipException("Method STORED, but compressed size != size"); } } else { entry.CompressedSize = entry.Size; } if (entry.Size < 0) { throw new ZipException("Method STORED, but size not set"); } else if (entry.Crc < 0) { throw new ZipException("Method STORED, but crc not set"); } break; case CompressionMethod.Deflated: if (entry.CompressedSize < 0 || entry.Size < 0 || entry.Crc < 0) { flags |= 8; } break; } if (curEntry != null) { CloseEntry(); } // if (entry.DosTime < 0) { // entry.Time = System.Environment.TickCount; // } entry.flags = flags; entry.offset = offset; entry.CompressionMethod = (CompressionMethod)method; curMethod = method; // Write the local file header WriteLeInt(ZipConstants.LOCSIG); // write ZIP version WriteLeShort(method == CompressionMethod.Stored ? ZIP_STORED_VERSION : ZIP_DEFLATED_VERSION); if ((flags & 8) == 0) { WriteLeShort(flags); WriteLeShort((byte)method); WriteLeInt((int)entry.DosTime); WriteLeInt((int)entry.Crc); WriteLeInt((int)entry.CompressedSize); WriteLeInt((int)entry.Size); } else { if (baseOutputStream.CanSeek) { shouldWriteBack = true; WriteLeShort((short)(flags & ~8)); } else { shouldWriteBack = false; WriteLeShort(flags); } WriteLeShort((byte)method); WriteLeInt((int)entry.DosTime); seekPos = baseOutputStream.Position; WriteLeInt(0); WriteLeInt(0); WriteLeInt(0); } byte[] name = ZipConstants.ConvertToArray(entry.Name); if (name.Length > 0xFFFF) { throw new ZipException("Name too long."); } byte[] extra = entry.ExtraData; if (extra == null) { extra = new byte[0]; } if (extra.Length > 0xFFFF) { throw new ZipException("Extra data too long."); } WriteLeShort(name.Length); WriteLeShort(extra.Length); baseOutputStream.Write(name, 0, name.Length); baseOutputStream.Write(extra, 0, extra.Length); offset += ZipConstants.LOCHDR + name.Length + extra.Length; /* Activate the entry. */ curEntry = entry; crc.Reset(); if (method == CompressionMethod.Deflated) { def.Reset(); } size = 0; }
/// <summary> /// Starts a new Zip entry. It automatically closes the previous /// entry if present. /// All entry elements bar name are optional, but must be correct if present. /// If the compression method is stored and the output is not patchable /// the compression for that entry is automatically changed to deflate level 0 /// </summary> /// <param name="entry"> /// the entry. /// </param> /// <exception cref="System.ArgumentNullException"> /// if entry passed is null. /// </exception> /// <exception cref="System.IO.IOException"> /// if an I/O error occured. /// </exception> /// <exception cref="System.InvalidOperationException"> /// if stream was finished /// </exception> /// <exception cref="ZipException"> /// Too many entries in the Zip file<br/> /// Entry name is too long<br/> /// Finish has already been called<br/> /// </exception> public void PutNextEntry(ZipEntry entry) { if ( entry == null ) { throw new ArgumentNullException("entry"); } if (entries == null) { throw new InvalidOperationException("ZipOutputStream was finished"); } if (curEntry != null) { CloseEntry(); } if (entries.Count == int.MaxValue) { throw new ZipException("Too many entries for Zip file"); } CompressionMethod method = entry.CompressionMethod; int compressionLevel = defaultCompressionLevel; // Clear flags that the library manages internally entry.Flags &= (int)GeneralBitFlags.UnicodeText; patchEntryHeader = false; bool headerInfoAvailable; // No need to compress - definitely no data. if (entry.Size == 0) { entry.CompressedSize = entry.Size; entry.Crc = 0; method = CompressionMethod.Stored; headerInfoAvailable = true; } else { headerInfoAvailable = (entry.Size >= 0) && entry.HasCrc; // Switch to deflation if storing isnt possible. if (method == CompressionMethod.Stored) { if (!headerInfoAvailable) { if (!CanPatchEntries) { // Can't patch entries so storing is not possible. method = CompressionMethod.Deflated; compressionLevel = 0; } } else // entry.size must be > 0 { entry.CompressedSize = entry.Size; headerInfoAvailable = entry.HasCrc; } } } if (headerInfoAvailable == false) { if (CanPatchEntries == false) { // Only way to record size and compressed size is to append a data descriptor // after compressed data. // Stored entries of this form have already been converted to deflating. entry.Flags |= 8; } else { patchEntryHeader = true; } } if (Password != null) { entry.IsCrypted = true; if (entry.Crc < 0) { // Need to append a data descriptor as the crc isnt available for use // with encryption, the date is used instead. Setting the flag // indicates this to the decompressor. entry.Flags |= 8; } } entry.Offset = offset; entry.CompressionMethod = (CompressionMethod)method; curMethod = method; sizePatchPos = -1; if ( (useZip64_ == UseZip64.On) || ((entry.Size < 0) && (useZip64_ == UseZip64.Dynamic)) ) { entry.ForceZip64(); } // Write the local file header WriteLeInt(ZipConstants.LocalHeaderSignature); WriteLeShort(entry.Version); WriteLeShort(entry.Flags); WriteLeShort((byte)method); WriteLeInt((int)entry.DosTime); // TODO: Refactor header writing. Its done in several places. if (headerInfoAvailable == true) { WriteLeInt((int)entry.Crc); if ( entry.LocalHeaderRequiresZip64 ) { WriteLeInt(-1); WriteLeInt(-1); } else { WriteLeInt(entry.IsCrypted ? (int)entry.CompressedSize + ZipConstants.CryptoHeaderSize : (int)entry.CompressedSize); WriteLeInt((int)entry.Size); } } else { if (patchEntryHeader == true) { crcPatchPos = baseOutputStream_.Position; } WriteLeInt(0); // Crc if ( patchEntryHeader ) { sizePatchPos = baseOutputStream_.Position; } // For local header both sizes appear in Zip64 Extended Information if ( entry.LocalHeaderRequiresZip64 || patchEntryHeader ) { WriteLeInt(-1); WriteLeInt(-1); } else { WriteLeInt(0); // Compressed size WriteLeInt(0); // Uncompressed size } } byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name); if (name.Length > 0xFFFF) { throw new ZipException("Entry name too long."); } ZipExtraData ed = new ZipExtraData(entry.ExtraData); if (entry.LocalHeaderRequiresZip64) { ed.StartNewEntry(); if (headerInfoAvailable) { ed.AddLeLong(entry.Size); ed.AddLeLong(entry.CompressedSize); } else { ed.AddLeLong(-1); ed.AddLeLong(-1); } ed.AddNewEntry(1); if ( !ed.Find(1) ) { throw new ZipException("Internal error cant find extra data"); } if ( patchEntryHeader ) { sizePatchPos = ed.CurrentReadIndex; } } else { ed.Delete(1); } byte[] extra = ed.GetEntryData(); WriteLeShort(name.Length); WriteLeShort(extra.Length); if ( name.Length > 0 ) { baseOutputStream_.Write(name, 0, name.Length); } if ( entry.LocalHeaderRequiresZip64 && patchEntryHeader ) { sizePatchPos += baseOutputStream_.Position; } if ( extra.Length > 0 ) { baseOutputStream_.Write(extra, 0, extra.Length); } offset += ZipConstants.LocalHeaderBaseSize + name.Length + extra.Length; // Activate the entry. curEntry = entry; crc.Reset(); if (method == CompressionMethod.Deflated) { deflater_.Reset(); deflater_.SetLevel(compressionLevel); } size = 0; if (entry.IsCrypted == true) { if (entry.Crc < 0) { // so testing Zip will says its ok WriteEncryptionHeader(entry.DosTime << 16); } else { WriteEncryptionHeader(entry.Crc); } } }
/// <summary> /// Add a compression method/algorithm /// </summary> /// <param name="method"> </param> public void AddMethod(CompressionMethod method) { if (!SupportsMethod(method)) AddChild(new Method(method)); }
// For AES the method in the entry is 99, and the real compression method is in the extradata // private void ProcessAESExtraData(ZipExtraData extraData) { if (extraData.Find(0x9901)) { // Set version and flag for Zipfile.CreateAndInitDecryptionStream versionToExtract = ZipConstants.VERSION_AES; // Ver 5.1 = AES see "Version" getter // Set StrongEncryption flag for ZipFile.CreateAndInitDecryptionStream Flags = Flags | (int)GeneralBitFlags.StrongEncryption; // // Unpack AES extra data field see http://www.winzip.com/aes_info.htm int length = extraData.ValueLength; // Data size currently 7 if (length < 7) throw new ZipException("AES Extra Data Length " + length + " invalid."); int ver = extraData.ReadShort(); // Version number (1=AE-1 2=AE-2) int vendorId = extraData.ReadShort(); // 2-character vendor ID 0x4541 = "AE" int encrStrength = extraData.ReadByte(); // encryption strength 1 = 128 2 = 192 3 = 256 int actualCompress = extraData.ReadShort(); // The actual compression method used to compress the file _aesVer = ver; _aesEncryptionStrength = encrStrength; method = (CompressionMethod)actualCompress; } else throw new ZipException("AES Extra Data missing"); }
/// <summary> /// Initializes an entry with the given name and made by information /// </summary> /// <param name="name">Name for this entry</param> /// <param name="madeByInfo">Version and HostSystem Information</param> /// <param name="versionRequiredToExtract">Minimum required zip feature version required to extract this entry</param> /// <param name="method">Compression method for this entry.</param> /// <exception cref="ArgumentNullException"> /// The name passed is null /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// versionRequiredToExtract should be 0 (auto-calculate) or > 10 /// </exception> /// <remarks> /// This constructor is used by the ZipFile class when reading from the central header /// It is not generally useful, use the constructor specifying the name only. /// </remarks> internal ZipEntry(string name, int versionRequiredToExtract, int madeByInfo, CompressionMethod method) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (name.Length > 0xffff) { throw new ArgumentException("Name is too long", nameof(name)); } if ((versionRequiredToExtract != 0) && (versionRequiredToExtract < 10)) { throw new ArgumentOutOfRangeException(nameof(versionRequiredToExtract)); } this.DateTime = DateTime.Now; this.name = CleanName(name); this.versionMadeBy = (ushort)madeByInfo; this.versionToExtract = (ushort)versionRequiredToExtract; this.method = method; }
/// <summary> /// Test a <see cref="CompressionMethod">compression method</see> to see if this library /// supports extracting data compressed with that method /// </summary> /// <param name="method">The compression method to test.</param> /// <returns>Returns true if the compression method is supported; false otherwise</returns> public static bool IsCompressionMethodSupported(CompressionMethod method) { return ((method == CompressionMethod.Deflated) || (method == CompressionMethod.Stored)); }