public void SetData(byte[] data, int index, int count)
{
using (var stream = new MemoryStream(data, index, count, false))
{
using (var stream2 = new ZipHelperStream(stream))
{
stream2.ReadLeInt();
while (stream2.Position < stream2.Length)
{
var num = stream2.ReadLeShort();
var num2 = stream2.ReadLeShort();
if (num == 1)
{
if (num2 >= 0x18)
{
var fileTime = stream2.ReadLeLong();
_lastModificationTime = DateTime.FromFileTime(fileTime);
var num4 = stream2.ReadLeLong();
_lastAccessTime = DateTime.FromFileTime(num4);
var num5 = stream2.ReadLeLong();
_createTime = DateTime.FromFileTime(num5);
}
return;
}
stream2.Seek(num2, SeekOrigin.Current);
}
}
}
}
public byte[] GetData()
{
byte[] buffer;
using (MemoryStream stream = new MemoryStream())
{
using (ZipHelperStream stream2 = new ZipHelperStream(stream))
{
stream2.IsStreamOwner = false;
stream2.WriteByte((byte)_flags);
if (((byte)(_flags & Flags.ModificationTime)) != 0)
{
DateTime time = new DateTime(0x7b2, 1, 1, 0, 0, 0);
TimeSpan span = _modificationTime.ToUniversalTime() - time.ToUniversalTime();
int totalSeconds = (int)span.TotalSeconds;
stream2.WriteLeInt(totalSeconds);
}
if (((byte)(_flags & Flags.AccessTime)) != 0)
{
DateTime time2 = new DateTime(0x7b2, 1, 1, 0, 0, 0);
TimeSpan span2 = _lastAccessTime.ToUniversalTime() - time2.ToUniversalTime();
int num2 = (int)span2.TotalSeconds;
stream2.WriteLeInt(num2);
}
if (((byte)(_flags & Flags.CreateTime)) != 0)
{
DateTime time3 = new DateTime(0x7b2, 1, 1, 0, 0, 0);
TimeSpan span3 = _createTime.ToUniversalTime() - time3.ToUniversalTime();
int num3 = (int)span3.TotalSeconds;
stream2.WriteLeInt(num3);
}
buffer = stream.ToArray();
}
}
return buffer;
}
public void SetData(byte[] data, int index, int count)
{
using (MemoryStream stream = new MemoryStream(data, index, count, false))
{
using (ZipHelperStream stream2 = new ZipHelperStream(stream))
{
_flags = (Flags)((byte)stream2.ReadByte());
if ((((byte)(_flags & Flags.ModificationTime)) != 0) && (count >= 5))
{
int seconds = stream2.ReadLeInt();
DateTime time = new DateTime(0x7b2, 1, 1, 0, 0, 0);
_modificationTime = (time.ToUniversalTime() + new TimeSpan(0, 0, 0, seconds, 0)).ToLocalTime();
}
if (((byte)(_flags & Flags.AccessTime)) != 0)
{
int num2 = stream2.ReadLeInt();
DateTime time3 = new DateTime(0x7b2, 1, 1, 0, 0, 0);
_lastAccessTime = (time3.ToUniversalTime() + new TimeSpan(0, 0, 0, num2, 0)).ToLocalTime();
}
if (((byte)(_flags & Flags.CreateTime)) != 0)
{
int num3 = stream2.ReadLeInt();
DateTime time5 = new DateTime(0x7b2, 1, 1, 0, 0, 0);
_createTime = (time5.ToUniversalTime() + new TimeSpan(0, 0, 0, num3, 0)).ToLocalTime();
}
}
}
}
public byte[] GetData()
{
byte[] buffer;
using (var stream = new MemoryStream())
{
using (var stream2 = new ZipHelperStream(stream))
{
stream2.IsStreamOwner = false;
stream2.WriteLeInt(0);
stream2.WriteLeShort(1);
stream2.WriteLeShort(0x18);
stream2.WriteLeLong(_lastModificationTime.ToFileTime());
stream2.WriteLeLong(_lastAccessTime.ToFileTime());
stream2.WriteLeLong(_createTime.ToFileTime());
buffer = stream.ToArray();
}
}
return(buffer);
}
public byte[] GetData()
{
byte[] buffer;
using (var stream = new MemoryStream())
{
using (var stream2 = new ZipHelperStream(stream))
{
stream2.IsStreamOwner = false;
stream2.WriteLeInt(0);
stream2.WriteLeShort(1);
stream2.WriteLeShort(0x18);
stream2.WriteLeLong(_lastModificationTime.ToFileTime());
stream2.WriteLeLong(_lastAccessTime.ToFileTime());
stream2.WriteLeLong(_createTime.ToFileTime());
buffer = stream.ToArray();
}
}
return buffer;
}
/// <summary>
/// Get the binary data representing this instance.
/// </summary>
/// <returns>The raw binary data representing this instance.</returns>
public byte[] GetData()
{
using (MemoryStream ms = new MemoryStream())
using (ZipHelperStream helperStream = new ZipHelperStream(ms))
{
helperStream.IsStreamOwner = false;
helperStream.WriteLEInt(0); // Reserved
helperStream.WriteLEShort(1); // Tag
helperStream.WriteLEShort(24); // Length = 3 x 8.
helperStream.WriteLELong(lastModificationTime_.ToFileTime());
helperStream.WriteLELong(lastAccessTime_.ToFileTime());
helperStream.WriteLELong(createTime_.ToFileTime());
return ms.ToArray();
}
}
private void UpdateCommentOnly()
{
var length = _baseStream.Length;
ZipHelperStream stream;
if (_archiveStorage.UpdateMode == FileUpdateMode.Safe)
{
stream = new ZipHelperStream(_archiveStorage.MakeTemporaryCopy(_baseStream))
{
IsStreamOwner = true
};
_baseStream.Close();
_baseStream = null;
}
else if (_archiveStorage.UpdateMode == FileUpdateMode.Direct)
{
_baseStream = _archiveStorage.OpenForDirectUpdate(_baseStream);
stream = new ZipHelperStream(_baseStream);
}
else
{
_baseStream.Close();
_baseStream = null;
stream = new ZipHelperStream(Name);
}
using (stream)
{
if (stream.LocateBlockWithSignature(ZipConstants.EndOfCentralDirectorySignature, length, 0x16, 0xffff) <
0L)
{
throw new ZipException("Cannot find central directory");
}
stream.Position += 0x10L;
var rawComment = _newComment.RawComment;
stream.WriteLeShort(rawComment.Length);
stream.Write(rawComment, 0, rawComment.Length);
stream.SetLength(stream.Position);
}
if (_archiveStorage.UpdateMode == FileUpdateMode.Safe)
{
Reopen(_archiveStorage.ConvertTemporaryToFinal());
}
else
{
ReadEntries();
}
}
public void CommitUpdate()
{
if (_isDisposed)
{
throw new ObjectDisposedException("ZipFile");
}
CheckUpdating();
try
{
_updateIndex.Clear();
_updateIndex = null;
if (_contentsEdited)
{
RunUpdates();
}
else if (_commentEdited)
{
UpdateCommentOnly();
}
else if (_entries.Length == 0)
{
var comment = (_newComment != null) ? _newComment.RawComment : ZipConstants.ConvertToArray(_comment);
using (var stream = new ZipHelperStream(_baseStream))
{
stream.WriteEndOfCentralDirectory(0L, 0L, 0L, comment);
}
}
}
finally
{
PostUpdateCleanup();
}
}
public override void Finish()
{
if (this.entries == null)
{
return;
}
if (this.curEntry != null)
{
this.CloseEntry();
}
long noOfEntries = (long)this.entries.Count;
long num = 0L;
foreach (object obj in this.entries)
{
ZipEntry zipEntry = (ZipEntry)obj;
this.WriteLeInt(33639248);
this.WriteLeShort(45);
this.WriteLeShort(zipEntry.Version);
this.WriteLeShort(zipEntry.Flags);
this.WriteLeShort((int)((short)zipEntry.CompressionMethod));
this.WriteLeInt((int)zipEntry.DosTime);
this.WriteLeInt((int)zipEntry.Crc);
if (zipEntry.IsZip64Forced() || zipEntry.CompressedSize >= unchecked ((long)((ulong)-1)))
{
this.WriteLeInt(-1);
}
else
{
this.WriteLeInt((int)zipEntry.CompressedSize);
}
if (zipEntry.IsZip64Forced() || zipEntry.Size >= unchecked ((long)((ulong)-1)))
{
this.WriteLeInt(-1);
}
else
{
this.WriteLeInt((int)zipEntry.Size);
}
byte[] array = ZipConstants.ConvertToArray(zipEntry.Flags, zipEntry.Name);
if (array.Length > 65535)
{
throw new ZipException("Name too long.");
}
ZipExtraData zipExtraData = new ZipExtraData(zipEntry.ExtraData);
if (zipEntry.CentralHeaderRequiresZip64)
{
zipExtraData.StartNewEntry();
if (zipEntry.IsZip64Forced() || zipEntry.Size >= unchecked ((long)((ulong)-1)))
{
zipExtraData.AddLeLong(zipEntry.Size);
}
if (zipEntry.IsZip64Forced() || zipEntry.CompressedSize >= unchecked ((long)((ulong)-1)))
{
zipExtraData.AddLeLong(zipEntry.CompressedSize);
}
if (zipEntry.Offset >= unchecked ((long)((ulong)-1)))
{
zipExtraData.AddLeLong(zipEntry.Offset);
}
zipExtraData.AddNewEntry(1);
}
else
{
zipExtraData.Delete(1);
}
byte[] entryData = zipExtraData.GetEntryData();
byte[] array2 = (zipEntry.Comment != null) ? ZipConstants.ConvertToArray(zipEntry.Flags, zipEntry.Comment) : new byte[0];
if (array2.Length > 65535)
{
throw new ZipException("Comment too long.");
}
this.WriteLeShort(array.Length);
this.WriteLeShort(entryData.Length);
this.WriteLeShort(array2.Length);
this.WriteLeShort(0);
this.WriteLeShort(0);
if (zipEntry.ExternalFileAttributes != -1)
{
this.WriteLeInt(zipEntry.ExternalFileAttributes);
}
else if (zipEntry.IsDirectory)
{
this.WriteLeInt(16);
}
else
{
this.WriteLeInt(0);
}
if (zipEntry.Offset >= unchecked ((long)((ulong)-1)))
{
this.WriteLeInt(-1);
}
else
{
this.WriteLeInt((int)zipEntry.Offset);
}
if (array.Length > 0)
{
this.baseOutputStream.Write(array, 0, array.Length);
}
if (entryData.Length > 0)
{
this.baseOutputStream.Write(entryData, 0, entryData.Length);
}
if (array2.Length > 0)
{
this.baseOutputStream.Write(array2, 0, array2.Length);
}
num += (long)(46 + array.Length + entryData.Length + array2.Length);
}
using (ZipHelperStream zipHelperStream = new ZipHelperStream(this.baseOutputStream))
{
zipHelperStream.WriteEndOfCentralDirectory(noOfEntries, num, this.offset, this.zipComment);
}
this.entries = null;
}
public bool TestArchive(bool testData,
TestStrategy strategy = TestStrategy.FindFirstError,
ZipTestResultHandler resultHandler = null)
{
if (_isDisposed)
{
throw new ObjectDisposedException("ZipFile");
}
var status = new TestStatus(this);
resultHandler?.Invoke(status, null);
var tests = testData ? (HeaderTest.Header | HeaderTest.Extract) : HeaderTest.Header;
var flag = true;
try
{
for (var i = 0; flag && (i < Count); i++)
{
if (resultHandler != null)
{
status.SetEntry(this[i]);
status.SetOperation(TestOperation.EntryHeader);
resultHandler(status, null);
}
try
{
TestLocalHeader(this[i], tests);
}
catch (ZipException exception)
{
status.AddError();
resultHandler?.Invoke(status, $"Exception during test - '{exception.Message}'");
if (strategy == TestStrategy.FindFirstError)
{
flag = false;
}
}
if ((flag && testData) && this[i].IsFile)
{
if (resultHandler != null)
{
status.SetOperation(TestOperation.EntryData);
resultHandler(status, null);
}
var crc = new Crc32();
using (var stream = GetInputStream(this[i]))
{
int num3;
var buffer = new byte[DefaultBufferSize];
var num2 = 0L;
while ((num3 = stream.Read(buffer, 0, buffer.Length)) > 0)
{
crc.Update(buffer, 0, num3);
if (resultHandler != null)
{
num2 += num3;
status.SetBytesTested(num2);
resultHandler(status, null);
}
}
}
if (this[i].Crc != crc.Value)
{
status.AddError();
resultHandler?.Invoke(status, "CRC mismatch");
if (strategy == TestStrategy.FindFirstError)
{
flag = false;
}
}
if ((this[i].Flags & 8) != 0)
{
var stream2 = new ZipHelperStream(_baseStream);
var data = new DescriptorData();
stream2.ReadDataDescriptor(this[i].LocalHeaderRequiresZip64, data);
if (this[i].Crc != data.Crc)
{
status.AddError();
}
if (this[i].CompressedSize != data.CompressedSize)
{
status.AddError();
}
if (this[i].Size != data.Size)
{
status.AddError();
}
}
}
if (resultHandler != null)
{
status.SetOperation(TestOperation.EntryComplete);
resultHandler(status, null);
}
}
if (resultHandler != null)
{
status.SetOperation(TestOperation.MiscellaneousTests);
resultHandler(status, null);
}
}
catch (Exception exception2)
{
status.AddError();
resultHandler?.Invoke(status, $"Exception during test - '{exception2.Message}'");
}
if (resultHandler != null)
{
status.SetOperation(TestOperation.Complete);
status.SetEntry(null);
resultHandler(status, null);
}
return (status.ErrorCount == 0);
}
/// <summary>
/// Commit current updates, updating this archive.
/// </summary>
/// <seealso cref="BeginUpdate()"></seealso>
/// <seealso cref="AbortUpdate"></seealso>
public void CommitUpdate()
{
CheckUpdating();
if ( contentsEdited_ ) {
RunUpdates();
}
else if ( commentEdited_ ) {
UpdateCommentOnly();
}
else {
// Create an empty archive if none existed originally.
if ( (entries_ != null) && (entries_.Length == 0) ) {
byte[] theComment = (newComment_ != null) ? newComment_.RawComment : ZipConstants.ConvertToArray(comment_);
using ( ZipHelperStream zhs = new ZipHelperStream(baseStream_) ) {
zhs.WriteEndOfCentralDirectory(0, 0, 0, theComment);
}
}
}
PostUpdateCleanup();
}
void RunUpdates()
{
long sizeEntries = 0;
long endOfStream = 0;
bool allOk = true;
bool directUpdate = false;
long destinationPosition = 0; // NOT SFX friendly
ZipFile workFile;
if ( IsNewArchive ) {
workFile = this;
workFile.baseStream_.Position = 0;
directUpdate = true;
}
else if ( archiveStorage_.UpdateMode == FileUpdateMode.Direct ) {
workFile = this;
workFile.baseStream_.Position = 0;
directUpdate = true;
// Sort the updates by offset within copies/modifies, then adds.
// This ensures that copies will not overwrite any required data.
updates_.Sort(new UpdateComparer());
}
else
{
workFile = ZipFile.Create(archiveStorage_.GetTemporaryOutput());
if (key != null) {
workFile.key = (byte[])key.Clone();
}
}
try {
foreach ( ZipUpdate update in updates_ ) {
switch ( update.Command ) {
case UpdateCommand.Copy:
if ( directUpdate ) {
CopyEntryDirect(workFile, update, ref destinationPosition);
}
else {
CopyEntry(workFile, update);
}
break;
case UpdateCommand.Modify:
// TODO: Direct modifying of an entry.
ModifyEntry(workFile, update);
break;
case UpdateCommand.Add:
if ( !IsNewArchive && directUpdate ) {
workFile.baseStream_.Position = destinationPosition;
}
AddEntry(workFile, update);
if ( directUpdate ) {
destinationPosition = workFile.baseStream_.Position;
}
break;
}
}
if ( !IsNewArchive && directUpdate ) {
workFile.baseStream_.Position = destinationPosition;
}
long centralDirOffset = workFile.baseStream_.Position;
foreach ( ZipUpdate update in updates_ ) {
sizeEntries += workFile.WriteCentralDirectoryHeader(update.OutEntry);
}
byte[] theComment = (newComment_ != null) ? newComment_.RawComment : ZipConstants.ConvertToArray(comment_);
using ( ZipHelperStream zhs = new ZipHelperStream(workFile.baseStream_) ) {
zhs.WriteEndOfCentralDirectory(updates_.Count, sizeEntries, centralDirOffset, theComment);
}
endOfStream = workFile.baseStream_.Position;
// And now patch entries...
foreach ( ZipUpdate update in updates_ ) {
// If the size of the entry is zero leave the crc as 0 as well.
// The calculated crc will be all bits on...
if ( (update.CrcPatchOffset > 0) && (update.OutEntry.CompressedSize > 0) ) {
workFile.baseStream_.Position = update.CrcPatchOffset;
workFile.WriteLEInt(( int )update.OutEntry.Crc);
}
if ( update.SizePatchOffset > 0 ) {
workFile.baseStream_.Position = update.SizePatchOffset;
if ( update.Entry.LocalHeaderRequiresZip64 ) {
workFile.WriteLeLong(update.OutEntry.Size);
workFile.WriteLeLong(update.OutEntry.CompressedSize);
}
else {
workFile.WriteLEInt(( int )update.OutEntry.CompressedSize);
workFile.WriteLEInt(( int )update.OutEntry.Size);
}
}
}
}
catch(Exception) {
allOk = false;
}
finally {
if ( directUpdate ) {
if ( allOk ) {
workFile.baseStream_.Flush();
workFile.baseStream_.SetLength(endOfStream);
}
}
else {
workFile.Close();
}
}
if ( allOk ) {
if ( directUpdate ) {
isNewArchive_ = false;
workFile.baseStream_.Flush();
ReadEntries();
}
else {
baseStream_.Close();
Reopen(archiveStorage_.ConvertTemporaryToFinal());
}
}
else {
workFile.Close();
if ( !directUpdate && (workFile.Name != null) ) {
File.Delete(workFile.Name);
}
}
}
void AddEntry(ZipFile workFile, ZipUpdate update)
{
Stream source = null;
if ( update.Entry.IsFile ) {
source = update.GetSource();
if ( source == null ) {
source = updateDataSource_.GetSource(update.Entry, update.Filename);
}
}
if ( source != null ) {
using ( source ) {
long sourceStreamLength = source.Length;
if ( update.OutEntry.Size < 0 ) {
update.OutEntry.Size = sourceStreamLength;
}
else {
// Check for errant entries.
if ( update.OutEntry.Size != sourceStreamLength ) {
throw new ZipException("Entry size/stream size mismatch");
}
}
workFile.WriteLocalEntryHeader(update);
long dataStart = workFile.baseStream_.Position;
using ( Stream output = workFile.GetOutputStream(update.OutEntry) ) {
CopyBytes(update, output, source, sourceStreamLength, true);
}
long dataEnd = workFile.baseStream_.Position;
update.OutEntry.CompressedSize = dataEnd - dataStart;
if ((update.OutEntry.Flags & (int)GeneralBitFlags.Descriptor) == (int)GeneralBitFlags.Descriptor)
{
ZipHelperStream helper = new ZipHelperStream(workFile.baseStream_);
helper.WriteDataDescriptor(update.OutEntry);
}
}
}
else {
workFile.WriteLocalEntryHeader(update);
update.OutEntry.CompressedSize = 0;
}
}
/// <summary>
/// Set the data from the raw values provided.
/// </summary>
/// <param name="data">The raw data to extract values from.</param>
/// <param name="index">The index to start extracting values from.</param>
/// <param name="count">The number of bytes available.</param>
public void SetData(byte[] data, int index, int count)
{
using (MemoryStream ms = new MemoryStream(data, index, count, false))
using (ZipHelperStream helperStream = new ZipHelperStream(ms))
{
helperStream.ReadLEInt(); // Reserved
while (helperStream.Position < helperStream.Length)
{
int ntfsTag = helperStream.ReadLEShort();
int ntfsLength = helperStream.ReadLEShort();
if (ntfsTag == 1)
{
if (ntfsLength >= 24)
{
long lastModificationTicks = helperStream.ReadLELong();
lastModificationTime_ = DateTime.FromFileTime(lastModificationTicks);
long lastAccessTicks = helperStream.ReadLELong();
lastAccessTime_ = DateTime.FromFileTime(lastAccessTicks);
long createTimeTicks = helperStream.ReadLELong();
createTime_ = DateTime.FromFileTime(createTimeTicks);
}
break;
}
else
{
// An unknown NTFS tag so simply skip it.
helperStream.Seek(ntfsLength, SeekOrigin.Current);
}
}
}
}
/// <summary>
/// Get the binary data representing this instance.
/// </summary>
/// <returns>The raw binary data representing this instance.</returns>
public byte[] GetData()
{
using (MemoryStream ms = new MemoryStream())
using (ZipHelperStream helperStream = new ZipHelperStream(ms))
{
helperStream.IsStreamOwner = false;
helperStream.WriteByte((byte)flags_); // Flags
if ( (flags_ & Flags.ModificationTime) != 0) {
TimeSpan span = modificationTime_.ToUniversalTime() - new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
int seconds = (int)span.TotalSeconds;
helperStream.WriteLEInt(seconds);
}
if ( (flags_ & Flags.AccessTime) != 0) {
TimeSpan span = lastAccessTime_.ToUniversalTime() - new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
int seconds = (int)span.TotalSeconds;
helperStream.WriteLEInt(seconds);
}
if ( (flags_ & Flags.CreateTime) != 0) {
TimeSpan span = createTime_.ToUniversalTime() - new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
int seconds = (int)span.TotalSeconds;
helperStream.WriteLEInt(seconds);
}
return ms.ToArray();
}
}
/// <summary>
/// Set the data from the raw values provided.
/// </summary>
/// <param name="data">The raw data to extract values from.</param>
/// <param name="index">The index to start extracting values from.</param>
/// <param name="count">The number of bytes available.</param>
public void SetData(byte[] data, int index, int count)
{
using (MemoryStream ms = new MemoryStream(data, index, count, false))
using (ZipHelperStream helperStream = new ZipHelperStream(ms))
{
// bit 0 if set, modification time is present
// bit 1 if set, access time is present
// bit 2 if set, creation time is present
flags_ = (Flags)helperStream.ReadByte();
if (((flags_ & Flags.ModificationTime) != 0) && (count >= 5))
{
int iTime = helperStream.ReadLEInt();
modificationTime_ = (new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
}
if ((flags_ & Flags.AccessTime) != 0)
{
int iTime = helperStream.ReadLEInt();
lastAccessTime_ = (new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
}
if ((flags_ & Flags.CreateTime) != 0)
{
int iTime = helperStream.ReadLEInt();
createTime_ = (new System.DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
}
}
}
private long LocateBlockWithSignature(int signature, long endLocation, int minimumBlockSize, int maximumVariableData)
{
using (var stream = new ZipHelperStream(_baseStream))
{
return stream.LocateBlockWithSignature(signature, endLocation, minimumBlockSize, maximumVariableData);
}
}
/// <summary>
/// Test an archive for integrity/validity
/// </summary>
/// <param name="testData">Perform low level data Crc check</param>
/// <param name="strategy">The <see cref="TestStrategy"></see> to apply.</param>
/// <param name="resultHandler">The <see cref="ZipTestResultHandler"></see> handler to call during testing.</param>
/// <returns>true if all tests pass, false otherwise</returns>
public bool TestArchive(bool testData, TestStrategy strategy, ZipTestResultHandler resultHandler)
{
TestStatus status = new TestStatus(this);
if ( resultHandler != null ) {
resultHandler(status, null);
}
HeaderTest test = testData ? (HeaderTest.Header | HeaderTest.Extract) : HeaderTest.Header;
bool testing = true;
try {
int entryIndex = 0;
while ( testing && (entryIndex < Count) ) {
if ( resultHandler != null ) {
status.SetEntry(this[entryIndex]);
status.SetOperation(TestOperation.EntryHeader);
resultHandler(status, null);
}
try {
TestLocalHeader(this[entryIndex], test);
}
catch(ZipException ex) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status,
string.Format("Exception during test - '{0}'", ex.Message));
}
if ( strategy == TestStrategy.FindFirstError ) {
testing = false;
}
}
if ( testing && testData && this[entryIndex].IsFile ) {
if ( resultHandler != null ) {
status.SetOperation(TestOperation.EntryData);
resultHandler(status, null);
}
Stream entryStream = this.GetInputStream(this[entryIndex]);
Crc32 crc = new Crc32();
byte[] buffer = new byte[4096];
long totalBytes = 0;
int bytesRead;
while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0) {
crc.Update(buffer, 0, bytesRead);
if ( resultHandler != null ) {
totalBytes += bytesRead;
status.SetBytesTested(totalBytes);
resultHandler(status, null);
}
}
if (this[entryIndex].Crc != crc.Value) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status, "CRC mismatch");
}
if ( strategy == TestStrategy.FindFirstError ) {
testing = false;
}
}
if (( this[entryIndex].Flags & (int)GeneralBitFlags.Descriptor) != 0 ) {
ZipHelperStream helper = new ZipHelperStream(baseStream_);
DescriptorData data = new DescriptorData();
helper.ReadDataDescriptor(this[entryIndex].LocalHeaderRequiresZip64, data);
if (this[entryIndex].Crc != data.Crc) {
status.AddError();
}
if (this[entryIndex].CompressedSize != data.CompressedSize) {
status.AddError();
}
if (this[entryIndex].Size != data.Size) {
status.AddError();
}
}
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.EntryComplete);
resultHandler(status, null);
}
entryIndex += 1;
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.MiscellaneousTests);
resultHandler(status, null);
}
// TODO: the 'Corrina Johns' test where local headers are missing from
// the central directory. They are therefore invisible to many archivers.
}
catch (Exception ex) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status, string.Format("Exception during test - '{0}'", ex.Message));
}
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.Complete);
status.SetEntry(null);
resultHandler(status, null);
}
return (status.ErrorCount == 0);
}
public override void Finish()
{
if (_entries != null)
{
if (_curEntry != null)
{
CloseEntry();
}
long count = _entries.Count;
long sizeEntries = 0L;
foreach (ZipEntry entry in _entries)
{
WriteLeInt(ZipConstants.CentralHeaderSignature);
WriteLeShort(0x33);
WriteLeShort(entry.Version);
WriteLeShort(entry.Flags);
WriteLeShort((short)entry.CompressionMethodForHeader);
WriteLeInt((int)entry.DosTime);
WriteLeInt((int)entry.Crc);
if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.CompressedSize);
}
if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Size);
}
byte[] buffer = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
if (buffer.Length > 0xffff)
{
throw new ZipException("Name too long.");
}
ZipExtraData extraData = new ZipExtraData(entry.ExtraData);
if (entry.CentralHeaderRequiresZip64)
{
extraData.StartNewEntry();
if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL))
{
extraData.AddLeLong(entry.Size);
}
if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL))
{
extraData.AddLeLong(entry.CompressedSize);
}
if (entry.Offset >= 0xffffffffL)
{
extraData.AddLeLong(entry.Offset);
}
extraData.AddNewEntry(1);
}
else
{
extraData.Delete(1);
}
if (entry.AesKeySize > 0)
{
AddExtraDataAes(entry, extraData);
}
byte[] entryData = extraData.GetEntryData();
byte[] buffer3 = (entry.Comment != null) ? ZipConstants.ConvertToArray(entry.Flags, entry.Comment) : new byte[0];
if (buffer3.Length > 0xffff)
{
throw new ZipException("Comment too long.");
}
WriteLeShort(buffer.Length);
WriteLeShort(entryData.Length);
WriteLeShort(buffer3.Length);
WriteLeShort(0);
WriteLeShort(0);
if (entry.ExternalFileAttributes != -1)
{
WriteLeInt(entry.ExternalFileAttributes);
}
else if (entry.IsDirectory)
{
WriteLeInt(0x10);
}
else
{
WriteLeInt(0);
}
if (entry.Offset >= 0xffffffffL)
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Offset);
}
if (buffer.Length > 0)
{
BaseOutputStream.Write(buffer, 0, buffer.Length);
}
if (entryData.Length > 0)
{
BaseOutputStream.Write(entryData, 0, entryData.Length);
}
if (buffer3.Length > 0)
{
BaseOutputStream.Write(buffer3, 0, buffer3.Length);
}
sizeEntries += ((ZipConstants.CentralHeaderBaseSize + buffer.Length) + entryData.Length) + buffer3.Length;
}
using (ZipHelperStream stream = new ZipHelperStream(BaseOutputStream))
{
stream.WriteEndOfCentralDirectory(count, sizeEntries, _offset, _zipComment);
}
_entries = null;
}
}
// NOTE this returns the offset of the first byte after the signature.
long LocateBlockWithSignature(int signature, long endLocation, int minimumBlockSize, int maximumVariableData)
{
using ( ZipHelperStream les = new ZipHelperStream(baseStream_) ) {
return les.LocateBlockWithSignature(signature, endLocation, minimumBlockSize, maximumVariableData);
}
}
/// <summary>
/// Finishes the stream. This will write the central directory at the
/// end of the zip file and flush the stream.
/// </summary>
/// <remarks>
/// This is automatically called when the stream is closed.
/// </remarks>
/// <exception cref="System.IO.IOException">
/// An I/O error occurs.
/// </exception>
/// <exception cref="ZipException">
/// Comment exceeds the maximum length<br/>
/// Entry name exceeds the maximum length
/// </exception>
public override void Finish()
{
if (entries == null)
{
return;
}
if (curEntry != null)
{
CloseEntry();
}
long numEntries = entries.Count;
long sizeEntries = 0;
foreach (ZipEntry entry in entries)
{
WriteLeInt(ZipConstants.CentralHeaderSignature);
WriteLeShort(ZipConstants.VersionMadeBy);
WriteLeShort(entry.Version);
WriteLeShort(entry.Flags);
WriteLeShort((short)entry.CompressionMethod);
WriteLeInt((int)entry.DosTime);
WriteLeInt((int)entry.Crc);
if (entry.IsZip64Forced() ||
(entry.CompressedSize >= uint.MaxValue))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.CompressedSize);
}
if (entry.IsZip64Forced() ||
(entry.Size >= uint.MaxValue))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Size);
}
byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
if (name.Length > 0xffff)
{
throw new ZipException("Name too long.");
}
ZipExtraData ed = new ZipExtraData(entry.ExtraData);
if (entry.CentralHeaderRequiresZip64)
{
ed.StartNewEntry();
if (entry.IsZip64Forced() ||
(entry.Size >= 0xffffffff))
{
ed.AddLeLong(entry.Size);
}
if (entry.IsZip64Forced() ||
(entry.CompressedSize >= 0xffffffff))
{
ed.AddLeLong(entry.CompressedSize);
}
if (entry.Offset >= 0xffffffff)
{
ed.AddLeLong(entry.Offset);
}
ed.AddNewEntry(1);
}
else
{
ed.Delete(1);
}
byte[] extra = ed.GetEntryData();
byte[] entryComment =
(entry.Comment != null) ?
ZipConstants.ConvertToArray(entry.Flags, entry.Comment) :
new byte[0];
if (entryComment.Length > 0xffff)
{
throw new ZipException("Comment too long.");
}
WriteLeShort(name.Length);
WriteLeShort(extra.Length);
WriteLeShort(entryComment.Length);
WriteLeShort(0); // disk number
WriteLeShort(0); // internal file attributes
// external file attributes
if (entry.ExternalFileAttributes != -1)
{
WriteLeInt(entry.ExternalFileAttributes);
}
else
{
if (entry.IsDirectory) // mark entry as directory (from nikolam.AT.perfectinfo.com)
{
WriteLeInt(16);
}
else
{
WriteLeInt(0);
}
}
if (entry.Offset >= uint.MaxValue)
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Offset);
}
if (name.Length > 0)
{
baseOutputStream.Write(name, 0, name.Length);
}
if (extra.Length > 0)
{
baseOutputStream.Write(extra, 0, extra.Length);
}
if (entryComment.Length > 0)
{
baseOutputStream.Write(entryComment, 0, entryComment.Length);
}
sizeEntries += ZipConstants.CentralHeaderBaseSize + name.Length + extra.Length + entryComment.Length;
}
using (ZipHelperStream zhs = new ZipHelperStream(baseOutputStream)) {
zhs.WriteEndOfCentralDirectory(numEntries, sizeEntries, offset, zipComment);
}
entries = null;
}
void UpdateCommentOnly()
{
long baseLength = baseStream_.Length;
ZipHelperStream updateFile = null;
if ( archiveStorage_.UpdateMode == FileUpdateMode.Safe ) {
Stream copyStream = archiveStorage_.MakeTemporaryCopy(baseStream_);
updateFile = new ZipHelperStream(copyStream);
updateFile.IsStreamOwner = true;
baseStream_.Close();
baseStream_ = null;
}
else {
if (archiveStorage_.UpdateMode == FileUpdateMode.Direct) {
// TODO: archiveStorage wasnt intended for this use.
// Need to revisit this to tidy up handling as archive storage currently doesnt
// handle the original stream well.
// The problem is when using an existing zip archive with an in memory archive storage.
// The open stream wont support writing but the memory storage should open the same file not an in memory one.
// Need to tidy up the archive storage interface and contract basically.
baseStream_ = archiveStorage_.OpenForDirectUpdate(baseStream_);
updateFile = new ZipHelperStream(baseStream_);
}
else {
baseStream_.Close();
baseStream_ = null;
updateFile = new ZipHelperStream(Name);
}
}
using ( updateFile ) {
long locatedCentralDirOffset =
updateFile.LocateBlockWithSignature(ZipConstants.EndOfCentralDirectorySignature,
baseLength, ZipConstants.EndOfCentralRecordBaseSize, 0xffff);
if ( locatedCentralDirOffset < 0 ) {
throw new ZipException("Cannot find central directory");
}
const int CentralHeaderCommentSizeOffset = 16;
updateFile.Position += CentralHeaderCommentSizeOffset;
byte[] rawComment = newComment_.RawComment;
updateFile.WriteLEShort(rawComment.Length);
updateFile.Write(rawComment, 0, rawComment.Length);
updateFile.SetLength(updateFile.Position);
}
if ( archiveStorage_.UpdateMode == FileUpdateMode.Safe ) {
Reopen(archiveStorage_.ConvertTemporaryToFinal());
}
else {
ReadEntries();
}
}
public override void Finish()
{
if (_entries != null)
{
if (_curEntry != null)
{
CloseEntry();
}
long count = _entries.Count;
long sizeEntries = 0L;
foreach (ZipEntry entry in _entries)
{
WriteLeInt(ZipConstants.CentralHeaderSignature);
WriteLeShort(0x33);
WriteLeShort(entry.Version);
WriteLeShort(entry.Flags);
WriteLeShort((short)entry.CompressionMethodForHeader);
WriteLeInt((int)entry.DosTime);
WriteLeInt((int)entry.Crc);
if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.CompressedSize);
}
if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL))
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Size);
}
byte[] buffer = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
if (buffer.Length > 0xffff)
{
throw new ZipException("Name too long.");
}
ZipExtraData extraData = new ZipExtraData(entry.ExtraData);
if (entry.CentralHeaderRequiresZip64)
{
extraData.StartNewEntry();
if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL))
{
extraData.AddLeLong(entry.Size);
}
if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL))
{
extraData.AddLeLong(entry.CompressedSize);
}
if (entry.Offset >= 0xffffffffL)
{
extraData.AddLeLong(entry.Offset);
}
extraData.AddNewEntry(1);
}
else
{
extraData.Delete(1);
}
if (entry.AesKeySize > 0)
{
AddExtraDataAes(entry, extraData);
}
byte[] entryData = extraData.GetEntryData();
byte[] buffer3 = (entry.Comment != null) ? ZipConstants.ConvertToArray(entry.Flags, entry.Comment) : new byte[0];
if (buffer3.Length > 0xffff)
{
throw new ZipException("Comment too long.");
}
WriteLeShort(buffer.Length);
WriteLeShort(entryData.Length);
WriteLeShort(buffer3.Length);
WriteLeShort(0);
WriteLeShort(0);
if (entry.ExternalFileAttributes != -1)
{
WriteLeInt(entry.ExternalFileAttributes);
}
else if (entry.IsDirectory)
{
WriteLeInt(0x10);
}
else
{
WriteLeInt(0);
}
if (entry.Offset >= 0xffffffffL)
{
WriteLeInt(-1);
}
else
{
WriteLeInt((int)entry.Offset);
}
if (buffer.Length > 0)
{
BaseOutputStream.Write(buffer, 0, buffer.Length);
}
if (entryData.Length > 0)
{
BaseOutputStream.Write(entryData, 0, entryData.Length);
}
if (buffer3.Length > 0)
{
BaseOutputStream.Write(buffer3, 0, buffer3.Length);
}
sizeEntries += ((ZipConstants.CentralHeaderBaseSize + buffer.Length) + entryData.Length) + buffer3.Length;
}
using (ZipHelperStream stream = new ZipHelperStream(BaseOutputStream))
{
stream.WriteEndOfCentralDirectory(count, sizeEntries, _offset, _zipComment);
}
_entries = null;
}
}
/// <summary>
/// Finishes the stream. This will write the central directory at the
/// end of the zip file and flush the stream.
/// </summary>
/// <remarks>
/// This is automatically called when the stream is closed.
/// </remarks>
/// <exception cref="System.IO.IOException">
/// An I/O error occurs.
/// </exception>
/// <exception cref="ZipException">
/// Comment exceeds the maximum length<br/>
/// Entry name exceeds the maximum length
/// </exception>
public override void Finish()
{
if (entries == null) {
return;
}
if (curEntry != null) {
CloseEntry();
}
long numEntries = entries.Count;
long sizeEntries = 0;
foreach (ZipEntry entry in entries) {
WriteLeInt(ZipConstants.CentralHeaderSignature);
WriteLeShort(ZipConstants.VersionMadeBy);
WriteLeShort(entry.Version);
WriteLeShort(entry.Flags);
WriteLeShort((short)entry.CompressionMethod);
WriteLeInt((int)entry.DosTime);
WriteLeInt((int)entry.Crc);
if ( entry.IsZip64Forced() ||
(entry.CompressedSize >= uint.MaxValue) )
{
WriteLeInt(-1);
}
else {
WriteLeInt((int)entry.CompressedSize);
}
if ( entry.IsZip64Forced() ||
(entry.Size >= uint.MaxValue) )
{
WriteLeInt(-1);
}
else {
WriteLeInt((int)entry.Size);
}
byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
if (name.Length > 0xffff) {
throw new ZipException("Name too long.");
}
ZipExtraData ed = new ZipExtraData(entry.ExtraData);
if ( entry.CentralHeaderRequiresZip64 ) {
ed.StartNewEntry();
if ( entry.IsZip64Forced() ||
(entry.Size >= 0xffffffff) )
{
ed.AddLeLong(entry.Size);
}
if ( entry.IsZip64Forced() ||
(entry.CompressedSize >= 0xffffffff) )
{
ed.AddLeLong(entry.CompressedSize);
}
if ( entry.Offset >= 0xffffffff )
{
ed.AddLeLong(entry.Offset);
}
ed.AddNewEntry(1);
}
else {
ed.Delete(1);
}
byte[] extra = ed.GetEntryData();
byte[] entryComment =
(entry.Comment != null) ?
ZipConstants.ConvertToArray(entry.Flags, entry.Comment) :
new byte[0];
if (entryComment.Length > 0xffff) {
throw new ZipException("Comment too long.");
}
WriteLeShort(name.Length);
WriteLeShort(extra.Length);
WriteLeShort(entryComment.Length);
WriteLeShort(0); // disk number
WriteLeShort(0); // internal file attributes
// external file attributes
if (entry.ExternalFileAttributes != -1) {
WriteLeInt(entry.ExternalFileAttributes);
} else {
if (entry.IsDirectory) { // mark entry as directory (from nikolam.AT.perfectinfo.com)
WriteLeInt(16);
} else {
WriteLeInt(0);
}
}
if ( entry.Offset >= uint.MaxValue ) {
WriteLeInt(-1);
}
else {
WriteLeInt((int)entry.Offset);
}
if ( name.Length > 0 ) {
baseOutputStream_.Write(name, 0, name.Length);
}
if ( extra.Length > 0 ) {
baseOutputStream_.Write(extra, 0, extra.Length);
}
if ( entryComment.Length > 0 ) {
baseOutputStream_.Write(entryComment, 0, entryComment.Length);
}
sizeEntries += ZipConstants.CentralHeaderBaseSize + name.Length + extra.Length + entryComment.Length;
}
using ( ZipHelperStream zhs = new ZipHelperStream(baseOutputStream_) ) {
zhs.WriteEndOfCentralDirectory(numEntries, sizeEntries, offset, zipComment);
}
entries = null;
}
private void RunUpdates()
{
ZipFile file;
var sizeEntries = 0L;
long num2;
var flag = false;
var destinationPosition = 0L;
if (IsNewArchive)
{
file = this;
file._baseStream.Position = 0L;
flag = true;
}
else if (_archiveStorage.UpdateMode == FileUpdateMode.Direct)
{
file = this;
file._baseStream.Position = 0L;
flag = true;
_updates.Sort(new UpdateComparer());
}
else
{
file = Create(_archiveStorage.GetTemporaryOutput());
file.UseZip64 = UseZip64;
if (_key != null)
{
file._key = (byte[])_key.Clone();
}
}
try
{
foreach (ZipUpdate update in _updates)
{
if (update != null)
{
switch (update.Command)
{
case UpdateCommand.Copy:
if (!flag)
{
goto Label_00EC;
}
CopyEntryDirect(file, update, ref destinationPosition);
break;
case UpdateCommand.Modify:
ModifyEntry(file, update);
break;
case UpdateCommand.Add:
goto Label_0104;
}
}
continue;
Label_00EC:
CopyEntry(file, update);
continue;
Label_0104:
if (!IsNewArchive && flag)
{
file._baseStream.Position = destinationPosition;
}
AddEntry(file, update);
if (flag)
{
destinationPosition = file._baseStream.Position;
}
}
if (!IsNewArchive && flag)
{
file._baseStream.Position = destinationPosition;
}
var position = file._baseStream.Position;
foreach (ZipUpdate update2 in _updates)
{
if (update2 != null)
{
sizeEntries += file.WriteCentralDirectoryHeader(update2.OutEntry);
}
}
var comment = (_newComment != null) ? _newComment.RawComment : ZipConstants.ConvertToArray(_comment);
using (var stream = new ZipHelperStream(file._baseStream))
{
stream.WriteEndOfCentralDirectory(_updateCount, sizeEntries, position, comment);
}
num2 = file._baseStream.Position;
foreach (ZipUpdate update3 in _updates)
{
if (update3 != null)
{
if ((update3.CrcPatchOffset > 0L) && (update3.OutEntry.CompressedSize > 0L))
{
file._baseStream.Position = update3.CrcPatchOffset;
file.WriteLeInt((int)update3.OutEntry.Crc);
}
if (update3.SizePatchOffset > 0L)
{
file._baseStream.Position = update3.SizePatchOffset;
if (update3.OutEntry.LocalHeaderRequiresZip64)
{
file.WriteLeLong(update3.OutEntry.Size);
file.WriteLeLong(update3.OutEntry.CompressedSize);
}
else
{
file.WriteLeInt((int)update3.OutEntry.CompressedSize);
file.WriteLeInt((int)update3.OutEntry.Size);
}
}
}
}
}
catch
{
file.Close();
if (!flag && (file.Name != null))
{
File.Delete(file.Name);
}
throw;
}
if (flag)
{
file._baseStream.SetLength(num2);
file._baseStream.Flush();
_isNewArchive = false;
ReadEntries();
}
else
{
_baseStream.Close();
Reopen(_archiveStorage.ConvertTemporaryToFinal());
}
}
