public WriteEndOfCentralDirectory ( long noOfEntries, long sizeEntries, long startOfCentralDirectory, byte comment ) : void | ||
noOfEntries | long | The number of entries in the directory. |
sizeEntries | long | The size of the entries in the directory. |
startOfCentralDirectory | long | The start of the central directory. |
comment | byte | The archive comment. (This can be null). |
return | void |
/// <summary> /// Commit current updates, updating this archive. /// </summary> /// <seealso cref="BeginUpdate()"></seealso> /// <seealso cref="AbortUpdate"></seealso> /// <exception cref="ObjectDisposedException">ZipFile has been closed.</exception> public void CommitUpdate() { if ( isDisposed_ ) { throw new ObjectDisposedException("ZipFile"); } CheckUpdating(); try { updateIndex_.Clear(); updateIndex_=null; if( contentsEdited_ ) { RunUpdates(); } else if( commentEdited_ ) { UpdateCommentOnly(); } else { // Create an empty archive if none existed originally. if( entries_.Length==0 ) { byte[] theComment=(newComment_!=null)?newComment_.RawComment:ZipConstants.ConvertToArray(comment_); using( ZipHelperStream zhs=new ZipHelperStream(baseStream_) ) { zhs.WriteEndOfCentralDirectory(0, 0, 0, theComment); } } } } finally { PostUpdateCleanup(); } }
void RunUpdates() { long sizeEntries = 0; long endOfStream = 0; 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 data required by copies will not be overwritten. updates_.Sort(new UpdateComparer()); } else { workFile = ZipFile.Create(archiveStorage_.GetTemporaryOutput()); workFile.UseZip64 = UseZip64; if (key != null) { workFile.key = (byte[])key.Clone(); } } try { foreach ( ZipUpdate update in updates_ ) { if (update != null) { 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 will take some legwork. 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_ ) { if (update != null) { sizeEntries += workFile.WriteCentralDirectoryHeader(update.OutEntry); } } byte[] theComment = (newComment_ != null) ? newComment_.RawComment : ZipConstants.ConvertToArray(comment_); using ( ZipHelperStream zhs = new ZipHelperStream(workFile.baseStream_) ) { zhs.WriteEndOfCentralDirectory(updateCount_, sizeEntries, centralDirOffset, theComment); } endOfStream = workFile.baseStream_.Position; // And now patch entries... foreach ( ZipUpdate update in updates_ ) { if (update != null) { // 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.OutEntry.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 { workFile.Close(); if (!directUpdate && (workFile.Name != null)) { File.Delete(workFile.Name); } throw; } if (directUpdate) { workFile.baseStream_.SetLength(endOfStream); workFile.baseStream_.Flush(); isNewArchive_ = false; ReadEntries(); } else { baseStream_.Close(); Reopen(archiveStorage_.ConvertTemporaryToFinal()); } }
/// <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(); }
/// <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.CompressionMethodForHeader); 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."); } var 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); } #if !NET_1_1 && !NETCF_2_0 if (entry.AESKeySize > 0) { AddExtraDataAES(entry, ed); } #endif 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 (var zhs = new ZipHelperStream(baseOutputStream_)) { zhs.WriteEndOfCentralDirectory(numEntries, sizeEntries, offset, zipComment); } entries = null; }
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 >= uint.MaxValue) { this.WriteLeInt(-1); } else { this.WriteLeInt((int)zipEntry.CompressedSize); } if (zipEntry.IsZip64Forced() || zipEntry.Size >= uint.MaxValue) { 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 >= 0xffffffff) { zipExtraData.AddLeLong(zipEntry.Size); } if (zipEntry.IsZip64Forced() || zipEntry.CompressedSize >= 0xffffffff) { zipExtraData.AddLeLong(zipEntry.CompressedSize); } if (zipEntry.Offset >= 0xffffffff) { 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 >= uint.MaxValue) { 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; }
/// <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.CompressionMethodForHeader); 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."); } var 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); } if (entry.AESKeySize > 0) { AddExtraDataAES(entry, ed); } 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; }
public override void Finish() { if (entries == null) { return; } if (curEntry != null) { CloseEntry(); } long noOfEntries = entries.get_Count(); long num = 0L; global::System.Collections.IEnumerator enumerator = entries.GetEnumerator(); try { while (enumerator.MoveNext()) { ZipEntry zipEntry = (ZipEntry)enumerator.get_Current(); WriteLeInt(33639248); WriteLeShort(51); WriteLeShort(zipEntry.Version); WriteLeShort(zipEntry.Flags); WriteLeShort((short)zipEntry.CompressionMethodForHeader); WriteLeInt((int)zipEntry.DosTime); WriteLeInt((int)zipEntry.Crc); if (zipEntry.IsZip64Forced() || zipEntry.CompressedSize >= 4294967295u) { WriteLeInt(-1); } else { WriteLeInt((int)zipEntry.CompressedSize); } if (zipEntry.IsZip64Forced() || zipEntry.Size >= 4294967295u) { WriteLeInt(-1); } else { 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 >= 4294967295u) { zipExtraData.AddLeLong(zipEntry.Size); } if (zipEntry.IsZip64Forced() || zipEntry.CompressedSize >= 4294967295u) { zipExtraData.AddLeLong(zipEntry.CompressedSize); } if (zipEntry.Offset >= 4294967295u) { 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."); } WriteLeShort(array.Length); WriteLeShort(entryData.Length); WriteLeShort(array2.Length); WriteLeShort(0); WriteLeShort(0); if (zipEntry.ExternalFileAttributes != -1) { WriteLeInt(zipEntry.ExternalFileAttributes); } else if (zipEntry.IsDirectory) { WriteLeInt(16); } else { WriteLeInt(0); } if (zipEntry.Offset >= 4294967295u) { WriteLeInt(-1); } else { WriteLeInt((int)zipEntry.Offset); } if (array.Length > 0) { baseOutputStream_.Write(array, 0, array.Length); } if (entryData.Length > 0) { baseOutputStream_.Write(entryData, 0, entryData.Length); } if (array2.Length > 0) { baseOutputStream_.Write(array2, 0, array2.Length); } num += 46 + array.Length + entryData.Length + array2.Length; } } finally { global::System.IDisposable disposable = enumerator as global::System.IDisposable; if (disposable != null) { disposable.Dispose(); } } ZipHelperStream zipHelperStream = new ZipHelperStream(baseOutputStream_); try { zipHelperStream.WriteEndOfCentralDirectory(noOfEntries, num, offset, zipComment); } finally { ((global::System.IDisposable)zipHelperStream)?.Dispose(); } entries = null; }
void RunUpdates() { long sizeEntries = 0; long endOfStream = 0; bool allOk = true; bool directUpdate = false; long destinationPosition = 0; 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; updates_.Sort(new UpdateComparer()); } else { workFile = ZipFile.Create(archiveStorage_.GetTemporaryOutput()); workFile.UseZip64 = UseZip64; if (key != null) { workFile.key = (byte[])key.Clone(); } } try { foreach ( ZipUpdate update in updates_ ) { if (update != null) { switch (update.Command) { case UpdateCommand.Copy: if (directUpdate) { CopyEntryDirect(workFile, update, ref destinationPosition); } else { CopyEntry(workFile, update); } break; case UpdateCommand.Modify: 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_ ) { if (update != null) { sizeEntries += workFile.WriteCentralDirectoryHeader(update.OutEntry); } } byte[] theComment = (newComment_ != null) ? newComment_.RawComment : ZipConstants.ConvertToArray(comment_); using ( ZipHelperStream zhs = new ZipHelperStream(workFile.baseStream_) ) { zhs.WriteEndOfCentralDirectory(updateCount_, sizeEntries, centralDirOffset, theComment); } endOfStream = workFile.baseStream_.Position; foreach ( ZipUpdate update in updates_ ) { if (update != null) { 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.OutEntry.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); } } }
public override void Finish() { if (this.entries != null) { if (this.curEntry != null) { this.CloseEntry(); } long count = this.entries.Count; long sizeEntries = 0L; foreach (ZipEntry entry in this.entries) { this.WriteLeInt(0x2014b50); this.WriteLeShort(0x2d); this.WriteLeShort(entry.Version); this.WriteLeShort(entry.Flags); this.WriteLeShort((short)entry.CompressionMethod); this.WriteLeInt((int)entry.DosTime); this.WriteLeInt((int)entry.Crc); if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL)) { this.WriteLeInt(-1); } else { this.WriteLeInt((int)entry.CompressedSize); } if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL)) { this.WriteLeInt(-1); } else { this.WriteLeInt((int)entry.Size); } byte[] buffer = ZipConstants.ConvertToArray(entry.Flags, entry.Name); if (buffer.Length > 0xffff) { throw new ZipException("Name too long."); } ZipExtraData data = new ZipExtraData(entry.ExtraData); if (entry.CentralHeaderRequiresZip64) { data.StartNewEntry(); if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL)) { data.AddLeLong(entry.Size); } if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL)) { data.AddLeLong(entry.CompressedSize); } if (entry.Offset >= 0xffffffffL) { data.AddLeLong(entry.Offset); } data.AddNewEntry(1); } else { data.Delete(1); } byte[] entryData = data.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."); } this.WriteLeShort(buffer.Length); this.WriteLeShort(entryData.Length); this.WriteLeShort(buffer3.Length); this.WriteLeShort(0); this.WriteLeShort(0); if (entry.ExternalFileAttributes != -1) { this.WriteLeInt(entry.ExternalFileAttributes); } else if (entry.IsDirectory) { this.WriteLeInt(0x10); } else { this.WriteLeInt(0); } if (entry.Offset >= 0xffffffffL) { this.WriteLeInt(-1); } else { this.WriteLeInt((int)entry.Offset); } if (buffer.Length > 0) { base.baseOutputStream_.Write(buffer, 0, buffer.Length); } if (entryData.Length > 0) { base.baseOutputStream_.Write(entryData, 0, entryData.Length); } if (buffer3.Length > 0) { base.baseOutputStream_.Write(buffer3, 0, buffer3.Length); } sizeEntries += ((0x2e + buffer.Length) + entryData.Length) + buffer3.Length; } using (ZipHelperStream stream = new ZipHelperStream(base.baseOutputStream_)) { stream.WriteEndOfCentralDirectory(count, sizeEntries, this.offset, this.zipComment); } this.entries = null; } }
public override void Finish() { if (entries != null) { if (curEntry != null) { CloseEntry(); } long noOfEntries = entries.Count; long num = 0L; foreach (ZipEntry entry in entries) { WriteLeInt(33639248); WriteLeShort(51); WriteLeShort(entry.Version); WriteLeShort(entry.Flags); WriteLeShort((short)entry.CompressionMethodForHeader); 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[] array = ZipConstants.ConvertToArray(entry.Flags, entry.Name); if (array.Length > 65535) { throw new ZipException("Name too long."); } ZipExtraData zipExtraData = new ZipExtraData(entry.ExtraData); if (entry.CentralHeaderRequiresZip64) { zipExtraData.StartNewEntry(); if (entry.IsZip64Forced() || entry.Size >= uint.MaxValue) { zipExtraData.AddLeLong(entry.Size); } if (entry.IsZip64Forced() || entry.CompressedSize >= uint.MaxValue) { zipExtraData.AddLeLong(entry.CompressedSize); } if (entry.Offset >= uint.MaxValue) { zipExtraData.AddLeLong(entry.Offset); } zipExtraData.AddNewEntry(1); } else { zipExtraData.Delete(1); } if (entry.AESKeySize > 0) { AddExtraDataAES(entry, zipExtraData); } byte[] entryData = zipExtraData.GetEntryData(); byte[] array2 = (entry.Comment != null) ? ZipConstants.ConvertToArray(entry.Flags, entry.Comment) : new byte[0]; if (array2.Length > 65535) { throw new ZipException("Comment too long."); } WriteLeShort(array.Length); WriteLeShort(entryData.Length); WriteLeShort(array2.Length); WriteLeShort(0); WriteLeShort(0); if (entry.ExternalFileAttributes != -1) { WriteLeInt(entry.ExternalFileAttributes); } else if (entry.IsDirectory) { WriteLeInt(16); } else { WriteLeInt(0); } if (entry.Offset >= uint.MaxValue) { WriteLeInt(-1); } else { WriteLeInt((int)entry.Offset); } if (array.Length != 0) { baseOutputStream_.Write(array, 0, array.Length); } if (entryData.Length != 0) { baseOutputStream_.Write(entryData, 0, entryData.Length); } if (array2.Length != 0) { baseOutputStream_.Write(array2, 0, array2.Length); } num += 46 + array.Length + entryData.Length + array2.Length; } using (ZipHelperStream zipHelperStream = new ZipHelperStream(baseOutputStream_)) { zipHelperStream.WriteEndOfCentralDirectory(noOfEntries, num, offset, zipComment); } entries = null; } }
public void CommitUpdate() { if (this.isDisposed_) { throw new ObjectDisposedException("ZipFile"); } this.CheckUpdating(); try { this.updateIndex_.Clear(); this.updateIndex_ = null; if (this.contentsEdited_) { this.RunUpdates(); } else if (this.commentEdited_) { this.UpdateCommentOnly(); } else if (this.entries_.Length == 0) { byte[] comment = (this.newComment_ != null) ? this.newComment_.RawComment : ZipConstants.ConvertToArray(this.comment_); using (ZipHelperStream stream = new ZipHelperStream(this.baseStream_)) { stream.WriteEndOfCentralDirectory(0L, 0L, 0L, comment); } } } finally { this.PostUpdateCleanup(); } }
private void RunUpdates() { ZipFile file; long sizeEntries = 0L; long num2 = 0L; bool flag = false; long destinationPosition = 0L; if (this.IsNewArchive) { file = this; file.baseStream_.Position = 0L; flag = true; } else if (this.archiveStorage_.UpdateMode == FileUpdateMode.Direct) { file = this; file.baseStream_.Position = 0L; flag = true; this.updates_.Sort(new UpdateComparer()); } else { file = Create(this.archiveStorage_.GetTemporaryOutput()); file.UseZip64 = this.UseZip64; if (this.key != null) { file.key = (byte[]) this.key.Clone(); } } try { foreach (ZipUpdate update in this.updates_) { if (update != null) { switch (update.Command) { case UpdateCommand.Copy: { if (!flag) { goto Label_00EC; } this.CopyEntryDirect(file, update, ref destinationPosition); continue; } case UpdateCommand.Modify: { this.ModifyEntry(file, update); continue; } case UpdateCommand.Add: goto Label_0104; } } continue; Label_00EC: this.CopyEntry(file, update); continue; Label_0104: if (!this.IsNewArchive && flag) { file.baseStream_.Position = destinationPosition; } this.AddEntry(file, update); if (flag) { destinationPosition = file.baseStream_.Position; } } if (!this.IsNewArchive && flag) { file.baseStream_.Position = destinationPosition; } long position = file.baseStream_.Position; foreach (ZipUpdate update2 in this.updates_) { if (update2 != null) { sizeEntries += file.WriteCentralDirectoryHeader(update2.OutEntry); } } byte[] comment = (this.newComment_ != null) ? this.newComment_.RawComment : ZipConstants.ConvertToArray(this.comment_); using (ZipHelperStream stream = new ZipHelperStream(file.baseStream_)) { stream.WriteEndOfCentralDirectory(this.updateCount_, sizeEntries, position, comment); } num2 = file.baseStream_.Position; foreach (ZipUpdate update3 in this.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(); this.isNewArchive_ = false; this.ReadEntries(); } else { this.baseStream_.Close(); this.Reopen(this.archiveStorage_.ConvertTemporaryToFinal()); } }
public override void Finish() { if (this.entries != null) { if (this.curEntry != null) { this.CloseEntry(); } long count = this.entries.Count; long sizeEntries = 0L; foreach (ZipEntry entry in this.entries) { this.WriteLeInt(0x2014b50); this.WriteLeShort(0x33); this.WriteLeShort(entry.Version); this.WriteLeShort(entry.Flags); this.WriteLeShort((short) entry.CompressionMethodForHeader); this.WriteLeInt((int) entry.DosTime); this.WriteLeInt((int) entry.Crc); if (entry.IsZip64Forced() || (entry.CompressedSize >= 0xffffffffL)) { this.WriteLeInt(-1); } else { this.WriteLeInt((int) entry.CompressedSize); } if (entry.IsZip64Forced() || (entry.Size >= 0xffffffffL)) { this.WriteLeInt(-1); } else { this.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."); } this.WriteLeShort(buffer.Length); this.WriteLeShort(entryData.Length); this.WriteLeShort(buffer3.Length); this.WriteLeShort(0); this.WriteLeShort(0); if (entry.ExternalFileAttributes != -1) { this.WriteLeInt(entry.ExternalFileAttributes); } else if (entry.IsDirectory) { this.WriteLeInt(0x10); } else { this.WriteLeInt(0); } if (entry.Offset >= 0xffffffffL) { this.WriteLeInt(-1); } else { this.WriteLeInt((int) entry.Offset); } if (buffer.Length > 0) { base.baseOutputStream_.Write(buffer, 0, buffer.Length); } if (entryData.Length > 0) { base.baseOutputStream_.Write(entryData, 0, entryData.Length); } if (buffer3.Length > 0) { base.baseOutputStream_.Write(buffer3, 0, buffer3.Length); } sizeEntries += ((0x2e + buffer.Length) + entryData.Length) + buffer3.Length; } using (ZipHelperStream stream = new ZipHelperStream(base.baseOutputStream_)) { stream.WriteEndOfCentralDirectory(count, sizeEntries, this.offset, this.zipComment); } this.entries = null; } }