void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition) { bool skipOver = false; if ( update.Entry.Offset == destinationPosition ) { skipOver = true; } if ( !skipOver ) { baseStream_.Position = destinationPosition; workFile.WriteLocalEntryHeader(update); destinationPosition = baseStream_.Position; } long sourcePosition = 0; const int NameLengthOffset = 26; // TODO: Add base for SFX friendly handling long entryDataOffset = update.Entry.Offset + NameLengthOffset; baseStream_.Seek(entryDataOffset, SeekOrigin.Begin); // Clumsy way of handling retrieving the original name and extra data length for now. // TODO: Stop re-reading name and data length in CopyEntryDirect. uint nameLength = ReadLEUshort(); uint extraLength = ReadLEUshort(); sourcePosition = baseStream_.Position + nameLength + extraLength; if (skipOver) { if (update.OffsetBasedSize != -1) destinationPosition += update.OffsetBasedSize; else // TODO: Find out why this calculation comes up 4 bytes short on some entries in ODT (Office Document Text) archives. // WinZip produces a warning on these entries: // "caution: value of lrec.csize (compressed size) changed from ..." destinationPosition += (sourcePosition - entryDataOffset) + NameLengthOffset + // Header size update.Entry.CompressedSize + GetDescriptorSize(update); } else { if ( update.Entry.CompressedSize > 0 ) { CopyEntryDataDirect(update, baseStream_, false, ref destinationPosition, ref sourcePosition ); } CopyDescriptorBytesDirect(update, baseStream_, ref destinationPosition, sourcePosition); } }
void CopyEntry(ZipFile workFile, ZipUpdate update) { workFile.WriteLocalEntryHeader(update); if ( update.Entry.CompressedSize > 0 ) { const int NameLengthOffset = 26; long entryDataOffset = update.Entry.Offset + NameLengthOffset; // TODO: This wont work for SFX files! baseStream_.Seek(entryDataOffset, SeekOrigin.Begin); uint nameLength = ReadLEUshort(); uint extraLength = ReadLEUshort(); baseStream_.Seek(nameLength + extraLength, SeekOrigin.Current); CopyBytes(update, workFile.baseStream_, baseStream_, update.Entry.CompressedSize, false); } CopyDescriptorBytes(update, workFile.baseStream_, baseStream_); }
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; } }
void ModifyEntry(ZipFile workFile, ZipUpdate update) { workFile.WriteLocalEntryHeader(update); long dataStart = workFile.baseStream_.Position; // TODO: This is slow if the changes don't effect the data!! if ( update.Entry.IsFile && (update.Filename != null) ) { using ( Stream output = workFile.GetOutputStream(update.OutEntry) ) { using ( Stream source = this.GetInputStream(update.Entry) ) { CopyBytes(update, output, source, source.Length, true); } } } long dataEnd = workFile.baseStream_.Position; update.Entry.CompressedSize = dataEnd - dataStart; }
private static void ModifyEntry(ZipFile workFile, ZipUpdate update) { workFile.WriteLocalEntryHeader(update); long dataStart = workFile.baseStream_.Position; long dataEnd = workFile.baseStream_.Position; update.Entry.CompressedSize = dataEnd - dataStart; }
private void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition) { bool skipOver = false; if (update.Entry.Offset == destinationPosition) { skipOver = true; } if (!skipOver) { baseStream_.Position = destinationPosition; workFile.WriteLocalEntryHeader(update); destinationPosition = baseStream_.Position; } long sourcePosition = 0; const int NameLengthOffset = 26; // TODO: Add base for SFX friendly handling long entryDataOffset = update.Entry.Offset + NameLengthOffset; baseStream_.Seek(entryDataOffset, SeekOrigin.Begin); // Clumsy way of handling retrieving the original name and extra data length for now. // TODO: Stop re-reading name and data length in CopyEntryDirect. uint nameLength = ReadLEUshort(); uint extraLength = ReadLEUshort(); sourcePosition = baseStream_.Position + nameLength + extraLength; if (skipOver) { destinationPosition += (sourcePosition - entryDataOffset) + NameLengthOffset + // Header size update.Entry.CompressedSize + GetDescriptorSize(update); } else { if (update.Entry.CompressedSize > 0) { CopyEntryDataDirect(update, baseStream_, false, ref destinationPosition, ref sourcePosition); } CopyDescriptorBytesDirect(update, baseStream_, ref destinationPosition, sourcePosition); } }
void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition) { bool skipOver = false; if ( update.Entry.Offset == destinationPosition ) { skipOver = true; } if ( !skipOver ) { baseStream_.Position = destinationPosition; workFile.WriteLocalEntryHeader(update); destinationPosition = baseStream_.Position; } long sourcePosition = 0; const int NameLengthOffset = 26; long entryDataOffset = update.Entry.Offset + NameLengthOffset; baseStream_.Seek(entryDataOffset, SeekOrigin.Begin); uint nameLength = ReadLEUshort(); uint extraLength = ReadLEUshort(); sourcePosition = baseStream_.Position + nameLength + extraLength; if ( skipOver ) { destinationPosition += (sourcePosition - entryDataOffset) + NameLengthOffset + update.Entry.CompressedSize + GetDescriptorSize(update); } else { if ( update.Entry.CompressedSize > 0 ) { CopyEntryDataDirect(update, baseStream_, false, ref destinationPosition, ref sourcePosition ); } CopyDescriptorBytesDirect(update, baseStream_, ref destinationPosition, sourcePosition); } }
private void ModifyEntry(ZipFile workFile, ZipUpdate update) { workFile.WriteLocalEntryHeader(update); long position = workFile.baseStream_.Position; if (update.Entry.IsFile && (update.Filename != null)) { using (Stream stream = workFile.GetOutputStream(update.OutEntry)) { using (Stream stream2 = this.GetInputStream(update.Entry)) { this.CopyBytes(update, stream, stream2, stream2.Length, true); } } } long num2 = workFile.baseStream_.Position; update.Entry.CompressedSize = num2 - position; }
private void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition) { bool flag = false; if (update.Entry.Offset == destinationPosition) { flag = true; } if (!flag) { this.baseStream_.Position = destinationPosition; workFile.WriteLocalEntryHeader(update); destinationPosition = this.baseStream_.Position; } long sourcePosition = 0L; long offset = update.Entry.Offset + 0x1aL; this.baseStream_.Seek(offset, SeekOrigin.Begin); uint num3 = this.ReadLEUshort(); uint num4 = this.ReadLEUshort(); sourcePosition = (this.baseStream_.Position + num3) + num4; if (flag) { if (update.OffsetBasedSize != -1L) { destinationPosition += update.OffsetBasedSize; } else { destinationPosition += (((sourcePosition - offset) + 0x1aL) + update.Entry.CompressedSize) + this.GetDescriptorSize(update); } } else { if (update.Entry.CompressedSize > 0L) { this.CopyEntryDataDirect(update, this.baseStream_, false, ref destinationPosition, ref sourcePosition); } this.CopyDescriptorBytesDirect(update, this.baseStream_, ref destinationPosition, sourcePosition); } }
private void CopyEntry(ZipFile workFile, ZipUpdate update) { workFile.WriteLocalEntryHeader(update); if (update.Entry.CompressedSize > 0L) { long offset = update.Entry.Offset + 0x1aL; this.baseStream_.Seek(offset, SeekOrigin.Begin); uint num2 = this.ReadLEUshort(); uint num3 = this.ReadLEUshort(); this.baseStream_.Seek((long) (num2 + num3), SeekOrigin.Current); this.CopyBytes(update, workFile.baseStream_, this.baseStream_, update.Entry.CompressedSize, false); } this.CopyDescriptorBytes(update, workFile.baseStream_, this.baseStream_); }
private void AddEntry(ZipFile workFile, ZipUpdate update) { Stream source = null; if (update.Entry.IsFile) { source = update.GetSource(); if (source == null) { source = this.updateDataSource_.GetSource(update.Entry, update.Filename); } } if (source != null) { using (source) { long length = source.Length; if (update.OutEntry.Size < 0L) { update.OutEntry.Size = length; } else if (update.OutEntry.Size != length) { throw new ZipException("Entry size/stream size mismatch"); } workFile.WriteLocalEntryHeader(update); long position = workFile.baseStream_.Position; using (Stream stream2 = workFile.GetOutputStream(update.OutEntry)) { this.CopyBytes(update, stream2, source, length, true); } long num3 = workFile.baseStream_.Position; update.OutEntry.CompressedSize = num3 - position; if ((update.OutEntry.Flags & 8) == 8) { new ZipHelperStream(workFile.baseStream_).WriteDataDescriptor(update.OutEntry); } return; } } workFile.WriteLocalEntryHeader(update); update.OutEntry.CompressedSize = 0L; }