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;
}
