Esempio n. 1
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;
        }
Esempio n. 2
0
        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_);
        }
Esempio n. 3
0
        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.
            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);
            }
        }
Esempio n. 4
0
        void AddEntry(ZipFile workFile, ZipUpdate update)
        {
            long dataStart = 0;
            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);
                    dataStart = workFile.baseStream_.Position;

                    using ( Stream output = workFile.GetOutputStream(update.OutEntry) ) {
                        CopyBytes(update, output, source, sourceStreamLength, true);
                    }
                }
            }
            else {
                workFile.WriteLocalEntryHeader(update);
                dataStart = workFile.baseStream_.Position;
            }

            long dataEnd = workFile.baseStream_.Position;
            update.OutEntry.CompressedSize = dataEnd - dataStart;
        }
Esempio n. 5
0
 private void ModifyEntry(ZipFile workFile, ZipUpdate update)
 {
     workFile.WriteLocalEntryHeader(update);
     var position = workFile._baseStream.Position;
     if (update.Entry.IsFile && (update.Filename != null))
     {
         using (var stream = workFile.GetOutputStream(update.OutEntry))
         {
             using (var stream2 = GetInputStream(update.Entry))
             {
                 CopyBytes(update, stream, stream2, stream2.Length, true);
             }
         }
     }
     var num2 = workFile._baseStream.Position;
     update.Entry.CompressedSize = num2 - position;
 }
Esempio n. 6
0
 private void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition)
 {
     var flag = update.Entry.Offset == destinationPosition;
     if (!flag)
     {
         _baseStream.Position = destinationPosition;
         workFile.WriteLocalEntryHeader(update);
         destinationPosition = _baseStream.Position;
     }
     var offset = update.Entry.Offset + 0x1aL;
     _baseStream.Seek(offset, SeekOrigin.Begin);
     uint num3 = ReadLeUshort();
     uint num4 = ReadLeUshort();
     var sourcePosition = (_baseStream.Position + num3) + num4;
     if (flag)
     {
         if (update.OffsetBasedSize != -1L)
         {
             destinationPosition += update.OffsetBasedSize;
         }
         else
         {
             destinationPosition += (((sourcePosition - offset) + 0x1aL) + update.Entry.CompressedSize) + GetDescriptorSize(update);
         }
     }
     else
     {
         if (update.Entry.CompressedSize > 0L)
         {
             CopyEntryDataDirect(update, _baseStream, false, ref destinationPosition, ref sourcePosition);
         }
         CopyDescriptorBytesDirect(update, _baseStream, ref destinationPosition, sourcePosition);
     }
 }
Esempio n. 7
0
 private void CopyEntry(ZipFile workFile, ZipUpdate update)
 {
     workFile.WriteLocalEntryHeader(update);
     if (update.Entry.CompressedSize > 0L)
     {
         var offset = update.Entry.Offset + 0x1aL;
         _baseStream.Seek(offset, SeekOrigin.Begin);
         uint num2 = ReadLeUshort();
         uint num3 = ReadLeUshort();
         _baseStream.Seek(num2 + num3, SeekOrigin.Current);
         CopyBytes(update, workFile._baseStream, _baseStream, update.Entry.CompressedSize, false);
     }
     CopyDescriptorBytes(update, workFile._baseStream, _baseStream);
 }
Esempio n. 8
0
 private 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)
         {
             var 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);
             var position = workFile._baseStream.Position;
             using (var stream2 = workFile.GetOutputStream(update.OutEntry))
             {
                 CopyBytes(update, stream2, source, length, true);
             }
             var 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;
 }