private static bool ReadHeader(Stream s, ZipEntry ze) { int signature = Shared.ReadSignature(s); if (IsNotValidSig(signature)) { s.Seek(-4L, SeekOrigin.Current); if (ZipDirEntry.IsNotValidSig(signature)) { throw new Exception(string.Format(" ZipEntry::Read(): Bad signature ({0:X8}) at position 0x{1:X8}", signature, s.Position)); } return false; } byte[] buffer = new byte[0x1a]; if (s.Read(buffer, 0, buffer.Length) != buffer.Length) { return false; } int num3 = 0; ze._VersionNeeded = (short) (buffer[num3++] + (buffer[num3++] * 0x100)); ze._BitField = (short) (buffer[num3++] + (buffer[num3++] * 0x100)); ze._CompressionMethod = (short) (buffer[num3++] + (buffer[num3++] * 0x100)); ze._LastModDateTime = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); if ((ze._BitField & 8) != 8) { ze._Crc32 = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); ze._CompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); ze._UncompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); } else { num3 += 12; } short num4 = (short) (buffer[num3++] + (buffer[num3++] * 0x100)); short num5 = (short) (buffer[num3++] + (buffer[num3++] * 0x100)); buffer = new byte[num4]; int num2 = s.Read(buffer, 0, buffer.Length); ze._FileNameInArchive = Shared.StringFromBuffer(buffer, 0, buffer.Length); ze._LocalFileName = ze._FileNameInArchive; ze._Extra = new byte[num5]; num2 = s.Read(ze._Extra, 0, ze._Extra.Length); ze._LastModified = Shared.PackedToDateTime(ze._LastModDateTime); if ((ze._BitField & 8) == 8) { long position = s.Position; long num7 = Shared.FindSignature(s, 0x8074b50); if (num7 == -1L) { return false; } buffer = new byte[12]; if (s.Read(buffer, 0, buffer.Length) != 12) { return false; } num3 = 0; ze._Crc32 = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); ze._CompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); ze._UncompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100); if (num7 != ze._CompressedSize) { throw new Exception("Data format error (bit 3 is set)"); } s.Seek(position, SeekOrigin.Begin); } return true; }
internal ZipDirEntry(ZipEntry ze) { }
internal static ZipEntry Read(Stream s) { ZipEntry ze = new ZipEntry(); if (!ReadHeader(s, ze)) { return null; } ze.__filedata = new byte[ze.CompressedSize]; if (s.Read(ze._FileData, 0, ze._FileData.Length) != ze._FileData.Length) { throw new Exception("badly formatted zip file."); } if ((ze._BitField & 8) == 8) { s.Seek(0x10L, SeekOrigin.Current); } return ze; }
internal static ZipEntry Create(string filename, string DirectoryPathInArchive) { ZipEntry entry = new ZipEntry { _LocalFileName = filename }; if (DirectoryPathInArchive == null) { entry._FileNameInArchive = filename; } else { entry._FileNameInArchive = Path.Combine(DirectoryPathInArchive, Path.GetFileName(filename)); } entry._LastModified = File.GetLastWriteTime(filename); if (entry._LastModified.IsDaylightSavingTime()) { DateTime time = entry._LastModified - new TimeSpan(1, 0, 0); entry._LastModDateTime = Shared.DateTimeToPacked(time); return entry; } entry._LastModDateTime = Shared.DateTimeToPacked(entry._LastModified); return entry; }
private static bool ReadHeader(System.IO.Stream s, ZipEntry ze) { int signature = Ionic.Utils.Zip.Shared.ReadSignature(s); // Return false if this is not a local file header signature. if (ZipEntry.IsNotValidSig(signature)) { s.Seek(-4, System.IO.SeekOrigin.Current); // unread the signature // Getting "not a ZipEntry signature" is not always wrong or an error. // This can happen when walking through a zipfile. After the last compressed entry, // we expect to read a ZipDirEntry signature. When we get this is how we // know we've reached the end of the compressed entries. if (ZipDirEntry.IsNotValidSig(signature)) { throw new Exception(String.Format(" ZipEntry::Read(): Bad signature ({0:X8}) at position 0x{1:X8}", signature, s.Position)); } return false; } byte[] block = new byte[26]; int n = s.Read(block, 0, block.Length); if (n != block.Length) return false; int i = 0; ze._VersionNeeded = (short)(block[i++] + block[i++] * 256); ze._BitField = (short)(block[i++] + block[i++] * 256); ze._CompressionMethod = (short)(block[i++] + block[i++] * 256); ze._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; // the PKZIP spec says that if bit 3 is set (0x0008), then the CRC, Compressed size, and uncompressed size // come directly after the file data. The only way to find it is to scan the zip archive for the signature of // the Data Descriptor, and presume that that signature does not appear in the (compressed) data of the compressed file. if ((ze._BitField & 0x0008) != 0x0008) { ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; } else { // the CRC, compressed size, and uncompressed size are stored later in the stream. // here, we advance the pointer. i += 12; } Int16 filenameLength = (short)(block[i++] + block[i++] * 256); Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256); block = new byte[filenameLength]; n = s.Read(block, 0, block.Length); ze._FileNameInArchive = Ionic.Utils.Zip.Shared.StringFromBuffer(block, 0, block.Length); // when creating an entry by reading, the LocalFileName is the same as the FileNameInArchivre ze._LocalFileName = ze._FileNameInArchive; ze._Extra = new byte[extraFieldLength]; n = s.Read(ze._Extra, 0, ze._Extra.Length); // transform the time data into something usable ze._LastModified = Ionic.Utils.Zip.Shared.PackedToDateTime(ze._LastModDateTime); // actually get the compressed size and CRC if necessary if ((ze._BitField & 0x0008) == 0x0008) { long posn = s.Position; long SizeOfDataRead = Ionic.Utils.Zip.Shared.FindSignature(s, ZipConstants.ZipEntryDataDescriptorSignature); if (SizeOfDataRead == -1) return false; // read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size) block = new byte[12]; n = s.Read(block, 0, block.Length); if (n != 12) return false; i = 0; ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; if (SizeOfDataRead != ze._CompressedSize) throw new Exception("Data format error (bit 3 is set)"); // seek back to previous position, to read file data s.Seek(posn, System.IO.SeekOrigin.Begin); } return true; }
internal static ZipEntry Create(String filename, string DirectoryPathInArchive) { ZipEntry entry = new ZipEntry(); entry._LocalFileName = filename; if (DirectoryPathInArchive == null) entry._FileNameInArchive = filename; else { // explicitly specify a pathname for this file entry._FileNameInArchive = System.IO.Path.Combine(DirectoryPathInArchive, System.IO.Path.GetFileName(filename)); } entry._LastModified = System.IO.File.GetLastWriteTime(filename); // adjust the time if the .NET BCL thinks it is in DST. // see the note elsewhere in this file for more info. if (entry._LastModified.IsDaylightSavingTime()) { System.DateTime AdjustedTime = entry._LastModified - new System.TimeSpan(1, 0, 0); entry._LastModDateTime = Ionic.Utils.Zip.Shared.DateTimeToPacked(AdjustedTime); } else entry._LastModDateTime = Ionic.Utils.Zip.Shared.DateTimeToPacked(entry._LastModified); // we don't actually slurp in the file until the caller invokes Write on this entry. return entry; }
/// <summary> /// Reads one ZipEntry from the given stream. /// </summary> /// <param name="s">the stream to read from.</param> /// <returns>the ZipEntry read from the stream.</returns> public static ZipEntry Read(System.IO.Stream s) { ZipEntry entry = new ZipEntry(); if (!ReadHeader(s, entry)) return null; entry.__filedata = new byte[entry.CompressedSize]; int n = s.Read(entry._FileData, 0, entry._FileData.Length); if (n != entry._FileData.Length) { throw new Exception("badly formatted zip file."); } // finally, seek past the (already read) Data descriptor if necessary if ((entry._BitField & 0x0008) == 0x0008) { s.Seek(16, System.IO.SeekOrigin.Current); } return entry; }